@hviana/sema 0.4.4 → 0.4.7

package/src/mind/pipeline-mechanism.ts

@@ -199,6 +199,10 @@ export interface WeaveInfo {
     vote: number;
     ctx: Uint8Array;
     runs: GradedRun[];
+    /** The query span the CLIMB elected this anchor from — its evidence,
+     *  independent of any literal run alignment (see Attention.start/end). */
+    start: number;
+    end: number;
   }>;
   /** Weighted depth at each query byte — sum of alignment weights.
    *  `depth[i]` is the total evidence that byte i is shared among the
@@ -235,27 +239,31 @@ function computeWeave(
   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
@@ -352,30 +360,38 @@ function computeWeave(
       },
     );
     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: GradedRun[] = [];
     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) {
@@ -384,6 +400,8 @@ function computeWeave(
         vote: cand.vote,
         ctx: ctxBytes,
         runs: free,
+        start: cand.start,
+        end: cand.end,
       };
       byAnchor.set(cand.anchor, pt);
       points.push(pt);
@@ -486,6 +504,8 @@ function computeWeave(
               vote: cand.vote,
               ctx: ctxBytes,
               runs: [run],
+              start: cand.start,
+              end: cand.end,
             };
             byAnchor.set(cand.anchor, made);
             points.push(made);
@@ -497,6 +517,46 @@ function computeWeave(
       }
     }
   }
+  // 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: WeaveInfo["points"][number]): Set<number> => {
+    const set = new Set<number>();
+    for (const r of p.runs) for (let i = r.qs; i < r.qe; i++) set.add(i);
+    return set;
+  };
+  const kept: WeaveInfo["points"] = [];
+  const keptCover: Array<Set<number>> = [];
+  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/src/mind/pipeline.ts

@@ -12,11 +12,12 @@
 import type { MindContext } from "./types.js";
 import { PASS, STEP } from "./graph-search.js";
 import type { ComputedSpan } from "../extension.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 { type PipelineMechanism, Precomputed } from "./pipeline-mechanism.js";
 import { coverMechanism } from "./mechanisms/cover.js";
 import { castMechanism } from "./mechanisms/cast.js";
@@ -367,12 +368,41 @@ export async function think(
   // 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),
+      () => reason(ctx, query, answer, preConsumed, pre, voiced),
     )
-    : await reason(ctx, query, answer, preConsumed, pre);
+    : 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

package/src/mind/reasoning.ts

@@ -5,7 +5,7 @@
 import { rItem, rNode } from "./trace.js";
 
 import { bytesEqual, indexOf } from "../bytes.js";
-import type { MindContext } from "./types.js";
+import type { Attention, MindContext } from "./types.js";
 import { resolve } from "./primitives.js";
 import { corpusN, hubBound } from "./traverse.js";
 import { follow, haloSiblings, project } from "./match.js";
@@ -31,7 +31,9 @@ export function restatesQuery(query: Uint8Array, bytes: Uint8Array): boolean {
  *  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(
@@ -40,6 +42,7 @@ export async function reason(
   answer: Uint8Array,
   preConsumed: ReadonlySet<number>,
   pre: Precomputed,
+  voiced: readonly Uint8Array[] = [],
 ): Promise<Uint8Array> {
   // 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
@@ -132,7 +135,7 @@ export async function reason(
 
     // 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);
@@ -201,8 +204,32 @@ export async function fuseAttention(
   // 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: Attention): boolean =>
+    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/src/mind/recognition.ts

@@ -242,6 +242,56 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
             if (eRight !== null) 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
@@ -384,12 +434,14 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
   }
 
   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;
     }
   }
 
@@ -443,8 +495,19 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
     if (starts.has(p)) {
       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);
     }
   }
 

package/src/mind/types.ts

@@ -101,9 +101,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-
@@ -158,6 +177,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. */
@@ -189,6 +226,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

package/src/rabitq-ivf/src/rabitq.ts

@@ -249,7 +249,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/src/sema.ts

@@ -47,6 +47,23 @@ let _foldBuf: Vec | null = null;
 export const bindSeat = (space: Space, v: Vec, seat: number): Vec =>
   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: number,
+  size: number,
+  index: number,
+): number {
+  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
@@ -82,7 +99,8 @@ export 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 function fold(space: Space, kids: Vec[]): Vec {
   if (kids.length > space.seats.length) {
     throw new Error(
@@ -95,7 +113,8 @@ export function fold(space: Space, kids: Vec[]): Vec {
   }
   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);