@hviana/sema 0.9.1 → 0.9.3

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

@@ -203,7 +203,21 @@ export class Precomputed {
      *  fusion all share.  Computed on first access; a query no mechanism
      *  climbs for (e.g. one an extension decided outright) never pays for it. */
     attention() {
-        return this._attention ??= this.shared("attention", () => climbAttentionAll(this.ctx, this.query, this.k));
+        return this._attention ??= this.shared("attention", () => climbAttentionAll(this.ctx, this.query, this.k)).then((read) => {
+            // The climb's scored anchors are what the exact tier reads co-instances
+            // of the question from (traverse.ts, `relationFrames`): the
+            // approximate climb proposes, witnessing decides.
+            // A pick made before the points existed read less evidence than one
+            // made after, so the response's pick memo starts over (traverse.ts,
+            // guidedNext: a pick is a function of the store, the guide AND the
+            // points — traced and untraced responses must agree).
+            const asked = this.ctx._edgeAsked;
+            if (asked !== null && asked.points === undefined) {
+                asked.points = read.ranked.map((a) => a.anchor);
+                this.ctx._edgeChoice.clear();
+            }
+            return read;
+        });
     }
     _weave;
     /** Result of {@link alignGraded} for the first k ranked anchors —

package/dist/src/mind/pipeline.js

@@ -15,7 +15,9 @@ import { fusionLayer, walkLayer } from "./reasoning.js";
 import { closed, closeOver, remainderOf, unaccountedBytes, unexplainedSpans, windowOf, } from "./derivation.js";
 import { rItem } from "./trace.js";
 import { unexplainedLabel } from "./rationale.js";
-import { hubBound } from "./traverse.js";
+import { hubBound, offsetCanon, scaffoldExtents } from "./traverse.js";
+import { windowIndex, witness } from "./evidence.js";
+import { indexOf } from "../bytes.js";
 import { Precomputed, } from "./pipeline-mechanism.js";
 import { coverMechanism } from "./mechanisms/cover.js";
 import { castMechanism } from "./mechanisms/cast.js";
@@ -83,6 +85,13 @@ export async function think(ctx, query, mechs) {
     if (query.length === 0)
         return null;
     ctx._edgeGuide = gistOf(ctx, query);
+    {
+        const asked = offsetCanon(ctx, query);
+        ctx._edgeAsked = {
+            bytes: asked,
+            index: windowIndex(asked, ctx.space.maxGroup),
+        };
+    }
     ctx._edgeChoice.clear();
     const t = ctx.trace?.enter("think", [rItem(query, "query")]);
     const done = (answer, note) => {
@@ -468,7 +477,17 @@ export async function think(ctx, query, mechs) {
         ...pre.computed.map((u) => [u.i, u.j]),
     ];
     const explained = priced.filter(([a, b]) => windowOf([a, b], answer, query, ctx.space.maxGroup) !== null);
-    const paid = remainderOf(query.length, explained, ctx.space.maxGroup);
+    // THE DERIVATION IS BORN OWING ITS DISCRIMINATIVE MATERIAL.  The bytes a
+    // corpus-global scaffolding window reaches (traverse.ts, `scaffoldExtents`)
+    // are nobody's debt — otherwise a later step could claim to pay them by
+    // restating ` is `, which every fact holds, and the law (which measures
+    // carrying by any window of what is owed) would admit it; the substitution
+    // bridge reads gaps the same way (`explainedSpan`).  PRICING is untouched:
+    // the ladder still charges every unexplained byte, because for a question
+    // made of nothing but scaffolding (`How are you today?`) covering those bytes
+    // IS the evidence.
+    const scaffold = scaffoldExtents(ctx, query);
+    const paid = remainderOf(query.length, [...explained, ...scaffold], ctx.space.maxGroup);
     // WHAT THE CONSTRUCTION WITHHOLDS, at or above one quantum: the difference between
     // the remainder paid in full and the remainder paid by carrying.  Both readings
     // are the law's, so the floor is applied once and in one place — and the
@@ -488,8 +507,23 @@ export async function think(ctx, query, mechs) {
     };
     const uncovered = state.remainder;
     // ── Post-grounding, gated by the declaration and the remainder ────────
+    // WHAT THE GROUNDING SPOKE FOR, when it did not declare it: the forms inside
+    // the answer that the ASKER already holds.  An answer is the asker's material
+    // plus what the corpus added — the fact's own value — and only the former was
+    // spoken for: re-entering it walks back to the question.  The latter is what a
+    // chain continues THROUGH.  Consuming every form recognised in the answer
+    // consumed that too, so a chain could start only where recognition happened
+    // to miss the next entity — measured on 133 held-out 2Wiki compositional
+    // questions, 3 pivot steps in all once interior recognition named the entity
+    // inside every fact.  Witnessed exactly, as `chooseNext`'s exact tier reads the
+    // question (evidence.ts); a form below one window cannot be witnessed, and is
+    // consumed as before.
+    const asked = ctx._edgeAsked;
     const preConsumed = declaredUsed ??
-        new Set(recognise(ctx, answer).sites.map((s) => s.payload));
+        new Set(recognise(ctx, answer).sites
+            .filter((s) => asked === null || s.end - s.start < ctx.space.maxGroup ||
+            witness(offsetCanon(ctx, answer.subarray(s.start, s.end)), [asked.index], ctx.space.maxGroup).complete)
+            .map((s) => s.payload));
     // A grounding that DECLARED itself complete is not extended: the answer is
     // already a trained form's own continuation, reached through an identity
     // claim about the query, so a multi-hop pivot could only chain past the
@@ -504,13 +538,14 @@ export async function think(ctx, query, mechs) {
     // Reading the used anchors' OWN bytes here says something stronger and
     // wrong: that nothing INSIDE what was voiced may be pivoted through.  A
     // comparison's seat sentence legitimately contains further terms with
-    // their own unrelated facts, and C3 pins exactly that — `Mona Lisa`, inside
-    // the voiced seat `The Mona Lisa was painted by Leonardo da Vinci.`, leads
-    // on to `Mona Lisa hangs in the Louvre`, which is about neither analog.
+    // their own unrelated facts — `Mona Lisa`, inside the voiced seat `The Mona
+    // Lisa was painted by Leonardo da Vinci.`, leads on to `Mona Lisa hangs in
+    // the Louvre`, which is about neither analog (test/29 C3: a candidate the
+    // walk takes only when the question names it).
     // The withheld content is the used anchors' CONTINUATIONS, so that is what
     // the containment rule reads: `speare` is contained in `Shakespeare wrote
     // 39 plays` and stays refused, while `Mona Lisa` appears in no withheld
-    // continuation and the genuine further hop fires.
+    // continuation and stays a candidate.
     //
     // Only a mechanism carrying its own `used` set (cast/join) gets this: there
     // `preConsumed` is a deliberate, short list of the anchors the answer
@@ -518,7 +553,15 @@ export async function think(ctx, query, mechs) {
     // `preConsumed` is derived by re-recognising the answer — "everything in
     // it", not "what it voiced" — and a containment rule over that would
     // suppress every pivot the answer legitimately contains.
-    const voiced = declaredUsed === undefined ? [] : [...declaredUsed].flatMap((id) => ctx.store.nextFirst(id, hubBound(ctx)).map((n) => read(ctx, n)));
+    //
+    // …and a continuation the ANSWER ITSELF holds was voiced, not withheld.  A
+    // substitution that answers with its anchor's own continuation (`The director
+    // of Beat Girl is Edmond T. Gréville.`) declared that anchor used, so reading
+    // its continuations as withheld refused every pivot inside the answer — the
+    // chain could never step past the entity the first hop introduced.
+    const voiced = declaredUsed === undefined ? [] : [...declaredUsed].flatMap((id) => ctx.store.nextFirst(id, hubBound(ctx))
+        .map((n) => read(ctx, n))
+        .filter((v) => indexOf(answer, v, 0) < 0));
     // WHAT THIS BRANCH READ, published where it was read.  Post-grounding decides
     // by the DECLARATION (`decided.used`, which becomes `voiced`), by what the
     // recognition already consumed (`preConsumed`) and by the derivation's own

package/dist/src/mind/reasoning.js

@@ -6,10 +6,11 @@ import { rItem, rNode } from "./trace.js";
 import { bytesEqual, indexOf, latin1 } from "../bytes.js";
 import { read, resolve } from "./primitives.js";
 import { countClusters } from "./attention.js";
-import { hubBound } from "./traverse.js";
+import { coInstanceFiller, guidedFirst, hubBound, namedContinuations, offsetCanon, } from "./traverse.js";
+import { unspoken, windowIndex } from "./evidence.js";
 import { containsSpan, follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
-import { closeOver, restates, unaccountedBytes, } from "./derivation.js";
+import { closed, closeOver, restates, unaccountedBytes, } from "./derivation.js";
 import { STEP } from "./graph-search.js";
 /** What one ADMITTED transition did to the question, published on the meter:
  *  the bytes its witnesses CARRIED and the remainder the move DRAINED.  The two
@@ -69,6 +70,11 @@ export function walkLayer(ctx, query, preConsumed, pre, voiced = []) {
     // fire — the same visibility trade chooseNext documents.
     const bound = hubBound(ctx);
     const consumed = new Set();
+    /** The windows each product of this derivation holds — what of the question
+     *  the derivation has already restated, so a later step is NAMED only by
+     *  question material none of them said. */
+    const spoken = [];
+    const speak = (product) => spoken.push(windowIndex(offsetCanon(ctx, product), ctx.space.maxGroup));
     /** `prev` lets a caller hand in an already-read reverse-edge list — hop 0
      *  reuses the guard's, below, instead of re-reading it. */
     const consumeNode = (id, prev) => {
@@ -89,6 +95,7 @@ export function walkLayer(ctx, query, preConsumed, pre, voiced = []) {
     const begin = async (d0) => {
         const answer = d0.product;
         startedFrom = answer;
+        speak(answer);
         // Echo guard: a query that is ITSELF a learnt continuation (some context's
         // answer) is being asked back at the system — hopping forward from it would
         // chain through the very fact that produced it and echo the conversation
@@ -204,16 +211,12 @@ export function walkLayer(ctx, query, preConsumed, pre, voiced = []) {
     // 30 s); and raising it from 12 to 200 changed neither the answer nor
     // `pivotSteps` on the chain fixtures.
     const qv = pre.guide; // the response-wide guide IS the query's gist
-    // WHOSE EXTENSION IS THIS?  `voiced` is what the mechanism WITHHELD (the
-    // pipeline sends the used anchors' CONTINUATIONS, not their bytes), so a
-    // non-empty `voiced` means exactly what that note says: the grounding came
-    // from a mechanism that carries its own short `used` set (cast/join) and
-    // therefore OWNS the shape of its answer.  The further terms inside such a
-    // seat are legitimately followable (test/29 C3's `Mona Lisa` lives inside the
-    // voiced seat and leads on to a fact about neither analog), which the law
-    // expresses as the identity species of progress — `moves` — declared by the
-    // reporter and never inferred from the mechanism's name.
-    const producerOwnsShape = voiced.length > 0;
+    // NO PRODUCER OWNS THE NEXT STEP.  A grounding that declared what it voiced
+    // (cast/join) used to MOVE through any further term inside its answer,
+    // unasked — `Who is the director of The Jerk?` grounded by CAST walked on to
+    // `The country of citizenship of Carl Reiner is American.`  What it voiced
+    // still bounds what may be pivoted through (`voiced`, pivotInto); whether a
+    // step is taken is the naming rule below, the same for every mechanism.
     let hop = 0;
     let t;
     // WHAT THE OFFERED STEP WOULD BE.  The law decides, so the accepted step is
@@ -328,21 +331,48 @@ export function walkLayer(ctx, query, preConsumed, pre, voiced = []) {
             ctx.trace?.step("pivotCandidateRefused", [rItem(cur, "answer")], [], `${why} — refused`);
             return null;
         }
+        // THE STEP THE QUESTION ASKS FOR.  The hop `follow` took is NAMED when one
+        // of its establishing contexts is witnessed by what of the question no
+        // product has restated yet, plus the pivot itself (traverse.ts,
+        // `namedContinuations`): `Where was the place of death of the director of
+        // film Beat Girl?` names `Edmond T. Gréville place of death` once the first
+        // hop has restated `director` and `Beat Girl` — and `Who is the father of
+        // Frederick II?` names nothing past `Peter III of Aragon`, because `father`
+        // was restated by the hop that reached him.  A named step MOVES to structure
+        // the question asked for, so it is admitted on that ground; an unnamed one
+        // must carry the question's remainder as before, and from a CLOSED
+        // derivation — nothing left owed — it is not offered at all: the question
+        // asks for no further step, and the law would otherwise admit any.
+        const asked = ctx._edgeAsked;
+        let named = false;
+        if (asked !== null) {
+            const unsaid = {
+                bytes: asked.bytes,
+                index: unspoken(asked.index, spoken),
+            };
+            const names = namedContinuations(ctx, pivot, unsaid);
+            const hop = guidedFirst(ctx, pivot);
+            named = names !== null && hop !== undefined && names.includes(hop);
+        }
+        if (!named && closed(d)) {
+            ctx.trace?.step("pivotUnasked", [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")], [rItem(fc, "withheld")], "the derivation owes nothing and the question names no further step — not offered");
+            return null;
+        }
         pending = { kind: "pivot", cur, pivot, fc };
-        // Offered with the identity species ONLY when the grounding declared what it
-        // speaks for; otherwise the law requires this step to carry question
-        // material the grounding left unaccounted, which is the drift the extension
-        // tests pin — refused by the law's own measure, not by a private window
-        // test.
+        // Offered with the identity species when the question names the step;
+        // otherwise the law requires this step to carry question material the grounding left
+        // unaccounted, which is the drift the extension tests pin — refused by the
+        // law's own measure, not by a private window test.
         return {
             product: fc,
             contains: true,
-            reaches: producerOwnsShape,
+            reaches: named,
             cost: STEP,
         };
     };
     const onTaken = (before, after, witnesses) => {
         meterTransition(ctx, before, after, witnesses);
+        speak(after.product);
         const p = pending;
         pending = null;
         if (p === null)
@@ -646,6 +676,23 @@ primarySpans = []) {
             // again would only restate it.  Deliberately NOT a magnitude measure:
             // it fires on exact content-addressed recurrence, not on how strongly
             // the root resonates.
+            // ANOTHER INSTANCE IS NOT ANOTHER TOPIC.  A root the question witnesses
+            // in every byte but one contiguous span is the question's own frame
+            // around a different filler (evidence.ts, `coInstanceFiller`): the climb
+            // committed `Where was Peter Jackson born?` as a second point of
+            // `Where was the director of film Beat Girl born?` on the frame windows
+            // alone, and fusing it voiced Peter Jackson's birthplace beside the
+            // answer.  Such a root says what the question's relation IS (traverse.ts,
+            // `byCoInstance`), never what it asks about.
+            const asked = ctx._edgeAsked;
+            if (asked !== null) {
+                const form = read(ctx, root.anchor, 2 * query.length);
+                const co = coInstanceFiller(ctx, form, [asked.index], asked.bytes);
+                if (co !== null) {
+                    ctx.trace?.step("coInstanceRoot", [rNode(ctx, root.anchor, "point", root.vote)], [rItem(form.subarray(co.span[0], co.span[1]), "filler")], "the question witnesses this point in every byte but one filler of its own — another instance of the question's frame, not a further topic");
+                    continue;
+                }
+            }
             const cont = await follow(ctx, root.anchor, qv);
             if (cont !== null && cont.length > 0 &&
                 // The law's positional reading: the caller knows the material it is

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

@@ -26,8 +26,9 @@ export declare function joinWithBridge(ctx: MindContext, left: Uint8Array, right
  *  Shakespeare" (id 676) and the pivot hopped through "speare" (id 606, not
  *  in `consumed`) straight into that analog's own biography, which is exactly
  *  what the comparison had refused to voice.  The rule is CONTAINMENT, not
- *  overlap, so C3's genuine further hop — "Mona Lisa", a term inside the seat
- *  sentence but part of NEITHER analog — still fires. */
+ *  overlap, so C3's further term — "Mona Lisa", inside the seat sentence but
+ *  part of NEITHER analog — stays a candidate; whether the walk steps through
+ *  it is the naming rule's decision (reasoning.ts, evidence.md). */
 export declare function pivotInto(ctx: MindContext, answer: Uint8Array, consumed: ReadonlySet<number>, voiced?: readonly Uint8Array[]): Promise<number | null>;
 export declare function meaningOf(ctx: MindContext, bytes: Uint8Array, anchors: ReadonlyArray<{
     name: string;

package/dist/src/mind/resonance.js

@@ -236,8 +236,9 @@ export async function joinWithBridge(ctx, left, right) {
  *  Shakespeare" (id 676) and the pivot hopped through "speare" (id 606, not
  *  in `consumed`) straight into that analog's own biography, which is exactly
  *  what the comparison had refused to voice.  The rule is CONTAINMENT, not
- *  overlap, so C3's genuine further hop — "Mona Lisa", a term inside the seat
- *  sentence but part of NEITHER analog — still fires. */
+ *  overlap, so C3's further term — "Mona Lisa", inside the seat sentence but
+ *  part of NEITHER analog — stays a candidate; whether the walk steps through
+ *  it is the naming rule's decision (reasoning.ts, evidence.md). */
 export async function pivotInto(ctx, answer, consumed, voiced = []) {
     // The pivot's OWN shortlist capacity — not `recallQueryK`: they are different
     // quantities (a mechanical sweep's probe budget vs the bridge's candidate-read

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

@@ -1,5 +1,6 @@
 import { Vec } from "../vec.js";
 import type { AncestorReach, MindContext } from "./types.js";
+import { type WindowIndex } from "./evidence.js";
 /** The reach memo this ask should use — see the note above.
  *
  *  A TRACED response always gets a fresh, empty one. `AncestorReach`'s
@@ -140,8 +141,10 @@ export declare function argmaxCosine<T>(query: Vec, items: Iterable<T>, vecOf: (
  *  formRules all share.  undefined when the node has no continuation. */
 export declare function guidedFirst(ctx: MindContext, id: number): number | undefined;
 export declare function guidedNext(ctx: MindContext, node: number): number | undefined;
-/** 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
@@ -153,6 +156,78 @@ export declare function guidedNext(ctx: MindContext, node: number): number | und
  *  therefore scores by guide cosine.  The two directions consult different
  *  halves of the evidence on purpose. */
 export declare function chooseNext(ctx: MindContext, id: number, guide?: Vec | null): number | undefined;
+/** 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 declare function offsetCanon(ctx: MindContext, bytes: Uint8Array): Uint8Array;
+/** 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 declare function answersOtherQuestions(ctx: MindContext, id: number, queryLen: number, siteLen: number): boolean;
+/** 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 declare function namedContinuations(ctx: MindContext, id: number, asked: {
+    bytes: Uint8Array;
+    index: WindowIndex;
+}): number[] | null;
+/** 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 declare function askedEvidence(ctx: MindContext, id: number, pick: number): Array<[number, number]>;
+/** 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 declare function canonHeldPoints(ctx: MindContext, minLen: number): Array<{
+    start: number;
+    end: number;
+    payload: number;
+}>;
+/** 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 declare function coInstanceFiller(ctx: MindContext, raw: Uint8Array, indexes: ReadonlyArray<WindowIndex>, question: Uint8Array): {
+    span: [number, number];
+    spans: Array<[number, number]>;
+} | null;
 /** 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
@@ -198,6 +273,23 @@ export declare function chooseAmong(ctx: MindContext, candidates: readonly numbe
  * NOT 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;
+/** 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 declare function hubWindows(ctx: MindContext, bytes: Uint8Array): Uint8Array;
+/** 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 declare function scaffoldSpans(ctx: MindContext, query: Uint8Array): Array<[number, number]>;
+/** 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 declare function scaffoldExtents(ctx: MindContext, query: Uint8Array): Array<[number, number]>;
 /** 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.
  *