@hviana/sema 0.5.2 → 0.5.3

package/dist/src/mind/bridge.js

@@ -97,7 +97,7 @@ import { chainReach, leafIdRun } from "./canonical.js";
 import { allWindowsAreScaffolding, corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "./traverse.js";
 import { rItem, rNode } from "./trace.js";
 import { junctionContainersFrom } from "./junction.js";
-import { spanHalo } from "./match.js";
+import { alignAround, spanHalo } from "./match.js";
 /** True when some query byte-range left UNACCOUNTED by `spans` contains a
  *  STORED window — content the store has seen that the proposed reading
  *  simply ignores.  The IGNORED-KNOWN principle: a span may be dismissed
@@ -121,102 +121,11 @@ export function dismissedKnownContent(ctx, query, spans) {
     }
     return false;
 }
-/** Extend a seed match (query offset qo ↔ candidate offset co) to its
- *  maximal common run, then walk outward in both directions collecting
- *  further common runs of at least W bytes across bounded mismatch gaps
- *  (each side ≤ chainReach).  Returns the matched query spans and the
- *  mismatch pairs between consecutive runs. */
-function align(ctx, q, c, qo, co) {
-    const W = ctx.space.maxGroup;
-    const reachCap = chainReach(W);
-    // Maximal run around the seed.
-    let qs = qo, ss = co;
-    while (qs > 0 && ss > 0 && q[qs - 1] === c[ss - 1]) {
-        qs--;
-        ss--;
-    }
-    let qe = qo, se = co;
-    while (qe < q.length && se < c.length && q[qe] === c[se]) {
-        qe++;
-        se++;
-    }
-    const matched = [[qs, qe]];
-    const gaps = [];
-    // The next common run of ≥ W bytes past (qi, si), with each side's gap
-    // bounded by chainReach; smallest total gap wins (nearest continuation).
-    const runLenAt = (qi, si) => {
-        let n = 0;
-        while (qi + n < q.length && si + n < c.length && q[qi + n] === c[si + n]) {
-            n++;
-        }
-        return n;
-    };
-    // RIGHT sweep.
-    let qi = qe, si = se;
-    for (;;) {
-        let found = false;
-        for (let total = 1; total <= 2 * reachCap && !found; total++) {
-            for (let gq = 0; gq <= Math.min(total, reachCap); gq++) {
-                const gs = total - gq;
-                if (gs > reachCap)
-                    continue;
-                if (qi + gq >= q.length || si + gs >= c.length)
-                    continue;
-                const n = runLenAt(qi + gq, si + gs);
-                if (n >= W || qi + gq + n === q.length) {
-                    if (n === 0)
-                        continue;
-                    if (gq > 0 || gs > 0) {
-                        gaps.push({ qs: qi, qe: qi + gq, cs: si, ce: si + gs });
-                    }
-                    matched.push([qi + gq, qi + gq + n]);
-                    qi = qi + gq + n;
-                    si = si + gs + n;
-                    found = true;
-                    break;
-                }
-            }
-        }
-        if (!found)
-            break;
-    }
-    // LEFT sweep (mirror).
-    qi = qs;
-    si = ss;
-    for (;;) {
-        let found = false;
-        for (let total = 1; total <= 2 * reachCap && !found; total++) {
-            for (let gq = 0; gq <= Math.min(total, reachCap); gq++) {
-                const gs = total - gq;
-                if (gs > reachCap)
-                    continue;
-                if (qi - gq <= 0 || si - gs <= 0)
-                    continue;
-                // Run ENDING at (qi - gq, si - gs).
-                let n = 0;
-                while (n < qi - gq && n < si - gs &&
-                    q[qi - gq - 1 - n] === c[si - gs - 1 - n]) {
-                    n++;
-                }
-                if (n >= W || n === qi - gq) {
-                    if (n === 0)
-                        continue;
-                    if (gq > 0 || gs > 0) {
-                        gaps.push({ qs: qi - gq, qe: qi, cs: si - gs, ce: si });
-                    }
-                    matched.push([qi - gq - n, qi - gq]);
-                    qi = qi - gq - n;
-                    si = si - gs - n;
-                    found = true;
-                    break;
-                }
-            }
-        }
-        if (!found)
-            break;
-    }
-    return { matched, gaps };
-}
+// The seeded aligner this file used to own now lives in the shared match
+// family as {@link alignAround} — the frame reading (match.ts) reads the same
+// gaps and asks the OPPOSITE question of them (see AlignGap's own doc).  Two
+// consumers, one definition (AGENTS §2.5); the bridge's reading is unchanged.
+const align = alignAround;
 /** Recall's corroborated-substitution bridge — see the module comment.
  *  Returns the best bridged grounding proposal, or null. */
 /** `proposed` is a THUNK, not a list: the bridge's own cheap gates (the

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

@@ -57,6 +57,165 @@ export interface GradedRun {
  *  (optional — when absent, only literal alignment fires and graded degrades
  *  to the original behaviour).  Context sites are recognised internally. */
 export declare function alignGraded(ctx: MindContext, query: Uint8Array, contextBytes: Uint8Array, querySites?: ReadonlyArray<Site>): GradedRun[];
+/** One place two byte streams DISAGREE, between runs where they agree: the
+ *  query span `[qs,qe)` standing where the candidate's `[cs,ce)` stands.
+ *
+ *  Two mechanisms read the same gap and ask OPPOSITE questions of it, which is
+ *  why the shape lives here rather than in either of them:
+ *
+ *    • the substitution bridge asks whether the two sides MEAN THE SAME, and
+ *      so EXPANDS the gap (absorbing flanking matched bytes) until the query
+ *      side is corpus-attested and the pair clears the concept bar;
+ *    • the frame reading asks WHERE THE SLOT IS, and so CONTRACTS it
+ *      ({@link contractGap}) until the two sides share nothing at all.
+ *
+ *  Neither reading is derivable from the other, and both need the same gap. */
+export interface AlignGap {
+    qs: number;
+    qe: number;
+    cs: number;
+    ce: number;
+}
+/** Extend a seed match (query offset qo ↔ candidate offset co) to its maximal
+ *  common run, then walk outward in both directions collecting further common
+ *  runs of at least W bytes across bounded mismatch gaps (each side ≤
+ *  chainReach).  Returns the matched query spans and the mismatch pairs
+ *  between consecutive runs.
+ *
+ *  This is the SEEDED aligner, distinct from {@link alignRuns}: that one finds
+ *  every run two structures share anywhere (a weave), this one reads two
+ *  streams as ONE structure that diverges in bounded places (a frame with
+ *  slots).
+ *
+ *  Gaps come back in SWEEP order (right sweep, then left), not query order,
+ *  and only the INTERIOR ones are reported — a consumer that needs the query's
+ *  unmatched head or tail derives it from `matched`.  Both are the bridge's
+ *  contract, which prices its edges separately (see its matchStart/matchEnd
+ *  window test); {@link frameSlots} takes the other reading. */
+export declare function alignAround(ctx: MindContext, q: Uint8Array, c: Uint8Array, qo: number, co: number): {
+    matched: Array<[number, number]>;
+    gaps: AlignGap[];
+};
+/** Contract a gap to its VARYING CORE: strip the prefix and suffix the two
+ *  sides share.  {@link alignAround} cannot match a shared affix shorter than
+ *  W, so that affix lands INSIDE the gap — measured, the slot of
+ *  `How do I compile main.c?` against `…hello.c?` comes back as
+ *  `main.c?`/`hello.c?`, three bytes of which (`.c?`) both sides hold.
+ *
+ *  Splicing the uncontracted gap carries the query's own punctuation into the
+ *  answer; worse, it hides what actually VARIES, which is the only thing a
+ *  cohort can agree about.  Returns null when nothing is left on either side —
+ *  a pure insertion or deletion, which names no slot. */
+export declare function contractGap(q: Uint8Array, c: Uint8Array, g: AlignGap): AlignGap | null;
+/** What one place two streams disagree IS, once contracted to its varying
+ *  core.  A consumer decides which kinds it can use; the matcher only reports.
+ *
+ *    substitution  both sides carry bytes — one thing stands where another does
+ *    insertion     the query carries bytes the candidate does not
+ *    deletion      the candidate carries bytes the query does not */
+export type SlotKind = "substitution" | "insertion" | "deletion";
+/** One VARIABLE POSITION of a pairing: where the query and a candidate differ,
+ *  contracted to the bytes that actually vary. */
+export interface FrameSlot {
+    /** Query span (empty for a deletion). */
+    qs: number;
+    qe: number;
+    /** Candidate span (empty for an insertion). */
+    cs: number;
+    ce: number;
+    kind: SlotKind;
+    /** The candidate's own bytes here — empty for an insertion. */
+    filler: Uint8Array;
+}
+/** One trained context read against the query as ONE structure with variable
+ *  positions.
+ *
+ *  EVERYTHING THE ALIGNER SAW, NOTHING JUDGED.  `slots` holds every place the
+ *  pairing varies, in query order, whatever its kind or size, and `covered`
+ *  says how much of the query the two hold in common.  No gate is applied
+ *  here — see {@link frameSlots}. */
+export interface FrameInstance {
+    /** The trained context this reading is against. */
+    id: number;
+    /** Every variable position, in query order. */
+    slots: FrameSlot[];
+    /** Query spans the pairing literally matched — the frame itself. */
+    matched: Array<[number, number]>;
+    /** Query bytes the frame accounts for: the size of what is shared. */
+    covered: number;
+}
+/** THE SLOT MATCHER: read one query ↔ context pairing as one structure with
+ *  variable positions.
+ *
+ *  IT REPORTS; IT DOES NOT JUDGE.  This returns every gap the aligner found,
+ *  contracted to its varying core and tagged with its kind, plus the shared
+ *  coverage — and rejects nothing.  That is the whole point of the split, and
+ *  it was got WRONG first: four VOICING gates (the frame must dominate the
+ *  query, each slot must reach one window on both sides, an insertion or
+ *  deletion disqualifies the pairing, fillers must be pairwise distinct) were
+ *  applied here, and every one of them is a requirement for SUBSTITUTING AND
+ *  SPEAKING, not for knowing where a pairing varies.  With them in place the
+ *  shared reading was reference-shaped: measured over four real pairings, three
+ *  were hidden from every consumer —
+ *
+ *    `What is the capital of the country where the Eiffel Tower is?`
+ *        against `What is the capital of France?`  (covered 23/61)  HIDDEN
+ *    `What is the capital of France, really?`      (an insertion)   HIDDEN
+ *    `What is the capital of Fran?`                (sub-window)     HIDDEN
+ *
+ *  — including the case of the one consumer that most obviously needed it.  A
+ *  shared layer with one usable consumer is private code at a public address.
+ *  Each gate now lives with the mechanism that needs it (see reference.ts).
+ *
+ *  Seeded at the origin, because a frame is shared structure the query and its
+ *  instances both OPEN with: the maximal run around (0,0) is the frame's head
+ *  and the sweeps find the rest.
+ *
+ *  Null only for a degenerate pairing (either side empty). */
+export declare function frameSlots(ctx: MindContext, query: Uint8Array, cand: Uint8Array, id: number): FrameInstance | null;
+/** Whether every member is byte-distinct from the others. */
+export declare function distinct(items: readonly Uint8Array[]): boolean;
+/** Substitute every `needle -> repl` pair SIMULTANEOUSLY: one left-to-right
+ *  pass, longest needle first at each position, and a replacement is never
+ *  re-examined.
+ *
+ *  SIMULTANEOUS IS NOT A DETAIL.  Applying the pairs in sequence lets one
+ *  substitution's OUTPUT be another's input: with slots `gcc -> zig` and
+ *  `hello.c -> zig.c` a sequential pass rewrites bytes it had just written,
+ *  and the result depends on the order the slots happened to be found in.
+ *  Longest-first at each position makes the pass independent of pair order,
+ *  which is what keeps {@link carriesFillers} and the binding it licenses the
+ *  SAME operation — if they could disagree, the licence would not be testing
+ *  what is voiced. */
+export declare function substituteAll(hay: Uint8Array, pairs: ReadonlyArray<{
+    needle: Uint8Array;
+    repl: Uint8Array;
+}>): Uint8Array;
+/** THE CARRIAGE LICENCE — the gate that decides whether a slot may be VOICED
+ *  through.  Given two instances of one frame and what each one continues to,
+ *  it asks one byte question:
+ *
+ *      substituteAll(contA, fillersA -> fillersB) == contB
+ *
+ *  When it holds, the corpus attests byte-exactly that the continuation is a
+ *  function of the fillers and nothing else, so putting a NEW occupant through
+ *  the same carriage is derivation rather than invention.  No threshold, no
+ *  similarity, no new constant: the store's own instances decide, exactly as
+ *  the bridge's `unanimous` decides whether a frame is a value slot.
+ *
+ *  Its FAILURE is what this is really for.  A frame whose continuation carries
+ *  filler-DEPENDENT content — `What is the capital of X?` answering a different
+ *  city per X — fails it, and that failure is the only thing between a slot
+ *  and an invented fact.  Measured on the trained 15.7M-node store (325,615
+ *  contexts): `What is the capital of Zamunda?` resonates to a PURE cohort,
+ *  every one of the top 14 hits an instance of that frame, with an unambiguous
+ *  slot; every structural gate passes and only this one refuses, on
+ *  `replace("Tokyo", "Japan" -> "France") != "Paris"`.
+ *
+ *  With SEVERAL slots the test is unchanged, which is the point of testing the
+ *  whole substitution at once: a frame whose answer tracks one slot but
+ *  invents around another fails exactly as a single-slot value slot does. */
+export declare function carriesFillers(contA: Uint8Array, fillersA: readonly Uint8Array[], contB: Uint8Array, fillersB: readonly Uint8Array[]): boolean;
 /** The IN-LIST halo matcher: the best halo-mate for `halo` among EXPLICIT
  *  candidates, above the concept threshold — the list counterpart of
  *  {@link haloSiblings}, which asks the halo INDEX for candidates instead.

package/dist/src/mind/match.js

@@ -18,16 +18,21 @@
 //                       direct or mutual-sibling)
 //   multi-hop pivot     byte containment               forward       —
 //   articulation        halo sibling                   substitute    conceptThreshold
+//   reference           frameSlots() (the shared       carry into    carriesFillers
+//                       aligner, gaps contracted)      the answer
 //
 // This module holds the shared vocabulary those configurations are built
-// from — the MATCHERS (locate, alignRuns, alignGraded, analogyStrength) and
-// the PROJECTIONS (follow, conceptHop, reverseContext, project) — so each
-// mechanism file states only its configuration, never its own copy of the
-// machinery.  The gates all live in geometry.ts (derived, never tuned).
+// from — the MATCHERS (locate, alignRuns, alignGraded, alignAround/frameSlots,
+// analogyStrength) and the PROJECTIONS (follow, conceptHop, reverseContext,
+// project) — so each mechanism file states only its configuration, never its
+// own copy of the machinery.  Most gates live in geometry.ts (derived, never
+// tuned); the two STRUCTURAL gates that are byte predicates rather than
+// thresholds — isSpanShaped and carriesFillers — live here beside the matchers
+// they gate.
 import { addInto, cosine, dot, normalize, zeros } from "../vec.js";
-import { conceptThreshold, identityBar, significanceBar } from "../geometry.js";
-import { indexOf } from "../bytes.js";
-import { leafIdRun } from "./canonical.js";
+import { conceptThreshold, identityBar, significanceBar, } from "../geometry.js";
+import { bytesEqual, indexOf } from "../bytes.js";
+import { chainReach, leafIdRun } from "./canonical.js";
 import { foldTree, gistOf, perceive, read, resolve } from "./primitives.js";
 import { argmaxCosine, chooseAmong, chooseNext, corpusN, edgeAncestors, guidedFirst, hubBound, hubCap, sharedReachMemo, } from "./traverse.js";
 import { recognise, segment } from "./recognition.js";
@@ -230,6 +235,294 @@ export function alignGraded(ctx, query, contextBytes, querySites) {
     out.sort((a, b) => a.qs - b.qs);
     return out;
 }
+/** Extend a seed match (query offset qo ↔ candidate offset co) to its maximal
+ *  common run, then walk outward in both directions collecting further common
+ *  runs of at least W bytes across bounded mismatch gaps (each side ≤
+ *  chainReach).  Returns the matched query spans and the mismatch pairs
+ *  between consecutive runs.
+ *
+ *  This is the SEEDED aligner, distinct from {@link alignRuns}: that one finds
+ *  every run two structures share anywhere (a weave), this one reads two
+ *  streams as ONE structure that diverges in bounded places (a frame with
+ *  slots).
+ *
+ *  Gaps come back in SWEEP order (right sweep, then left), not query order,
+ *  and only the INTERIOR ones are reported — a consumer that needs the query's
+ *  unmatched head or tail derives it from `matched`.  Both are the bridge's
+ *  contract, which prices its edges separately (see its matchStart/matchEnd
+ *  window test); {@link frameSlots} takes the other reading. */
+export function alignAround(ctx, q, c, qo, co) {
+    const W = ctx.space.maxGroup;
+    const reachCap = chainReach(W);
+    // Maximal run around the seed.
+    let qs = qo, ss = co;
+    while (qs > 0 && ss > 0 && q[qs - 1] === c[ss - 1]) {
+        qs--;
+        ss--;
+    }
+    let qe = qo, se = co;
+    while (qe < q.length && se < c.length && q[qe] === c[se]) {
+        qe++;
+        se++;
+    }
+    const matched = [[qs, qe]];
+    const gaps = [];
+    // The next common run of ≥ W bytes past (qi, si), with each side's gap
+    // bounded by chainReach; smallest total gap wins (nearest continuation).
+    const runLenAt = (qi, si) => {
+        let n = 0;
+        while (qi + n < q.length && si + n < c.length && q[qi + n] === c[si + n]) {
+            n++;
+        }
+        return n;
+    };
+    // RIGHT sweep.
+    let qi = qe, si = se;
+    for (;;) {
+        let found = false;
+        for (let total = 1; total <= 2 * reachCap && !found; total++) {
+            for (let gq = 0; gq <= Math.min(total, reachCap); gq++) {
+                const gs = total - gq;
+                if (gs > reachCap)
+                    continue;
+                if (qi + gq >= q.length || si + gs >= c.length)
+                    continue;
+                const n = runLenAt(qi + gq, si + gs);
+                if (n >= W || qi + gq + n === q.length) {
+                    if (n === 0)
+                        continue;
+                    if (gq > 0 || gs > 0) {
+                        gaps.push({ qs: qi, qe: qi + gq, cs: si, ce: si + gs });
+                    }
+                    matched.push([qi + gq, qi + gq + n]);
+                    qi = qi + gq + n;
+                    si = si + gs + n;
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found)
+            break;
+    }
+    // LEFT sweep (mirror).
+    qi = qs;
+    si = ss;
+    for (;;) {
+        let found = false;
+        for (let total = 1; total <= 2 * reachCap && !found; total++) {
+            for (let gq = 0; gq <= Math.min(total, reachCap); gq++) {
+                const gs = total - gq;
+                if (gs > reachCap)
+                    continue;
+                if (qi - gq <= 0 || si - gs <= 0)
+                    continue;
+                // Run ENDING at (qi - gq, si - gs).
+                let n = 0;
+                while (n < qi - gq && n < si - gs &&
+                    q[qi - gq - 1 - n] === c[si - gs - 1 - n]) {
+                    n++;
+                }
+                if (n >= W || n === qi - gq) {
+                    if (n === 0)
+                        continue;
+                    if (gq > 0 || gs > 0) {
+                        gaps.push({ qs: qi - gq, qe: qi, cs: si - gs, ce: si });
+                    }
+                    matched.push([qi - gq - n, qi - gq]);
+                    qi = qi - gq - n;
+                    si = si - gs - n;
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found)
+            break;
+    }
+    return { matched, gaps };
+}
+/** Contract a gap to its VARYING CORE: strip the prefix and suffix the two
+ *  sides share.  {@link alignAround} cannot match a shared affix shorter than
+ *  W, so that affix lands INSIDE the gap — measured, the slot of
+ *  `How do I compile main.c?` against `…hello.c?` comes back as
+ *  `main.c?`/`hello.c?`, three bytes of which (`.c?`) both sides hold.
+ *
+ *  Splicing the uncontracted gap carries the query's own punctuation into the
+ *  answer; worse, it hides what actually VARIES, which is the only thing a
+ *  cohort can agree about.  Returns null when nothing is left on either side —
+ *  a pure insertion or deletion, which names no slot. */
+export function contractGap(q, c, g) {
+    let { qs, qe, cs, ce } = g;
+    while (qs < qe && cs < ce && q[qs] === c[cs]) {
+        qs++;
+        cs++;
+    }
+    while (qe > qs && ce > cs && q[qe - 1] === c[ce - 1]) {
+        qe--;
+        ce--;
+    }
+    return qe > qs && ce > cs ? { qs, qe, cs, ce } : null;
+}
+/** THE SLOT MATCHER: read one query ↔ context pairing as one structure with
+ *  variable positions.
+ *
+ *  IT REPORTS; IT DOES NOT JUDGE.  This returns every gap the aligner found,
+ *  contracted to its varying core and tagged with its kind, plus the shared
+ *  coverage — and rejects nothing.  That is the whole point of the split, and
+ *  it was got WRONG first: four VOICING gates (the frame must dominate the
+ *  query, each slot must reach one window on both sides, an insertion or
+ *  deletion disqualifies the pairing, fillers must be pairwise distinct) were
+ *  applied here, and every one of them is a requirement for SUBSTITUTING AND
+ *  SPEAKING, not for knowing where a pairing varies.  With them in place the
+ *  shared reading was reference-shaped: measured over four real pairings, three
+ *  were hidden from every consumer —
+ *
+ *    `What is the capital of the country where the Eiffel Tower is?`
+ *        against `What is the capital of France?`  (covered 23/61)  HIDDEN
+ *    `What is the capital of France, really?`      (an insertion)   HIDDEN
+ *    `What is the capital of Fran?`                (sub-window)     HIDDEN
+ *
+ *  — including the case of the one consumer that most obviously needed it.  A
+ *  shared layer with one usable consumer is private code at a public address.
+ *  Each gate now lives with the mechanism that needs it (see reference.ts).
+ *
+ *  Seeded at the origin, because a frame is shared structure the query and its
+ *  instances both OPEN with: the maximal run around (0,0) is the frame's head
+ *  and the sweeps find the rest.
+ *
+ *  Null only for a degenerate pairing (either side empty). */
+export function frameSlots(ctx, query, cand, id) {
+    if (query.length === 0 || cand.length === 0)
+        return null;
+    const { matched, gaps } = alignAround(ctx, query, cand, 0, 0);
+    const spans = [...matched].sort((a, b) => a[0] - b[0]);
+    // Where the alignment RAN OUT on each side.  Seeded at the origin there is
+    // no leading gap, so both cursors are everything consumed so far: the
+    // matched runs (equal length on both sides by construction) plus what each
+    // interior gap ate of its own side.  Counting only the runs reads the
+    // candidate cursor short by exactly the fillers already seen, and invents a
+    // trailing gap on every well-aligned instance.
+    const all = [...gaps];
+    let qEnd = 0, cEnd = 0;
+    for (const [s, e] of spans) {
+        cEnd += e - s;
+        qEnd = Math.max(qEnd, e);
+    }
+    for (const g of gaps)
+        cEnd += g.ce - g.cs;
+    if (qEnd < query.length || cEnd < cand.length) {
+        all.push({ qs: qEnd, qe: query.length, cs: cEnd, ce: cand.length });
+    }
+    const slots = [];
+    for (const gap of all.sort((a, b) => a.qs - b.qs)) {
+        if (gap.qe <= gap.qs && gap.ce <= gap.cs)
+            continue;
+        // Contract to the varying core.  contractGap returns null when one side is
+        // wholly shared with the other — a pure insertion or deletion, which is a
+        // real variation and is reported AS ONE, not discarded.
+        const core = contractGap(query, cand, gap);
+        const g = core ?? gap;
+        const kind = g.qe > g.qs && g.ce > g.cs
+            ? "substitution"
+            : g.qe > g.qs
+                ? "insertion"
+                : "deletion";
+        slots.push({
+            qs: g.qs,
+            qe: g.qe,
+            cs: g.cs,
+            ce: g.ce,
+            kind,
+            filler: cand.slice(g.cs, g.ce),
+        });
+    }
+    const covered = spans.reduce((n, [s, e]) => n + e - s, 0);
+    return { id, slots, matched: spans, covered };
+}
+/** Whether every member is byte-distinct from the others. */
+export function distinct(items) {
+    for (let i = 0; i < items.length; i++) {
+        for (let j = i + 1; j < items.length; j++) {
+            if (bytesEqual(items[i], items[j]))
+                return false;
+        }
+    }
+    return true;
+}
+/** Substitute every `needle -> repl` pair SIMULTANEOUSLY: one left-to-right
+ *  pass, longest needle first at each position, and a replacement is never
+ *  re-examined.
+ *
+ *  SIMULTANEOUS IS NOT A DETAIL.  Applying the pairs in sequence lets one
+ *  substitution's OUTPUT be another's input: with slots `gcc -> zig` and
+ *  `hello.c -> zig.c` a sequential pass rewrites bytes it had just written,
+ *  and the result depends on the order the slots happened to be found in.
+ *  Longest-first at each position makes the pass independent of pair order,
+ *  which is what keeps {@link carriesFillers} and the binding it licenses the
+ *  SAME operation — if they could disagree, the licence would not be testing
+ *  what is voiced. */
+export function substituteAll(hay, pairs) {
+    const usable = pairs.filter((p) => p.needle.length > 0);
+    if (usable.length === 0)
+        return hay;
+    // Longest needle first, so a needle that is a prefix of another can never
+    // pre-empt it.  Ties cannot arise: an instance whose fillers are not
+    // pairwise distinct is refused by frameSlots.
+    const order = [...usable].sort((a, b) => b.needle.length - a.needle.length);
+    const out = [];
+    let i = 0;
+    let hit = false;
+    outer: while (i < hay.length) {
+        for (const p of order) {
+            if (i + p.needle.length > hay.length)
+                continue;
+            let k = 0;
+            while (k < p.needle.length && hay[i + k] === p.needle[k])
+                k++;
+            if (k < p.needle.length)
+                continue;
+            for (const b of p.repl)
+                out.push(b);
+            i += p.needle.length;
+            hit = true;
+            continue outer;
+        }
+        out.push(hay[i]);
+        i++;
+    }
+    return hit ? Uint8Array.from(out) : hay;
+}
+/** THE CARRIAGE LICENCE — the gate that decides whether a slot may be VOICED
+ *  through.  Given two instances of one frame and what each one continues to,
+ *  it asks one byte question:
+ *
+ *      substituteAll(contA, fillersA -> fillersB) == contB
+ *
+ *  When it holds, the corpus attests byte-exactly that the continuation is a
+ *  function of the fillers and nothing else, so putting a NEW occupant through
+ *  the same carriage is derivation rather than invention.  No threshold, no
+ *  similarity, no new constant: the store's own instances decide, exactly as
+ *  the bridge's `unanimous` decides whether a frame is a value slot.
+ *
+ *  Its FAILURE is what this is really for.  A frame whose continuation carries
+ *  filler-DEPENDENT content — `What is the capital of X?` answering a different
+ *  city per X — fails it, and that failure is the only thing between a slot
+ *  and an invented fact.  Measured on the trained 15.7M-node store (325,615
+ *  contexts): `What is the capital of Zamunda?` resonates to a PURE cohort,
+ *  every one of the top 14 hits an instance of that frame, with an unambiguous
+ *  slot; every structural gate passes and only this one refuses, on
+ *  `replace("Tokyo", "Japan" -> "France") != "Paris"`.
+ *
+ *  With SEVERAL slots the test is unchanged, which is the point of testing the
+ *  whole substitution at once: a frame whose answer tracks one slot but
+ *  invents around another fails exactly as a single-slot value slot does. */
+export function carriesFillers(contA, fillersA, contB, fillersB) {
+    if (fillersA.length !== fillersB.length)
+        return false;
+    const projected = substituteAll(contA, fillersA.map((needle, s) => ({ needle, repl: fillersB[s] })));
+    return bytesEqual(projected, contB);
+}
 /** The IN-LIST halo matcher: the best halo-mate for `halo` among EXPLICIT
  *  candidates, above the concept threshold — the list counterpart of
  *  {@link haloSiblings}, which asks the halo INDEX for candidates instead.

package/dist/src/mind/mechanisms/prefix-completion.d.ts

@@ -0,0 +1,22 @@
+import type { MindContext } from "../types.js";
+import type { PipelineMechanism } from "../pipeline-mechanism.js";
+/** A trained form the query opens, and the bytes by which it continues. */
+export interface PrefixCompletion {
+    /** The trained form whose opening the query is — the answer, voiced whole. */
+    id: number;
+    /** The form's own bytes.  The mechanism grounds a FORM, never a slice of
+     *  one: slicing at the query's end would cut at an offset the geometry has
+     *  no reason to treat as a boundary. */
+    form: Uint8Array;
+    /** The bytes past the query — carried for the rationale and for the
+     *  uniqueness comparison, not voiced on its own. */
+    continuation: Uint8Array;
+}
+/** The sole trained form the query opens — or null when no candidate opens with
+ *  it, when the continuation is sub-quantum, when a candidate's continuation
+ *  cannot be read through, or when the candidates disagree.
+ *
+ *  `ranked` must be a list the caller has ALREADY fetched; this mechanism never
+ *  resonates on its own (see the header's cost note). */
+export declare function prefixCompletion(ctx: MindContext, query: Uint8Array, ranked: ReadonlyArray<number>): PrefixCompletion | null;
+export declare const prefixMechanism: PipelineMechanism;