Metrics

The geometry and metric come from the checkpoint itself.

Binding-only.

Binding-only.

The index stores no values: every key a walk scores resolves through rowOf to a row of values, borrowed for the call, so only the keys a walk scores are ever resolved. The values must be as wide as the keys and stored in the index's own scalar kind, and a key resolving outside them refuses the call with ShapeMismatch, since a missing row is a wrong softmax rather than a smaller one. Row t * headCount + h of the queries, outputs and carry is head h of token t, every head of a token sharing one walk.

rowOf runs on the calling thread, which no executor's thread is, so only the index itself offers attend. The first exception it throws stops every later lookup and is rethrown once the call returns. Being a host function, it serves RAM handles alone: a VRAM walk resolves rows through a device function, which this binding does not build, so a Vram arena refuses with Status.Device.

Binding-only sugar over count.

Without starts it yields every entry as stored; with them, the start keys' own entries first in order, then the entries those link to breadth-first, each once.

A typed array is one row, and a RowsView is a batch borrowed in place. A single key broadcasts across every row. A batch is all-or-nothing: a rejected one leaves the index untouched.

Rows keep whatever type they arrived in and the engine converts them into the index's own quantization, so the two are independent - a packed u1x8 or a bf16 row travels as bytes with its RowsView naming what they mean.

A cheap insertion pass followed by one refinement reaches a better graph, in less total time, than a single expensive insertion pass - so a wide breadth belongs here.

The matches land in arena and come back as a view into it, so a recall sweep reusing one arena allocates once.

The run is over keys rather than rows, which is what an index built with valuesPerKey above one exists for. Runs on the inner-product kinds alone.

Rows land in arena and come back as a view into it, converted into scalar, shaped by the width and stride the call reports.

How many pairs a walk scores is known only once it ends, so the products land in arena and come back as views into it. The scores are unnormalized logits, so the handle must hold the inner-product kind.

A donor the library consumed refuses every later verb with Status.Uninitialized; one it did not absorb, like a donor of another scalar refused with Status.ConfigMismatch, stays a live index the caller still owns, though its entries may already have moved here. Until a deferred absorb is final, every donor it names refuses every verb, and no other absorb can name it.

Receivers must be empty and share the index's residency, scalar, class, metric, geometry and shard count, or the call refuses with Status.ConfigMismatch, moving nothing.

A larger wanted draws a superset, so a view grows one connected sample as it zooms. Only RAM samples yet.

The bytes are what a checkpoint holds, so a service that keeps its indexes in an object store never touches the filesystem. They land in arena and come back as a view into it.