#!/usr/bin/env bats
# Seam: scripts/grams-to-imatrix.py — the calibration recording (RADGRAM2 grams)
# folded into the GGUF v3 imatrix `rad-convert --imatrix F` reads.
#
# The only contract that matters is the reader's: core/format/imatrix.cpp joins
# `<base>.in_sum2` with `<base>.counts`, takes cols from in_sum2 dims[0] and
# n_expert from dims[1], demands ggml f32 tensors and GGUF version 3, and
# silently IGNORES an entry whose width does not match the weight it is asked
# about. So every test here parses the artifact back with its own tiny GGUF
# reader and asserts bytes — a file that merely exists and exits 0 proves
# nothing about a quantiser that will read it hours later on another machine.
#
# Fixtures are synthetic: k=4 grams with real RADGRAM2 headers (rows is a u64
# at offset 16 — pack it as u32 and 100 rows read back as 4294967296000) and
# real f32 payloads whose OFF-DIAGONAL is filled with 99.0, so an entry built
# from anything but the diagonal is instantly visible. Expected numbers are
# worked examples from the fixture tables below, never recomputed the way the
# tool computes them.

load helpers

TOOL="$REPO_ROOT/scripts/grams-to-imatrix.py"

# make_gram <path> <k> <rank> <rows> <domain> <diag,csv>
# A RADGRAM2 file: 32-byte header <8sIIQI (magic, k, rank, rows, domain, pad)
# then k*k f32 row-major. Off-diagonals are 99.0 — a sentinel, not data.
make_gram() {
    python3 - "$@" <<'PY'
import struct, sys
path, k, rank, rows, domain = sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), \
    int(sys.argv[4]), int(sys.argv[5])
diag = [float(x) for x in sys.argv[6].split(",")]
assert len(diag) == k, "diagonal must hold k values"
vals = [99.0] * (k * k)
for i, d in enumerate(diag):
    vals[i * k + i] = d
hdr = struct.pack("<8sIIQI", b"RADGRAM2", k, rank, rows, domain) + struct.pack("<I", 0)
with open(path, "wb") as f:
    f.write(hdr + struct.pack("<%df" % (k * k), *vals))
PY
}

# full_recording <dir> — the fixture every happy-path test reads.
#
# layer 0 (k=4, own-gram floor 4*k = 16 rows):
#   pooled   r0 rows 40 diag 1,2,3,4   + r1 rows 8 diag .5,.5,.5,.5
#            -> summed gram (the engine's calib_sum law): diag 1.5,2.5,3.5,4.5,
#               pooled rows 48
#   expert 0 r0 rows 100 diag 10,20,30,40   (>= 16: own gram kept)
#   expert 1 r0 rows   3 diag 7,7,7,7       (<  16: inherits pooled)
#   expert 2 r1 rows  64 diag 1,1,1,2       (>= 16: own gram kept)
#   expert 3           no file at all       (inherits pooled, count 0)
#   expert 4 r1 rows 100 diag 5,6,7,8       (>= 16: own gram kept)
#   -> n_expert 5, counts 100 3 64 0 100, inherited 2, routing 267
# layer 1: pooled r0 rows 48 diag 2,2,2,2 ; expert 0 on r1 rows 48 diag 1,1,1,1
#   -> n_expert 1, counts 48, inherited 0, routing 48
# Corpus rows = the largest single-layer pooled rows = 48.
full_recording() {
    local d="$1"
    mkdir -p "$d"
    make_gram "$d/gram.r0.blk.0.ffn_down_exps.bin" 4 0 40 0 "1,2,3,4"
    make_gram "$d/gram.r1.blk.0.ffn_down_exps.bin" 4 1 8 0 "0.5,0.5,0.5,0.5"
    make_gram "$d/gram.r0.blk.0.ffn_down_exps.0.bin" 4 0 100 0 "10,20,30,40"
    make_gram "$d/gram.r0.blk.0.ffn_down_exps.1.bin" 4 0 3 0 "7,7,7,7"
    make_gram "$d/gram.r1.blk.0.ffn_down_exps.2.bin" 4 1 64 0 "1,1,1,2"
    make_gram "$d/gram.r1.blk.0.ffn_down_exps.4.bin" 4 1 100 0 "5,6,7,8"
    make_gram "$d/gram.r0.blk.1.ffn_down_exps.bin" 4 0 48 0 "2,2,2,2"
    make_gram "$d/gram.r1.blk.1.ffn_down_exps.0.bin" 4 1 48 0 "1,1,1,1"
}

# gguf_read <file> [vals <tensor> <float-index> <count>] — an independent GGUF
# v3 reader: KV block, tensor infos, and (on request) the f32 values behind a
# tensor's own declared offset. Prints KV/HDR/TENSOR lines. Nothing here shares
# code with the writer, which is the only reason the byte assertions mean
# anything: imatrix.cpp walks the same three structures.
gguf_read() {
    python3 - "$@" <<'PY'
import struct, sys
d = open(sys.argv[1], "rb").read()
def u32(o): return struct.unpack_from("<I", d, o)[0]
def u64(o): return struct.unpack_from("<Q", d, o)[0]
def st(o):
    n = u64(o)
    return d[o + 8:o + 8 + n].decode(), o + 8 + n
assert d[:4] == b"GGUF", "magic is %r" % d[:4]
ver, n_t, n_kv = u32(4), u64(8), u64(16)
p, align, out = 24, 32, []
for _ in range(n_kv):
    key, p = st(p)
    ty = u32(p); p += 4
    if ty == 4:                                   # uint32
        v = u32(p); p += 4
        if key == "general.alignment":
            align = v
    elif ty == 8:                                 # string
        v, p = st(p)
    elif ty == 9:                                 # array
        et = u32(p); n = u64(p + 4); p += 12
        got = []
        for _i in range(n):
            if et != 8:
                raise SystemExit("kv array element type %d" % et)
            s, p = st(p)
            got.append(s)
        v = ",".join(got)
    else:
        raise SystemExit("kv type %d is not steppable" % ty)
    out.append("KV %s %s" % (key, v))
tens = []
for _ in range(n_t):
    name, p = st(p)
    nd = u32(p); p += 4
    dims = [u64(p + 8 * i) for i in range(nd)]; p += 8 * nd
    ty = u32(p); off = u64(p + 4); p += 12
    tens.append((name, dims, ty, off))
ds = (p + align - 1) // align * align
out.append("HDR version=%d n_tensors=%d n_kv=%d alignment=%d data_start=%d"
           % (ver, n_t, n_kv, align, ds))
for name, dims, ty, off in tens:
    out.append("TENSOR %s %s %d %d" % (name, "x".join(str(x) for x in dims), ty, off))
if len(sys.argv) > 2 and sys.argv[2] == "vals":
    name, i0, n = sys.argv[3], int(sys.argv[4]), int(sys.argv[5])
    for nm, dims, ty, off in tens:
        if nm == name:
            base = ds + off
            vals = [("%d" % v) if float(v).is_integer() else repr(v)
                    for v in (struct.unpack_from("<f", d, base + 4 * (i0 + i))[0]
                              for i in range(n))]
            out.append("VALS %s %s" % (name, " ".join(vals)))
print("\n".join(out))
PY
}

# aligned_offsets <file> — exit 0 iff the data section starts aligned AND every
# tensor's absolute data offset (data_start + t.off) is a multiple of
# general.alignment. This is the writer bug that no value assertion can see: an
# unaligned offset makes the reader's extent arithmetic land mid-float in the
# previous tensor, and it reads the result without complaining.
aligned_offsets() {
    python3 - "$1" <<'PY'
import struct, sys
d = open(sys.argv[1], "rb").read()
def u32(o): return struct.unpack_from("<I", d, o)[0]
def u64(o): return struct.unpack_from("<Q", d, o)[0]
def st(o):
    n = u64(o)
    return d[o + 8:o + 8 + n].decode(), o + 8 + n
ver, n_t, n_kv = u32(4), u64(8), u64(16)
p, align = 24, 32
for _ in range(n_kv):
    key, p = st(p)
    ty = u32(p); p += 4
    if ty == 4:
        v = u32(p); p += 4
        if key == "general.alignment":
            align = v
    if ty == 8:
        _v, p = st(p)
    elif ty == 9:
        et = u32(p); n = u64(p + 4); p += 12
        for _i in range(n):
            if et == 8:
                _v, p = st(p)
            elif et == 4:
                p += 4
            else:
                raise SystemExit("kv array element type %d" % et)
    elif ty in (0, 1):
        p += 1
    elif ty in (2, 3):
        p += 2
    elif ty in (5, 6):
        p += 4
    elif ty in (10, 11, 12):
        p += 8
tens = []
for _ in range(n_t):
    name, p = st(p)
    nd = u32(p); p += 4
    p += 8 * nd
    ty = u32(p); off = u64(p + 4); p += 12
    tens.append((name, ty, off))
ds = (p + align - 1) // align * align
bad = [] if ds % align == 0 else ["data_start=%d" % ds]
bad += ["%s=%d" % (nm, ds + off) for nm, _ty, off in tens if (ds + off) % align]
if bad:
    print("UNALIGNED", ";".join(bad))
    sys.exit(1)
print("ALIGNED %d tensor(s), data_start=%d, alignment=%d" % (len(tens), ds, align))
PY
}

# --- the artifact -----------------------------------------------------------

@test "a complete recording becomes a GGUF v3 file and the run reports itself" {
    C="$BATS_TEST_TMPDIR/full"
    full_recording "$C"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/im.gguf" \
        --datasets calib,chat --chunk-size 16
    [ "$status" -eq 0 ]
    [[ "$output" == *"IMATRIX_OK"* ]]
    head -c 4 "$BATS_TEST_TMPDIR/im.gguf" | grep -q "GGUF"
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf"
    [[ "$output" == *"HDR version=3"* ]]
    # The reader refuses anything but version 3, so this is the whole gate.
    [[ "$output" != *"version=2"* ]]
    # Everything the reader looks for by key, and the honesty of the chunk math:
    # 48 corpus rows over 16-row chunks is 3 chunks.
    [[ "$output" == *"KV general.alignment 32"* ]]
    [[ "$output" == *"KV imatrix.chunk_size 16"* ]]
    [[ "$output" == *"KV imatrix.chunk_count 3"* ]]
    [[ "$output" == *"KV imatrix.datasets calib,chat"* ]]
    [[ "$output" == *"n_tensors=12"* ]]
}

@test "the reader finds the folded MoE entry: one per layer, expert-major, f32" {
    C="$BATS_TEST_TMPDIR/full"
    full_recording "$C"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/im.gguf"
    [ "$status" -eq 0 ]
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf"
    # dims (k, n_expert) with k fastest, ggml type 0 (f32) or the entry is
    # warned away, and 5 experts because the fixture's largest global id is 4.
    [[ "$output" == *"TENSOR blk.0.ffn_down_exps.in_sum2 4x5 0 "* ]]
    [[ "$output" == *"TENSOR blk.0.ffn_down_exps.counts 1x5 0 "* ]]
    # counts are the routing rows, not the energy trace: 100 3 64 0 100.
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ffn_down_exps.counts 0 5
    [[ "$output" == *"VALS blk.0.ffn_down_exps.counts 100 3 64 0 100"* ]]
    # Expert 0 (floats 0..3) and expert 4 (floats 16..19) carry their own
    # matrices' diagonals; the 99.0 off-diagonal fill appears nowhere.
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ffn_down_exps.in_sum2 0 4
    [[ "$output" == *"VALS blk.0.ffn_down_exps.in_sum2 10 20 30 40"* ]]
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ffn_down_exps.in_sum2 16 4
    [[ "$output" == *"VALS blk.0.ffn_down_exps.in_sum2 5 6 7 8"* ]]
    [[ "$output" != *"99"* ]]
}

@test "an expert with no own gram carries the pooled diagonal, and the count of them is reported" {
    C="$BATS_TEST_TMPDIR/full"
    full_recording "$C"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/im.gguf"
    [ "$status" -eq 0 ]
    [[ "$output" == *"inherited=2"* ]]
    # Expert 1 has a gram (3 rows, under the 4*k floor) and expert 3 has none at
    # all; both slices must be the POOLED diag 1+0.5, 2+0.5, 3+0.5, 4+0.5.
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ffn_down_exps.in_sum2 4 4
    [[ "$output" == *"VALS blk.0.ffn_down_exps.in_sum2 1.5 2.5 3.5 4.5"* ]]
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ffn_down_exps.in_sum2 12 4
    [[ "$output" == *"VALS blk.0.ffn_down_exps.in_sum2 1.5 2.5 3.5 4.5"* ]]
    # Their counts stay their own routing: 3 for the under-threshold expert, 0
    # for the unrecorded one — popularity is count's job, never the gram's.
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ffn_down_exps.counts 1 3
    [[ "$output" == *"VALS blk.0.ffn_down_exps.counts 3 64 0"* ]]
    # The census is a report for the operator, so it belongs on stderr. `run`
    # folds both streams into $output, so a second run into a different -o (an
    # existing output is refused by design) captures stderr alone: without the
    # stderr write there is no file to grep and this assertion goes red.
    python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/im2.gguf" 2>"$BATS_TEST_TMPDIR/err"
    [ -s "$BATS_TEST_TMPDIR/err" ]
    grep -q "inherited=2" "$BATS_TEST_TMPDIR/err"
}

@test "the hidden-width entries are the same bytes, and nothing else is emitted" {
    C="$BATS_TEST_TMPDIR/full"
    full_recording "$C"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/im.gguf"
    [ "$status" -eq 0 ]
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf"
    # gate_up shares the down matrices (same hidden-state rows), so its slice 4
    # must read 5 6 7 8 at its own tensor info's offset.
    [[ "$output" == *"TENSOR blk.0.ffn_gate_up_exps.in_sum2 4x5 0 "* ]]
    [[ "$output" == *"TENSOR blk.0.ssm_inz.in_sum2 4 0 "* ]]
    [[ "$output" == *"TENSOR blk.0.ssm_inz.counts 1 0 "* ]]
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ffn_gate_up_exps.in_sum2 16 4
    [[ "$output" == *"VALS blk.0.ffn_gate_up_exps.in_sum2 5 6 7 8"* ]]
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ssm_inz.in_sum2 0 4
    [[ "$output" == *"VALS blk.0.ssm_inz.in_sum2 1.5 2.5 3.5 4.5"* ]]
    run gguf_read "$BATS_TEST_TMPDIR/im.gguf" vals blk.0.ssm_inz.counts 0 1
    [[ "$output" == *"VALS blk.0.ssm_inz.counts 48"* ]]
    # The stop rule: importance_for() false-on-a-width-mismatch means an entry
    # for a projection whose input is NOT the gram's width is a silent lie.
    [[ "$output" != *"ssm_out"* ]]
    [[ "$output" != *"attn"* ]]
    [[ "$output" != *"mtp."* ]]
    [[ "$output" != *"ple_ngram"* ]]
    [[ "$output" != *"output.weight"* ]]
}

@test "rows is a u64: a corpus too big for u32 survives the header" {
    # The trap this fixture law exists for: pack rows as u32 at offset 16 and a
    # 100-row file reads back as 4294967296000. 2**32 is exactly representable
    # in f32, so the count round-trips only if the tool read 8 bytes.
    C="$BATS_TEST_TMPDIR/wide"
    mkdir -p "$C"
    make_gram "$C/gram.r0.blk.0.ffn_down_exps.bin" 4 0 4294967296 0 "1,1,1,1"
    make_gram "$C/gram.r0.blk.0.ffn_down_exps.0.bin" 4 0 4294967296 0 "3,3,3,3"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/wide.gguf" --chunk-size 4096
    [ "$status" -eq 0 ]
    run gguf_read "$BATS_TEST_TMPDIR/wide.gguf" vals blk.0.ffn_down_exps.counts 0 1
    [[ "$output" == *"VALS blk.0.ffn_down_exps.counts 4294967296"* ]]
    [[ "$output" != *"4294967296000"* ]]
    run gguf_read "$BATS_TEST_TMPDIR/wide.gguf"
    [[ "$output" == *"KV imatrix.chunk_count 1048576"* ]]
    # imatrix.chunk_count is a u32 field, so 2**32 rows in 1-row chunks has no
    # legal encoding: wrapping it would put a number downstream believes.
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/wide2.gguf" --chunk-size 1
    [ "$status" -eq 2 ]
    [[ "$output" == *"REFUSED"*"CHUNK_COUNT"* ]]
    [ ! -e "$BATS_TEST_TMPDIR/wide2.gguf" ]
}

@test "every tensor's data offset is a multiple of general.alignment" {
    C="$BATS_TEST_TMPDIR/full"
    full_recording "$C"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/im.gguf"
    [ "$status" -eq 0 ]
    run aligned_offsets "$BATS_TEST_TMPDIR/im.gguf"
    [ "$status" -eq 0 ]
    [[ "$output" == "ALIGNED 12 tensor(s),"*"alignment=32" ]]

    # Red proof, in the same test so the assertion cannot rot: the same file
    # with one tensor's declared offset nudged by 4. A counts tensor is 4 bytes,
    # so a writer that forgets to pad between tensors produces exactly this
    # shape of file — and every value assertion above still passes on it.
    python3 - "$BATS_TEST_TMPDIR/im.gguf" "$BATS_TEST_TMPDIR/unaligned.gguf" <<'PY'
import struct, sys
src, dst = sys.argv[1], sys.argv[2]
d = bytearray(open(src, "rb").read())
def u32(o): return struct.unpack_from("<I", d, o)[0]
def u64(o): return struct.unpack_from("<Q", d, o)[0]
def st(o):
    n = u64(o)
    return d[o + 8:o + 8 + n].decode(), o + 8 + n
p = 24
for _ in range(u64(16)):
    key, p = st(p)
    ty = u32(p); p += 4
    if ty == 4:
        p += 4
    elif ty == 8:
        _v, p = st(p)
    elif ty == 9:
        et = u32(p); n = u64(p + 4); p += 12
        for _i in range(n):
            _v, p = st(p)
for _ in range(u64(8)):
    name, p = st(p)
    nd = u32(p); p += 4
    p += 8 * nd
    off_at = p + 4                      # the u64 offset field of this tensor
    if name == "blk.0.ssm_inz.counts":
        struct.pack_into("<Q", d, off_at, u64(off_at) + 4)
    p += 12
open(dst, "wb").write(bytes(d))
PY
    run aligned_offsets "$BATS_TEST_TMPDIR/unaligned.gguf"
    [ "$status" -eq 1 ]
    [[ "$output" == *"UNALIGNED"*"blk.0.ssm_inz.counts"* ]]
}

# --- the refusals -----------------------------------------------------------

@test "a gram short by one float is refused and the file is named" {
    C="$BATS_TEST_TMPDIR/short"
    full_recording "$C"
    # Cut the last 4 bytes of one expert gram: a torn write, which is what a
    # killed tap actually leaves behind.
    p="$C/gram.r0.blk.0.ffn_down_exps.0.bin"
    python3 -c 'import sys
p = sys.argv[1]
open(p, "wb").write(open(p, "rb").read()[:-4])' "$p"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/no.gguf"
    [ "$status" -eq 2 ]
    [[ "$output" == *"REFUSED"*"SHORT"* ]]
    [[ "$output" == *"gram.r0.blk.0.ffn_down_exps.0.bin"* ]]
    [ ! -e "$BATS_TEST_TMPDIR/no.gguf" ]
}

@test "an empty recording directory is refused" {
    mkdir -p "$BATS_TEST_TMPDIR/empty"
    run python3 "$TOOL" "$BATS_TEST_TMPDIR/empty" -o "$BATS_TEST_TMPDIR/no.gguf"
    [ "$status" -eq 2 ]
    [[ "$output" == *"REFUSED"*"NO_GRAMS"* ]]
    [[ "$output" == *"$BATS_TEST_TMPDIR/empty"* ]]
    [ ! -e "$BATS_TEST_TMPDIR/no.gguf" ]
}

@test "expert grams with no pooled gram for the layer are refused" {
    # Without the pooled gram there is nothing for an under-threshold expert to
    # inherit, and the tool would quietly invent a zero diagonal for it.
    C="$BATS_TEST_TMPDIR/nopooled"
    mkdir -p "$C"
    make_gram "$C/gram.r0.blk.3.ffn_down_exps.7.bin" 4 0 500 0 "1,2,3,4"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/no.gguf"
    [ "$status" -eq 2 ]
    [[ "$output" == *"REFUSED"*"NO_POOLED"*"layer 3"* ]]
    [[ "$output" == *"gram.r<rank>.blk.3.ffn_down_exps.bin"* ]]
}

@test "the same global expert recorded twice with different numbers is refused" {
    # Rank files carry GLOBAL expert numbering and so describe disjoint experts;
    # a collision means the recording is corrupt, and whichever file sorted last
    # would win.
    C="$BATS_TEST_TMPDIR/conflict"
    full_recording "$C"
    make_gram "$C/gram.r1.blk.0.ffn_down_exps.0.bin" 4 1 77 0 "10,20,30,40"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/no.gguf"
    [ "$status" -eq 2 ]
    [[ "$output" == *"REFUSED"*"EXPERT_CONFLICT"*"expert 0"* ]]
    [[ "$output" == *"gram.r0.blk.0.ffn_down_exps.0.bin"* ]]
    [[ "$output" == *"gram.r1.blk.0.ffn_down_exps.0.bin"* ]]
}

@test "an existing output is refused by name rather than overwritten" {
    # The trash law: a re-run must not destroy the imatrix a convert is reading.
    C="$BATS_TEST_TMPDIR/full"
    full_recording "$C"
    : > "$BATS_TEST_TMPDIR/keep.gguf"
    printf 'do not clobber me\n' > "$BATS_TEST_TMPDIR/keep.gguf"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/keep.gguf"
    [ "$status" -eq 2 ]
    [[ "$output" == *"REFUSED"*"EXISTS"*"keep.gguf"* ]]
    run cat "$BATS_TEST_TMPDIR/keep.gguf"
    [[ "$output" == *"do not clobber me"* ]]
}

@test "--min-rows moves the threshold and the bytes follow it" {
    # The default threshold is the engine's own law (4*k rows, lq_hess.h), but
    # the operator has to be able to raise it when a corpus is thin. Asserted on
    # the slices, not on a report line: a flag that only changes prose is a
    # flag that changes nothing.
    C="$BATS_TEST_TMPDIR/floor"
    full_recording "$C"
    run python3 "$TOOL" "$C" -o "$BATS_TEST_TMPDIR/far.gguf" --min-rows 200
    [ "$status" -eq 0 ]
    # 200 is above every expert's routing (100, 3, 64, 0, 100 and layer 1's 48),
    # so all six slices now inherit.
    [[ "$output" == *"inherited=6"* ]]
    run gguf_read "$BATS_TEST_TMPDIR/far.gguf" vals blk.0.ffn_down_exps.in_sum2 0 4
    [[ "$output" == *"VALS blk.0.ffn_down_exps.in_sum2 1.5 2.5 3.5 4.5"* ]]
    # The counts do not move with the threshold: routing is a measurement, not a
    # judgement about how much data is enough.
    run gguf_read "$BATS_TEST_TMPDIR/far.gguf" vals blk.0.ffn_down_exps.counts 0 5
    [[ "$output" == *"VALS blk.0.ffn_down_exps.counts 100 3 64 0 100"* ]]
}