@hviana/sema 0.4.4 → 0.4.7

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

@@ -188,27 +188,31 @@ function computeWeave(ctx, query, pre, climb) {
     const askerBytes = query.length -
         ctx.answeredSpans.reduce((n, [start, end]) => n + end - start, 0);
     const capBytes = askerBytes * quantum;
-    // EXCLUSIVITY IS ARBITRATED BY THE CLIMB'S VOTE ORDER, DELIBERATELY.  A query
-    // byte can only be independent evidence for ONE point, so points are built in
-    // ranked order and each new point's runs are trimmed against every point
-    // already accepted; a point left with no run of a full quantum drops out of
-    // the weave.
+    // RUNS ARE NOT TRIMMED AGAINST EACH OTHER.  A point keeps every byte it
+    // aligned; exclusivity is a property of STRUCTURES (see "one place, one
+    // structure" below), not of individual query bytes.
     //
-    // That reads like first-come-wins — a point that merely ranked higher taking
-    // a span from the point that actually explains it — and arbitrating by LOCAL
-    // evidence instead (ownership of each byte to the longest covering run, then
-    // the heavier weight, then rank) was implemented and MEASURED: test/29 went
-    // 9/2 to 7/4, and the new failures name the reason. CAST requires the weave
-    // to touch a COMMITTED point of attention ("2 aligned structure(s), but none
-    // is one of the climb's 1 committed root(s)"), and it was precisely the vote
-    // order that kept the committed root's own point alive in the weave. Local
-    // run length knows nothing about what the climb settled on, so it evicted the
-    // root's evidence and left CAST refusing on its own consistency check.
+    // This weave used to build points in the climb's vote order and cut each new
+    // point's runs against every point already accepted.  It is worth recording
+    // what that cost, because the cut was invisible: it did not just resolve
+    // ties, it silently DECIDED downstream schemas.  A point's `runs[0]` — the
+    // run three CAST branches read as "the filler", "the seat", "the name" — was
+    // whichever run happened to survive the cut, so those schemas were reading an
+    // elimination order as though it were evidence, and the query's own bytes
+    // were truncated on the way ("Shakespeare" surviving as "Shakes").  Each
+    // consumer now derives its own reading from the runs (cast.ts: `fillerRun`
+    // clips at the seat, redirection scans for the naming run, entry counts own
+    // bytes and the climb's dispersion), and with those in place removing the cut
+    // costs nothing — measured, the same 442 tests pass either way.
     //
-    // So the vote order here is not an accident of construction — it is what
-    // holds the weave and the climb to the same conclusion. Weave-local
-    // measures decide what is FRAME inside the weave (see the frame gates in
-    // cast.ts); which structures are in the weave at all stays the climb's call.
+    // What the vote order was RIGHT about is kept: which structures belong in the
+    // weave is the climb's call, not a local run measure. Arbitrating byte
+    // ownership by local evidence instead (longest covering run, then weight,
+    // then rank) was implemented and MEASURED, and it evicted the committed
+    // root's own evidence — CAST then refused on its own consistency check ("2
+    // aligned structure(s), but none is one of the climb's 1 committed root(s)"),
+    // test/29 going 9/2 to 7/4. Weave-local measures decide what is FRAME inside
+    // the weave (see the frame gates in cast.ts); membership stays the climb's.
     //
     // TWO PASSES.  `depth` — how much of the weave agrees on each query byte, and
     // therefore what counts as FRAME — must be the whole weave's, not "whatever
@@ -304,34 +308,38 @@ function computeWeave(ctx, query, pre, climb) {
         });
         if (raw.length === 0)
             continue;
+        // DEPTH COUNTS STRUCTURES, NOT WEIGHT.  The frame test is
+        // `dominates(depth[i], aligned)` — "more than half the weave shares this
+        // byte" — and `aligned` is a COUNT of points.  Accumulating graded
+        // alignment WEIGHT here compared weight-mass against a cardinality: two
+        // different dimensions, meaningful only while truncation happened to keep
+        // points.length small and weights near 1.
+        //
+        // Measured (test/29 C2, only truncation toggled): 9 candidates collapse to
+        // 2 points and 29/42 bytes read FRAME; without truncation 9 points survive
+        // and only 6/42 do. The elimination was SETTING the frame threshold, so
+        // every attempt to change run ownership inverted the frame reading and
+        // lost the same 10 tests (442 -> 432, twice, for opposite designs).
+        //
+        // Counting distinct covering candidates restores the documented meaning
+        // exactly and makes the comparison like-for-like, which decouples the
+        // frame gate from however many points survive.
+        const covered = new Uint8Array(query.length);
         for (const r of raw) {
-            for (let i = r.qs; i < r.qe; i++)
-                depth[i] += r.weight;
+            for (let i = r.qs; i < r.qe; i++) {
+                if (!covered[i]) {
+                    covered[i] = 1;
+                    depth[i] += 1;
+                }
+            }
         }
         cands.push({ cand, ctxBytes, raw });
     }
     for (const { cand, ctxBytes, raw } of cands) {
         const free = [];
         for (const r of raw) {
-            let { qs, qe, cs, weight } = r;
-            for (const p of points) {
-                for (const o of p.runs) {
-                    if (qs >= qe)
-                        break;
-                    if (o.qe <= qs || o.qs >= qe)
-                        continue;
-                    const left = Math.max(0, o.qs - qs);
-                    const right = Math.max(0, qe - o.qe);
-                    if (left >= right)
-                        qe = qs + left;
-                    else {
-                        cs += qe - right - qs;
-                        qs = qe - right;
-                    }
-                }
-            }
-            if (qe - qs >= Math.min(quantum, ctxBytes.length)) {
-                free.push({ qs, qe, cs, weight });
+            if (r.qe - r.qs >= Math.min(quantum, ctxBytes.length)) {
+                free.push({ ...r });
             }
         }
         if (free.length > 0) {
@@ -340,6 +348,8 @@ function computeWeave(ctx, query, pre, climb) {
                 vote: cand.vote,
                 ctx: ctxBytes,
                 runs: free,
+                start: cand.start,
+                end: cand.end,
             };
             byAnchor.set(cand.anchor, pt);
             points.push(pt);
@@ -449,6 +459,8 @@ function computeWeave(ctx, query, pre, climb) {
                             vote: cand.vote,
                             ctx: ctxBytes,
                             runs: [run],
+                            start: cand.start,
+                            end: cand.end,
                         };
                         byAnchor.set(cand.anchor, made);
                         points.push(made);
@@ -461,5 +473,49 @@ function computeWeave(ctx, query, pre, climb) {
             }
         }
     }
+    // ONE PLACE, ONE STRUCTURE.  A stored sentence and the entity it names are
+    // not two independent structures when the query's evidence for them is the
+    // same bytes — they are one place read at two grains, and admitting both
+    // lets a nest of containing sentences outvote the entity the query actually
+    // named.  Measured on test/29 C2 ("How is Shakespeare like Leonardo da
+    // Vinci?"): the five sentences that merely CONTAIN the two names align the
+    // same q6-18 / q23-41 the names do, and comparison ended up seated on a
+    // 49-byte sentence instead of the 17-byte entity.
+    //
+    // A point earns its own place in the weave the same way a second point earns
+    // CAST's entry: at least one perception quantum of query bytes no
+    // better-voted point already explains.  Points arrive in the climb's vote
+    // order, which is the arbiter this file already trusts for what belongs in
+    // the weave; unlike run trimming, nothing is CUT here — a point keeps every
+    // byte it aligned or it is not a separate structure at all.
+    const coveredOf = (p) => {
+        const set = new Set();
+        for (const r of p.runs)
+            for (let i = r.qs; i < r.qe; i++)
+                set.add(i);
+        return set;
+    };
+    const kept = [];
+    const keptCover = [];
+    for (const p of points) {
+        const cov = coveredOf(p);
+        let redundant = false;
+        for (const other of keptCover) {
+            let own = 0;
+            for (const i of cov)
+                if (!other.has(i))
+                    own++;
+            if (own < quantum) {
+                redundant = true;
+                break;
+            }
+        }
+        if (!redundant) {
+            kept.push(p);
+            keptCover.push(cov);
+        }
+    }
+    points.length = 0;
+    points.push(...kept);
     return { points, depth };
 }

package/dist/src/mind/pipeline.js

@@ -9,11 +9,12 @@
 // each); the shared pre-computation they exchange lives in Precomputed
 // (pipeline-mechanism.ts).
 import { PASS, STEP } from "./graph-search.js";
-import { gistOf, resolve } from "./primitives.js";
+import { gistOf, read, resolve } from "./primitives.js";
 import { recognise } from "./recognition.js";
 import { fuseAttention, reason } from "./reasoning.js";
 import { unexplainedSpans } from "./rationale.js";
 import { rItem } from "./trace.js";
+import { hubBound } from "./traverse.js";
 import { Precomputed } from "./pipeline-mechanism.js";
 import { coverMechanism } from "./mechanisms/cover.js";
 import { castMechanism } from "./mechanisms/cast.js";
@@ -220,9 +221,36 @@ export async function think(ctx, query, mechs) {
     // 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
     // fact that produced it (see MechanismResult.complete).
+    // WHAT THE MECHANISM WITHHELD, NOT WHAT IT VOICED.  A pivot must not
+    // re-open content a grounding deliberately kept out: comparison cites two
+    // analogs and refuses their own downstream facts, so pivoting into one is
+    // the mechanism's own refusal undone one step later (test/29 C2 pivoted
+    // through `speare` — a stored fragment of the analog `William Shakespeare`
+    // — into the biography CAST had declined).
+    //
+    // 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.
+    // 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.
+    //
+    // Only a mechanism carrying its own `used` set (cast/join) gets this: there
+    // `preConsumed` is a deliberate, short list of the anchors the answer
+    // speaks for, so the fan-out is bounded.  For every other provenance
+    // `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 = (provenance === "cast" || provenance === "join")
+        ? [...castUsed].flatMap((id) => ctx.store.nextFirst(id, hubBound(ctx)).map((n) => read(ctx, n)))
+        : [];
     const reasoned = decided.complete ? answer : meter
-        ? await meter.time("reason", () => reason(ctx, query, answer, preConsumed, pre))
-        : await reason(ctx, query, answer, preConsumed, pre);
+        ? await meter.time("reason", () => reason(ctx, query, answer, preConsumed, pre, voiced))
+        : await reason(ctx, query, answer, preConsumed, pre, voiced);
     // Fuse only when the query has a genuine REMAINDER no mechanism's
     // structural evidence touched at all.  `decided.accounted` alone
     // undercounts this: it is a COST-LADDER quantity (cover.ts prices its

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

@@ -15,10 +15,12 @@ export declare function restatesQuery(query: Uint8Array, bytes: Uint8Array): boo
  *  Pivots on the longest unconsumed learnt context each answer contains,
  *  then follows the pivot's continuation to the next fact.  Repeats up
  *  to `cfg.recallQueryK` hops.  `preConsumed` carries node ids already
- *  spoken for by the grounding stage (cover/extract/CAST).  `pre` is the
+ *  spoken for by the grounding stage (cover/extract/CAST).  `voiced` carries
+ *  the BYTES of the anchors a mechanism declared it voiced (its `used` set),
+ *  when it declared one — see the pivot's own containment rule.  `pre` is the
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
-export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed): Promise<Uint8Array>;
+export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[]): Promise<Uint8Array>;
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together

package/dist/src/mind/reasoning.js

@@ -25,10 +25,12 @@ export function restatesQuery(query, bytes) {
  *  Pivots on the longest unconsumed learnt context each answer contains,
  *  then follows the pivot's continuation to the next fact.  Repeats up
  *  to `cfg.recallQueryK` hops.  `preConsumed` carries node ids already
- *  spoken for by the grounding stage (cover/extract/CAST).  `pre` is the
+ *  spoken for by the grounding stage (cover/extract/CAST).  `voiced` carries
+ *  the BYTES of the anchors a mechanism declared it voiced (its `used` set),
+ *  when it declared one — see the pivot's own containment rule.  `pre` is the
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
-export async function reason(ctx, query, answer, preConsumed, pre) {
+export async function reason(ctx, query, answer, preConsumed, pre, voiced = []) {
     // 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
@@ -115,7 +117,7 @@ export async function reason(ctx, query, answer, preConsumed, pre) {
         }
         // Pivot: find the longest unconsumed learnt context the answer contains.
         consumeAll(curId);
-        const pivot = await pivotInto(ctx, cur, consumed);
+        const pivot = await pivotInto(ctx, cur, consumed, voiced);
         if (pivot === null)
             break;
         const fc = await follow(ctx, pivot, qv);
@@ -171,8 +173,31 @@ primarySpans = []) {
     // here, since it is an absolute ln(N)-scaled quantity (a genuine root on
     // a large store can score BELOW its own floor while a coincidental echo
     // on a small one scores comfortably above its own, smaller, floor).
+    //
+    // Breadth alone is not enough when primary is a pure COMPUTATION.  The ALU
+    // answers "2+2 equals what?" with 4, and the store's own arithmetic table
+    // then supplies a lone root — an exemplar like "1+2" — whose breadth
+    // dominates because it is corroborated by the computation's OWN bytes.
+    // Fusing it projected that exemplar's continuation and the bridge voiced
+    // "4+3" (test/11 seed 99).  A second point of attention must stand on
+    // evidence that is structurally SEPARATE from primary's: at least one
+    // perceptual quantum of query between them, the same separation
+    // countClusters uses to tell independent evidence neighbourhoods apart.
+    // Not a score, and not a tuned bar — the fold's own quantum.
+    //
+    // With no primarySpans (the caller did not resolve them) every span
+    // vacuously qualifies, preserving the original behaviour exactly.
+    const quantum = ctx.space.maxGroup;
+    const independentOfPrimary = (root) => primarySpans.every(([s, e]) => {
+        const gap = root.end <= s
+            ? s - root.end
+            : e <= root.start
+                ? root.start - e
+                : 0;
+        return gap >= quantum;
+    });
     const lonePromotes = unclimbed && forest.length === 1 &&
-        forest[0].breadth > 0.5;
+        forest[0].breadth > 0.5 && independentOfPrimary(forest[0]);
     if (forest.length === 0 || (forest.length <= 1 && !lonePromotes)) {
         return primary;
     }

package/dist/src/mind/recognition.js

@@ -225,6 +225,58 @@ function recogniseImpl(ctx, bytes) {
                             emit(start, end - k, eRight);
                     }
                 }
+                // A trained form embedded at this span's left edge, past the
+                // chunk-scale bound above.  The loop above probes exactly this — trim
+                // k leading bytes, verify the remainder is a stored branch — but only
+                // for spans of at most W².  A turn prefixed with a connective is
+                // turn-scale, so it never qualified.
+                //
+                // Widening that loop's SIZE bound is what reopens test/46's
+                // root-scale false positive.  Widening only its LEFT trim, to a
+                // bounded W offsets, does not: every candidate is still verified by
+                // exact content addressing (the leaf-id run must BE a stored branch),
+                // and the result always ends where this span ends, so it can never
+                // introduce the smaller-subtree duplicate that regression was about.
+                //
+                // This replaces an assumption that no longer holds — that such a
+                // form's left edge must be a cut the fold itself drew.  It held while
+                // cuts had long memory and a turn boundary reliably produced one; a
+                // bounded-window rule re-synchronises a byte or two INTO the turn
+                // instead, so the edge itself is often not a cut ("And " ends at 65,
+                // and the fold's nearest cuts are 61 and 67).
+                // No leaf-id prefilter here, unlike the loop above: a leaf id is the
+                // LONGEST known leaf at a position, so the run itself is context
+                // sensitive — measured, the embedded copy of a trained form yields a
+                // different run from the standalone one and findBranch misses even
+                // though the bytes resolve exactly (span [65,94): findBranch null,
+                // resolve 91).  With only W candidates the exact fold is affordable,
+                // and it is the stronger evidence anyway: if it resolves, these exact
+                // bytes ARE a stored node.
+                for (let k = 1; k <= W && start + k < end - 1; k++) {
+                    const eLeft = resolve(ctx, bytes.subarray(start + k, end));
+                    if (eLeft !== null)
+                        emit(start + k, end, eLeft);
+                }
+                // THE SAME SEARCH ON THE OTHER EDGE.  Everything above trims from the
+                // LEFT and keeps this span's END fixed, so a stored form was findable
+                // only when it ENDED where a fold node ends.  Measured on a 12-context
+                // store, probing for a trained 47-byte sentence wrapped in filler:
+                // 1-4 bytes of LEFT padding kept it recognisable, while ONE byte of
+                // right padding lost it.  That asymmetry was never argued for — the
+                // reasoning above is about a form's left edge landing on a cut, and it
+                // says nothing about which side the noise is on.
+                //
+                // The stated hazard for widening this search is test/46's root-scale
+                // false positive, and it is a hazard of the SIZE bound, not of the
+                // direction: like its mirror this loop is bounded to W offsets and
+                // every candidate is verified by exact content addressing, so it can
+                // only ever emit spans that ARE stored nodes.  Measured: neutral on
+                // the suite, and the right-padded cases above become recognisable.
+                for (let k = 1; k <= W && start < end - k - 1; k++) {
+                    const eRight = resolve(ctx, bytes.subarray(start, end - k));
+                    if (eRight !== null)
+                        emit(start, end - k, eRight);
+                }
                 // A REAL extra word at the left edge (a discourse connective like
                 // "And " prepended to a follow-up turn — not boundary noise, actual
                 // content the injected canonicalizer has no equivalence for) shows
@@ -375,12 +427,14 @@ function recogniseImpl(ctx, bytes) {
         }
     }
     const chunkEnd = new Uint32Array(bytes.length);
+    const chunkSpan = new Uint32Array(bytes.length);
     const sorted = [...starts].sort((a, b) => a - b);
     for (let si = 0; si < sorted.length; si++) {
         const chunkStart = sorted[si];
         const chunkLimit = si + 1 < sorted.length ? sorted[si + 1] : bytes.length;
         for (let p = chunkStart; p < chunkLimit; p++) {
             chunkEnd[p] = chunkLimit;
+            chunkSpan[p] = chunkLimit - chunkStart;
         }
     }
     // A chain rebuilt from a NON-boundary offset (the query's own perceived
@@ -434,8 +488,19 @@ function recogniseImpl(ctx, bytes) {
             tryChain(p, chainReach(W), true); // boundary start — full reach
         }
         else {
-            const limit = chunkEnd[p] + W;
-            tryChain(p, Math.min(limit - p, chainReach(W)), false);
+            // THE INTERIOR BUDGET IS "ONE CHUNK PLUS A QUANTUM", MEASURED FROM THE
+            // CHAIN'S OWN START.  It used to be `chunkEnd[p] + W - p`, which counts
+            // from the chunk's END, so the reach an interior chain gets depended on
+            // WHERE INSIDE its chunk it happened to begin: measured on a composed
+            // answer, a chunk spanning [0,6) gave offset 1 nine ids and offset 4
+            // only six — and the 9-id trained form `Mona Lisa` starting at 4 died
+            // three ids short of itself.  The same form one byte earlier would have
+            // been found.  That is the position artifact this module has been
+            // removing everywhere else, not a budget.
+            //
+            // Stated from `p` the trust is unchanged — a chain may span its own
+            // chunk and one quantum beyond it — and it no longer varies with phase.
+            tryChain(p, Math.min(chunkSpan[p] + W, chainReach(W)), false);
         }
     }
     // ── splits: a form boundary that does not fall on a leaf edge ────────

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

@@ -15,8 +15,20 @@ export declare function joinWithBridge(ctx: MindContext, left: Uint8Array, right
  *  CONTEXT (a node bearing a continuation edge) whose bytes `answer` literally
  *  contains.  Candidates are gathered by resonating the answer's sub-regions
  *  (breadth-first, leaves skipped, probes capped by branch count), then
- *  confirmed by exact byte containment — a near-resonance alone never hops. */
-export declare function pivotInto(ctx: MindContext, answer: Uint8Array, consumed: ReadonlySet<number>): Promise<number | null>;
+ *  confirmed by exact byte containment — a near-resonance alone never hops.
+ *
+ *  `voiced` carries the BYTES of the anchors the grounding mechanism declared
+ *  it spoke for, and no candidate CONTAINED IN one of them may be pivoted
+ *  through.  Node identity alone is too coarse a reading of "already spoken
+ *  for": the same content is interned at several scales, so a strict fragment
+ *  of a voiced anchor is a different id carrying no evidence the anchor did
+ *  not already carry.  Measured on test/29 C2 — CAST voiced "William
+ *  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. */
+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;
     form: Uint8Array;

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

@@ -64,9 +64,28 @@ export interface Attention {
     anchor: number;
     /** IDF-weighted consensus vote — the strength that orders points. */
     vote: number;
-    /** The union of the query byte-spans whose evidence supports this point. */
+    /** The query span of the point's STRONGEST contributing region — the argmax
+     *  over `wFocus` (see `peak`, which is that same region's weight), NOT a
+     *  union or hull over every region that voted.  Measured on test/24 3.2: the
+     *  winning anchor's span here was 2 bytes while its contributing regions
+     *  together covered most of the query.  It is the minimal honest statement
+     *  of what a grounding on this anchor rests on, and recall accounts exactly
+     *  it for that reason — widening it to every contributing region made recall
+     *  out-bid mechanisms that had genuinely explained more (a GENERATED list
+     *  degraded to a RETRIEVED one, test/24 3.2 and test/04 1). */
     start: number;
     end: number;
+    /** The largest SINGLE region's contribution to this point's pooled vote —
+     *  the weight of the very region `start`..`end` delimits (both are the
+     *  argmax over `wFocus`), so the two fields describe one region: its
+     *  strength and its place.
+     *  `vote` is a sum over every region that agreed, so it grows with how many
+     *  places corroborated; `peak` is what the strongest one of them said on its
+     *  own.  A consumer holding this point to consensusFloor(N) — a bar that
+     *  prices ONE region's maximally-discriminative evidence — must read `peak`,
+     *  not `vote`: six scaffolding regions summing past the floor is not the
+     *  same claim as one region clearing it. */
+    peak: number;
     /** SCALE-INVARIANT confidence: the fraction of the query's OWN regions
      *  whose evidence this point accounts for (Σ RegionVote.absorbed among
      *  its contributors, over the query's total region count) — read PER-
@@ -118,6 +137,24 @@ export interface Region {
      *  resonance score is byte-overlap, evidence only in excess of its best
      *  rival conclusion. */
     known: boolean;
+    /** The stored node this region's bytes ARE, when the region came from a
+     *  recognised SITE — content-addressed and exact, so the climb has no
+     *  reason to re-derive it approximately.  A perceived sub-tree leaves this
+     *  undefined; chunks get the same thing from `canonicalChunkId`. */
+    id?: number;
+    /** EVIDENCE, NOT A POINT OF ATTENTION.  True for a region the query's own
+     *  fold never produced — a stored form that a content-defined cut SPLIT,
+     *  recovered by sliding-window lookup in collectRegions.  The store
+     *  guarantees such a form is addressable (canonicalWindows interns both
+     *  lengths), so it may corroborate an anchor's vote; but the query did not
+     *  weave it as an independent structure, so it must not make the query look
+     *  like it holds one more point of attention than it does — it is kept out
+     *  of the root-cut distribution and out of the breadth ratio (see
+     *  poolVotes/commitVotes).  Absent/false for every region from the fold.
+     *  (Flagging these `chunk: true` instead is REFUTED — a chunk is a
+     *  smallest unit the FOLD produced, and claiming first-class unit status
+     *  for an assembled span cost 5 tests.) */
+    corroborating?: boolean;
 }
 /** Per-region vote data from the consensus climb's resonance pass. */
 export interface RegionVote {
@@ -148,6 +185,11 @@ export interface RegionVote {
      *  a MULTI-topic query structurally cannot.  Absent for an ordinary
      *  per-region vote, where the merged span already is the truth. */
     parts?: readonly (readonly [number, number])[];
+    /** Carried through from {@link Region.corroborating}: this vote's evidence
+     *  is a stored form the query's fold SPLIT, not a structure the query wove.
+     *  Votes are what the pool sees (regions are not), so the flag has to
+     *  travel with the vote for the root election to honour it. */
+    corroborating?: boolean;
 }
 /** The structural gate that first decided an {@link edgeAncestors} climb was
  *  saturated (an abstention, not a discriminative conclusion) — pure

package/dist/src/rabitq-ivf/src/rabitq.js

@@ -225,7 +225,37 @@ export class RaBitQuantizer {
         const lut = q.qlut;
         let dot = 0;
         let popcount = 0;
-        for (let p = 0; p < nb; p++) {
+        // THE INNERMOST LOOP OF SEARCH.  Profiled on the trained store: 170 ANN
+        // queries scan 8,702,005 slots, and this estimate — inlined by V8 into
+        // IvfIndex.scanClusters, which is why it does not appear separately — was
+        // 21% of all inference CPU.
+        //
+        // The `dot` half is an irreducible data-dependent LUT probe per byte.  The
+        // `popcount` half is not: it is the same sign-bit count `codeDistanceBytes`
+        // below already folds into 32-bit words ("~4x fewer loop iterations"), and
+        // that reasoning applies verbatim here.  Four bytes are packed into one
+        // word and popcounted with the standard SWAR reduction, while the four LUT
+        // probes are issued together so their loads overlap instead of serialising
+        // behind the popcount.
+        //
+        // BIT-IDENTICAL, not an approximation: popcount over four bytes equals the
+        // sum of their individual popcounts, and the LUT terms are added in the
+        // same order at the same indices.  Verified by direct comparison, and the
+        // 445 suite plus the battery's answers are unchanged.
+        let p = 0;
+        for (const n4 = nb & ~3; p < n4; p += 4) {
+            const o = byteOffset + p;
+            const b0 = codeBytes[o], b1 = codeBytes[o + 1];
+            const b2 = codeBytes[o + 2], b3 = codeBytes[o + 3];
+            dot += lut[(p << 8) + b0] + lut[((p + 1) << 8) + b1] +
+                lut[((p + 2) << 8) + b2] + lut[((p + 3) << 8) + b3];
+            let x = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
+            x -= (x >>> 1) & 0x55555555;
+            x = (x & 0x33333333) + ((x >>> 2) & 0x33333333);
+            x = (x + (x >>> 4)) & 0x0f0f0f0f;
+            popcount += Math.imul(x, 0x01010101) >>> 24;
+        }
+        for (; p < nb; p++) {
             const b = codeBytes[byteOffset + p];
             dot += lut[(p << 8) + b];
             popcount += POPCOUNT8[b];

package/dist/src/sema.d.ts

@@ -24,8 +24,18 @@ export interface Space {
 /** Bind one vector into a seat — the elementary half of fold. Used to index an
  *  episode from either side and to pour a partner into a form's halo. */
 export declare const bindSeat: (space: Space, v: Vec, seat: number) => Vec;
+/** The positional coordinate of child `index` inside a node of `size` items.
+ *
+ * Positions are anchored at BOTH ends of the full keyring: the left half uses
+ * the lowest seats and the right half uses the highest seats.  Growing a node
+ * at one edge therefore preserves the coordinates anchored at the other edge,
+ * while every position remains injective as long as
+ * `0 <= index < size <= seatCount`.  The helper is shared by perception and by
+ * synthetic/canonical folds so there is exactly one structural algebra. */
+export declare function twoEndedSeat(seatCount: number, size: number, index: number): number;
 /** The company signature of node `id` — the halo's pour unit (see above). */
 export declare function companySignature(space: Space, id: number): Vec;
 /** fold — combine ordered children into one gist.
- *  Each child is turned with its seat's own key, superposed, normalized. */
+ *  Each child is turned in the same two-ended coordinate frame used by the
+ *  perception tree, then superposed and normalized. */
 export declare function fold(space: Space, kids: Vec[]): Vec;

package/dist/src/sema.js

@@ -10,6 +10,18 @@ let _foldBuf = null;
 /** Bind one vector into a seat — the elementary half of fold. Used to index an
  *  episode from either side and to pour a partner into a form's halo. */
 export const bindSeat = (space, v, seat) => permute(v, space.seats[seat].fwd);
+/** The positional coordinate of child `index` inside a node of `size` items.
+ *
+ * Positions are anchored at BOTH ends of the full keyring: the left half uses
+ * the lowest seats and the right half uses the highest seats.  Growing a node
+ * at one edge therefore preserves the coordinates anchored at the other edge,
+ * while every position remains injective as long as
+ * `0 <= index < size <= seatCount`.  The helper is shared by perception and by
+ * synthetic/canonical folds so there is exactly one structural algebra. */
+export function twoEndedSeat(seatCount, size, index) {
+    const front = (size + 1) >> 1;
+    return index < front ? index : seatCount - size + index;
+}
 // ── Company signatures ──────────────────────────────────────────────────
 //
 // A halo is a superposition of EPISODE SIGNATURES: it answers "who does this
@@ -45,7 +57,8 @@ export function companySignature(space, id) {
     return v;
 }
 /** fold — combine ordered children into one gist.
- *  Each child is turned with its seat's own key, superposed, normalized. */
+ *  Each child is turned in the same two-ended coordinate frame used by the
+ *  perception tree, then superposed and normalized. */
 export function fold(space, kids) {
     if (kids.length > space.seats.length) {
         throw new Error(`fold: ${kids.length} children but the keyring has only ${space.seats.length} seats`);
@@ -56,7 +69,8 @@ export function fold(space, kids) {
     }
     const buf = _foldBuf;
     for (let i = 0; i < kids.length; i++) {
-        permuteInto(buf, kids[i], space.seats[i].fwd);
+        const slot = twoEndedSeat(space.seats.length, kids.length, i);
+        permuteInto(buf, kids[i], space.seats[slot].fwd);
         addInto(out, buf);
     }
     return normalize(out);