@hviana/sema 0.1.7 → 0.1.8

package/dist/example/train_base.js

@@ -152,8 +152,11 @@ const LOCAL_PATH = env("LOCAL_PATH", ""); // train from a local dir of *.zip
 const CACHE_DIR = env("CACHE_DIR", join(process.cwd(), "cache"));
 const MAX_CACHE_BYTES = Number(env("MAX_CACHE_GB", "100")) * 1e9;
 const PROGRESS_MS = Number(env("PROGRESS_MS", "250")); // panel refresh cadence
-// Index maintenance at checkpoints: compact (remove garbage) then repair (fill
-// gaps). Both are idempotent batch operations; INDEX_MAINTENANCE=0 disables.
+// Index maintenance at checkpoints: compact (remove garbage), repair (fill
+// gaps), then refresh the canonical-form index (equivalence-class resolution —
+// src/canon.ts). All three are idempotent batch operations (the canon build is
+// additionally incremental via the store's `canon.upto` cursor);
+// INDEX_MAINTENANCE=0 disables.
 const INDEX_MAINTENANCE = env("INDEX_MAINTENANCE", "1") !== "0";
 const DOWNLOAD_TRIES = 5;
 // In-progress downloads are written to a sibling "<dest>.part" and atomically
@@ -1485,8 +1488,9 @@ async function main() {
     // final exit for tidiness. Same lesson as waitMs above (deliberately un-unref'd).
     const keepAlive = setInterval(() => { }, 1 << 30);
     const checkpoint = () => mind.save();
-    /** Run index maintenance: compact (remove garbage) then repair (fill gaps).
-     *  Both are idempotent — running twice produces the same result as once.
+    /** Run index maintenance: compact (remove garbage), repair (fill gaps),
+     *  then refresh the canonical-form index (see below).  All three are
+     *  idempotent — running twice produces the same result as once.
      *  Compaction frees index space first; repair then adds back every
      *  edge/halo-bearing node whose gist was evicted from the pending cache
      *  before it reached the content index, completing the coverage that
@@ -1528,6 +1532,22 @@ async function main() {
         catch (err) {
             progress.log(`  ${YEL}⚠ index repair failed${R}: ${err instanceof Error ? err.message : String(err)}`);
         }
+        // Canonical-form index (src/canon.ts): lets resolution find stored forms
+        // across surface variation (case, width, whitespace).  Incremental and
+        // idempotent by construction — the `canon.upto` meta cursor scans only
+        // nodes newer than the last pass, and the (h, id) primary key ignores
+        // re-inserted rows — so it composes with the resume model exactly like
+        // compact/repair: every checkpoint (and finish) leaves the index
+        // covering all content trained so far.
+        try {
+            const added = await mind.buildCanonIndex();
+            if (added > 0) {
+                progress.log(`  ${GRN}canon index: added ${int(added)} canonical-form entries${R}`);
+            }
+        }
+        catch (err) {
+            progress.log(`  ${YEL}⚠ canon index build failed${R}: ${err instanceof Error ? err.message : String(err)}`);
+        }
     };
     // The checkpoint recall is a best-effort diagnostic. It is time-bounded so a
     // slow/large store can never freeze the deposit loop, and guarded so a still

package/dist/src/alu/src/parser.d.ts

@@ -144,6 +144,15 @@ export declare class QueryParser {
      *  same judgement the perception tree makes about spacing — so no character
      *  is privileged as "the" separator. */
     private arithmeticRuns;
+    /** 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;
     /** 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/dist/src/alu/src/parser.js

@@ -113,8 +113,26 @@ export class QueryParser {
             j,
             bytes: this.evalRun(query.subarray(i, j)),
         }));
-        const spans = runs.filter((r) => 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.bytes !== null);
+        const absorbed = (r) => 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 = [
+            ...runs.filter((r) => r.bytes !== null),
+            ...bracketed,
+        ];
+        let stream = compose(tokens, composedRuns);
         const readings = new Map();
         for (;;) {
             const fired = await this.operations(query, stream, readings);
@@ -231,6 +249,96 @@ 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. */
+    bracketedRuns(query, tokens) {
+        const OPEN = 0x28, CLOSE = 0x29;
+        const bracketPrefix = (t, b) => {
+            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, b) => bracketPrefix(t, b) === t.j - t.i;
+        const bridged = (from, to) => from >= to || this.host.segment(query.subarray(from, to)).length <= 1;
+        const runs = [];
+        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/dist/src/canon.d.ts

@@ -0,0 +1,26 @@
+/** 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;
+/** 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 declare function textCanon(bytes: Uint8Array): Uint8Array;
+/** 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 declare function canonHash(key: Uint8Array): number;

package/dist/src/canon.js

@@ -0,0 +1,57 @@
+// 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.
+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) {
+    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) {
+    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/dist/src/geometry.js

@@ -376,6 +376,18 @@ export function bytesToTreePyramid(space, alphabet, bytes, prev) {
             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) => {
         // prev's TOPMOST level holds its normalized ROOT — reusable blocks must

package/dist/src/index.d.ts

@@ -9,6 +9,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";
 export { IvfIndex, Prng, RaBitQuantizer, VectorDatabase, } from "./rabitq-ivf/src/index.js";
 export type { DatabaseOptions, ExternalId, IvfConfig, IvfHit, QueryContext, QueryResult, RaBitQOptions, StorageStats, } from "./rabitq-ivf/src/index.js";

package/dist/src/index.js

@@ -11,6 +11,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 { IvfIndex, Prng, RaBitQuantizer, VectorDatabase, } from "./rabitq-ivf/src/index.js";

package/dist/src/mind/learning.js

@@ -4,7 +4,7 @@
 //   node.  A fact is an EDGE between node ids; recall traverses edges.
 import { bindSeat, companySignature, isChunk } from "../sema.js";
 import { changedNodes } from "./types.js";
-import { inputBytes, perceiveDeposit } from "./primitives.js";
+import { inputBytes, perceiveDeposit, resolve, } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
 import { fold as foldVecs } from "../sema.js";
 /** Intern a perceived tree into node ids, bottom-up, sharing equal subtrees.
@@ -152,12 +152,44 @@ export async function ingestOne(ctx, input) {
     }
     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, src, dst) {
+    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, ctxInput, cont) {
     const c = await deposit(ctx, ctxInput, true);
     const cont_ = await deposit(ctx, cont, false);
     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.
     const contSeat = bindSeat(ctx.space, companySignature(ctx.space, contId), 1);

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

@@ -94,8 +94,10 @@ export declare function follow(ctx: MindContext, id: number, guide?: Vec | null)
  *  `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

package/dist/src/mind/match.js

@@ -370,8 +370,10 @@ export async function follow(ctx, id, guide) {
  *  `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
@@ -386,11 +388,33 @@ export function reverseContext(ctx, id, guide, rev) {
     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 = 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/dist/src/mind/mechanisms/cast.js

@@ -262,7 +262,21 @@ export async function counterfactualTransfer(ctx, query, pre) {
     // 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, fallback) => reverseContext(ctx, id, qv) ?? fallback;
+    // 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, fallback) => {
+        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) => seatOfNode(p.anchor, p.ctx);
     const analogs = [];
     for (const p of points) {
@@ -381,10 +395,10 @@ export async function counterfactualTransfer(ctx, query, pre) {
             rNode(ctx, dominant.anchor, "analog", bestSim),
             rNode(ctx, bestAnalog.anchor, "analog", bestSim),
         ], [], "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, "analogical comparison — each analog voiced by the context that establishes its role", new Set([dominant.anchor, bestAnalog.anchor]), 
         // A halo-mediated act (the analogy gate) plus two seat projections.

package/dist/src/mind/mechanisms/confluence.js

@@ -70,6 +70,18 @@ export async function confluenceJoin(ctx, query, pre) {
     // below.
     const queryWin = pre.queryWindows;
     const queryIds = new Set(queryWin.values());
+    // 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) => cover.some(([cs, ce]) => ce - cs >= 2 * W);
     const streams = [];
     const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
     for (const cand of rankedCapped) {
@@ -96,7 +108,7 @@ export async function confluenceJoin(ctx, query, pre) {
             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 });
         }
     }