@hviana/sema 0.1.6 → 0.1.8

package/src/alu/src/parser.ts

@@ -172,10 +172,27 @@ export class QueryParser {
       j,
       bytes: this.evalRun(query.subarray(i, j)),
     }));
-    const spans: ComputedSpan[] = runs.filter(
-      (r): r is ComputedSpan => r.bytes !== null,
-    );
-    let stream = compose(tokens, runs);
+    // BRACKETED runs — "(3 + 4) * (10 - 2)" — extend across grouping
+    // notation the flat alternation cannot cross.  The expression grammar
+    // (expr.ts) already nests and parenthesizes; this only hands it the
+    // WHOLE bracketed span instead of the fragments between brackets.  A
+    // bracketed run that evaluates ABSORBS the flat runs inside it (the
+    // authority law: contained spans are its material); one that does not
+    // evaluate leaves the flat readings untouched.
+    const bracketed = this.bracketedRuns(query, tokens)
+      .map(([i, j]) => ({ i, j, bytes: this.evalRun(query.subarray(i, j)) }))
+      .filter((r): r is ComputedSpan => r.bytes !== null);
+    const absorbed = (r: { i: number; j: number }) =>
+      bracketed.some((b) => b.i <= r.i && r.j <= b.j);
+    const composedRuns = [
+      ...runs.filter((r) => !absorbed(r)),
+      ...bracketed,
+    ].sort((a, b) => a.i - b.i);
+    const spans: ComputedSpan[] = [
+      ...runs.filter((r): r is ComputedSpan => r.bytes !== null),
+      ...bracketed,
+    ];
+    let stream = compose(tokens, composedRuns);
     const readings = new Map<Token, readonly string[]>();
     for (;;) {
       const fired = await this.operations(query, stream, readings);
@@ -302,6 +319,90 @@ export class QueryParser {
     return runs;
   }
 
+  /** The maximal BRACKETED arithmetic runs: like {@link arithmeticRuns} but
+   *  grouping brackets participate — an all-'(' term opens depth where an
+   *  operand is expected, a term beginning with ')' closes it where an
+   *  operator could follow (only its bracket prefix joins the run; anything
+   *  after — a trailing "?" — ends it).  A run is recorded only when it is
+   *  BALANCED, actually crossed a bracket, and contains an operator — the
+   *  bracket-free case is {@link arithmeticRuns}' own.  Evaluation is the
+   *  same registry-derived grammar, whose lexer already reads the brackets. */
+  private bracketedRuns(
+    query: Uint8Array,
+    tokens: Token[],
+  ): Array<[number, number]> {
+    const OPEN = 0x28, CLOSE = 0x29;
+    const bracketPrefix = (t: Token, b: number): number => {
+      if (t.kind !== "term") return 0;
+      let n = 0;
+      while (t.i + n < t.j && query[t.i + n] === b) n++;
+      return n;
+    };
+    const allOf = (t: Token, b: number): boolean =>
+      bracketPrefix(t, b) === t.j - t.i;
+    const bridged = (from: number, to: number): boolean =>
+      from >= to || this.host.segment(query.subarray(from, to)).length <= 1;
+    const runs: Array<[number, number]> = [];
+    let k = 0;
+    while (k < tokens.length) {
+      const first = tokens[k];
+      if (first.kind !== "operand" && !allOf(first, OPEN)) {
+        k++;
+        continue;
+      }
+      let depth = 0;
+      let ops = 0;
+      let brackets = 0;
+      let expectOperand = true;
+      let end = -1; // byte end of the last VALID run state (balanced, after operand/close)
+      let endTok = k; // token index just past the accepted prefix
+      let m = k;
+      let prevJ = -1;
+      while (m < tokens.length) {
+        const t = tokens[m];
+        if (prevJ >= 0 && !bridged(prevJ, t.i)) break;
+        if (expectOperand) {
+          if (allOf(t, OPEN)) {
+            depth += t.j - t.i;
+            brackets++;
+          } else if (t.kind === "operand") {
+            expectOperand = false;
+            if (depth === 0) {
+              end = t.j;
+              endTok = m + 1;
+            }
+          } else break;
+        } else {
+          const c = bracketPrefix(t, CLOSE);
+          if (c > 0 && depth > 0) {
+            const take = Math.min(c, depth);
+            depth -= take;
+            brackets++;
+            if (depth === 0) {
+              end = t.i + take;
+              endTok = m + 1;
+            }
+            // A term with content beyond its usable bracket prefix ("?")
+            // ends the run inside the term.
+            if (take < t.j - t.i) break;
+          } else if (t.kind === "operator") {
+            expectOperand = true;
+            ops++;
+          } else break;
+        }
+        prevJ = t.j;
+        m++;
+      }
+      if (end >= 0 && ops > 0 && brackets > 0) {
+        runs.push([first.i, end]);
+        k = endTok;
+      } else {
+        k++;
+      }
+    }
+    return runs;
+  }
+
   /** Evaluate an infix-arithmetic run to its canonical result bytes, through
    *  the kernel's recursive expression evaluator, or null if it does not
    *  evaluate.  A whole result stays an exact int; otherwise the canonical

package/src/canon.ts

@@ -0,0 +1,65 @@
+// canon.ts — content canonicalization for equivalence-class resolution.
+//
+// The store is content-addressed on RAW bytes: "What", "WHAT" and "what" are
+// three different hashes, so a query whose surface form varies from the
+// trained form resolves to nothing even though the CONTENT is the same.  A
+// CANONICALIZER maps every surface variant of the same content onto one
+// canonical byte string; the store keeps a small hash index from canonical
+// keys to node ids (see Store.canonAdd/canonFind), and resolution falls back
+// to that index when the exact content-addressed lookup misses.
+//
+// The canonicalizer is MODALITY-SPECIFIC and always INJECTED — nothing in the
+// store or the mind's core knows what "case" or "whitespace" is.  The text
+// canonicalizer below is the one `respondText`/`respondTurnText` pass down;
+// a grid or audio modality would supply its own (or none).
+//
+// Canonical keys are equivalence-class LABELS, never content: they are hashed
+// and verified (canon(stored bytes) must equal canon(query bytes) before an
+// id is accepted), so a hash collision costs a read, never a wrong id — the
+// same discipline as the node table's own `h` index.
+
+/** A content canonicalizer: maps a byte span to the canonical representative
+ *  of its equivalence class.  Must be pure and deterministic.  Returning the
+ *  input unchanged is always sound (the class is then {input}). */
+export type Canon = (bytes: Uint8Array) => Uint8Array;
+
+const dec = new TextDecoder("utf-8", { fatal: false });
+const enc = new TextEncoder();
+
+/** The TEXT canonicalizer: Unicode-aware equivalence over every character
+ *  variation that does not change what the text SAYS —
+ *
+ *   • compatibility normalization (NFKC): full-width forms, ligatures,
+ *     composed vs decomposed accents collapse to one representation;
+ *   • case folding (locale-independent lowercase after NFKC — the standard
+ *     simple fold);
+ *   • whitespace: every INTERIOR run of Unicode whitespace becomes one plain
+ *     space.  EDGE whitespace is preserved verbatim: a span's leading or
+ *     trailing separator belongs BETWEEN forms, not to the form — trimming
+ *     it would let a recognised span swallow the boundary byte that
+ *     separates it from its neighbour (observed: "ice fire" composing to
+ *     "coldhot" because the span "ice " matched the stored "ice").
+ *
+ *  "WHAT  IS", "What is" and "ｗｈａｔ is" share one canonical form.  This is
+ *  deliberately conservative: punctuation, digits and word order are content
+ *  and pass through untouched. */
+export function textCanon(bytes: Uint8Array): Uint8Array {
+  const s = dec
+    .decode(bytes)
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/(\S)\s+(?=\S)/g, "$1 ");
+  return enc.encode(s);
+}
+
+/** 32-bit FNV-1a over a canonical key — the integer the store's canon index
+ *  is keyed on.  Same construction as the node table's content hash; a
+ *  collision is resolved by verifying canon(stored) === key, never trusted. */
+export function canonHash(key: Uint8Array): number {
+  let h = 0x811c9dc5 >>> 0;
+  for (let i = 0; i < key.length; i++) {
+    h ^= key[i];
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h >>> 0;
+}

package/src/geometry.ts

@@ -314,17 +314,32 @@ export function knownPrefixLength(
 /** Bytes → Sema tree.  `leafAt` and `lookup` are store capabilities for
  *  detecting previously-stored prefixes so the river can split at the
  *  correct boundary.  Pass them through from `perceive`; the geometry
- *  computes the stable prefix internally. */
+ *  computes the stable prefix internally.
+ *
+ *  `boundaries` is the CALLER-computed stable-prefix boundary set (§10.3):
+ *  strictly-increasing proper byte offsets, each the length of a prefix that
+ *  is already a stored whole-stream form.  When given, the fold splits into
+ *  the segments between consecutive boundaries — each folded independently,
+ *  exactly as it folded when it was learned — and the segment roots join
+ *  LEFT-NESTED (((s₀·s₁)·s₂)…), so every learnt cumulative-context root
+ *  reappears as an identical subtree (and, by hash-consing, the very same
+ *  node) inside the grown stream.  This is what lets a conversation's next
+ *  turn extend perception instead of refolding it: identical prefixes
+ *  produce identical subtrees regardless of what follows them. */
 export function bytesToTree(
   space: Space,
   alphabet: Alphabet,
   bytes: Uint8Array,
   leafAt?: (i: number) => number | null,
   lookup?: (leafIds: number[]) => number | null,
+  boundaries?: readonly number[],
 ): Sema {
   if (bytes.length === 0) {
     return sema(alphabet.vecs[0], new Uint8Array(0), null);
   }
+  if (boundaries !== undefined && boundaries.length > 0) {
+    return stablePrefixFold(space, alphabet, bytes, boundaries);
+  }
   const sb = (leafAt && lookup) ? knownPrefixLength(bytes, leafAt, lookup) : 0;
   return riverFold(
     space,
@@ -333,6 +348,83 @@ export function bytesToTree(
   ).tree;
 }
 
+/** The stable-prefix segmented fold (§10.3).  Each segment between
+ *  consecutive boundaries folds PLAINLY and independently; segment roots
+ *  join left-nested, and only the final root is normalized (the linear-fold
+ *  contract: one normalize per perception).  A segment's own inner splits
+ *  need no recursion here: a nested learnt prefix is itself an earlier
+ *  boundary, so the left-nested join reproduces every intermediate learnt
+ *  root ((s₀·s₁) IS the root the store learnt for the first two segments'
+ *  bytes, and so on). */
+function stablePrefixFold(
+  space: Space,
+  alphabet: Alphabet,
+  bytes: Uint8Array,
+  boundaries: readonly number[],
+): Sema {
+  const cuts: number[] = [];
+  let prev = 0;
+  for (const b of boundaries) {
+    if (b > prev && b < bytes.length) {
+      cuts.push(b);
+      prev = b;
+    }
+  }
+  if (cuts.length === 0) {
+    return riverFold(space, bytesToLeaves(alphabet, bytes), bytes.length).tree;
+  }
+  const edges = [0, ...cuts, bytes.length];
+  const segs: Folded[] = [];
+  for (let i = 0; i + 1 < edges.length; i++) {
+    const seg = bytes.subarray(edges[i], edges[i + 1]);
+    segs.push(riverFoldRaw(space, bytesToLeaves(alphabet, seg)));
+  }
+  let cur = segs[0];
+  for (let i = 1; i < segs.length; i++) cur = fold2(space, cur, segs[i]);
+  normalize(cur.tree.v);
+  return cur.tree;
+}
+
+/** Join two folded items as one 2-kid branch — the top-level join of the
+ *  stable-prefix fold, identical FP ops to foldSlice's seat-bound
+ *  accumulation over a group of two.  Unnormalized (interior). */
+function fold2(space: Space, a: Folded, b: Folded): Folded {
+  const D = space.D;
+  const gist = new Float32Array(D);
+  const kids = [a.tree, b.tree];
+  for (let k = 0; k < 2; k++) {
+    const seat = space.seats[k].fwd;
+    const v = kids[k].v;
+    for (let d = 0; d < D; d++) gist[d] += v[seat[d]];
+  }
+  return { tree: sema(gist, null, kids), len: a.len + b.len };
+}
+
+/** Plain river fold WITHOUT the final root normalize — the segment-level
+ *  building block of {@link stablePrefixFold} (interiors must keep their
+ *  byte-proportional magnitude; only the whole perception's root is ever
+ *  normalized). */
+function riverFoldRaw(space: Space, row: Folded[]): Folded {
+  if (row.length === 0) {
+    const z = new Float32Array(space.D);
+    return { tree: sema(z, new Uint8Array(0), null), len: 0 };
+  }
+  if (row.length === 1) return row[0];
+  let level = row;
+  while (level.length > 1) {
+    const next: Folded[] = [];
+    foldSlice(space, level, 0, level.length, next, false);
+    if (next.length === level.length) {
+      const forced: Folded[] = [];
+      foldSlice(space, next, 0, next.length, forced, true);
+      level = forced;
+    } else {
+      level = next;
+    }
+  }
+  return level[0];
+}
+
 // ---- pyramid fold (incremental plain perception) ----
 
 /** The PLAIN fold's full level pyramid — every level's item list, bottom
@@ -368,6 +460,18 @@ export function bytesToTreePyramid(
       pyramid: { levels: [], bytes: 0 },
     };
   }
+  // ZERO GROWTH: the previous pyramid already covers every byte — its top
+  // level holds the finished, normalized root.  Refolding here would not
+  // only waste the work: when the whole span is one full block, the refold's
+  // top item is a REUSED raw interior of `prev`, and the final normalize
+  // below would mutate that shared raw block in place, corrupting every
+  // later incremental fold built on `prev`.
+  if (prev && prev.bytes === bytes.length && prev.levels.length > 0) {
+    return {
+      tree: prev.levels[prev.levels.length - 1][0].tree,
+      pyramid: prev,
+    };
+  }
   const mg = space.maxGroup;
   const reusable = (L: number): ReadonlyArray<Folded> | null => {
     // prev's TOPMOST level holds its normalized ROOT — reusable blocks must

package/src/index.ts

@@ -12,6 +12,7 @@ export * from "./mind/index.js";
 export * from "./store-sqlite.js";
 export * from "./config.js";
 export * from "./extension.js";
+export * from "./canon.js";
 export * from "./ingest-cache.js";
 // rabitq-ivf: the partitioned (IVF) vector index over 1-bit RaBitQ codes.
 export {

package/src/mind/attention.ts

@@ -27,7 +27,7 @@ import type {
   SaturationInfo,
 } from "./types.js";
 import { consensusFloor, dominates, estimatorNoise } from "../geometry.js";
-import { foldTree, gistOf, perceive, read } from "./primitives.js";
+import { foldTree, gistOf, latin1Key, perceive, read } from "./primitives.js";
 import { recognise } from "./recognition.js";
 import { leafIdRun } from "./canonical.js";
 import { corpusN, edgeAncestors } from "./traverse.js";
@@ -65,14 +65,19 @@ export async function climbAttentionAll(
   k: number,
   mode: DFMode = "inverse",
 ): Promise<AttentionRead> {
+  // Content-keyed memo — works for both single-turn respond() and multi-turn
+  // respondTurn().  Skipped while tracing.
   if (ctx.climbMemo && !ctx.trace) {
-    const key = `${k}:${mode}`;
-    let byRead = ctx.climbMemo.get(query);
-    if (byRead === undefined) ctx.climbMemo.set(query, byRead = new Map());
-    const hit = byRead.get(key);
+    const contentKey = latin1Key(query);
+    const modeKey = `${k}:${mode}`;
+    let byRead = ctx.climbMemo.get(contentKey);
+    if (byRead === undefined) {
+      ctx.climbMemo.set(contentKey, byRead = new Map());
+    }
+    const hit = byRead.get(modeKey);
     if (hit !== undefined) return hit;
     const read = await computeAttention(ctx, query, k, mode);
-    byRead.set(key, read);
+    byRead.set(modeKey, read);
     return read;
   }
   return computeAttention(ctx, query, k, mode);

package/src/mind/learning.ts

@@ -7,7 +7,12 @@ import { Vec } from "../vec.js";
 import { bindSeat, companySignature, isChunk, Sema } from "../sema.js";
 import type { Input, MindContext } from "./types.js";
 import { changedNodes } from "./types.js";
-import { inputBytes, perceive, perceiveDeposit } from "./primitives.js";
+import {
+  inputBytes,
+  perceive,
+  perceiveDeposit,
+  resolve,
+} from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
 import { fold as foldVecs } from "../sema.js";
 
@@ -171,6 +176,38 @@ export async function ingestOne(
   return Object.assign(tree, { id: rootId });
 }
 
+/** For each right-edge suffix of the context bytes, resolve it against the
+ *  store.  A suffix whose resolved node is already a known form inherits the
+ *  continuation edge.  Gate: ≥ 2 structural parents (reused across deposits),
+ *  or (halo > 0 ∧ already an edge source).  Pure answers do not qualify. */
+async function propagateSuffixes(
+  ctx: MindContext,
+  src: number,
+  dst: number,
+): Promise<void> {
+  const W = ctx.space.maxGroup;
+  const bytes = ctx.store.bytes(src);
+  const n = bytes.length;
+  if (n < 2 * W) return;
+  // Existence prefilter — the write side of the canonical contract: every
+  // deposit interns its WHOLE byte stream as a flat branch of per-byte leaf
+  // ids (deposit(), canonical.ts).  A suffix is a stored form exactly when
+  // that flat twin exists, so one content-hash probe per offset decides;
+  // only a hit pays for resolve()'s deposit-shaped perception.  This keeps
+  // the scan free of river folds — O(1) probes over cheap byte hashes
+  // instead of O(suffix) vector folds per offset.
+  const leafIds = leafIdPrefix(ctx, bytes);
+  for (let i = 1; i <= n - W; i++) {
+    if (ctx.store.findBranch(leafIds.slice(i)) === null) continue;
+    const id = resolve(ctx, bytes.subarray(i));
+    if (id === null || id === src) continue;
+    const known = ctx.store.parentsFirst(id, 2).length >= 2 ||
+      (ctx.store.haloMass(id) > 0 && ctx.store.hasNext(id));
+    if (!known) continue;
+    await ctx.store.link(id, dst);
+  }
+}
+
 /** Ingest a pair (context, continuation) — learn an edge and pour halos. */
 export async function ingestPair(
   ctx: MindContext,
@@ -182,6 +219,7 @@ export async function ingestPair(
   const ctxId = c.rootId, contId = cont_.rootId;
 
   await ctx.store.link(ctxId, contId);
+  await propagateSuffixes(ctx, ctxId, contId);
 
   // Halos pour company SIGNATURES (identity), not gists (content) — see
   // companySignature in sema.ts.

package/src/mind/match.ts

@@ -446,8 +446,10 @@ export async function follow(
  *  `guide` the context whose gist resonates with the query wins (seat
  *  symmetry) — without one, the most-corroborated context wins (poured halo
  *  MASS, the direct measure of how many episodes established it), falling
- *  back to first-learnt on equal mass.  Callers that HAVE a query gist must
- *  pass it, or they silently change disambiguation regime.
+ *  back to first-learnt on equal mass.  Among many predecessors RECIPROCAL
+ *  ones (mutual edges) are preferred when any exist (RC5).  Callers that
+ *  HAVE a query gist must pass it, or they silently change disambiguation
+ *  regime.
  *
  *  `rev`, when the caller has already materialised prevOf (one read per
  *  relation — a hub's reverse fan-in is corpus-sized), is reused instead of
@@ -466,11 +468,32 @@ export function reverseContext(
   // keeps the single-predecessor shortcut exact.
   const candidates = rev ?? ctx.store.prevFirst(id, hubBound(ctx));
   if (candidates.length === 0) return null;
-  const pick = candidates.length === 1
-    ? candidates[0]
+  // RECIPROCAL PREFERENCE: among many predecessors, one that `id` also
+  // continues TO (cand → id AND id → cand both learnt) is a mutually
+  // established pairing — the strongest structural evidence a predecessor
+  // can carry (bidirectional training deposits both directions of a genuine
+  // pair).  A bare predecessor is one episode's adjacency; guide-resonance
+  // over bare predecessors favours whichever stored document merely
+  // CONTAINS the query's bytes (the linear fold's cosine is byte overlap —
+  // the observed "merci → unrelated French document" failure).  One capped
+  // forward read decides; when no reciprocal exists, behaviour is unchanged
+  // — bare predecessors ARE the honest answer for a shared deposited
+  // continuation (two questions → one answer; audited by 31-audit C1), and
+  // this arm serves every mechanism's reverse projection, so abstaining
+  // here starves far more than the one containment failure it would fix.
+  let pool: readonly number[] = candidates;
+  if (candidates.length > 1) {
+    const fwd = new Set(ctx.store.nextFirst(id, hubBound(ctx)));
+    if (fwd.size > 0) {
+      const mutual = candidates.filter((c) => fwd.has(c));
+      if (mutual.length > 0) pool = mutual;
+    }
+  }
+  const pick = pool.length === 1
+    ? pool[0]
     : guide
-    ? chooseAmong(ctx, candidates, guide).id
-    : pickByMass(ctx, candidates);
+    ? chooseAmong(ctx, pool, guide).id
+    : pickByMass(ctx, pool);
   const g = read(ctx, pick);
   return g.length > 0 ? g : null;
 }

package/src/mind/mechanisms/cast.ts

@@ -345,9 +345,24 @@ export async function counterfactualTransfer(
   // corrupted-store read now falls back here instead of voicing a hollow
   // seat into the comparison — the same "empty bytes are no grounding"
   // invariant project() has always enforced.
-  const seatOfNode = (id: number, fallback: Uint8Array): Uint8Array =>
-    reverseContext(ctx, id, qv) ?? fallback;
-  const seatOf = (p: Point): Uint8Array => seatOfNode(p.anchor, p.ctx);
+  // A node that only ever CONTINUES — an edge SOURCE with no predecessor —
+  // is a learnt CONTEXT (a stored question-shaped frame), not an entity.
+  // Voicing it verbatim answers a question with a question (the observed
+  // cast echo: two stored questions concatenated as an "answer").  The
+  // context's role is established by what it LEADS TO, so its seat is its
+  // own continuation — the fact — with the reverse projection and the raw
+  // bytes as the ordinary fallbacks for genuine entities.
+  const seatOfNode = async (
+    id: number,
+    fallback: Uint8Array,
+  ): Promise<Uint8Array> => {
+    if (ctx.store.prevCount(id) === 0 && ctx.store.hasNext(id)) {
+      const fwd = await follow(ctx, id, qv);
+      if (fwd !== null) return fwd;
+    }
+    return reverseContext(ctx, id, qv) ?? fallback;
+  };
+  const seatOf = (p: Point): Promise<Uint8Array> => seatOfNode(p.anchor, p.ctx);
   interface AnalogCandidate {
     anchor: number;
     /** The point this candidate came from, or null when it is a nextOf
@@ -494,10 +509,10 @@ export async function counterfactualTransfer(
       [],
       "the two structures keep distributional company beyond chance — genuine analogs",
     );
-    const a = seatOf(dominant);
+    const a = await seatOf(dominant);
     const b = bestAnalog.point !== null
-      ? seatOf(bestAnalog.point)
-      : seatOfNode(bestAnalog.anchor, read(ctx, bestAnalog.anchor));
+      ? await seatOf(bestAnalog.point)
+      : await seatOfNode(bestAnalog.anchor, read(ctx, bestAnalog.anchor));
     const answer = await joinWithBridge(ctx, a, b);
     record(
       answer,

package/src/mind/mechanisms/confluence.ts

@@ -116,6 +116,20 @@ export async function confluenceJoin(
      *  recognised common form). */
     held: Array<[number, number]>;
   }
+  // A constraint must bind a CONSTITUENT, not a shard.  A genuinely shared
+  // form weaves a contiguous RUN of shared discriminative windows — its
+  // merged cover span is the form's own length, beyond one perception
+  // quantum (2W: the same "two quanta of structure" bar the conjunctive
+  // precondition `query.length < 2W` and CAST's weave live under).  A long
+  // stored document holds thousands of W-windows and will hold a FEW of any
+  // query's by accident, but accidental sharing is one window (a merged
+  // span of W, at most ~W+overlap bytes: "ow ma", "ys a", "ías " —
+  // observed), never a run ("​ translucent", " featherlight" — the genuine
+  // constraints).  Shard-bound streams are no constraints, and their meets
+  // are connective debris (". Sure,", "ngul" — observed).
+  const bindsAConstituent = (cover: Array<[number, number]>): boolean =>
+    cover.some(([cs, ce]) => ce - cs >= 2 * W);
+
   const streams: Stream[] = [];
   const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
   for (const cand of rankedCapped) {
@@ -134,7 +148,7 @@ export async function confluenceJoin(
       if (curC !== null && off <= curC[1]) curC[1] = off + W;
       else cover.push(curC = [off, off + W]);
     }
-    if (cover.length > 0) {
+    if (cover.length > 0 && bindsAConstituent(cover)) {
       streams.push({ anchor: cand.anchor, vote: cand.vote, ids, cover, held });
     }
   }