@hviana/sema 0.9.1 → 0.9.3

package/dist/src/mind/traverse.js

@@ -6,14 +6,16 @@
 // The PROJECTIONS built on these walks (follow, conceptHop, reverseContext,
 // project) live in match.ts — the elementary match-and-project operation.
 import { cosine } from "../vec.js";
-import { gistOf, read } from "./primitives.js";
-import { canonicalWindows, leafIdPrefix, leafIdRun } from "./canonical.js";
+import { gistOf, read, resolve } from "./primitives.js";
+import { canonicalWindows, chainReach, leafIdPrefix, leafIdRun, } from "./canonical.js";
 // Imported at the TOP, where every other import is.  They used to sit 800 lines
 // down under a note claiming the position mattered ("before trace module is
 // loaded") — it does not: an ES module's static imports are HOISTED, so the
 // file's line order never decides load order.  The note described an intention
 // the runtime does not honour; the imports move and the claim goes.
 import { decodeText } from "./rationale.js";
+import { concatBytes, indexOf, latin1 } from "../bytes.js";
+import { windowIndex, witness } from "./evidence.js";
 //
 // Budgeted on the same terms as the reach memo below (caches.md): these three
 // maps are cleared on every write, but a long read-only session over a large
@@ -588,7 +590,9 @@ export function guidedNext(ctx, node) {
     // policy climbMemo and recogniseMemo follow (every mechanism must emit its
     // own steps; a memo hit would swallow the repeat's `disambiguate` step).
     // Consistency does not need the memo: chooseNext is a pure function of the
-    // (read-only) store and the guide, so recomputation yields the same pick.
+    // (read-only) store, the guide and the consensus climb's points once they
+    // exist (the memo is cleared when they arrive), so recomputation yields the
+    // same pick.
     if (!ctx.trace) {
         const memo = ctx._edgeChoice.get(node);
         if (memo !== undefined)
@@ -599,8 +603,10 @@ export function guidedNext(ctx, node) {
         ctx._edgeChoice.set(node, pick ?? -1);
     return pick;
 }
-/** Disambiguate among a node's learnt continuations by distributional
- *  support.  NOTE the `guide` contract: its VALUE is deliberately unused —
+/** Disambiguate among a node's learnt continuations: first by the question's
+ *  own witness of an establishing context (the exact tier, see
+ *  {@link askedContinuations}), then by distributional support.  NOTE the
+ *  `guide` contract: its VALUE is deliberately unused —
  *  only its PRESENCE gates disambiguation (a null guide means no query is in
  *  flight, so structural walkers keep plain first-edge behaviour).  The
  *  gist-cosine of short answer candidates against a query guide is dominated
@@ -621,13 +627,30 @@ export function chooseNext(ctx, id, guide) {
         return undefined;
     if (nx.length === 1 || !guide)
         return nx[0];
+    // THE EXACT TIER — the continuation the QUESTION names.  Every other
+    // disambiguation below reads popularity, and is right to refuse the gist (see
+    // the doc above); but the corpus also wrote down, for each continuation,
+    // WHICH QUESTIONS IT ANSWERS — its establishing contexts — and a question is
+    // not a gist.  When one of them is witnessed by the asker's bytes plus the
+    // node's own, that continuation is the one being asked for.  Measured on the
+    // 31.7M-node store: `Who is the father of Frederick II?` answered the
+    // citizenship fact (the most-poured of eight) while `Frederick II father` —
+    // one of the father fact's own establishing contexts — lay wholly inside the
+    // question.  Exact, so it ranks first (exact-vs-approximate.md); when nothing
+    // is witnessed the ladder below decides exactly as before.
+    const asked = ctx._edgeAsked;
+    const named = asked === null ? null : askedContinuations(ctx, id, nx, asked);
+    if (named !== null && named.length === 1)
+        return named[0];
     // Cap candidates at √N — the same bound the original chooseAmong used.
     // A hub context can accumulate thousands of continuations; the best-fit
     // one is among the first √N by insertion order (edges are never deleted,
     // so the oldest are the most established).  A strongly-supported edge
     // inserted beyond the cap is invisible here — the deliberate trade
-    // against paying O(fan-out) count reads on every disambiguation.
-    const capped = nx; // already the hub-capped prefix, by the read above
+    // against paying O(fan-out) count reads on every disambiguation.  Several
+    // continuations named EQUALLY by the question are told apart by the same
+    // ladder, over them alone.
+    const capped = named ?? nx; // already the hub-capped prefix, by the read above
     // Distributional-evidence disambiguation, consulting BOTH read-outs of the
     // evidence the training poured:
     //   1. prevCount — how many DISTINCT contexts predict this candidate (one
@@ -691,6 +714,509 @@ export function chooseNext(ctx, id, guide) {
     }
     return best;
 }
+/** The response canonicalizer's reading of `bytes` when it keeps every offset
+ *  — so a window found in the canonical bytes sits at the same place in the
+ *  asker's — else the bytes themselves.  Text canon is offset-preserving on
+ *  ASCII without interior whitespace runs; where it is not, the raw bytes are
+ *  read and a case-variant window simply does not match. */
+export function offsetCanon(ctx, bytes) {
+    if (ctx.canon === null)
+        return bytes;
+    const c = ctx.canon(bytes);
+    return c.length === bytes.length ? c : bytes;
+}
+/** A FRAGMENT ANSWERS OTHER QUESTIONS.  A recognised form that sits inside
+ *  other forms (it has structural parents or containers) holds continuations
+ *  because the forms it is a piece of were asked — suffix inheritance gives
+ *  `f death` the answer of every `… place of death` question, and `director`
+ *  the answer of every `… director` one.  Choosing one of several such
+ *  continuations by popularity voices some other question's answer.  A
+ *  fragment with several continuations leads somewhere FOR THIS QUESTION only
+ *  when the question names one (the exact tier below).  A form that is
+ *  (nearly) the whole question is not a piece of it: the question says
+ *  nothing beyond it, so its continuations answer THIS question.  Read by
+ *  every mechanism that projects through a recognised site (cover's sites,
+ *  recall's argument binding). */
+export function answersOtherQuestions(ctx, id, queryLen, siteLen) {
+    const asked = ctx._edgeAsked;
+    if (asked === null || queryLen - siteLen < ctx.space.maxGroup)
+        return false;
+    if (!(ctx.store.hasParents(id) || ctx.store.hasContainers(id)))
+        return false;
+    if (ctx.store.nextFirst(id, 2).length < 2)
+        return false;
+    return namedContinuations(ctx, id, asked) === null;
+}
+/** The continuations of `id` that `asked` NAMES (see {@link
+ *  askedContinuations}) — for a caller holding material other than the whole
+ *  question: the multi-hop walk asks with what of the question no product has
+ *  restated yet.  null when none is named. */
+export function namedContinuations(ctx, id, asked) {
+    const nx = ctx.store.nextFirst(id, hubBound(ctx));
+    return nx.length === 0 ? null : askedContinuations(ctx, id, nx, asked);
+}
+/** The continuations of `id` (among `nx`) that the question NAMES: one of
+ *  their establishing contexts — a predecessor other than `id` itself — is
+ *  wholly witnessed by the question plus `id`'s own bytes (evidence.ts), with
+ *  the question supplying at least one window the node does not.  Ranked by
+ *  how much of the question witnesses it; null when none is named.
+ *
+ *  THE NODE'S OWN BYTES ARE MATERIAL because a derivation stands on them.  On
+ *  the second hop of `Where was the place of death of the director of film
+ *  Beat Girl?` the node is `Edmond T. Gréville` — reached, never written — and
+ *  its fact's establishing context `Edmond T. Gréville place of death` is held
+ *  by neither the question nor the node, only by both.  Measured over 5,236
+ *  held-out 2Wiki questions: such a context is wholly witnessed by the
+ *  question alone 69 times, by the question and the first hop 2,153 times.
+ *
+ *  BOUNDED: predecessor reads share one √N budget across the candidates (see
+ *  the loop below), asked cheapest first; past it the tier abstains for the
+ *  rest, metered, and the ladder decides as before.
+ *  Each form is read at most to the material's length — a form longer than
+ *  everything at hand cannot be wholly witnessed without repeating it. */
+function askedContinuations(ctx, id, nx, asked) {
+    return askedEntry(ctx, id, nx, asked).named;
+}
+/** The question spans that NAMED `pick` among `id`'s continuations — the
+ *  evidence a projection through that pick stands on, so a mechanism can
+ *  account for what the question said about it (mechanism-market.md:
+ *  evidence travels).  Empty when the question names no continuation of `id`
+ *  or names others. */
+export function askedEvidence(ctx, id, pick) {
+    const asked = ctx._edgeAsked;
+    if (asked === null)
+        return [];
+    const nx = ctx.store.nextFirst(id, hubBound(ctx));
+    const entry = askedEntry(ctx, id, nx, asked);
+    return entry.named?.includes(pick) ? entry.spans.get(pick) ?? [] : [];
+}
+function askedEntry(ctx, id, nx, asked) {
+    let memo = askedMemo.get(asked);
+    if (memo === undefined)
+        askedMemo.set(asked, memo = new Map());
+    const hit = memo.get(id);
+    if (hit !== undefined && !ctx.trace)
+        return hit;
+    const entry = askedContinuationsImpl(ctx, id, nx, asked);
+    // Nothing named before the climb has run is provisional: a co-instance
+    // read from its points may still name one.
+    if (entry.named !== null || ctx._edgeAsked?.points !== undefined) {
+        memo.set(id, entry);
+    }
+    return entry;
+}
+/** One pick per node per question — every mechanism of a response asks the
+ *  same node about the same question (the guided-pick memo's own reason). */
+const askedMemo = new WeakMap();
+function askedContinuationsImpl(ctx, id, nx, asked) {
+    const none = { named: null, spans: new Map() };
+    const W = ctx.space.maxGroup;
+    // A SATURATED READ IS NOT A CANDIDATE SET.  When the continuations came back
+    // at the √N cap the read may have cut the named one off, so "none of these is
+    // named" and "this is the named one" are both unfounded — and this is exactly
+    // where witnessing would read most.  The tier abstains, metered, and the
+    // distributional ladder decides as it always has.
+    if (nx.length >= hubBound(ctx)) {
+        if (ctx.meter)
+            ctx.meter.askedReadsSaturated++;
+        return none;
+    }
+    const cache = getStructCache(ctx);
+    const ownCap = asked.bytes.length * W;
+    const own = offsetCanon(ctx, read(ctx, id, ownCap));
+    const ownIndex = windowIndex(own, W);
+    // Naming needs the question to say at least one window the node does not:
+    // when the node already holds every window of the question (the question IS
+    // this context, or a piece of it), nothing can be named, and nothing is read.
+    let beyond = false;
+    for (const key of asked.index.keys()) {
+        if (!ownIndex.has(key)) {
+            beyond = true;
+            break;
+        }
+    }
+    if (!beyond)
+        return none;
+    const indexes = [asked.index, ownIndex];
+    const formCap = asked.bytes.length + own.length;
+    // BOUNDED READS (bounded-reads.md): the decision reads at most √N
+    // establishing contexts — floored at the write side's own arity `chainReach(W)`
+    // so a store too small for √N to cover one fact's questions still decides.
+    // Candidates are asked CHEAPEST FIRST (fewest establishing contexts): a common
+    // reply established by hundreds of contexts would otherwise spend the whole
+    // allowance alone.  The order changes what is READ, never what wins: scores
+    // are compared afterwards in the continuations' own order.
+    const allowance = Math.max(hubBound(ctx), chainReach(W));
+    let budget = allowance;
+    const order = nx
+        .map((n, at) => ({ n, at, support: cachedPrevCount(ctx, n, cache) }))
+        .filter((c) => c.support >= 2) // only `id` establishes the rest
+        .sort((a, b) => a.support - b.support || a.at - b.at);
+    const scored = [];
+    for (const { n, at, support } of order) {
+        if (support > budget) {
+            if (ctx.meter)
+                ctx.meter.askedReadsSaturated++;
+            break;
+        }
+        budget -= support;
+        if (ctx.meter)
+            ctx.meter.askedPredecessorReads += support;
+        let score = 0;
+        let by = -1;
+        let spans = [];
+        for (const c of ctx.store.prevFirst(n, support)) {
+            if (c === id)
+                continue;
+            // The form's FIRST window decides most refusals: one short prefix read
+            // before the whole form is reconstructed (a conversation-length
+            // predecessor would otherwise be read in full to fail on its opening).
+            const head = offsetCanon(ctx, read(ctx, c, W));
+            if (head.length < W)
+                continue;
+            if (!indexes.some((ix) => ix.has(latin1(head))))
+                continue;
+            // AN ESTABLISHING CONTEXT IS A DEPOSITED ONE.  A span interned inside
+            // bigger forms inherits their edges (the fragment ` born?` leads to the
+            // fact of every `Where was … born?` question), so witnessing it names
+            // every one of them — measured on the 2Wiki fixture with one-hop
+            // questions deposited, ` born?` named nine strangers' birthplaces.  The
+            // structural predicate pivotInto already reads: a form with parents or
+            // containers was never a context on its own.
+            if (cachedHasParents(ctx, c, cache) || ctx.store.hasContainers(c))
+                continue;
+            const form = read(ctx, c, formCap + 1);
+            if (form.length < W || form.length > formCap)
+                continue;
+            const w = witness(offsetCanon(ctx, form), indexes, W);
+            if (!w.complete || w.bytes < W)
+                continue;
+            if (w.bytes > score) {
+                score = w.bytes;
+                by = c;
+                spans = w.spans;
+            }
+        }
+        if (score > 0)
+            scored.push({ n, at, score, by, spans });
+    }
+    scored.sort((a, b) => a.at - b.at);
+    let best = [];
+    let bestBytes = 0;
+    let witnessed = null;
+    for (const { n, score, by } of scored) {
+        if (score > bestBytes) {
+            best = [n];
+            bestBytes = score;
+            witnessed = by;
+        }
+        else if (score === bestBytes)
+            best.push(n);
+    }
+    if (best.length === 0) {
+        return byCoInstance(ctx, id, nx, asked, formCap, allowance);
+    }
+    if (ctx.meter)
+        ctx.meter.askedContinuations++;
+    if (ctx.trace && witnessed !== null) {
+        ctx.trace.step("askedContinuation", [rItemShort(ctx, id, "node"), rItemShort(ctx, witnessed, "asked")], best.map((n) => rItemShort(ctx, n, "named")), `${nx.length} continuations — the question witnesses ` +
+            `${best.length === 1 ? "one's" : `${best.length}'`} own establishing ` +
+            `context (${bestBytes} question byte(s) beyond the node)`);
+    }
+    const evidence = new Map();
+    for (const c of scored)
+        if (best.includes(c.n))
+            evidence.set(c.n, c.spans);
+    return { named: best, spans: evidence };
+}
+/** The climb's points the question HOLDS under the response's equivalence —
+ *  stored forms whose canonical bytes occur in the question's, as sites.  The
+ *  recognition walk matches bytes and the fold's own boundaries, so a stored
+ *  `Man at Bath` inside `… of film Man At Bath work at?` is no site; the
+ *  consensus climb reaches it through the windows the two spellings share, and
+ *  containment under the canon (offset-preserving, so the span is the
+ *  question's own) decides.  Approximate proposes, exact decides.  Read off
+ *  the `chainReach(W)` most corroborated points; empty before the climb. */
+export function canonHeldPoints(ctx, minLen) {
+    const asked = ctx._edgeAsked;
+    if (asked === null || asked.points === undefined || ctx.canon === null) {
+        return [];
+    }
+    const W = ctx.space.maxGroup;
+    const out = [];
+    for (const id of asked.points.slice(0, chainReach(W))) {
+        const raw = read(ctx, id, asked.bytes.length);
+        if (raw.length < minLen || raw.length >= asked.bytes.length)
+            continue;
+        const form = ctx.canon(raw);
+        if (form.length !== raw.length)
+            continue;
+        const at = indexOf(asked.bytes, form, 0);
+        if (at >= 0)
+            out.push({ start: at, end: at + raw.length, payload: id });
+    }
+    return out;
+}
+/** A CO-INSTANCE of the question: a stored form that shares the question's
+ *  FRAME — the same opening and the same close, byte for byte under the
+ *  response's equivalence — around ONE different filler.  `Where was Peter
+ *  Jackson born?` against `Where was the director of film Beat Girl born?`
+ *  shares `Where was ` and ` born?`, and leaves `Peter Jackson` against `the
+ *  director of film Beat Girl`: another instance of the same question, never
+ *  this one.  It is the ordered limit of witnessing: a frame is not a bag of
+ *  windows (an order-free reading lets `Lyon is a city in France` pass for an
+ *  instance of `what if the capital of France were Lyon?`, which NAMES Lyon;
+ *  and a coincidental window inside a filler splits it).
+ *
+ *  The frame must reach one window, every window inside it must be held by
+ *  the material (so on the walk, a frame a product already said cannot name a
+ *  second step), and the form's filler must be a thing the corpus knows
+ *  (below) — a record that differs from the question only inside the frame
+ *  by a description (`converts sunlight into chemical energy` against
+ *  `works`) is the same question about the frame's own subject.  (Requiring
+ *  the two fillers to share no window as well was measured redundant with
+ *  this and cost two answers on the 2Wiki fixture.)  Returns the form's filler span in `raw` and the
+ *  question spans of the frame, or null.  One reading for every consumer: the
+ *  exact tier transfers the relation through it, and the readers that would
+ *  VOICE such a form's own continuation refuse it. */
+export function coInstanceFiller(ctx, raw, indexes, question) {
+    const W = ctx.space.maxGroup;
+    const form = offsetCanon(ctx, raw);
+    const max = Math.min(form.length, question.length);
+    let a = 0;
+    while (a < max && form[a] === question[a])
+        a++;
+    let b = 0;
+    while (b < max - a &&
+        form[form.length - 1 - b] === question[question.length - 1 - b])
+        b++;
+    const fe = form.length - b;
+    if (a + b < W || fe <= a || question.length - b <= a)
+        return null;
+    // Scaffolding is nobody's evidence, so a frame window that is a hub need not
+    // be unsaid (` is ` in `Which country Leo Mittler is from?`, which the first
+    // hop's `… is Arshad Khan.` already said).
+    const hub = hubWindows(ctx, raw);
+    const held = (o) => {
+        if (hub[o])
+            return true;
+        const key = latin1(form.subarray(o, o + W));
+        return indexes.some((ix) => ix.has(key));
+    };
+    for (let o = 0; o + W <= a; o++)
+        if (!held(o))
+            return null;
+    for (let o = fe; o + W <= form.length; o++)
+        if (!held(o))
+            return null;
+    // THE FILLER IS A THING THE CORPUS KNOWS: a stored context with
+    // continuations of its own, opening where the slot opens (up to one window
+    // earlier — a filler byte can sit in a window the question holds by chance:
+    // the `T` of `Taika` inside `as t` of `was the`).  `Peter Jackson` is one;
+    // `converts sunlight into chemical energy`, the slot of `Explain how
+    // photosynthesis …`, is a description of the frame's own subject, and the
+    // record answers the question.  The longest such context is the filler.
+    // One content-addressed probe per byte (the `keyEnds` reading); only a run
+    // some deposit spelled whole is looked up.
+    const ids = leafIdPrefix(ctx, raw);
+    let best = null;
+    const cache = getStructCache(ctx);
+    const reach = Math.min(ids.length, fe + W - 1);
+    for (let st = Math.max(0, a - W + 1); st <= a; st++) {
+        const run = [];
+        for (let en = st + 1; en <= reach; en++) {
+            run.push(ids[en - 1]);
+            if (en - st < W)
+                continue;
+            // The flat branch over the whole run exists only where some deposit
+            // spelled exactly these bytes — the cheap filter; the context it names
+            // is then looked up by content.
+            if (ctx.store.findBranch(run) === null)
+                continue;
+            if (best !== null && en - st <= best[1] - best[0])
+                continue;
+            const id = resolve(ctx, raw.subarray(st, en));
+            if (id !== null && cachedHasNext(ctx, id, cache))
+                best = [st, en];
+        }
+    }
+    if (best === null)
+        return null;
+    const spans = [];
+    if (a > 0)
+        spans.push([0, a]);
+    if (b > 0)
+        spans.push([question.length - b, question.length]);
+    return { span: best, spans };
+}
+/** THE RELATION, READ OFF ANOTHER INSTANCE — the exact tier's second reading,
+ *  asked only when no establishing context of `id`'s continuations is
+ *  witnessed outright.
+ *
+ *  `When was the director of film Jinpa born?` reaches `Pema Tseden`, whose
+ *  date-of-birth fact is established by `Pema Tseden date of birth`: the
+ *  question says `born`, the corpus says `date of birth`, and no window joins
+ *  them.  What can join them is ANOTHER INSTANCE of the same question.  A
+ *  stored context the question witnesses in every byte but ONE contiguous span
+ *  (`When was Peter Jackson born?`, residue `Peter Jackson`) is the question's
+ *  own frame around a different filler — a CO-INSTANCE.  Its continuation is
+ *  established by other contexts too (`Peter Jackson date of birth`), and one
+ *  that holds the filler is the relation spelled the way the corpus spells it.
+ *  Put this node where the filler was and look the result up by content:
+ *  `Pema Tseden date of birth` exists, and its continuation is named.
+ *
+ *  Nothing here is stored as a unit — not `born` ≈ `date of birth`, not the
+ *  frame — and nothing is approximate: the co-instance is witnessed, the
+ *  substitution is bytes, the target is an exact lookup that either exists
+ *  with this node's continuation or does not.  A frame the question shares only
+ *  partly (`Where was … born?` against `When was …`) leaves two residues and
+ *  is no co-instance.
+ *
+ *  BOUNDED: the frames are a property of the question and are read once per
+ *  question (`relationFrames`); co-instances are proposed by the edge-bearing
+ *  ancestors of its windows (`edgeAncestors`, the climb's own memoised reach;
+ *  a saturated window proposes nothing), rarest first, at most `allowance` of
+ *  them, each read once.  A node pays one exact lookup per frame. */
+function byCoInstance(ctx, id, nx, asked, formCap, allowance) {
+    const none = { named: null, spans: new Map() };
+    const frames = relationFrames(ctx, asked, allowance);
+    if (frames.length === 0)
+        return none;
+    const node = read(ctx, id, formCap);
+    const support = new Map();
+    const spans = new Map();
+    const via = new Map();
+    for (const fr of frames) {
+        const t = resolve(ctx, concatBytes([fr.prefix, node, fr.suffix]));
+        if (t === null || t === id)
+            continue;
+        for (const n of ctx.store.nextFirst(t, allowance)) {
+            if (!nx.includes(n))
+                continue;
+            let by = support.get(n);
+            if (by === undefined)
+                support.set(n, by = new Set());
+            for (const q of fr.by)
+                by.add(q);
+            if (!spans.has(n)) {
+                spans.set(n, fr.spans);
+                via.set(n, { q: fr.by[0], t });
+            }
+        }
+    }
+    let best = [];
+    let most = 0;
+    for (const n of nx) {
+        const k = support.get(n)?.size ?? 0;
+        if (k === 0)
+            continue;
+        if (k > most) {
+            best = [n];
+            most = k;
+        }
+        else if (k === most)
+            best.push(n);
+    }
+    if (best.length === 0)
+        return none;
+    if (ctx.meter)
+        ctx.meter.coInstanceNamings++;
+    const first = via.get(best[0]);
+    if (ctx.trace && first !== undefined) {
+        ctx.trace.step("askedByCoInstance", [
+            rItemShort(ctx, id, "node"),
+            rItemShort(ctx, first.q, "co-instance"),
+            rItemShort(ctx, first.t, "asked"),
+        ], best.map((n) => rItemShort(ctx, n, "named")), `${nx.length} continuations — no establishing context is witnessed; ` +
+            `${most} co-instance(s) of the question carry the relation to ` +
+            `${best.length === 1 ? "one" : best.length} of them`);
+    }
+    const evidence = new Map();
+    for (const n of best)
+        evidence.set(n, spans.get(n) ?? []);
+    return { named: best, spans: evidence };
+}
+/** The relation frames the question's co-instances carry — a property of the
+ *  QUESTION, not of the node asked about, so it is read once per question
+ *  (and once per walk material) and every node only pays the exact lookups.
+ *  A question the corpus holds verbatim is its own instance and reads none. */
+function relationFrames(ctx, asked, allowance) {
+    // A co-instance is the question's frame around ONE other filler, so it is
+    // read at most to twice the question's length.
+    const formCap = 2 * asked.bytes.length;
+    const hit = frameMemo.get(asked);
+    if (hit !== undefined && !ctx.trace)
+        return hit;
+    const whole = ctx._edgeAsked;
+    // THE PROPOSALS ARE THE CLIMB'S.  The consensus climb already scored the
+    // stored forms the question's regions reach — measured on the 2Wiki
+    // fixture with one-hop questions, the co-instances were among its points —
+    // so the tier reads co-instances from those and climbs nothing of its own.
+    // Before the climb has run there is nothing to read, and nothing is
+    // remembered: a later ask, after the climb, reads its points.
+    const points = whole?.points;
+    if (points === undefined)
+        return [];
+    const frames = [];
+    frameMemo.set(asked, frames);
+    if (whole !== null && resolve(ctx, whole.bytes) !== null)
+        return frames;
+    const W = ctx.space.maxGroup;
+    const cache = getStructCache(ctx);
+    const deposited = (c) => !cachedHasParents(ctx, c, cache) && !ctx.store.hasContainers(c);
+    const spelled = new Map();
+    // Most corroborated first (the climb's own ranking), at most
+    // `chainReach(W)` read — the exact tier's own floor.
+    const proposals = points.filter((c) => cachedHasNext(ctx, c, cache))
+        .slice(0, Math.min(allowance, chainReach(W)));
+    for (const q of proposals) {
+        if (!deposited(q))
+            continue;
+        const raw = read(ctx, q, formCap + 1);
+        if (raw.length > formCap)
+            continue;
+        if (ctx.meter)
+            ctx.meter.coInstanceReads++;
+        const co = coInstanceFiller(ctx, raw, [asked.index], asked.bytes);
+        if (co === null)
+            continue;
+        const [fs, fe] = co.span;
+        const filler = raw.subarray(fs, fe);
+        for (const f of ctx.store.nextFirst(q, W)) {
+            for (const c of ctx.store.prevFirst(f, allowance)) {
+                if (c === q || !deposited(c))
+                    continue;
+                const cb = read(ctx, c, formCap + 1);
+                const at = indexOf(cb, filler, 0);
+                if (at < 0)
+                    continue;
+                const prefix = cb.subarray(0, at);
+                const suffix = cb.subarray(at + filler.length);
+                if (prefix.length + suffix.length === 0)
+                    continue;
+                const key = latin1(prefix) + "\u0000" + latin1(suffix);
+                const known = spelled.get(key);
+                if (known === undefined) {
+                    spelled.set(key, { by: [q], prefix, suffix, spans: co.spans });
+                }
+                else if (!known.by.includes(q))
+                    known.by.push(q);
+            }
+        }
+    }
+    // ONE INSTANCE AGREES WITH NOTHING.  A relation is read off the corpus only
+    // where two co-instances spell it the same way — the agreement `reference`
+    // demands of a frame (MIN_INSTANCES), for the same reason: a single
+    // coincidental alignment is not evidence of what the frame means.  Measured
+    // on the trained store, long dialogue turns proposed hundreds of one-off
+    // "frames", each an exact lookup for every node asked about.
+    for (const fr of spelled.values())
+        if (fr.by.length >= 2)
+            frames.push(fr);
+    frames.sort((a, b) => b.by.length - a.by.length);
+    return frames;
+}
+const frameMemo = new WeakMap();
 /** The perceived gist of a candidate node, through the session gist cache.
  *  Re-gisting a candidate is a full river fold of its bytes — the measured
  *  recall bottleneck (a hub context offers up to √N continuations, EACH
@@ -776,6 +1302,84 @@ export function allWindowsAreScaffolding(ctx, query) {
     }
     return sawOne;
 }
+/** Per offset of `bytes`: 1 when the W-window there is a stored form contained
+ *  in more than √N places (corpus-global scaffolding; see the floor below),
+ *  else 0.  Memoised per
+ *  byte array for the life of the store's read-only response. */
+export function hubWindows(ctx, bytes) {
+    const hit = hubWindowMemo.get(bytes);
+    if (hit !== undefined)
+        return hit;
+    const W = ctx.space.maxGroup;
+    // Floored at the write side's arity: inside ONE deposit's fold a window is
+    // already contained by up to `chainReach(W)` chunks and branches, so on a
+    // store of a few facts the √N reading would call every window frame — that
+    // is fold structure, not corpus commonality.
+    const bound = Math.max(hubBound(ctx), chainReach(W));
+    const hub = new Uint8Array(Math.max(0, bytes.length - W + 1));
+    for (let o = 0; o < hub.length; o++) {
+        const ids = leafIdRun(ctx, bytes, o, o + W);
+        const id = ids === null ? null : ctx.store.findBranch(ids);
+        if (id !== null && ctx.store.containersSlice(id, bound, 1).length > 0) {
+            hub[o] = 1;
+        }
+    }
+    hubWindowMemo.set(bytes, hub);
+    return hub;
+}
+const hubWindowMemo = new WeakMap();
+/** The query's SCAFFOLDING CORE, as spans: the bytes every W-window over which
+ *  is a hub (see {@link hubWindows}) — what is nothing but frame, where
+ *  {@link scaffoldExtents} is what a frame window reaches. */
+export function scaffoldSpans(ctx, query) {
+    const W = ctx.space.maxGroup;
+    const hub = hubWindows(ctx, query);
+    const n = hub.length;
+    if (n <= 0)
+        return [];
+    const spans = [];
+    let start = -1;
+    for (let i = 0; i < query.length; i++) {
+        let all = true;
+        for (let o = Math.max(0, i - W + 1); o <= Math.min(i, n - 1); o++) {
+            if (!hub[o]) {
+                all = false;
+                break;
+            }
+        }
+        if (all && start < 0)
+            start = i;
+        if (!all && start >= 0) {
+            spans.push([start, i]);
+            start = -1;
+        }
+    }
+    if (start >= 0)
+        spans.push([start, query.length]);
+    return spans;
+}
+/** The EXTENTS of the query's SCAFFOLDING windows, merged: every byte some
+ *  W-window reaches that is a stored form contained in more than √N places —
+ *  corpus-global commonality (commonality.md), the same "hub" reading as
+ *  {@link allWindowsAreScaffolding} and the bridge's `explainedSpan`.  A window
+ *  the store never saw is NOT scaffolding.  The extent, not the core, is what
+ *  a coverage test needs: a span that still holds one hub window can be
+ *  "carried" by any fact that holds that window. */
+export function scaffoldExtents(ctx, query) {
+    const W = ctx.space.maxGroup;
+    const hub = hubWindows(ctx, query);
+    const spans = [];
+    for (let o = 0; o < hub.length; o++) {
+        if (!hub[o])
+            continue;
+        const last = spans[spans.length - 1];
+        if (last !== undefined && o <= last[1])
+            last[1] = o + W;
+        else
+            spans.push([o, o + W]);
+    }
+    return spans;
+}
 // ── THE PREFIX SUPPLY ───────────────────────────────────────────────────────
 //
 // A RETRIEVAL capability, not a grounding one: "which trained forms does this