@hviana/sema 0.8.2 → 0.8.5

package/dist/src/mind/attention.d.ts

@@ -75,6 +75,10 @@ export interface ConsensusAnchorTrace {
     rank: number;
     pooledVote: number;
     idfVote: number;
+    /** The LARGEST single-region contribution behind this anchor — the bar
+     *  recall's own gate reads (mechanisms/recall.ts).  Published so the one
+     *  decision-making quantity the climb computes is not invisible. */
+    peak: number;
     candidateBreadth: number;
     contributingVotes: number;
     contributingEvidence: number;

package/dist/src/mind/attention.js

@@ -15,6 +15,7 @@ import { leafIdRun } from "./canonical.js";
 import { atomIsHub, corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "./traverse.js";
 import { cachedRead, junctionContainersFrom, junctionSeeds, junctionSynonyms, loadJunctionSynonymSides, walkCache, } from "./junction.js";
 import { indexOf } from "../bytes.js";
+import { restates } from "./derivation.js";
 import { rItem, rNode, traceDerivation } from "./trace.js";
 function newTraceDraft(perceivedCount) {
     return {
@@ -775,15 +776,18 @@ export async function voteRegions(ctx, query, regions, k, mode, N, reachMemo, td
             }
             contrastiveMargin = margin;
             // Scaled by what this region does NOT address — see `cov` above.
-            const noiseFloor = estimatorNoise(ctx.store.D) * (1 - cov);
-            if (margin <= noiseFloor) {
+            // The bar THIS gate applies: the estimator's noise scaled by what the
+            // region does NOT address (`cov`).  ONE definition, used by the rejection
+            // path below and by the voted payload — the trace reports the applied bar.
+            const appliedFloor = estimatorNoise(ctx.store.D) * (1 - cov);
+            if (margin <= appliedFloor) {
                 recordRegion("contrastive-margin-rejection", {
                     selected,
                     reachNode: voterId,
                     idf,
                     dfWeight: wf,
                     contrastiveMargin: margin,
-                    contrastiveNoiseFloor: noiseFloor,
+                    contrastiveNoiseFloor: appliedFloor,
                     ...(contrastiveRival ? { contrastiveRival } : {}),
                 });
                 continue;
@@ -834,7 +838,12 @@ export async function voteRegions(ctx, query, regions, k, mode, N, reachMemo, td
             ...(contrastiveMargin !== undefined
                 ? {
                     contrastiveMargin,
-                    contrastiveNoiseFloor: estimatorNoise(ctx.store.D),
+                    // THE BAR THE GATE ACTUALLY APPLIED — the same expression
+                    // the rejection path's `appliedFloor` defines, inline here because
+                    // this payload is built in a scope that does not carry that local.
+                    // Publishing the raw estimatorNoise(D) instead made a region that
+                    // PASSED look closer to its limit than it was.
+                    contrastiveNoiseFloor: estimatorNoise(ctx.store.D) * (1 - cov),
                     ...(contrastiveRival ? { contrastiveRival } : {}),
                 }
                 : {}),
@@ -939,7 +948,17 @@ export function poolVotes(ctx, regionVotes, sat, N, td) {
         },
         pool,
     };
-    lightestDerivation(system);
+    // THE SEARCH WAS THE ONE LAYER WITH NO TIME.  The climb's phases are timed
+    // (voteRegions, structuralResonance, crossRegion) but the pooled derivation
+    // was not, so any cost or gain inside it stayed invisible.
+    // `timeSync`, not `time`: the search is SYNCHRONOUS, and wrapping it in a
+    // promise only to time it would make the profiled path wait where the
+    // unprofiled one does not (meter.ts's own contract).
+    if (ctx.meter) {
+        ctx.meter.timeSync("climb.derivation", () => lightestDerivation(system));
+    }
+    else
+        lightestDerivation(system);
     const votes = new Map();
     const votesIdf = new Map();
     const support = new Map();
@@ -973,12 +992,24 @@ export function poolVotes(ctx, regionVotes, sat, N, td) {
     // The LARGEST single region's contribution to this anchor's pooled vote.
     // The pool is a SUM (deliberately — see the pooling note above), so it says
     // how much evidence there is in total, never whether any ONE place in the
-    // query carries evidence on its own.  Consumers that hold an anchor to
-    // consensusFloor(N) = ln(N) + 1/2 need the latter: that bar prices ONE
-    // region's maximally-discriminative evidence (ln N is the IDF of content
-    // reaching a single context), so comparing a six-region sum against it is a
-    // dimensional error.  Recorded here, beside the count, because this is the
-    // only place the per-region contributions are still separable.
+    // query carries evidence on its own.  Recorded here, beside the count,
+    // because this is the only place the per-region contributions are still
+    // separable.
+    //
+    // THE BAR IS THE POOLED FLOOR, AND IT WAS ONCE CLAIMED OTHERWISE HERE.
+    // This comment used to say that holding an anchor to consensusFloor(N)
+    // "prices ONE region's evidence", so comparing a six-region sum against it
+    // was "a dimensional error".  THAT WAS FALSE.  `thresholds.md` §2 derives
+    // `consensusFloor` as the POOLED-vote significance floor ("each region
+    // contributes at most ln(N/c) <= ln(N); ln(N) + 1/2 demands ..."), and the
+    // climb weights by IDF, so the sum and the floor are in ONE dimension —
+    // which is exactly why `recall.ts` gates `forest[0].idfVote` against it and
+    // why `commitVotes` does too.  The other two weighting modes DO leave that
+    // dimension (by at most ln 2, two-sided: `direct` deflates a region and
+    // `combined` inflates it), and the gates therefore read the IDF sum, which
+    // is mode-independent; `test/55` tests 19 and 20 pin both halves — the sum
+    // as the reading the bar is derived for, and the absence of any gate
+    // inversion across the three modes.
     const regionPeak = new Map();
     const steps = [];
     let order = 0;
@@ -1136,12 +1167,23 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
             anchor,
             vote,
             peak: regionPeak.get(anchor) ?? 0,
+            idfVote: votesIdf.get(anchor) ?? 0,
             start: s.start,
             end: s.end,
             breadth: (regionSupport.get(anchor) ?? 0) / totalRegions,
             clusters: countClusters(regionSpans.get(anchor) ?? [], ctx.space.maxGroup),
         };
     })
+        // THE ORDER IS NOT A PREFERENCE: with equal evidence it decides ADMISSION,
+        // through the stable sort and the first-come overlap absorption below.
+        // Measured on test/34's corpus, query "red": the two candidates (`red
+        // circle` and `red square`) carry IDENTICAL `vote` and IDENTICAL `idfVote`
+        // (1.3863 each, three seeds), so this comparator leaves them tied and the
+        // stable sort keeps the ENUMERATION order — which is corpus-determined and
+        // admits `red square`, 60/60 seeds.  Adding an id tie-break (`|| a.anchor -
+        // b.anchor`) picks `red circle` instead and makes a single region reach the
+        // JOINT context, which is the premise `test/34` exists to protect.  The
+        // gates read IDF; this line only decides who gets looked at first.
         .sort((a, b) => b.vote - a.vote);
     const overlaps = (a, b) => a.start < b.end && b.start < a.end;
     // Read the root cut from the anchors the QUERY pointed at.  A vote standing
@@ -1177,6 +1219,13 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
             rank,
             pooledVote: point.vote,
             idfVote: votesIdf.get(point.anchor) ?? 0,
+            // The LARGEST single-region contribution behind this anchor — the bar
+            // recall's own gate reads (mechanisms/recall.ts: forest[0].peak > LN2),
+            // and until now the only decision-making quantity the climb computed and
+            // did not publish.  `regionPeak` reached `ranked` (see its build below)
+            // and stopped there.  Published, not recomputed: the value is the one the
+            // climb already carries.
+            peak: point.peak,
             candidateBreadth: regions.length,
             contributingVotes: regionAxioms.get(point.anchor) ?? 0,
             contributingEvidence: regionSupport.get(point.anchor) ?? 0,
@@ -1206,6 +1255,18 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
         let passesConsensusFloor;
         let pastLeadingSaturation;
         let tiedWithDominant;
+        // ── ONE OF THREE ADMISSIONS, AND THEY ARE NOT THE SAME READING ────────
+        // This block admits by VOTES: per-region evidence pooled, gated on the
+        // natural break and on consensusFloor, with the dominant allowed to bypass
+        // both.  `structuralResonance` admits by a MARGIN over the estimator's own
+        // noise, and `crossRegionVotes` admits by STRUCTURE (which regions may pair
+        // at all, with at least one side individually discriminative).  Read
+        // together they look like one policy written three times; they are three
+        // different measurements of the same question ("is this evidence?"), and
+        // unifying them would average three readings into one — the mistake
+        // `extraction.ts` records as "do not unify the two into one machine".
+        // What they DO share, and must keep sharing, is the discipline of deriving
+        // every bar from D/W/N rather than choosing it (thresholds.md).
         const rejectionReasons = [];
         if (absorbed) {
             status = "overlap";
@@ -1216,9 +1277,75 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
             pastLeadingSaturation = pastLeading;
             const vote = votesIdf.get(point.anchor) ?? 0;
             if (roots.length === 0) {
-                // The first non-overlapping root is DOMINANT and bypasses the two
-                // vote thresholds (it always grounds) — only the leading-saturation
-                // gate still applies to it.
+                // THE DOMINANCE PRIVILEGE, AND THE TENSION IT CARRIES (measured).
+                //
+                // The first non-overlapping candidate is DOMINANT: it bypasses both
+                // vote gates below and grounds on its own; only the leading-saturation
+                // gate still applies to it.  The privilege is load-bearing — analogies,
+                // substitutions and composed contexts are precisely candidates the
+                // query does NOT contain, and the engine loses them without it.
+                //
+                // WHICH candidate receives it, though, is decided by this loop's ORDER.
+                // That order comes from `ranked`, and when two candidates carry equal
+                // evidence the stable sort preserves the ENUMERATION order, so the
+                // privilege is allocated by an ordering rather than by a rule.
+                //
+                // Measured on test/34's corpus, query "red":
+                //
+                //   0:#77 vote=1.3863 idf=1.3863 [0,3) | 1:#49 vote=1.3863 idf=1.3863 [0,3)
+                //
+                // Both candidates (`red square` #77, `red circle` #49) have IDENTICAL
+                // `vote` AND IDENTICAL `idfVote` over the SAME support span, so the
+                // comparator leaves them tied, the second is absorbed as "overlap", and
+                // the first grounds.  With this build's enumeration order that first is
+                // `red square`, 60/60 seeds, and `red circle` — the JOINT context — is
+                // never reached by "red" alone.  That is the premise test/34 exists to
+                // protect: no single region reaches the joint context, which is what
+                // makes the binding query unreachable without direct region
+                // interaction.
+                //
+                // THE TENSION: the premise therefore holds BY ENUMERATION ORDER, not by
+                // a rule, so any change to this ordering can move the privilege onto the
+                // joint context and let one region reach it.  Measured: adding
+                // `|| a.anchor - b.anchor` — the lowest-id tie-break that AGENTS.md §2
+                // sanctions as an equivalent corpus-determined tie-break — does exactly
+                // that: "red" then attends to `red circle`, test/34 fails 6/1, and the
+                // canonical suite reports 1 failure.
+                //
+                // TWO ATTEMPTS TO MAKE IT A RULE, BOTH REFUTED BY MEASUREMENT:
+                //
+                //  1. EVIDENCE SEPARATION.  Grant the privilege only when the first
+                //     candidate's evidence is separated from the next distinct
+                //     candidate's by more than the co-dominant band (sqrt(k) *
+                //     estimatorNoise(D)).  Refuted: that band exists to ADMIT the
+                //     anchors the estimator cannot separate from the dominant — its own
+                //     documented purpose — so withholding the privilege on ties removes
+                //     the very case it was written for.  Suite: 4 failures (the two
+                //     co-dominant band laws, breadth/scale invariance, test/29 D2).
+                //
+                //  2. QUERY-OWNED CONTENT.  Grant the privilege only to a candidate
+                //     that IS a recognised region's identity (regions.some(r => r.id ===
+                //     point.anchor)).  Measured: for "circle" that identity IS the
+                //     ranked candidate, so the privilege stays and `circle` grounds; for
+                //     "red" the identity is the `red` node itself while the candidates
+                //     are the conjunctions, so neither is privileged; for "red then
+                //     circle" the composed context carries idf 3.958 and clears both
+                //     gates on its own evidence.  All four control queries came out
+                //     right — and the suite: 10 failures, six of them in the
+                //     analogy/counterfactual/CAST suites ("an analogy still transfers
+                //     from a structure the query never names"; "a substitute the query
+                //     NAMES may still be voiced").  Refuted: the privilege exists to
+                //     admit what the query does NOT contain, so identity is the wrong
+                //     axis.
+                //
+                // WHAT A FUTURE ATTEMPT MUST RESPECT: whatever allocates this privilege
+                // has to (a) keep it available to candidates the query does not contain
+                // — analogies, substitutions, compositions — and (b) not depend on the
+                // estimator's ordering among anchors of equal evidence, because that
+                // ordering is not a fact about the corpus.  No lever satisfying both has
+                // been found.  Until one is, this premise rests on the enumeration order
+                // recorded above, and test/34 is the only test that notices if it
+                // moves.
                 dominant = true;
                 if (pastLeading) {
                     status = "root";
@@ -1229,8 +1356,15 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
                 }
             }
             else {
-                passesNaturalBreak = vote >= rootCut;
-                passesConsensusFloor = vote >= floor;
+                // THE FLOOR AND THE BREAK READ THE IDF WEIGHTING.  `floor` is derived
+                // for pooled IDF-weighted votes, and `rootCut` comes from the IDF
+                // distribution (`idfDesc`), so gating the mode-dependent `vote` against
+                // either let a weighting mode change an admission (measured: anchor 87,
+                // inverse 2.682 admitted vs direct 1.468 refused).  Reading the IDF sum
+                // makes the verdict mode-independent, and changes nothing in the
+                // engine's own mode, where the two readings coincide.
+                passesNaturalBreak = point.idfVote >= rootCut;
+                passesConsensusFloor = point.idfVote >= floor;
                 // CO-DOMINANT — an anchor the estimator cannot separate from the
                 // dominant inherits the dominant's exemption, because that exemption's
                 // only warrant is being TOP, and "top" is not a fact about the corpus
@@ -1685,6 +1819,13 @@ ownRootsA, ownRootsB, trace) {
             outcome,
         });
     };
+    // ── ADMISSION BY MARGIN, not by votes (see voteRegions' note) ─────────
+    // What this site measures: how far the best ANN proposal's effective score
+    // (score × semanticConfidence) stands above the runner-up's, against
+    // `estimatorNoise(D)`.  What it does NOT measure: how many regions voted,
+    // or whether the query's regions agree — that is voteRegions' question, and
+    // here a synthetic gist has already replaced them.  The two bars are both
+    // derived (thresholds.md), and neither is a tuning of the other.
     let selected = null;
     let selectedReach = null;
     let selectedIdf = 0;
@@ -1790,6 +1931,15 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
     // successfully reconstructed while probing one pair must not be read and
     // perceived again while probing another pair in the same climb.
     const siblingGistMemo = new Map();
+    // ── ADMISSION BY STRUCTURE, not by a bar (see voteRegions' note) ──────
+    // What this site decides: WHICH regions may pair at all — a region that
+    // already voted (individually discriminative), or a KNOWN non-voting one as
+    // the weak side of a pair whose other side voted; never two non-voting
+    // regions, and never a span contained in a maximal one whose reading is
+    // exact.  The bar (the container's idf) comes later, on the candidate.  So
+    // its "rejection reasons" name structural disqualifications — a different
+    // vocabulary because it answers a different question, and the three
+    // taxonomies stay separate for the same reason the readings do.
     const votedSpans = new Set();
     for (const rv of rvs.votes)
         votedSpans.add(`${rv.start},${rv.end}`);
@@ -2130,7 +2280,7 @@ async function crossRegionVotes(ctx, query, regions, rvs, k, N, reachMemo, td) {
                     const ri = indexOf(bytes, right, 0);
                     if (li >= 0 && ri >= 0) {
                         const joined = bytes.subarray(Math.min(li, ri), Math.max(li + left.length, ri + right.length));
-                        if (indexOf(query, joined, 0) >= 0) {
+                        if (restates(query, joined, 0)) {
                             if (structuralTrace)
                                 structuralTrace.selfEvidenceRejected++;
                             continue; // query says it itself

package/dist/src/mind/canonical.d.ts

@@ -23,6 +23,22 @@ export declare function leafIdRun(ctx: MindContext, bytes: Uint8Array, from: num
  *  what a partial prefix means (deposit only interns the whole-stream flat
  *  branch when the prefix covers everything). */
 export declare function leafIdPrefix(ctx: MindContext, bytes: Uint8Array): number[];
+/** Which prefixes of `prefix ‖ tail` are STORED NODES — as lengths in the
+ *  tail's own coordinates, ascending, excluding the empty one.  This is the
+ *  candidate set a rule needs to join an already-stored prefix to a suffix it
+ *  has not stored: a key names a relation exactly when `prefix ‖ tail[0..p]` IS
+ *  a node, and a key can end strictly inside the tail without sitting on any
+ *  fold boundary (a stored member's end is the end of ITS OWN stream, and the
+ *  fold never emits a cut at a stream's end).  Measured: "stockholm mayor"
+ *  exists, leads on, and its boundary 6 is in neither the tail's cuts nor the
+ *  concatenation's.
+ *
+ *  ONE cheap content-addressed probe per offset — `leafIdPrefix` walks the bytes
+ *  once (a point probe each), `findBranch` hashes the growing kid run — and NO
+ *  `resolve`, which is what keeps this off the O(suffix) vector folds the
+ *  recognition path pays.  It stops at the first byte that was never interned,
+ *  which costs nothing real: a stored key's bytes are interned by construction. */
+export declare function keyEnds(ctx: MindContext, prefix: Uint8Array, tail: Uint8Array): number[];
 /** The canonical W-window node ids of a byte stream, offset → id — the
  *  CONTENT-ADDRESSED IDENTITY of every W-sized slice, under which any content
  *  two deposits share IS the same node (hash-consing paid the comparison at

package/dist/src/mind/canonical.js

@@ -70,6 +70,47 @@ export function leafIdPrefix(ctx, bytes) {
     }
     return ids;
 }
+/** Which prefixes of `prefix ‖ tail` are STORED NODES — as lengths in the
+ *  tail's own coordinates, ascending, excluding the empty one.  This is the
+ *  candidate set a rule needs to join an already-stored prefix to a suffix it
+ *  has not stored: a key names a relation exactly when `prefix ‖ tail[0..p]` IS
+ *  a node, and a key can end strictly inside the tail without sitting on any
+ *  fold boundary (a stored member's end is the end of ITS OWN stream, and the
+ *  fold never emits a cut at a stream's end).  Measured: "stockholm mayor"
+ *  exists, leads on, and its boundary 6 is in neither the tail's cuts nor the
+ *  concatenation's.
+ *
+ *  ONE cheap content-addressed probe per offset — `leafIdPrefix` walks the bytes
+ *  once (a point probe each), `findBranch` hashes the growing kid run — and NO
+ *  `resolve`, which is what keeps this off the O(suffix) vector folds the
+ *  recognition path pays.  It stops at the first byte that was never interned,
+ *  which costs nothing real: a stored key's bytes are interned by construction. */
+export function keyEnds(ctx, prefix, tail) {
+    if (prefix.length === 0 || tail.length === 0)
+        return [];
+    const joined = new Uint8Array(prefix.length + tail.length);
+    joined.set(prefix, 0);
+    joined.set(tail, prefix.length);
+    const ids = leafIdPrefix(ctx, joined);
+    if (ids.length < prefix.length)
+        return [];
+    const ends = [];
+    // The kid run GROWS by one id per offset; `findBranch` wants an array, so the
+    // run is built once and pushed into, never re-sliced.  Re-slicing
+    // `ids.slice(0, prefix.length + p)` per offset made this O(|tail| ·
+    // (|prefix| + |tail|)) — quadratic in the tail, where the learning path this
+    // follows slices a run that SHRINKS.  Same ends, linear copying.
+    const run = ids.slice(0, prefix.length);
+    // The loop ENDS at the first byte that was never interned (`ids.length`):
+    // every later prefix contains it, so none of them can be a node either — this
+    // is where the scan stops, not a silent truncation of the answer.
+    for (let p = 1; prefix.length + p <= ids.length; p++) {
+        run.push(ids[prefix.length + p - 1]);
+        if (ctx.store.findBranch(run) !== null)
+            ends.push(p);
+    }
+    return ends;
+}
 /** The canonical W-window node ids of a byte stream, offset → id — the
  *  CONTENT-ADDRESSED IDENTITY of every W-sized slice, under which any content
  *  two deposits share IS the same node (hash-consing paid the comparison at

package/dist/src/mind/derivation.d.ts

@@ -0,0 +1,201 @@
+/** A half-open `[start, end)` span of the asker's own bytes. */
+export type Span = readonly [number, number];
+/** The BYTE COUNT of a span list — what the currency calls `unaccounted` in
+ *  `weight = moves + PASS·unaccounted`.  ONE definition: this was four copies of
+ *  the same `reduce` before the architecture audit collapsed them. */
+export declare function unaccountedBytes(spans: ReadonlyArray<Span>): number;
+/** The `[start, end)` gaps of `[0, queryLen)` NOT covered by `accounted` — the
+ *  union-of-spans reading the ladder prices at PASS per byte, and the raw
+ *  material every closure decision measures.  Clipped to the question, sorted
+ *  and merged, so two overlapping spans account for their union once. */
+export declare function unexplainedSpans(queryLen: number, accounted: ReadonlyArray<Span>): Array<[number, number]>;
+/** THE REMAINDER: what no step has accounted for, with every span below one
+ *  river-fold quantum dropped.  `W` is the mind's own line between bridging
+ *  punctuation and a substantive phrase — the same floor `liftedScaffolding`
+ *  and the honesty-density bar use — so a remainder under it licenses nothing
+ *  and blocks nothing.  This is the law's measure. */
+export declare function remainderOf(queryLen: number, explained: ReadonlyArray<Span>, W: number): Array<[number, number]>;
+/** A WITNESS — what a transition carries, in one reading: the SPAN it accounts
+ *  for, and the WINDOW of the question the product itself holds.  The window is
+ *  present only when the product holds question material, and it is the ONLY
+ *  thing the question's remainder may be consumed by. */
+export interface Witness {
+    readonly span: Span;
+    readonly window?: Span;
+}
+/** The window of `span` that `product` holds, or null: the ONE reading of
+ *  coverage — used by {@link carries}, by the move branch, and by the GROUNDING
+ *  when it decides what its answer has actually paid for. */
+export declare function windowOf(span: Span, product: Uint8Array, query: Uint8Array, W: number): Span | null;
+/** PROGRESS, by coverage: the first member of `remainder` that `product` carries
+ *  a whole quantum of, or null when it carries none.  The window is taken from
+ *  `query`, the asker's own bytes, so the test is "this product restates a
+ *  quantum of what was left unaccounted", never a similarity score.
+ *
+ *  One witness per step, deterministically the FIRST in remainder order: the
+ *  measure stays a single member of a finite list, which is what makes the walk
+ *  reviewable — and, because the remainder is not drained, it is the walker's
+ *  cycle protection (not this) that terminates a chain. */
+export declare function carries(remainder: ReadonlyArray<Span>, product: Uint8Array, query: Uint8Array, W: number): Array<Witness> | null;
+/** Whether `bytes` RESTATES the question — says nothing the asker did not just
+ *  say — and is therefore not an answer.  This is a closure condition: a
+ *  derivation whose product is already the question has added nothing, and the
+ *  engine asks it in five places.  ONE definition, asked everywhere, with the
+ *  DIFFERENCES between those places supplied as WITNESSES by the caller — never
+ *  as a mechanism or a producer.  If this function ever needs to know who
+ *  produced the bytes to decide, the right conclusion is that a witness is
+ *  missing, not that it should dispatch.
+ *
+ *  `floor` is one river-fold quantum: below it, byte overlap is chance, not
+ *  evidence — the same line `identityBar`, the bridge's `attestedQ` and
+ *  recognition's site floor all draw.  `0` disables the floor, which is the
+ *  reading the callers that ask before any structure exists use.
+ *
+ *  THE THREE READINGS the callers need, and why each is a witness rather than a
+ *  branch here:
+ *
+ *   • `proper` — a PROPER part of the question (strictly shorter).  This is the
+ *     reading every tier that rejects a fragment uses.
+ *   • `whole` — the EQUALITY reading: only "the answer IS the question" counts,
+ *     because the caller has already handled a proper fragment elsewhere (a
+ *     recall tier's own subspan tests).
+ *   • `equate` — the response's own notion of "the same text" (whatever
+ *     `src/canon.ts` equates: case, width, whitespace).  A caller that has one
+ *     passes it; a caller that does not gets the byte-exact reading.  It is the
+ *     same fallback `resolve` already makes when an exact lookup misses.
+ *
+ *  The LITERAL EXEMPTION is deliberately NOT here: whether a span is the site's
+ *  own bytes at its own position is the CALLER's knowledge, and a caller states
+ *  it by not asking (see `segRestatesQuery` in types.ts, which returns false for
+ *  a literal span before reaching this). */
+export declare function restates(query: Uint8Array, bytes: Uint8Array, floor?: number, witnesses?: {
+    equate?: ((b: Uint8Array) => Uint8Array) | null;
+    proper?: boolean;
+    whole?: boolean;
+    /** THE POSITIONAL WITNESS: search from this offset, because the caller has
+     *  established that only material at or after it counts.  A transcript pasted
+     *  into a single response is the case that needs it — a caller's own prior
+     *  answer lies LATER in the query, after the root that would restate it — and
+     *  the reasoner's per-root `alreadyAnswered` guard asks exactly that question.
+     *  Omitted, the search starts at 0 and the reading is the plain one. */
+    from?: number;
+}): boolean;
+/** Whether the query span `[from, to)` lies inside a COMPLETED ASSISTANT TURN —
+ *  material the engine has already produced, so it is context rather than
+ *  something the asker is asserting.  Recognition and attention still see the
+ *  full transcript; what excludes these spans is the closure reading "this was
+ *  already answered", and it is a closure reading rather than a budget: a window
+ *  inside a prior reply is not a fresh constraint.
+ *
+ *  ONE definition of it.  `cursor` is the CALLER's own progress through `turns`
+ *  (they are ascending and each caller scans its candidates in ascending order),
+ *  so the amortised search is preserved exactly and a caller passes the same
+ *  holder for a whole scan: extracting the reading must not cost the scan. */
+export declare function insideAnsweredTurn(turns: ReadonlyArray<Span>, cursor: {
+    at: number;
+}, from: number, to: number): boolean;
+/** THE derivation state — the unit that crosses one inference.
+ *
+ *  Every field is read by the law or by the market's one cost ladder, and
+ *  nothing else travels.  A count of steps is a consequence (the cost), and
+ *  cycle protection belongs to the layer that walks a graph. */
+export interface DerivationState {
+    /** PRODUCT — the structure produced: what this derivation stands on. */
+    readonly product: Uint8Array;
+    /** ACCOUNTED — the asker's spans the producing transition priced.  A COST
+     *  quantity, and the producing mechanism's own judgement of what its answer
+     *  explains: cover leaves its computed spans out so the PASS-bridged bytes
+     *  they account for stay charged, while a corroborated substitution DOES
+     *  account for its span, because the mechanism paid a move for it. */
+    readonly accounted: ReadonlyArray<Span>;
+    /** REMAINDER — the asker's material no step has accounted for, each member at
+     *  or above one quantum.  Empty means the derivation is CLOSED. */
+    readonly remainder: ReadonlyArray<Span>;
+    /** COST — position on the one ladder (`graph-search.ts`'s MICRO/STEP/CONCEPT/
+     *  PASS); the market takes the lattice minimum over it. */
+    readonly cost: number;
+    /** FIXED — the producer SUPPLIED a fixed point: the query IS the context, so
+     *  no transition may consume this state.  Declared, never inferred. */
+    readonly fixed?: boolean;
+    /** USED — what the product speaks for.  An EMPTY set is itself a declaration
+     *  ("this answer voices nothing"); omitted means the layer must re-recognise
+     *  the product to decide for itself. */
+    readonly used?: ReadonlySet<number>;
+}
+/** A candidate continuation, as reported by the layer that knows the structure.
+ *  The layer says what it has; the law decides. */
+export interface Continuation {
+    /** The structure the transition would make the derivation's product. */
+    readonly product: Uint8Array;
+    /** CONTAINS — the transition's structure holds the product: a node in its
+     *  tree, or one contiguous byte run of it.  Resolved by the reporter.
+     *
+     *  SUFFICIENT FOR EVERY DECISION THIS CORE MAKES, and a boolean is the minimum:
+     *  the law reads it ONCE, as the admission gate, and that decision is binary —
+     *  may this state be consumed by this transition at all?  Every other decision
+     *  is fed by other witnesses, never by this one: the product's identity is
+     *  `resolve(product)`, progress is the window a move carries or the
+     *  `reaches` declaration, accounting is the span.  Carrying the reporter's
+     *  structure here would therefore be a dump of mechanism internals bought for
+     *  nothing.  The producers make it true by construction — a continuation is
+     *  built from the CURRENT product's own structure, never from a different one
+     *  — and test/133 pins the refusal when a reporter declares false. */
+    readonly contains: boolean;
+    /** REACHES — the transition MOVES: it reaches structure this derivation has
+     *  not consumed
+     *  (a node outside the walker's own set).  The second species of progress: a
+     *  step need not excuse itself with question material when it moves to new
+     *  structure.  Resolved by the reporter, declared by the transition — never
+     *  inferred from its producer. */
+    readonly reaches?: boolean;
+    /** What the transition accounts for, when it declares it.  A transition
+     *  taken from a CLOSED state has nothing to progress on, so it is the one
+     *  case that must say what it accounts for; a transition that carries the
+     *  remainder declares nothing and the law's own witness is used. */
+    readonly explains?: ReadonlyArray<Span>;
+    /** The transition's own moves, in ladder units. */
+    readonly cost: number;
+}
+/** CLOSED — nothing of the asker's material is left unaccounted. */
+export declare function closed(d: DerivationState): boolean;
+/** THE LAW, evaluated once.
+ *
+ *  Returns the spans the transition accounts for — the witness that lets it be
+ *  taken — or `null` when it is inadmissible.  Evaluating it once and advancing
+ *  the state with {@link advance} is the whole of a transition; asking twice for
+ *  the same pair would repeat the scan, which this module must not make anyone
+ *  do.
+ *
+ *      ¬FIXED  ∧  CONTAINS  ∧  ( CLOSED ∨ CARRIES ∨ MOVES )
+ *
+ *  Cost is not a term: it is the lattice order the market minimises over, and
+ *  neither is any budget — a cap decides with a number of work, this decides
+ *  with the remainder. */
+export declare function admissible(d: DerivationState, t: Continuation, query: Uint8Array, W: number): ReadonlyArray<Witness> | null;
+export declare function advance(d: DerivationState, t: Continuation, explains: ReadonlyArray<Witness>): DerivationState;
+/** What a layer offers the law: the next continuation of a state, or null when
+ *  it has none.  A layer OFFERS; the law disposes.
+ *
+ *  ONE OFFER, AND IT IS THE LAYER'S LAST: {@link closure} stops when the law
+ *  refuses what was offered, so a refusal is read as "no continuation exists".
+ *  A layer must not offer candidates one at a time and expect the walk to
+ *  continue after a refusal — its own fallbacks belong inside this function.
+ *  The producers do exactly that: they choose between the forward absorb and the
+ *  pivot before offering, and return null only when neither exists, which is why
+ *  the one offer the law can still refuse (a pivot without ownership, whose
+ *  material the answer does not carry) really is the last one. */
+export type Offer = (d: DerivationState) => Promise<Continuation | null>;
+/** THE CLOSURE — the walk of {@link advance} over the continuations `offer`
+ *  proposes, run until the layer has nothing further to offer or the law refuses
+ *  the one it offered.
+ *
+ *  ADMISSION is entirely the law's; TERMINATION is the layer's, and deliberately
+ *  so.  The remainder does not descend (draining it was implemented and refuted
+ *  — see the module note), so a walk cannot run forever only because the layer
+ *  offering continuations keeps its own cycle protection over a finite graph.
+ *  Nothing here counts steps, and nothing here decides admissibility. */
+export declare function closure(d: DerivationState, query: Uint8Array, W: number, offer: Offer, 
+/** Called for each step the law admits, with the state before and after. */
+onTaken?: (before: DerivationState, after: DerivationState) => void, 
+/** Called when the law refused the continuation the layer offered. */
+onRefused?: (at: DerivationState) => void): Promise<DerivationState>;