@hviana/sema 0.5.2 → 0.5.3

package/dist/src/mind/pipeline-mechanism.d.ts

@@ -1,8 +1,9 @@
 import type { AncestorReach, MindContext, Recognition } from "./types.js";
 import type { AttentionRead } from "./types.js";
 import type { ComputedSpan } from "../extension.js";
+import type { Hit } from "../store.js";
 import type { Vec } from "../vec.js";
-import { type GradedRun } from "./match.js";
+import { type FrameInstance, type GradedRun } from "./match.js";
 export declare class Precomputed {
     readonly ctx: MindContext;
     readonly query: Uint8Array;
@@ -52,6 +53,60 @@ export declare class Precomputed {
      *  which every later consumer then got free.  Attribution must follow the
      *  work, not the caller. */
     private shared;
+    private _resonance?;
+    /** The response's ONE top-k content-index read: the k learnt forms nearest
+     *  the whole-query gist, ranked.  Recall's every gist tier is built on it,
+     *  and {@link frames} assembles the frame inventory from it.
+     *
+     *  An ANN query is the single most expensive read in the engine, and two
+     *  mechanisms asking the same question of the same gist is the one
+     *  duplication a profile shows as doubled `annVectorReads` with nothing to
+     *  account for it.  Cached BY PROMISE, so a second caller awaits the first. */
+    resonance(): Promise<ReadonlyArray<Hit>>;
+    private _wide?;
+    /** The response's WIDE candidate list — the top-k when the query's gist has
+     *  no concept-level match anywhere, and an exhaustive √N read when it does.
+     *
+     *  Every mechanism that has to look PAST the top-k reads this one list: the
+     *  substitution bridge, prefix completion and the frame filler all did, and
+     *  it was memoised inside recall for exactly that reason (measured: 490 ms
+     *  median re-issued against 13 ms non-exhaustive, 36x).  A memo inside one
+     *  mechanism only serves that mechanism's own tiers, so it lives here now —
+     *  the same move `resonance` made for the top-k.
+     *
+     *  THE CONDITION IS THE TOP HIT'S SCORE, NOT THE CORPUS SIZE.  When nothing
+     *  ranks at concept level, an exhaustive ANN only scores more vectors below
+     *  the bar (profiled at 38K–40K annVectorReads per refusing query on a 325K-
+     *  context store); the structural channels — junction walks, anchor climbs,
+     *  the write side's window index — are the correct proposal source there,
+     *  because the ANN cannot propose what the gist cannot rank.  This was once
+     *  spelled `corpusN(ctx) <= (k · W)³`, which asks a different question and
+     *  answers it wrongly at exactly the scale it was written from: at N =
+     *  325,608 with k = 24 and W = 4 the cube is 884,736, so that store took the
+     *  exhaustive branch — the very branch measured above.  Measured cost of the
+     *  mismatch: substitutionBridge 8,544 ms of a 19,548 ms think (44%), against
+     *  1,248 ms and 14,218 ms without it, every answer byte-identical. */
+    wideResonance(): Promise<ReadonlyArray<number>>;
+    private _frames?;
+    /** THE FRAME INVENTORY — every ranked candidate that reads as an instance of
+     *  the same frame as the query, each with the query spans it leaves VARIABLE
+     *  ({@link FrameInstance}).  The one place the engine represents "a position
+     *  whose occupant comes from the context rather than the corpus".
+     *
+     *  AN INVENTORY, NOT AN ELECTION.  It reports every pairing and elects no
+     *  frame, deliberately: a slot is a property of a PAIRING, not of the query,
+     *  and different candidates put slots in different places.  Committing to one
+     *  reading here would push whichever consumer asked first onto everyone else
+     *  — the market's decoupling (§2.6) broken from inside the shared container,
+     *  and the population error §2.7 names.  Each consumer groups and commits
+     *  for its own question; reference elects the modal slot signature, and a
+     *  consumer wanting a different reading is not fighting this one.
+     *
+     *  NO LICENCE EITHER.  Knowing a span is variable is safe for every consumer
+     *  — it can only improve an alignment.  Knowing one may be VOICED through is
+     *  a different and much stronger claim, gated separately by
+     *  {@link carriesFillers}, which needs projections this must not perform. */
+    frames(): Promise<ReadonlyArray<FrameInstance>>;
     private _attention?;
     /** The full consensus climb (roots + ranked anchors) — the query-level
      *  evidence CAST, confluence, extraction, recall's scaffolding tier, and

package/dist/src/mind/pipeline-mechanism.js

@@ -13,12 +13,12 @@
 //   4. TRAVELING EVIDENCE — run() returns MechanismResult with accounted, moves,
 //      and unexplained.  The pipeline computes the weight.
 import { indexOf } from "../bytes.js";
-import { dominates } from "../geometry.js";
+import { conceptThreshold, dominates } from "../geometry.js";
 import { windowIds } from "./canonical.js";
 import { read, resolve } from "./primitives.js";
-import { alignGraded, skillExemplar } from "./match.js";
+import { alignGraded, frameSlots, skillExemplar, } from "./match.js";
 import { climbAttentionAll } from "./attention.js";
-import { sharedReachMemo } from "./traverse.js";
+import { hubBound, sharedReachMemo } from "./traverse.js";
 // ── Precomputed ──────────────────────────────────────────────────────────────
 //
 // Precomputed is a LAZY container for structural analyses of the query — the
@@ -116,6 +116,107 @@ export class Precomputed {
         const meter = this.ctx.meter;
         return meter ? meter.time(phase, fn) : fn();
     }
+    _resonance;
+    /** The response's ONE top-k content-index read: the k learnt forms nearest
+     *  the whole-query gist, ranked.  Recall's every gist tier is built on it,
+     *  and {@link frames} assembles the frame inventory from it.
+     *
+     *  An ANN query is the single most expensive read in the engine, and two
+     *  mechanisms asking the same question of the same gist is the one
+     *  duplication a profile shows as doubled `annVectorReads` with nothing to
+     *  account for it.  Cached BY PROMISE, so a second caller awaits the first. */
+    resonance() {
+        return this._resonance ??= this.shared("resonance", () => this.ctx.store.resonate(this.guide, this.k));
+    }
+    _wide;
+    /** The response's WIDE candidate list — the top-k when the query's gist has
+     *  no concept-level match anywhere, and an exhaustive √N read when it does.
+     *
+     *  Every mechanism that has to look PAST the top-k reads this one list: the
+     *  substitution bridge, prefix completion and the frame filler all did, and
+     *  it was memoised inside recall for exactly that reason (measured: 490 ms
+     *  median re-issued against 13 ms non-exhaustive, 36x).  A memo inside one
+     *  mechanism only serves that mechanism's own tiers, so it lives here now —
+     *  the same move `resonance` made for the top-k.
+     *
+     *  THE CONDITION IS THE TOP HIT'S SCORE, NOT THE CORPUS SIZE.  When nothing
+     *  ranks at concept level, an exhaustive ANN only scores more vectors below
+     *  the bar (profiled at 38K–40K annVectorReads per refusing query on a 325K-
+     *  context store); the structural channels — junction walks, anchor climbs,
+     *  the write side's window index — are the correct proposal source there,
+     *  because the ANN cannot propose what the gist cannot rank.  This was once
+     *  spelled `corpusN(ctx) <= (k · W)³`, which asks a different question and
+     *  answers it wrongly at exactly the scale it was written from: at N =
+     *  325,608 with k = 24 and W = 4 the cube is 884,736, so that store took the
+     *  exhaustive branch — the very branch measured above.  Measured cost of the
+     *  mismatch: substitutionBridge 8,544 ms of a 19,548 ms think (44%), against
+     *  1,248 ms and 14,218 ms without it, every answer byte-identical. */
+    wideResonance() {
+        return this._wide ??= this.shared("wideResonance", async () => {
+            const hits = await this.resonance();
+            if (hits.length > 0 &&
+                hits[0].score >= conceptThreshold(this.ctx.store.D)) {
+                const exhaustive = await this.ctx.store.resonate(this.guide, hubBound(this.ctx), true);
+                return exhaustive.map((h) => h.id);
+            }
+            return hits.map((h) => h.id);
+        });
+    }
+    _frames;
+    /** THE FRAME INVENTORY — every ranked candidate that reads as an instance of
+     *  the same frame as the query, each with the query spans it leaves VARIABLE
+     *  ({@link FrameInstance}).  The one place the engine represents "a position
+     *  whose occupant comes from the context rather than the corpus".
+     *
+     *  AN INVENTORY, NOT AN ELECTION.  It reports every pairing and elects no
+     *  frame, deliberately: a slot is a property of a PAIRING, not of the query,
+     *  and different candidates put slots in different places.  Committing to one
+     *  reading here would push whichever consumer asked first onto everyone else
+     *  — the market's decoupling (§2.6) broken from inside the shared container,
+     *  and the population error §2.7 names.  Each consumer groups and commits
+     *  for its own question; reference elects the modal slot signature, and a
+     *  consumer wanting a different reading is not fighting this one.
+     *
+     *  NO LICENCE EITHER.  Knowing a span is variable is safe for every consumer
+     *  — it can only improve an alignment.  Knowing one may be VOICED through is
+     *  a different and much stronger claim, gated separately by
+     *  {@link carriesFillers}, which needs projections this must not perform. */
+    frames() {
+        return this._frames ??= this.shared("frames", async () => {
+            const ctx = this.ctx;
+            const W = ctx.space.maxGroup;
+            // PHRASE SCALE, the same bound the bridge and the frame filler put on a
+            // candidate's bytes: a form an order of magnitude longer than the query
+            // is not a candidate for BEING it with a span replaced.
+            const capBytes = this.query.length * W;
+            const out = [];
+            for (const h of await this.resonance()) {
+                // REJECT BY LENGTH BEFORE RECONSTRUCTING (§2.8): `contentLen` is an
+                // indexed read, `bytesPrefix` rebuilds a subtree.  ONLY the phrase-scale
+                // cap is applied — it is a bounded-read discipline, not a judgement.
+                //
+                // A LOWER bound was here too (`dominates(len, query.length)`, on the
+                // reasoning that a candidate shorter than half the query cannot supply
+                // a frame that dominates it).  That is reference's gate wearing a cost
+                // argument's clothes, and it hid the very pairings another consumer
+                // needs: `What is the capital of France?` (30 B) against `What is the
+                // capital of the country where the Eiffel Tower is?` (61 B) was
+                // rejected before it was ever read — a definite description standing
+                // where a noun stands, which is exactly the shape the frame filler
+                // exists for.
+                const len = ctx.store.contentLen(h.id, capBytes + 1);
+                if (len === 0 || len > capBytes)
+                    continue;
+                const cand = ctx.store.bytesPrefix(h.id, capBytes + 1);
+                if (cand.length === 0 || cand.length > capBytes)
+                    continue;
+                const inst = frameSlots(ctx, this.query, cand, h.id);
+                if (inst !== null)
+                    out.push(inst);
+            }
+            return out;
+        });
+    }
     _attention;
     /** The full consensus climb (roots + ranked anchors) — the query-level
      *  evidence CAST, confluence, extraction, recall's scaffolding tier, and

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

@@ -3,7 +3,7 @@ import { type PipelineMechanism } from "./pipeline-mechanism.js";
 export { resolveConcepts, resolveConnectors } from "./mechanisms/cover.js";
 export { aluToMechanism } from "./mechanisms/alu.js";
 export declare const defaultMechanisms: PipelineMechanism[];
-export type Provenance = "cast" | "join" | "cover" | "extract" | "recall" | "recall-echo";
+export type Provenance = "cast" | "join" | "cover" | "extract" | "reference" | "recall" | "recall-echo" | "prefix";
 export interface Thought {
     bytes: Uint8Array;
     provenance: Provenance;

package/dist/src/mind/pipeline.js

@@ -20,6 +20,8 @@ import { coverMechanism } from "./mechanisms/cover.js";
 import { castMechanism } from "./mechanisms/cast.js";
 import { confluenceMechanism } from "./mechanisms/confluence.js";
 import { extractionMechanism } from "./mechanisms/extraction.js";
+import { referenceMechanism } from "./mechanisms/reference.js";
+import { prefixMechanism } from "./mechanisms/prefix-completion.js";
 import { recallMechanism } from "./mechanisms/recall.js";
 // Re-exports: cover's pre-resolution helpers and the ALU adapter kept
 // importable from the pipeline module (their historical home).
@@ -49,13 +51,23 @@ async function collectComputed(ctx, mechanisms, query) {
 // floor pruning every mechanism is already subject to — not by asking
 // "is this an extension?". Grade TIES keep the earlier candidate, so this
 // order is also the tie-break priority: cover, cast, confluence, extraction,
-// recall.
+// reference, recall.
+//
+// REFERENCE sits after extraction and before recall because that is what its
+// claim is worth: extraction READS a span out of the query (no synthesis),
+// reference voices one through a learnt slot, and recall's tiers degrade
+// toward echo and silence.  It does not PRUNE recall — its floor is two
+// projections, so recall's one-STEP floor still clears `worthRunning` — and it
+// is not meant to: both run, share one resonance read
+// (Precomputed.resonance), and the ladder decides.
 export const defaultMechanisms = [
     coverMechanism,
     castMechanism,
     confluenceMechanism,
     extractionMechanism,
+    referenceMechanism,
     recallMechanism,
+    prefixMechanism,
 ];
 /** Think: a single lightest-derivation exploration of the Sema graph.
  *

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

@@ -156,3 +156,41 @@ export declare function chooseAmong(ctx: MindContext, candidates: readonly numbe
  *  scaffolding-only — it has no evidence either way, and its callers already
  *  refuse it on their own terms. */
 export declare function allWindowsAreScaffolding(ctx: MindContext, query: Uint8Array): boolean;
+/** Trained forms the query may OPEN, proposed from the write side's own
+ *  leaf-id window index — the supply of last resort for prefix completion.
+ *
+ *  WHY A SECOND SUPPLY EXISTS.  The ranked list prefix completion normally reads
+ *  is a resonance list, and resonance cannot rank a proper prefix: measured on
+ *  the trained store, cos(prefix, form) falls from 0.9629 at a one-byte
+ *  truncation to 0.6206 at three bytes, against a reachThreshold of 0.8750.
+ *  Three bytes of truncation put the answer out of reach on GEOMETRY, not on a
+ *  bug, so no k and no re-ranking recovers it.
+ *
+ *  WHY THIS ROUTE WORKS WHERE THE FOLD DOES NOT.  A query's own fold is
+ *  useless here: content addressing is not phrase-position-invariant, so a
+ *  standalone prefix folds to a DIFFERENT node than the same bytes sitting
+ *  inside a longer deposit, and neither the prefix's own node nor its
+ *  ancestors lead to the deposit (measured: the 22-byte prefix of the
+ *  photosynthesis form resolves, is shared by 6 contexts, and does not have
+ *  the form among its ancestors).  Leaf ids ARE position-invariant — they are
+ *  content-addressed on single bytes — and `indexSubSpans` already interns a
+ *  flat branch over every canonical WINDOW of a deposit's leaf-id stream, with
+ *  containment edges to the chunks that window spans.  A query that is a
+ *  prefix therefore shares those window nodes exactly, and reaches the deposit
+ *  by climbing containment then parents.  Nothing is added to the write side;
+ *  this reads an index training already built.
+ *
+ *  BOUNDED (§2.8), AND WITH NO NEW THRESHOLD.  The window whose containment is
+ *  SMALLEST carries the most evidence, and one saturated at `hubBound` carries
+ *  none — that is the same √N reading of "hub" the rest of the mind uses, not
+ *  a tuned knob.  The upward walk spends a budget of `hubBound` nodes and
+ *  fans out by W, so a hub query enumerates nothing and the caller stays
+ *  silent rather than guessing (§2.13).  Measured on the trained store: the
+ *  photosynthesis form at a one-byte truncation picks a window with 52
+ *  containers, visits 446 nodes, and yields exactly ONE candidate that
+ *  survives the caller's byte compare — the form itself.
+ *
+ *  These are PROPOSALS only.  Every candidate still faces the byte-exact
+ *  prefix compare and all three guards below, so a wrong proposal costs one
+ *  bounded read and can never be voiced (§2.3). */
+export declare function formsOpenedBy(ctx: MindContext, query: Uint8Array): number[];

package/dist/src/mind/traverse.js

@@ -7,7 +7,7 @@
 // project) live in match.ts — the elementary match-and-project operation.
 import { cosine } from "../vec.js";
 import { gistOf, read } from "./primitives.js";
-import { leafIdRun } from "./canonical.js";
+import { canonicalWindows, leafIdPrefix, leafIdRun } from "./canonical.js";
 //
 // Budgeted on the same terms as the reach memo below (AGENTS §2.12): these
 // three maps are cleared on every write, but a long read-only session over a
@@ -714,3 +714,93 @@ export function allWindowsAreScaffolding(ctx, query) {
     }
     return sawOne;
 }
+// ── THE PREFIX SUPPLY ───────────────────────────────────────────────────────
+//
+// A RETRIEVAL capability, not a grounding one: "which trained forms does this
+// byte run OPEN?"  It lived inside a recall tier, which is the wrong altitude
+// — it reads the write side's own leaf-id window index and answers a question
+// about the STORE, so any mechanism may ask it.
+/** Trained forms the query may OPEN, proposed from the write side's own
+ *  leaf-id window index — the supply of last resort for prefix completion.
+ *
+ *  WHY A SECOND SUPPLY EXISTS.  The ranked list prefix completion normally reads
+ *  is a resonance list, and resonance cannot rank a proper prefix: measured on
+ *  the trained store, cos(prefix, form) falls from 0.9629 at a one-byte
+ *  truncation to 0.6206 at three bytes, against a reachThreshold of 0.8750.
+ *  Three bytes of truncation put the answer out of reach on GEOMETRY, not on a
+ *  bug, so no k and no re-ranking recovers it.
+ *
+ *  WHY THIS ROUTE WORKS WHERE THE FOLD DOES NOT.  A query's own fold is
+ *  useless here: content addressing is not phrase-position-invariant, so a
+ *  standalone prefix folds to a DIFFERENT node than the same bytes sitting
+ *  inside a longer deposit, and neither the prefix's own node nor its
+ *  ancestors lead to the deposit (measured: the 22-byte prefix of the
+ *  photosynthesis form resolves, is shared by 6 contexts, and does not have
+ *  the form among its ancestors).  Leaf ids ARE position-invariant — they are
+ *  content-addressed on single bytes — and `indexSubSpans` already interns a
+ *  flat branch over every canonical WINDOW of a deposit's leaf-id stream, with
+ *  containment edges to the chunks that window spans.  A query that is a
+ *  prefix therefore shares those window nodes exactly, and reaches the deposit
+ *  by climbing containment then parents.  Nothing is added to the write side;
+ *  this reads an index training already built.
+ *
+ *  BOUNDED (§2.8), AND WITH NO NEW THRESHOLD.  The window whose containment is
+ *  SMALLEST carries the most evidence, and one saturated at `hubBound` carries
+ *  none — that is the same √N reading of "hub" the rest of the mind uses, not
+ *  a tuned knob.  The upward walk spends a budget of `hubBound` nodes and
+ *  fans out by W, so a hub query enumerates nothing and the caller stays
+ *  silent rather than guessing (§2.13).  Measured on the trained store: the
+ *  photosynthesis form at a one-byte truncation picks a window with 52
+ *  containers, visits 446 nodes, and yields exactly ONE candidate that
+ *  survives the caller's byte compare — the form itself.
+ *
+ *  These are PROPOSALS only.  Every candidate still faces the byte-exact
+ *  prefix compare and all three guards below, so a wrong proposal costs one
+ *  bounded read and can never be voiced (§2.3). */
+export function formsOpenedBy(ctx, query) {
+    const store = ctx.store;
+    const W = ctx.space.maxGroup;
+    const run = leafIdPrefix(ctx, query);
+    // The widest canonical window is the most discriminative one the write side
+    // ever interned; a query too short to spell one carries no window evidence.
+    const len = canonicalWindows(W)[1];
+    if (run.length < len)
+        return [];
+    const bound = hubBound(ctx);
+    let best = null;
+    let bestN = 0;
+    for (let off = 0; off + len <= run.length; off++) {
+        const wid = store.findBranch(run.slice(off, off + len));
+        if (wid === null)
+            continue;
+        const n = store.containersSlice(wid, 0, bound).length;
+        // Empty says the window spans no chunk; saturated says it is a hub, whose
+        // containment discriminates nothing.  Neither is evidence.
+        if (n === 0 || n >= bound)
+            continue;
+        if (best === null || n < bestN) {
+            best = wid;
+            bestN = n;
+        }
+    }
+    if (best === null)
+        return [];
+    let frontier = store.containersSlice(best, 0, bound);
+    const seen = new Set(frontier);
+    let budget = bound;
+    while (frontier.length > 0 && budget > 0) {
+        const next = [];
+        for (const f of frontier) {
+            if (budget-- <= 0)
+                break;
+            for (const p of store.parentsFirst(f, W)) {
+                if (seen.has(p))
+                    continue;
+                seen.add(p);
+                next.push(p);
+            }
+        }
+        frontier = next;
+    }
+    return [...seen];
+}

package/dist/src/store.d.ts

@@ -533,15 +533,15 @@ export declare abstract class AbstractStore implements Store {
         vector: Float32Array;
     }>;
     /** Halo index write buffer — keyed by id so repeats within a batch coalesce. */
-    protected _haloBuffer: Map<number, Float32Array<ArrayBufferLike>>;
+    protected _haloBuffer: Map<NodeId, Float32Array>;
     /** Containment write buffer: child → new parents, merged on flush cadence. */
-    protected _containBuf: Map<number, Set<number>>;
+    protected _containBuf: Map<NodeId, Set<NodeId>>;
     /** Dedup-target candidates still in the write buffer (keyed by id).  Only
      *  roots that have gained an edge/halo are targets; a fresh intermediate
      *  branch is never folded onto. */
-    protected _nearDedupBuf: Map<number, Float32Array<ArrayBufferLike>>;
+    protected _nearDedupBuf: Map<NodeId, Float32Array>;
     /** Ids currently in `_contentBuffer` (not yet flushed) — O(1) membership. */
-    protected _bufferedIds: Set<number>;
+    protected _bufferedIds: Set<NodeId>;
     /** {@link Store.chainRun} results, valid for the store's lifetime BETWEEN
      *  writes: a chain is a pure function of the kid and edge tables, so any
      *  write that could break a node's transparency (a fresh mint inserting kid

package/jsr.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://jsr.io/schema/config-file.v1.json",
+  "name": "@hviana/sema",
+  "version": "0.5.3",
+  "exports": "./src/index.ts"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/mind/bridge.ts

@@ -105,16 +105,13 @@ import {
 } from "./traverse.js";
 import { rItem, rNode } from "./trace.js";
 import { junctionContainersFrom } from "./junction.js";
-import { spanHalo } from "./match.js";
+import { alignAround, type AlignGap, spanHalo } from "./match.js";
 
 /** One accepted substitution: query span [qs,qe) stands in for the
- *  candidate context's span — recorded for the rationale trace. */
-interface Substitution {
-  qs: number;
-  qe: number;
-  cs: number;
-  ce: number;
-}
+ *  candidate context's span — recorded for the rationale trace.  The same
+ *  shape the shared aligner reports a disagreement as ({@link AlignGap}); an
+ *  accepted substitution is a gap that cleared this file's gates. */
+type Substitution = AlignGap;
 
 /** A bridged grounding proposal: the trained context to ground, the query
  *  spans its alignment accounts for, and the substitutions that closed it. */
@@ -151,102 +148,11 @@ export function dismissedKnownContent(
   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: MindContext,
-  q: Uint8Array,
-  c: Uint8Array,
-  qo: number,
-  co: number,
-): { matched: Array<[number, number]>; gaps: Substitution[] } {
-  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: Array<[number, number]> = [[qs, qe]];
-  const gaps: Substitution[] = [];
-  // 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: number, si: number): number => {
-    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. */