@hviana/sema 0.8.1 → 0.8.2

package/dist/src/mind/graph-search.js

@@ -194,6 +194,13 @@ export class GraphSearch {
         this.maxGroup = maxGroup;
         this.host = host;
     }
+    /** The nodes the QUERY canonically names — the same identity the store's keys
+     *  were written through.  A byte-exact test is not enough: the query writes
+     *  `Eiffel Tower country` and the deposited node is `eiffel tower country`, so
+     *  a join that filters the query's own subject by RAW bytes re-admits it —
+     *  measured: that is the trap's wrong answer (`The capital of Eiffel Tower
+     *  country is Berlin.`).  Cached by query identity, because the search is
+     *  reused across responses. */
     /* * The hub bound √N (bounded-reads.md) — the ONE
      *  fan-out cap, stated here rather than imported from `traverse.ts` because
      *  this module is deliberately host-based (it holds a bare Store, never a
@@ -461,7 +468,7 @@ export class GraphSearch {
                     return this.coverRules(it, coversDone, coverableByStart);
                 }
                 if (it.kind === "form") {
-                    return this.formRules(it, conceptTarget, substitutions, nodeBytes);
+                    return this.formRules(it, conceptTarget, substitutions, nodeBytes, queryLen);
                 }
                 return this.outRules(it, {
                     W,
@@ -547,7 +554,7 @@ export class GraphSearch {
     }
     /** form(i,j,node,via): follow the graph out of `node`, or (in articulation)
      *  emit its substitute voice directly. */
-    *formRules(it, conceptTarget, substitutions, nodeBytes) {
+    *formRules(it, conceptTarget, substitutions, nodeBytes, queryLen) {
         // Articulation: emit voice bytes at the recognised span; the hop/concept/
         // emit chain is suppressed — the form contributes only its substitute.
         if (substitutions) {
@@ -581,7 +588,46 @@ export class GraphSearch {
             // guard then dead-ends it) with no way to reach the forward edge.
             // Forking offers every continuation as its own rule so the one that
             // genuinely advances (not a duplicate) is still reachable.
+            // A CHAIN HOP OFFERS ONLY WHAT THE QUESTION CAN PAY FOR.
+            //
+            // `hubBound` = √N is the READ cap — every read here stays inside it — but
+            // it is not an exploration bound: measured, a hub of degree 1083 sits
+            // BELOW √N = 1559, so a hop offered all 1083 continuations, the chart grew
+            // to 3113 outs for a two-word question, and since every out with an
+            // uncovered tail probes its tail's prefixes (measured: 16 885 canonical
+            // probes = 87% of that query's work, and its 270 MB peak / 256 MB OOM),
+            // the cost came from OFFERING rather than from reading.
+            //
+            // The bound is derived, not tuned: a derivation of L hops consumes ~L
+            // units of the question, so a hop cannot be paid for by offering more
+            // continuations than the question has units —
+            // `ceil(queryLen / W)`, floored at 2 for plurality. It is QUERY-sized
+            // (invariant 5: no per-query read grows with N) and it leaves `hubBound`
+            // and every read untouched.
+            // THE OFFER IS THE CORPUS'S OWN STRUCTURE, and the search pays for
+            // exploring it.  There is no offer cap here any more: the traversal cap I
+            // had put on this hop was a short-circuit — it bounded what a hop could
+            // OFFER instead of charging for it — and it was not needed.
+            //
+            // MEASURED in the regime where it used to bite (`hubBound = ceil(√N)`
+            // GREATER than the hub's degree — reached in a fixture by choosing the
+            // degree below √N, so the trained store is not needed): with the cap the
+            // offer was 8/9/9 continuations at degrees 35/70/120; without it, 52/84/120
+            // — and the WORK is LINEAR in the degree, not quadratic: pushes 262/296/332,
+            // perceptions 530/592/757, while the PEAK is identical with and without the
+            // cap (218/415/689 MB against 215/410/662) because it is set by the store,
+            // not by the fan-out.  What made this hop expensive was never the fan-out
+            // breadth: it was the per-offer work, two duplicate/oversized computations
+            // since removed (the per-offset canonical scan, and the tail scan now
+            // restricted to the fold's boundaries).
+            //
+            // The residual, stated: the trained store's hub (degree 1 083) is an
+            // EXTRAPOLATION from this linear shape, not a measurement.
             const nx = this.store.nextFirst(it.node, this.hubBound());
+            // Count what is OFFERED, not what was read: the evidence-preferred
+            // continuation is yielded too, even when it lies outside the cap.
+            if (this.host.meter)
+                this.host.meter.chainOffers += nx.length + 1;
             if (nx.length) {
                 // The SAME evidence-weighted disambiguation the first hop uses
                 // (below) identifies the most-corroborated continuation.  Yielding
@@ -590,10 +636,14 @@ export class GraphSearch {
                 // arrivals at an EQUAL cost (`cost < current`, strictly) — so
                 // among same-depth sibling forks that tie in cost, the
                 // evidence-backed edge wins deterministically, never by
-                // exploration-order luck.  `preferred`, when set, is necessarily
-                // an element of `nx` (chooseNext reads the identical hub-bounded
-                // set — see traverse.ts), so a plain skip-in-place suffices; no
-                // second array need be allocated to reorder it to the front.
+                // exploration-order luck.  `preferred` is NOT necessarily an element
+                // of `nx` any more: `nx` is the capped read above, while `chooseNext`
+                // reads its own hub-bounded set (see traverse.ts) — so the evidence
+                // pick may lie outside the cap, and it is still yielded FIRST on
+                // purpose.  The cap bounds what the hop EXPLORES; it must never make
+                // the evidence-ranked continuation unreachable, or the derivation the
+                // corpus corroborates would lose to exploration order.  Nothing is
+                // reallocated: `nx` is walked with a skip-in-place for the duplicate.
                 const preferred = nx.length > 1
                     ? this.host.chooseNext?.(it.node)
                     : undefined;
@@ -820,8 +870,46 @@ export class GraphSearch {
             // a deeper rewrite chain is made of.
             const rec = this.host.recogniseSpan(bytes);
             const kids = new Set(nrec.kids);
+            // THE NODE'S OWN KIDS ARE SITES BY STRUCTURE — recognition cannot be the
+            // only source.  A produced composite is decomposed by ITS OWN SHAPE, and
+            // at hub scale the recognition of a produced span returns the WHOLE while
+            // deliberately suppressing its atoms (the off-boundary suppression), so
+            // the kid filter below would admit nothing at all and the chain would end
+            // at the intermediate composite.  Measured on the chain
+            // `seed → "p q" → (p→r, q→s) → "r s" → "m n"`: below the flip it reaches
+            // "m n" with fuse+recompose, above it stops at "p q" — the trace shows
+            // `recognise("p q") ⇒ form "p q"` alone, no parts.
+            //
+            // Laying the node's kids out over its own bytes restores exactly the
+            // decomposition the node's tree already states; a kid recognition ALREADY
+            // offers is skipped, so below the flip the seed set is byte-identical to
+            // what it was.  The filter's guarantee is untouched: nothing beyond the
+            // node's own kids may enter.
+            const recognised = rec.sites.filter((s) => kids.has(s.payload));
+            // DEDUPED BY SPAN, not by payload.  A node whose kids repeat (`"abab"`
+            // folds as ["ab","ab"]) has TWO occurrences of the same node at different
+            // offsets; a payload-keyed set suppressed the structural site for BOTH, so
+            // the second occurrence had no site at all.  The set now holds the spans
+            // recognition already covers, and a structural site is added exactly when
+            // nothing covers that PLACE — O(1) lookups, no extra reads.
+            const seenSpans = new Set(recognised.map((s) => `${s.start}:${s.end}`));
+            const structural = [];
+            {
+                let off = 0;
+                for (const k of nrec.kids) {
+                    const len = this.store.bytesPrefix(k, ALL).length;
+                    if (!seenSpans.has(`${off}:${off + len}`) && len > 0) {
+                        structural.push({
+                            start: off,
+                            end: Math.min(off + len, bytes.length),
+                            payload: k,
+                        });
+                    }
+                    off += len;
+                }
+            }
             const solved = this.solve(bytes.length, {
-                sites: rec.sites.filter((s) => kids.has(s.payload)),
+                sites: [...recognised, ...structural],
                 leaves: rec.leaves,
                 splits: rec.splits,
                 starts: rec.starts,
@@ -892,6 +980,14 @@ export class GraphSearch {
         const tail = queryBytes.subarray(fact.j, queryLen);
         if (tail.length === 0)
             return;
+        // Report ONLY the invocations that could have joined: the search asks this
+        // rule for every finalized out with a node, which includes the one-byte
+        // outs the cover bridges with — measured, 68 refusals for a single
+        // 3-relation query, all of them letters.  A form shorter than one window is
+        // not a fact a join could travel through, so it is not a refusal worth
+        // reporting; W is the same line the rest of the mind draws between a chance
+        // overlap and a form.
+        const reportable = fact.bytes.length >= this.maxGroup;
         // The entity candidates are the forms the fact's own bytes CONTAIN — the
         // same recogniser the query went through, so the evidence standard is the
         // query's.  A byte atom is never a subject; the fact's own node is the span
@@ -900,10 +996,62 @@ export class GraphSearch {
         // LENDS it when it can (Mind does, with the response-scoped struct cache),
         // and a bare host falls back to the raw-store probe, so the search stays
         // host-based.
-        const leading = this.host.recogniseSpan(fact.bytes).sites.filter((s) => s.payload >= 0 && s.payload !== fact.node &&
-            (this.host.leadsSomewhere !== undefined
-                ? this.host.leadsSomewhere(s.payload)
-                : this.store.hasNext(s.payload) || this.store.hasHalo(s.payload)));
+        const factRec = this.host.recogniseSpan(fact.bytes);
+        const leads = (id) => this.host.leadsSomewhere !== undefined
+            ? this.host.leadsSomewhere(id)
+            : this.store.hasNext(id) || this.store.hasHalo(id);
+        // THE QUERY'S OWN SUBJECT, CANONICALLY.  The filter used raw bytes and the
+        // store's nodes are canonical, so `Eiffel Tower country` in the query did
+        // not match the deposited `eiffel tower country` — measured, that is the
+        // trap's wrong answer.
+        //
+        // TAKEN FROM THE RECOGNITION THE RESPONSE ALREADY COMPUTED — the host's
+        // `recogniseSpan`, the same surface the rest of this search uses — not from
+        // a second offset scan.  `canonicalQueryNodes` re-derived, per byte offset,
+        // what `recognise` had already resolved once per query (its memo is keyed by
+        // content), and that scan was the largest single cost the DIANOT join added:
+        // measured against the pre-change tree, the same fixture and the same test
+        // were 21 s slower with the scan than without it.  A recognised site IS a
+        // canonical node of the query that can lead somewhere, which is exactly the
+        // set this filter wants, and it costs nothing to read.
+        const queryNodes = new Set((this.host.recogniseSpan?.(queryBytes)?.sites ?? []).map((s) => s.payload));
+        // TWO SOURCES, ONE ADMISSION.  The recognition of a STORED WHOLE returns the
+        // whole and stops — measured: for `The director of Eva is Gustaf Molander.`
+        // it yields exactly ONE site, the fact's own node — so the entity a join
+        // exists for is never proposed.  The canonical fold is the second source,
+        // and the scan runs only for a FORM (≥ W: a one-byte out is not something to
+        // join through, and running it per letter measured 20-26 s in test/99).
+        const W = this.maxGroup;
+        const proposed = new Map();
+        // The SOURCE of each proposal travels with it: a refusal that names only the
+        // bytes leaves the next reader guessing which path proposed them — three
+        // attempts at the chained join were spent fixing paths that never produced
+        // the offending candidate.
+        const source = new Map();
+        for (const s of factRec.sites) {
+            if (s.payload >= 0 && leads(s.payload)) {
+                proposed.set(s.payload, this.store.bytesPrefix(s.payload, ALL));
+                source.set(s.payload, "recognised site");
+            }
+        }
+        if (this.host.canonResolve !== undefined && fact.bytes.length >= W) {
+            const canon = this.host.canonResolve.bind(this.host);
+            for (let start = 0; start < fact.bytes.length; start++) {
+                for (let end = fact.bytes.length; end - start >= W; end--) {
+                    const id = canon(fact.bytes.subarray(start, end));
+                    if (id === null)
+                        continue;
+                    if (leads(id)) {
+                        proposed.set(id, this.store.bytesPrefix(id, ALL));
+                        source.set(id, "canonical fold");
+                    }
+                    break; // the longest form at this offset wins
+                }
+            }
+        }
+        const leading = [...proposed]
+            .filter(([payload]) => payload !== fact.node && !queryNodes.has(payload))
+            .map(([payload, bytes]) => ({ payload, bytes }));
         // …then prefer the entity the query did NOT name, and the MAXIMAL one.  The
         // join exists to reach the subject the query never wrote, so:
         //   • a candidate the query already contains is the query's OWN subject, and
@@ -914,30 +1062,93 @@ export class GraphSearch {
         //     introduces ("Timur" must not win over "Timur Bekmambetov").
         // Byte work over bytes already read, and the pruning REMOVES the
         // resolve()/nextFirst() probes these candidates would have paid.
+        if (leading.length === 0) {
+            if (this.host.meter)
+                this.host.meter.joinNoEntity++;
+            if (reportable) {
+                // Report WHAT the recognition returned, not just that nothing led: the
+                // count and the first few site texts are the difference between "the
+                // fact was not recognised" and "it was recognised but nothing led".
+                const seen = factRec.sites.slice(0, 3).map((s) => this.store.bytesPrefix(s.payload, ALL));
+                this.host.reportSearch?.("deriveThroughMiss", [fact.bytes, tail, ...seen], `no entity inside the fact leads anywhere — ${factRec.sites.length} site(s) recognised inside it`);
+            }
+        }
         const candidates = leading
-            .map((s) => ({
-            payload: s.payload,
-            bytes: this.store.bytesPrefix(s.payload, ALL),
-        }))
-            .filter((c) => indexOf(queryBytes, c.bytes, 0) < 0)
             .filter((c, _i, all) => !all.some((o) => o.bytes.length > c.bytes.length && indexOf(o.bytes, c.bytes, 0) >= 0));
         for (const c of candidates) {
-            const key = this.host.resolve(concat2(c.bytes, tail));
-            if (key === null)
-                continue;
-            const nx = this.store.nextFirst(key, 1);
-            if (nx.length === 0)
+            // THE SHORTEST TAIL PREFIX WHOSE KEY ALSO LEADS SOMEWHERE.
+            //
+            // The conclusion covers only that prefix, so the rest of the tail stays
+            // for the step after — which is what CHAINING is (a whole-tail key
+            // consumed the whole remainder and made every join terminal: measured,
+            // `joinFired=0` on a three-relation query).
+            //
+            // A KEY THAT RESOLVES IS NOT ENOUGH.  Measured with a dry run of these
+            // very primitives: for the candidate `Sweden` the first tail prefix that
+            // resolves is `" "` — the key `Sweden ` (a trailing space) — and it leads
+            // NOWHERE (`nextFirst` = 0), so accepting it refused the join while the
+            // key that names the fact (`sweden capital`) sat one prefix further.  The
+            // loop therefore asks BOTH questions before accepting, and keeps looking
+            // otherwise.
+            //
+            // EXACT FIRST, THEN CANONICAL: the corpus holds both identities.
+            let key = null;
+            let used = 0;
+            // The continuation the accepted key leads to, carried out of the loop:
+            // the loop already HAD to read it to accept the key (a key that leads
+            // nowhere is not the relation), so re-reading it after the loop was a
+            // duplicate read and a branch that could never be taken.
+            let next = null;
+            let keyBytes = c.bytes;
+            // THE PREFIX ENDS ARE THE TAIL'S OWN FOLD BOUNDARIES, not every byte
+            // length.  The key is `entity + prefix`, and the prefix that names a
+            // stored relation ends where the fold cuts: measured over four join-firing
+            // queries, 5 of 5 accepted keys ended on a boundary (or the tail's end)
+            // while the byte-by-byte scan spent 153 probes where 14 boundaries would
+            // do.  Same criterion — resolves AND leads — same shortest-first order, so
+            // the answer is the same one the enumeration found; only the candidates
+            // come from the structure instead of from the byte count.  A host with no
+            // boundary rule falls back to the enumeration.
+            const cuts = this.host.contentCuts?.(tail);
+            const ends = cuts && cuts.length > 0
+                ? [...cuts.filter((c) => c > 0 && c < tail.length), tail.length]
+                : Array.from({ length: tail.length }, (_, i) => i + 1);
+            for (const len of ends) {
+                keyBytes = concat2(c.bytes, tail.subarray(0, len));
+                const k = this.host.resolve(keyBytes) ??
+                    this.host.canonResolve?.(keyBytes) ??
+                    null;
+                if (k === null)
+                    continue;
+                const nx = this.store.nextFirst(k, 1);
+                if (nx.length === 0)
+                    continue;
+                key = k;
+                used = len;
+                next = nx[0];
+                break;
+            }
+            if (key === null) {
+                if (this.host.meter)
+                    this.host.meter.joinNoKey++;
+                if (reportable) {
+                    this.host.reportSearch?.("deriveThroughMiss", [c.bytes, tail, keyBytes], `no learnt key names this entity and tail together ` +
+                        `(candidate #${c.payload}, from the ${source.get(c.payload) ?? "unknown"} source)`);
+                }
                 continue;
+            }
+            if (this.host.meter)
+                this.host.meter.joinFired++;
             yield {
                 premises: [fact],
                 conclusion: {
                     kind: "out",
                     i: fact.i,
-                    j: queryLen,
-                    bytes: this.store.bytesPrefix(nx[0], ALL),
+                    j: fact.j + used,
+                    bytes: this.store.bytesPrefix(next, ALL),
                     cover: true,
                     rec: true,
-                    node: nx[0],
+                    node: next,
                     throughFact: true,
                 },
                 cost: STEP,

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

@@ -1,5 +1,5 @@
 export { Mind } from "./mind.js";
-export type { Input, Response } from "./mind.js";
+export type { CorpusTextPair, CorpusTextResult, Input, Response, } from "./mind.js";
 export type { ComputedSpan, ExtensionHost } from "./mind.js";
 export type { MechanismResult, PipelineMechanism, Precomputed, } from "./pipeline-mechanism.js";
 export type { InspectRationale, RationaleItem, RationaleStep, } from "./rationale.js";
@@ -7,3 +7,5 @@ export type { AnchorRejectionReason, ClimbConsensusData, ConsensusAnchorTrace, C
 export type { AncestorReach, AttentionRead, SaturationReason, SaturationStop, } from "./types.js";
 export type { DepositReport } from "./learning.js";
 export type { DecideGroundingData, NarrowDecisionData, Provenance, } from "./pipeline.js";
+export { sampleCorpus, searchCorpus } from "./corpus.js";
+export type { CorpusMiss, CorpusPair, CorpusResult } from "./corpus.js";

package/dist/src/mind/index.js

@@ -3,3 +3,4 @@
 // Re-exports the Mind class and all public types that were previously
 // exported from mind/mind.ts directly.
 export { Mind } from "./mind.js";
+export { sampleCorpus, searchCorpus } from "./corpus.js";

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

@@ -78,9 +78,14 @@ export interface AlignGap {
 }
 /** 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.
+ *  runs of at least W bytes across mismatch gaps.  Each gap's LENGTH is the
+ *  pair's own extent (a gap cannot be longer than the bytes it spans) and the
+ *  sweep's WORK is proportional to the bytes a run spans (the context's windows
+ *  are indexed once, then the query's are walked) — the arity bound
+ *  (`chainReach`) used to cap BOTH, and truncated every learned frame whose
+ *  slot was longer.  Each sweep owns its own budget, so an exhausted right
+ *  sweep never starves the left one.  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

package/dist/src/mind/match.js

@@ -31,8 +31,8 @@
 // they gate.
 import { addInto, cosine, dot, normalize, zeros } from "../vec.js";
 import { conceptThreshold, dominates, identityBar, significanceBar, } from "../geometry.js";
-import { bytesEqual, indexOf } from "../bytes.js";
-import { chainReach, leafIdRun } from "./canonical.js";
+import { bytesEqual, indexOf, latin1 } from "../bytes.js";
+import { 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";
@@ -237,9 +237,14 @@ export function alignGraded(ctx, query, contextBytes, querySites) {
 }
 /** 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.
+ *  runs of at least W bytes across mismatch gaps.  Each gap's LENGTH is the
+ *  pair's own extent (a gap cannot be longer than the bytes it spans) and the
+ *  sweep's WORK is proportional to the bytes a run spans (the context's windows
+ *  are indexed once, then the query's are walked) — the arity bound
+ *  (`chainReach`) used to cap BOTH, and truncated every learned frame whose
+ *  slot was longer.  Each sweep owns its own budget, so an exhausted right
+ *  sweep never starves the left one.  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
@@ -253,7 +258,21 @@ export function alignGraded(ctx, query, contextBytes, querySites) {
  *  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);
+    // THE GAP LENGTH IS THE PAIR'S OWN EXTENT; THE WORK IS BUDGETED.
+    //
+    // The sweep walks (queryGap, contextGap) pairs by ASCENDING total, so reaching
+    // a gap of size G costs about G²/2 pairs.  Bounding the LENGTH by the write
+    // side's arity (`chainReach(W)` = 16) therefore truncated every learned frame
+    // whose slot is longer — measured: `bindReference` reported the cap at 18, 24,
+    // 30 and 36 bytes and `recall` answered with ANOTHER instance's filler — while
+    // removing the bound outright took the corpus-cost guard (test/89) from
+    // milliseconds to 68 seconds.
+    //
+    // Bounding the PAIRS keeps a call's cost constant however long the pair is,
+    // and the ascending order means an exhausted budget drops the FAR
+    // continuations and never the near ones — the same degradation recognition.ts
+    // documents for its canon budget.  Length and work are different questions;
+    // this is the one place they were conflated.
     // Maximal run around the seed.
     let qs = qo, ss = co;
     while (qs > 0 && ss > 0 && q[qs - 1] === c[ss - 1]) {
@@ -267,8 +286,66 @@ export function alignAround(ctx, q, c, qo, co) {
     }
     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).
+    // THE SWEEP IS STRUCTURAL, NOT ENUMERATIVE.
+    //
+    // The criterion is unchanged: the next common run, MINIMUM TOTAL GAP, ties to
+    // the smaller query gap.  What changed is how it is found.  Enumerating
+    // (queryGap, contextGap) pairs by ascending total reaches a run at total t in
+    // about t²/2 pairs — and that quadratic shape, not the reach, was the cost
+    // problem: capping the pairs dropped reach (a legitimate 24-byte slot stopped
+    // being found), while leaving them uncapped cost 68 seconds on the corpus
+    // guard.  Neither is the answer, because the answer is the algorithm.
+    //
+    // The context's windows are indexed ONCE, for lengths 1..W — W being the
+    // geometry's own unit of composition, so nothing is chosen here.  Each step
+    // then walks the query's windows outward from the anchor: for a given query
+    // gap the nearest context gap that continues a run is one O(1) lookup, and the
+    // walk stops the moment the query gap alone exceeds the best total already
+    // found.  So the work is proportional to the bytes the run SPANS.  No budget,
+    // no cap, no number: a long slot is reached, and its price is already the
+    // ladder's (its bytes are unaccounted, so the search pays PASS per byte).
+    const index = [];
+    for (let len = 1; len <= W; len++) {
+        const m = new Map();
+        for (let o = 0; o + len <= c.length; o++) {
+            const key = latin1(c.subarray(o, o + len));
+            const at = m.get(key);
+            if (at === undefined)
+                m.set(key, [o]);
+            else
+                at.push(o);
+        }
+        index.push(m);
+    }
+    /** Smallest listed offset at or after `from`, or -1. */
+    const fromAt = (list, from) => {
+        let lo = 0, hi = list.length - 1, best = -1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (list[mid] >= from) {
+                best = list[mid];
+                hi = mid - 1;
+            }
+            else
+                lo = mid + 1;
+        }
+        return best;
+    };
+    /** Largest listed offset at or before `to`, or -1. */
+    const toAt = (list, to) => {
+        let lo = 0, hi = list.length - 1, best = -1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (list[mid] <= to) {
+                best = list[mid];
+                lo = mid + 1;
+            }
+            else
+                hi = mid - 1;
+        }
+        return best;
+    };
+    /** Length of the common run STARTING at (qi, si). */
     const runLenAt = (qi, si) => {
         let n = 0;
         while (qi + n < q.length && si + n < c.length && q[qi + n] === c[si + n]) {
@@ -276,69 +353,76 @@ export function alignAround(ctx, q, c, qo, co) {
         }
         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)
+    /** Length of the common run ENDING at (qi, si). */
+    const runLenBefore = (qi, si) => {
+        let n = 0;
+        while (n < qi && n < si && q[qi - 1 - n] === c[si - 1 - n])
+            n++;
+        return n;
+    };
+    /** The next run outward from an anchor, or null when the bytes run out. */
+    const nextRun = (qi, si, forward) => {
+        const qLim = forward ? q.length - qi : qi;
+        let best = null;
+        for (let gq = 0; gq < qLim; gq++) {
+            // No later query gap can beat a total already found.
+            if (best !== null && gq > best.gq + best.gs)
+                break;
+            const left = qLim - gq;
+            // A run of >= W bytes, or — when the query itself ends inside one window —
+            // the run that REACHES that end.  Exactly the acceptance the sweep had.
+            const lens = left >= W ? [W] : [left];
+            for (const len of lens) {
+                const key = latin1(q.subarray(forward ? qi + gq : qi - gq - len, forward ? qi + gq + len : qi - gq));
+                const list = index[len - 1].get(key);
+                if (list === undefined)
                     continue;
-                if (qi + gq >= q.length || si + gs >= c.length)
+                const o = forward ? fromAt(list, si) : toAt(list, si - len);
+                if (o < 0)
                     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 });
+                const n = forward
+                    ? runLenAt(qi + gq, o)
+                    : runLenBefore(qi - gq, o + len);
+                if (n < 1)
+                    continue;
+                if (forward ? n >= W || qi + gq + n === q.length : n >= W || n === qi - gq) {
+                    const gs = forward ? o - si : si - len - o;
+                    if (best === null || gq + gs < best.gq + best.gs) {
+                        best = { gq, gs, n };
                     }
-                    matched.push([qi + gq, qi + gq + n]);
-                    qi = qi + gq + n;
-                    si = si + gs + n;
-                    found = true;
                     break;
                 }
             }
         }
-        if (!found)
+        return best;
+    };
+    // RIGHT sweep.
+    let qi = qe, si = se;
+    for (;;) {
+        const step = nextRun(qi, si, true);
+        if (step === null)
             break;
+        if (step.gq > 0 || step.gs > 0) {
+            gaps.push({ qs: qi, qe: qi + step.gq, cs: si, ce: si + step.gs });
+        }
+        matched.push([qi + step.gq, qi + step.gq + step.n]);
+        qi = qi + step.gq + step.n;
+        si = si + step.gs + step.n;
     }
-    // LEFT sweep (mirror).
+    // LEFT sweep (mirror): an independent walk, so an exhausted right side can
+    // never starve it (pinned by test/114).
     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)
+        const step = nextRun(qi, si, false);
+        if (step === null)
             break;
+        if (step.gq > 0 || step.gs > 0) {
+            gaps.push({ qs: qi - step.gq, qe: qi, cs: si - step.gs, ce: si });
+        }
+        matched.push([qi - step.gq - step.n, qi - step.gq]);
+        qi = qi - step.gq - step.n;
+        si = si - step.gs - step.n;
     }
     return { matched, gaps };
 }