@hviana/sema 0.9.0 → 0.9.1

package/dist/src/mind/recognition.js

@@ -5,10 +5,11 @@
 //               that leads somewhere (has a continuation edge or a halo).
 //   segment   — leaf-parent segmentation using the geometry's own groupings.
 import { rItem } from "./trace.js";
-import { canonResolve, foldTree, gistOf, latin1Key, perceive, resolve, } from "./primitives.js";
+import { canonResolve, foldTree, gistOf, perceive, resolve, } from "./primitives.js";
 import { atomIsHub, bearsEdge, corpusN, leadsSomewhere } from "./traverse.js";
 import { chainReach, leafIdAt, leafIdRun } from "./canonical.js";
 import { canonHash } from "../canon.js";
+import { latin1 } from "../bytes.js";
 import { isChunk } from "../sema.js";
 /** Decompose a byte stream into every stored form that leads somewhere
  *  (has a continuation edge or a halo).  Two complementary readings:
@@ -77,7 +78,7 @@ export function recognise(ctx, bytes) {
     // not silent), so it is emitted here directly rather than only inside
     // recogniseImpl.
     if (ctx.recogniseMemo) {
-        const key = latin1Key(bytes);
+        const key = latin1(bytes);
         const hit = ctx.recogniseMemo.get(key);
         if (hit !== undefined) {
             if (ctx.meter)
@@ -483,9 +484,21 @@ function recogniseImpl(ctx, bytes) {
             // encoding is the identity, so the span's bytes ARE the branch key.
             // `subarray` is a view — this allocates nothing per probe, and the
             // bloom filter answers the misses without touching the database.
-            const flatProbe = (start, end) => store.findFlatBranch
-                ? store.findFlatBranch(bytes.subarray(start, end))
-                : store.findBranch(allLeafIds.slice(start, end));
+            //
+            // Through ONE span prober (Store.flatSpans), because hashing the key was
+            // itself the quadratic: every probe hashed its span from the start, and
+            // the interior pass below sweeps up to `reach` ends past each endpoint —
+            // O(n · reach²) bytes hashed.  Measured on the 31.7M-node store, one
+            // composition-regime response (#97 of the battery) probed 2,079,400
+            // spans and hashed 251,660,406 bytes for them.  The prober extends each
+            // start's hash instead, so the same probes, answered identically, cost
+            // O(n · reach).
+            const spans = store.flatSpans?.(bytes) ?? null;
+            const flatProbe = (start, end) => spans !== null
+                ? spans(start, end)
+                : store.findFlatBranch
+                    ? store.findFlatBranch(bytes.subarray(start, end))
+                    : store.findBranch(allLeafIds.slice(start, end));
             // THE TWO ROUTES COST DIFFERENT THINGS, SO THEY ARE PRICED SEPARATELY.
             //
             // The exact route is a bloom-gated hash over a subarray VIEW: no
@@ -627,13 +640,17 @@ function recogniseImpl(ctx, bytes) {
                 const reach = chainReach(W) * W * W + 2 * radius;
                 if (ctx.meter)
                     ctx.meter.recogniseInteriorGaps += ordered.length;
+                // Each end pairs only with the starts in [end − reach, end − W], in
+                // ascending order — the pairs, and the order the budget is spent in,
+                // of the all-pairs scan, without its O(n²) enumeration.
+                let lo = 0;
                 for (const end of ordered) {
-                    for (const start of ordered) {
-                        if (start >= end)
-                            continue;
-                        const span = end - start;
-                        if (span < W || span > reach)
-                            continue;
+                    while (ordered[lo] < end - reach)
+                        lo++;
+                    for (let i = lo; i < ordered.length; i++) {
+                        const start = ordered[i];
+                        if (end - start < W)
+                            break;
                         if (ctx.meter)
                             ctx.meter.recogniseInteriorPairs++;
                         spend(start, end);
@@ -672,8 +689,7 @@ function recogniseImpl(ctx, bytes) {
     // arithmetic, not evidence.  Removing it wholesale was measured and
     // REVERTED: it also drops legitimate multi-byte chains (the 12-byte
     // "Eiffel Tower" site vanished with it).  The premise is wrong but the
-    // trust it stood in for is real; a replacement signal is still open work.
-    // See bench/README.md.
+    // trust it stood in for is real; the replacement signal follows.
     //
     // THE REPLACEMENT SIGNAL (2026-08-13): `leadsSomewhere` on the BYTE-EXACT
     // branch the chain already found.  The blanket off-boundary suppression is

package/dist/src/mind/resonance.js

@@ -6,7 +6,7 @@
 import { rItem } from "./trace.js";
 import { cosine } from "../vec.js";
 import { mergeThreshold } from "../geometry.js";
-import { concat2, concatBytes, indexOf } from "../bytes.js";
+import { concat2, concatBytes, indexOf, latin1 } from "../bytes.js";
 import { gistOf, read, resolve, walkTree } from "./primitives.js";
 import { perceive } from "./primitives.js";
 import { argmaxCosine, candidateGist, hubBound } from "./traverse.js";
@@ -107,16 +107,6 @@ function junctionEdges(ctx, left, right, maxContainer) {
     }
     return out;
 }
-/** A byte string as a string, ONE code unit per byte — injective, so it is
- *  safe to build a cache key from.  Chunked to keep the spread within the
- *  engine's argument limit on long contexts. */
-function latin1(b) {
-    let s = "";
-    for (let i = 0; i < b.length; i += 4096) {
-        s += String.fromCharCode(...b.subarray(i, i + 4096));
-    }
-    return s;
-}
 /** Per-response memo of bridge results, keyed by the response's lifecycle
  *  object (ctx.climbMemo — created fresh by respond() and nulled after, so
  *  entries can never outlive the read-only window they are valid in).  The

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

@@ -58,9 +58,9 @@ export declare function atomIsHub(ctx: MindContext, contextCount: number): boole
  *  it is sound as a pre-filter before a consumer that applies the full
  *  predicate, and never as a replacement for it. */
 export declare function bearsEdge(ctx: MindContext, id: number): boolean;
-/** Whether a node LEADS SOMEWHERE — it bears a continuation edge or a halo.
- * The admission predicate recognition filters sites with (cover.md): a form
- * that
+/** Whether a node LEADS SOMEWHERE — the store's admission predicate
+ * ({@link Store.leadsSomewhere}: edge or halo) with its edge tier memoised for
+ * the response.  Recognition filters sites with it (cover.md): a form that
  * leads nowhere contributes nothing to any derivation. Runs once per candidate
  * span on the recognition hot path — `hasNext` is cached per response (the same
  * flat-branch ids are probed across prefix variants by canonicalChunkId).

package/dist/src/mind/traverse.js

@@ -432,9 +432,9 @@ export function atomIsHub(ctx, contextCount) {
 export function bearsEdge(ctx, id) {
     return cachedHasNext(ctx, id, getStructCache(ctx));
 }
-/** Whether a node LEADS SOMEWHERE — it bears a continuation edge or a halo.
- * The admission predicate recognition filters sites with (cover.md): a form
- * that
+/** Whether a node LEADS SOMEWHERE — the store's admission predicate
+ * ({@link Store.leadsSomewhere}: edge or halo) with its edge tier memoised for
+ * the response.  Recognition filters sites with it (cover.md): a form that
  * leads nowhere contributes nothing to any derivation. Runs once per candidate
  * span on the recognition hot path — `hasNext` is cached per response (the same
  * flat-branch ids are probed across prefix variants by canonicalChunkId).

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

@@ -157,7 +157,13 @@ export interface Attention {
      *  a genuine further topic is named in its own distinctive wording
      *  somewhere the query's scaffolding does not reach, always a SEPARATE
      *  cluster from whatever else corroborates it.  See
-     *  test/37-cluster-dispersion-fusion.test.mjs. */
+     *  test/37-cluster-dispersion-fusion.test.mjs.
+     *
+     *  Read from the VOTES, this is a lossy witness: a region votes once, for its
+     *  top anchor, so a place can be lost to a tie or won through an accident.
+     *  Fusion therefore also asks the root's CONTEXT the same question at window
+     *  scale (reasoning.ts `sharedPlaces`) and trusts a root that either reading
+     *  finds in two places. */
     clusters: number;
 }
 /** Both read-outs of one consensus climb. */

package/dist/src/store-sqlite.d.ts

@@ -28,6 +28,20 @@ export declare class SQliteStore extends AbstractStore implements Store {
     private _bloom;
     /** Dedup probes answered by the filter alone this session (observability). */
     bloomSkips: number;
+    /** The same negative filter over the CANON index's key hashes.  Recognition's
+     *  canonical admission and the join's canonical entity scan ask `canonFind`
+     *  once per probed span, and almost every answer is "no such key" — on an
+     *  index that is often EMPTY (it is built only by `buildCanonIndex`).
+     *  Loaded on first use from `canon_bloom` when its stamp matches the meta,
+     *  else built by one sequential scan of the h column; kept exact on
+     *  `canonAdd` (rebuilt bigger from the table, uncommitted rows included,
+     *  when growth saturates it) and persisted with the commit that wrote the
+     *  rows.  The canon table is never deleted from, so the filter can never
+     *  hold a false negative: a miss it reports is a miss the query would have
+     *  returned. */
+    private _canonBloom;
+    /** The in-memory canon filter differs from the persisted one. */
+    private _canonBloomDirty;
     private _insertNode;
     private _insertKid;
     private _selContain;
@@ -79,6 +93,9 @@ export declare class SQliteStore extends AbstractStore implements Store {
     protected _dbGetNode(id: NodeId): NodeRec | null;
     protected _dbFindLeaf(h: number, bytes: Uint8Array): NodeId | null;
     protected _dbFindBranchByLeaf(h: number, bytes: Uint8Array): NodeId | null;
+    /** The node filter alone: never a false negative (every inserted hash is
+     *  added before any probe can see it), so `false` is exact. */
+    protected _dbFlatMayExist(h: number, bytes: Uint8Array): boolean;
     protected _dbFindBranchByKids(h: number, packed: Uint8Array): NodeId | null;
     protected _dbInsertKid(child: NodeId, parent: NodeId): void;
     protected _dbGetParents(id: NodeId): NodeId[];
@@ -137,6 +154,14 @@ export declare class SQliteStore extends AbstractStore implements Store {
     protected _dbSetMeta(key: string, val: string): void;
     protected _dbDeleteMeta(key: string): void;
     canonAdd(h: number, id: number): void;
+    /** The canon filter: the persisted one when its stamp matches the meta,
+     *  else built from the index as it stands. */
+    private _canonFilter;
+    private _canonScan;
+    /** What a persisted canon filter is stamped with: the incremental build's
+     *  cursor, which every canon writer advances in the transaction it writes. */
+    private _canonStamp;
+    private _canonBloomPersist;
     canonFind(h: number): number[];
     sketchGet(id: number): number[] | null;
     sketchPut(id: number, ids: readonly number[]): void;

package/dist/src/store-sqlite.js

@@ -124,6 +124,17 @@ CREATE TABLE IF NOT EXISTS canon (
   id INTEGER NOT NULL,
   PRIMARY KEY (h, id)
 ) WITHOUT ROWID;
+-- The canon index's negative filter, persisted so an open does not rescan the
+-- h column (seconds on a trained store).  Written in the SAME transaction as
+-- the canon rows it covers, stamped with the meta 'canon.upto' of that commit;
+-- a stamp that disagrees with the meta (rows a writer added without it) makes
+-- the filter stale, and it is rebuilt from the table instead.
+CREATE TABLE IF NOT EXISTS canon_bloom (
+  id   INTEGER PRIMARY KEY CHECK (id = 1),
+  bits BLOB NOT NULL,
+  n    INTEGER NOT NULL,
+  upto TEXT NOT NULL
+);
 -- CONSTITUENT SKETCH (Store.sketchGet/sketchPut): the bottom-k minimal
 -- constituents of a node's subtree, k = √D, chosen by identity hash.  The blob is
 -- a packed int32 little-endian run, already in hash order; an EMPTY blob is a
@@ -223,6 +234,20 @@ export class SQliteStore extends AbstractStore {
     _bloom = null;
     /** Dedup probes answered by the filter alone this session (observability). */
     bloomSkips = 0;
+    /** The same negative filter over the CANON index's key hashes.  Recognition's
+     *  canonical admission and the join's canonical entity scan ask `canonFind`
+     *  once per probed span, and almost every answer is "no such key" — on an
+     *  index that is often EMPTY (it is built only by `buildCanonIndex`).
+     *  Loaded on first use from `canon_bloom` when its stamp matches the meta,
+     *  else built by one sequential scan of the h column; kept exact on
+     *  `canonAdd` (rebuilt bigger from the table, uncommitted rows included,
+     *  when growth saturates it) and persisted with the commit that wrote the
+     *  rows.  The canon table is never deleted from, so the filter can never
+     *  hold a false negative: a miss it reports is a miss the query would have
+     *  returned. */
+    _canonBloom = null;
+    /** The in-memory canon filter differs from the persisted one. */
+    _canonBloomDirty = false;
     _insertNode = null;
     _insertKid = null;
     _selContain = null;
@@ -453,8 +478,10 @@ export class SQliteStore extends AbstractStore {
             "n = excluded.n, upto = excluded.upto").run(this._bloom.bits, this._bloom.n, this._nextId);
     }
     _dbClose() {
-        if (this.sqlite)
+        if (this.sqlite) {
             this._bloomPersist();
+            this._canonBloomPersist();
+        }
         if (this.content) {
             this.content.close();
             this.content = null;
@@ -478,6 +505,8 @@ export class SQliteStore extends AbstractStore {
     _dbCommitTx() {
         if (!this._inTx || !this.sqlite)
             return;
+        // The canon filter commits WITH the rows it covers — see canon_bloom.
+        this._canonBloomPersist();
         this._inTx = false; // clear first so a throw can't wedge us mid-commit
         this.sqlite.exec("COMMIT");
     }
@@ -534,6 +563,16 @@ export class SQliteStore extends AbstractStore {
         const row = this._selFlat.get(h, bytes);
         return row ? row.id : null;
     }
+    /** The node filter alone: never a false negative (every inserted hash is
+     *  added before any probe can see it), so `false` is exact. */
+    _dbFlatMayExist(h, bytes) {
+        if (this._bloom === null)
+            return super._dbFlatMayExist(h, bytes);
+        if (this._bloom.mightContain(h))
+            return true;
+        this.bloomSkips++;
+        return false;
+    }
     _dbFindBranchByKids(h, packed) {
         if (this._bloom && !this._bloom.mightContain(h)) {
             this.bloomSkips++;
@@ -855,8 +894,57 @@ export class SQliteStore extends AbstractStore {
         // bulk index build coalesces instead of paying autocommit per row.
         this._dbBeginTx();
         this._insCanon.run(h, id);
+        const b = this._canonFilter();
+        b.add(h);
+        // Rebuilt bigger at once, from the table as THIS connection sees it — the
+        // persisted filter cannot stand in, it lacks this transaction's rows.
+        if (b.saturated)
+            this._canonBloom = this._canonScan();
+        this._canonBloomDirty = true;
+    }
+    /** The canon filter: the persisted one when its stamp matches the meta,
+     *  else built from the index as it stands. */
+    _canonFilter() {
+        if (this._canonBloom === null) {
+            const row = this.sqlite.prepare("SELECT bits, n, upto FROM canon_bloom WHERE id = 1").get();
+            if (row !== undefined && row.upto === this._canonStamp()) {
+                const b = new NodeBloom(31 - Math.clz32(row.bits.length * 8));
+                b.bits.set(row.bits);
+                b.n = row.n;
+                this._canonBloom = b;
+            }
+            else {
+                this._canonBloom = this._canonScan();
+                this._canonBloomDirty = true;
+            }
+        }
+        return this._canonBloom;
+    }
+    _canonScan() {
+        const b = new NodeBloom(bloomLog2For(this.canonCount()));
+        const scan = this.sqlite.prepare("SELECT h FROM canon");
+        scan.setReturnArrays(true);
+        for (const r of scan.iterate())
+            b.add(r[0]);
+        return b;
+    }
+    /** What a persisted canon filter is stamped with: the incremental build's
+     *  cursor, which every canon writer advances in the transaction it writes. */
+    _canonStamp() {
+        return this._dbGetMeta("canon.upto") ?? "";
+    }
+    _canonBloomPersist() {
+        const b = this._canonBloom;
+        if (b === null || !this._canonBloomDirty || !this.sqlite)
+            return;
+        this.sqlite.prepare("INSERT INTO canon_bloom (id, bits, n, upto) VALUES (1, ?, ?, ?) " +
+            "ON CONFLICT(id) DO UPDATE SET bits = excluded.bits, " +
+            "n = excluded.n, upto = excluded.upto").run(b.bits, b.n, this._canonStamp());
+        this._canonBloomDirty = false;
     }
     canonFind(h) {
+        if (!this._canonFilter().mightContain(h))
+            return [];
         if (!this._selCanon) {
             this._selCanon = this.sqlite.prepare("SELECT id FROM canon WHERE h = ?");
         }

package/dist/src/store.d.ts

@@ -1,5 +1,5 @@
 import { Vec } from "./vec.js";
-import { type StoreConfig } from "./config.js";
+import type { StoreConfig } from "./config.js";
 import type { Meter } from "./meter.js";
 /** A node id: a dense, non-negative integer assigned in creation order. */
 export type NodeId = number;
@@ -166,6 +166,20 @@ export interface Store {
      *  bytes — the allocation-free probe span scanners use.  Optional: a store
      *  without it is simply probed through `findBranch`. */
     findFlatBranch?(bytes: Uint8Array): NodeId | null;
+    /** Whether a flat branch with these bytes MAY exist.  `false` is EXACT — no
+     *  such node exists, and a {@link findFlatBranch} would return null; `true`
+     *  means only that a lookup is needed.  The existence half of the probe,
+     *  without its verification: a caller that will resolve the bytes anyway
+     *  (and so verify them) asks this to refuse a miss without paying for the
+     *  lookup a hit would repeat.  Optional, like the probe it answers for. */
+    flatBranchMayExist?(bytes: Uint8Array): boolean;
+    /** A {@link findFlatBranch} over spans of ONE buffer: `probe(start, end)`
+     *  answers exactly `findFlatBranch(bytes.subarray(start, end))`, but a span's
+     *  content hash extends the one its start was last probed at, so a scanner
+     *  that sweeps ends upward per start pays O(1) per probe instead of
+     *  O(span).  The buffer must not change while the prober is used.
+     *  Optional, like the probe it accelerates. */
+    flatSpans?(bytes: Uint8Array): (start: number, end: number) => NodeId | null;
     /** The branch nodes that list `id` among their children — the reverse of
      *  `get(id).kids`. Lets the structural DAG be climbed upward, from a
      *  recognised fragment to the larger learned forms that contain it. */
@@ -314,6 +328,12 @@ export interface Store {
      *  the search's fuse guard) must ask this instead: one row read, a mass
      *  compare, no decode. */
     hasHalo(id: NodeId): boolean;
+    /** THE ADMISSION PREDICATE — whether `id` LEADS SOMEWHERE: it bears a
+     *  continuation edge ({@link hasNext}) or a halo ({@link hasHalo}).  A form
+     *  that leads nowhere contributes nothing to any derivation.  This is the ONE
+     *  raw definition; `traverse.ts`'s `leadsSomewhere` is the same predicate with
+     *  its edge tier memoised for the response.  Two point probes at most. */
+    leadsSomewhere(id: NodeId): boolean;
     /** How many episode signatures were poured into `id`'s halo — the DIRECT
      *  measure of distributional evidence (each training pair pours once, so
      *  repetition counts, unlike {@link prevCount}, which counts DISTINCT
@@ -507,6 +527,9 @@ export declare abstract class AbstractStore implements Store {
     /** Exact-content dedup: content-key → node id. Intrinsic compression. */
     protected readonly _leafKey: BoundedMap<string, NodeId>;
     protected readonly _branchKey: BoundedMap<string, NodeId>;
+    /** {@link findFlatBranch}'s hits, keyed by the bytes themselves (latin1 —
+     *  exact, unlike the hash keys above). */
+    protected readonly _flatKey: BoundedMap<string, NodeId>;
     /** Reconstructed-bytes read cache (regenerable), keyed by node id. */
     protected readonly _bytesCache: BoundedMap<NodeId, Uint8Array>;
     /** contentLen memo — content is immutable, so entries never invalidate. */
@@ -643,10 +666,29 @@ export declare abstract class AbstractStore implements Store {
      *  answers most of those with no I/O at all, so the allocations dominated.
      *
      *  Pass a subarray: it is a view, so a caller scanning spans of a query
-     *  allocates nothing per probe.  Deliberately NOT memoized — its callers
-     *  probe many spans that miss, and a key string per probe is the cost this
-     *  exists to remove. */
+     *  allocates nothing per probe that misses.  HITS ARE MEMOIZED, MISSES ARE
+     *  NOT: the negative filter answers first, so a span that is not stored
+     *  builds no key; one that may be pays a key and then usually skips the
+     *  lookup — the spans the identity fold names are segments, a few bytes
+     *  each, asked over and over by every span that contains them.  A node, once
+     *  minted, keeps its bytes and its id, so a cached hit never goes stale. */
     findFlatBranch(bytes: Uint8Array): NodeId | null;
+    /** {@link Store.flatSpans}.  Each start keeps the hash of the span it was
+     *  last probed to, plus the hash one byte short of it; a probe ending at or
+     *  past that end extends it, one ending one byte short of it reuses the
+     *  second, and any other probe hashes from the start.  `hashOf` is FNV-1a,
+     *  a left fold over the bytes, so an extended hash IS the span's hash —
+     *  same key, same filter answer, same lookup. */
+    flatSpans(bytes: Uint8Array): (start: number, end: number) => NodeId | null;
+    /** {@link findFlatBranch} past the hash: `h` must be `hashOf(bytes)`. */
+    private _findFlatHashed;
+    /** {@link Store.flatBranchMayExist} — the backend's negative filter when it
+     *  keeps one ({@link _dbFlatMayExist}), else the lookup itself. */
+    flatBranchMayExist(bytes: Uint8Array): boolean;
+    /** Default: no filter, so anything MAY exist and the lookup decides.  A
+     *  backend with a negative filter over node hashes overrides this to answer
+     *  from the filter alone. */
+    protected _dbFlatMayExist(_h: number, _bytes: Uint8Array): boolean;
     findBranch(kids: NodeId[]): NodeId | null;
     parents(id: NodeId): NodeId[];
     parentsFirst(id: NodeId, limit: number): NodeId[];
@@ -792,6 +834,8 @@ export declare abstract class AbstractStore implements Store {
     /** {@link Store.hasHalo} — MUST mirror {@link halo}'s null condition
      *  exactly (row present AND mass ≥ minHaloMass), minus the decode. */
     hasHalo(id: NodeId): boolean;
+    /** {@link Store.leadsSomewhere} — edge first (the cheaper, commoner probe). */
+    leadsSomewhere(id: NodeId): boolean;
     pourHalo(id: NodeId, add: Vec): Promise<void>;
     resonateHalo(v: Vec, k: number): Promise<Hit[]>;
     private pending;

package/dist/src/store.js

@@ -29,6 +29,7 @@
 // essentials required for SQLite + VectorDatabase communication.
 import { addInto, copy, dot, normalize } from "./vec.js";
 import { identityBar } from "./geometry.js";
+import { latin1 } from "./bytes.js";
 /** Entry cap for the two ANN read caches ({@link AbstractStore._resonateCache}
  *  / `_resonateHaloCache`).  They are only dropped on index writes, so a long
  *  query-only session otherwise grows them without bound — a slow memory/GC
@@ -335,11 +336,13 @@ export function unpackKids(blob) {
 }
 /** 32-bit FNV-1a of a byte blob — the integer content hash `idx_node_h` keys
  *  on. Collisions are resolved by verifying the stored blob, never trusted. */
+const FNV_OFFSET = 0x811c9dc5 >>> 0;
+const FNV_PRIME = 0x01000193;
 function hashOf(bytes) {
-    let h = 0x811c9dc5 >>> 0;
+    let h = FNV_OFFSET;
     for (let i = 0; i < bytes.length; i++) {
         h ^= bytes[i];
-        h = Math.imul(h, 0x01000193) >>> 0;
+        h = Math.imul(h, FNV_PRIME) >>> 0;
     }
     return h >>> 0;
 }
@@ -458,6 +461,9 @@ export class AbstractStore {
     /** Exact-content dedup: content-key → node id. Intrinsic compression. */
     _leafKey;
     _branchKey;
+    /** {@link findFlatBranch}'s hits, keyed by the bytes themselves (latin1 —
+     *  exact, unlike the hash keys above). */
+    _flatKey;
     /** Reconstructed-bytes read cache (regenerable), keyed by node id. */
     _bytesCache;
     /** contentLen memo — content is immutable, so entries never invalidate. */
@@ -542,6 +548,7 @@ export class AbstractStore {
         this.compactEveryNWrites = config.compactEveryNWrites;
         this._leafKey = new BoundedMap(config.dedupCacheMax);
         this._branchKey = new BoundedMap(config.dedupCacheMax);
+        this._flatKey = new BoundedMap(config.dedupCacheMax, undefined, "lru", "clock");
         this._bytesCache = new BoundedMap(config.bytesCacheMax, (v) => v.byteLength, "smallest", "clock");
         this._lenCache = new BoundedMap(config.bytesCacheMax, () => 16);
         this._recCache = new BoundedMap(config.recCacheBytes, (r) => (r.leaf?.byteLength ?? 0) + (r.kids?.length ?? 0) * 4 + 12, "lru", "clock");
@@ -848,13 +855,82 @@ export class AbstractStore {
      *  answers most of those with no I/O at all, so the allocations dominated.
      *
      *  Pass a subarray: it is a view, so a caller scanning spans of a query
-     *  allocates nothing per probe.  Deliberately NOT memoized — its callers
-     *  probe many spans that miss, and a key string per probe is the cost this
-     *  exists to remove. */
+     *  allocates nothing per probe that misses.  HITS ARE MEMOIZED, MISSES ARE
+     *  NOT: the negative filter answers first, so a span that is not stored
+     *  builds no key; one that may be pays a key and then usually skips the
+     *  lookup — the spans the identity fold names are segments, a few bytes
+     *  each, asked over and over by every span that contains them.  A node, once
+     *  minted, keeps its bytes and its id, so a cached hit never goes stale. */
     findFlatBranch(bytes) {
+        return this._findFlatHashed(hashOf(bytes), bytes);
+    }
+    /** {@link Store.flatSpans}.  Each start keeps the hash of the span it was
+     *  last probed to, plus the hash one byte short of it; a probe ending at or
+     *  past that end extends it, one ending one byte short of it reuses the
+     *  second, and any other probe hashes from the start.  `hashOf` is FNV-1a,
+     *  a left fold over the bytes, so an extended hash IS the span's hash —
+     *  same key, same filter answer, same lookup. */
+    flatSpans(bytes) {
+        const n = bytes.length;
+        const runEnd = new Int32Array(n + 1).fill(-1);
+        const runH = new Uint32Array(n + 1);
+        const shortH = new Uint32Array(n + 1);
+        return (start, end) => {
+            let h;
+            let from;
+            const e0 = runEnd[start];
+            if (e0 >= 0 && e0 <= end) {
+                h = runH[start];
+                from = e0;
+            }
+            else if (e0 >= 0 && e0 - 1 === end && end > start) {
+                h = shortH[start];
+                from = end;
+            }
+            else {
+                h = FNV_OFFSET;
+                from = start;
+            }
+            let prev = h;
+            for (let i = from; i < end; i++) {
+                prev = h;
+                h = Math.imul(h ^ bytes[i], FNV_PRIME) >>> 0;
+            }
+            if (from < end) {
+                runEnd[start] = end;
+                runH[start] = h;
+                shortH[start] = prev;
+            }
+            return this._findFlatHashed(h, bytes.subarray(start, end));
+        };
+    }
+    /** {@link findFlatBranch} past the hash: `h` must be `hashOf(bytes)`. */
+    _findFlatHashed(h, bytes) {
         if (this.meter)
             this.meter.branchLookups++;
-        return this._dbFindBranchByLeaf(hashOf(bytes), bytes);
+        if (!this._dbFlatMayExist(h, bytes))
+            return null;
+        const key = bytes.length <= DEDUP_KEY_MAX ? latin1(bytes) : null;
+        if (key !== null) {
+            const hit = this._flatKey.get(key);
+            if (hit !== undefined)
+                return hit;
+        }
+        const id = this._dbFindBranchByLeaf(h, bytes);
+        if (id !== null && key !== null)
+            this._flatKey.set(key, id);
+        return id;
+    }
+    /** {@link Store.flatBranchMayExist} — the backend's negative filter when it
+     *  keeps one ({@link _dbFlatMayExist}), else the lookup itself. */
+    flatBranchMayExist(bytes) {
+        return this._dbFlatMayExist(hashOf(bytes), bytes);
+    }
+    /** Default: no filter, so anything MAY exist and the lookup decides.  A
+     *  backend with a negative filter over node hashes overrides this to answer
+     *  from the filter alone. */
+    _dbFlatMayExist(_h, _bytes) {
+        return true;
     }
     findBranch(kids) {
         if (this.meter)
@@ -1731,6 +1807,10 @@ export class AbstractStore {
         const r = this._dbGetHalo(id);
         return r !== null && r.mass >= this.minHaloMass;
     }
+    /** {@link Store.leadsSomewhere} — edge first (the cheaper, commoner probe). */
+    leadsSomewhere(id) {
+        return this.hasNext(id) || this.hasHalo(id);
+    }
     async pourHalo(id, add) {
         await this._ensureReady();
         // A node with a halo is a genuine resonance target — the consensus climb

package/docs/INDEX.md

@@ -21,22 +21,22 @@ proof in `test/` (pins that fail when the law is broken).
 
 ## Architecture laws (14)
 
-| Law | File                                        | Summary                                                                                                         | Pins                 |
-| --- | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | -------------------- |
-| 1   | `docs/architecture/determinism.md`          | No `Math.random`/`Date.now` in behaviour; seed-derived randomness; corpus-determined tie-breaks                 | `test/20`            |
-| 2   | `docs/architecture/thresholds.md`           | Every decision cutoff derived in `geometry.ts` over D/W/N; no tunable knobs                                     | `test/40`, `test/64` |
-| 3   | `docs/architecture/exact-vs-approximate.md` | Vector scores rank only; identity via content-addressed lookup; five graded ladders                             | `test/51`            |
-| 4   | `docs/architecture/cost-model.md`           | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; weight `moves + PASS·unaccounted`; `STEP`-grade compare          | `test/04`, `test/55` |
-| 5   | `docs/architecture/match-project.md`        | Shared `match.ts` family (`locate`/`alignGraded`/`frameSlots`/`project`); voicing gates belong to consumers     | `test/24`, `test/76` |
-| 6   | `docs/architecture/mechanism-market.md`     | `PipelineMechanism` (`floor`/`run`/`parse`); admissible-floor pruning and investment discipline                 | `test/01`, `test/04` |
-| 7   | `docs/architecture/commonality.md`          | Three: global (`reachOf`+`dominates`), weave-local (`depth[]`), window rarity                                   | `test/17`, `test/34` |
-| 8   | `docs/architecture/bounded-reads.md`        | No per-query read grows with N; `hubBound=√N` enforced at store via LIMIT/probe/prefix caps                     | `test/77`, `test/90` |
-| 9   | `docs/architecture/store.md`                | `AbstractStore` owns dedup/indexing/batch; `store-sqlite.ts` is thin wrappers; canon index optional             | `test/08`            |
-| 10  | `docs/architecture/fold-contract.md`        | `perceiveDeposit` and `perceive` agree; `contentLevels` is single boundary rule; no W/offset dependence         | `test/59`, `test/63` |
-| 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle        | `test/42`            |
-| 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                          | `test/27`, `test/16` |
-| 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are exact, phases nest                                         | `test/55`            |
-| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law | `test/133`–`147`     |
+| Law | File                                        | Summary                                                                                                                                                | Pins                                         |
+| --- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------- |
+| 1   | `docs/architecture/determinism.md`          | No `Math.random`/`Date.now` in behaviour; seed-derived randomness; corpus-determined tie-breaks                                                        | `test/20`                                    |
+| 2   | `docs/architecture/thresholds.md`           | Every decision cutoff derived in `geometry.ts` over D/W/N; no tunable knobs                                                                            | `test/40`, `test/64`                         |
+| 3   | `docs/architecture/exact-vs-approximate.md` | Vector scores rank only; identity via content-addressed lookup; five graded ladders                                                                    | `test/51`                                    |
+| 4   | `docs/architecture/cost-model.md`           | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; weight `moves + PASS·unaccounted`; `STEP`-grade compare                                                 | `test/04`, `test/55`                         |
+| 5   | `docs/architecture/match-project.md`        | Shared `match.ts` family (`locate`/`alignGraded`/`frameSlots`/`project`); voicing gates belong to consumers                                            | `test/24`, `test/76`                         |
+| 6   | `docs/architecture/mechanism-market.md`     | `PipelineMechanism` (`floor`/`run`/`parse`); admissible-floor pruning, investment discipline, run-ahead bounds                                         | `test/01`, `test/04`, `test/153`             |
+| 7   | `docs/architecture/commonality.md`          | Three: global (`reachOf`+`dominates`), weave-local (`depth[]`), window rarity                                                                          | `test/17`, `test/34`                         |
+| 8   | `docs/architecture/bounded-reads.md`        | No per-query read grows with N; `hubBound=√N` enforced at store via LIMIT/probe/prefix caps                                                            | `test/77`, `test/90`                         |
+| 9   | `docs/architecture/store.md`                | `AbstractStore` owns dedup/indexing/batch; `store-sqlite.ts` is thin wrappers; canon index optional                                                    | `test/08`                                    |
+| 10  | `docs/architecture/fold-contract.md`        | `perceiveDeposit` and `perceive` agree; the read side names a branch as `intern` does; `contentLevels` is single boundary rule; no W/offset dependence | `test/59`, `test/63`, `test/148`, `test/152` |
+| 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle                                               | `test/42`                                    |
+| 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                                                                 | `test/27`, `test/16`                         |
+| 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are exact, phases nest                                                                                | `test/55`                                    |
+| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law, one engine walks the layers           | `test/133`–`151`                             |
 
 ## Mechanisms (8)
 
@@ -65,6 +65,6 @@ proof in `test/` (pins that fail when the law is broken).
   exact-decides, one cost currency, bounded reads) with file-level routing.
 - `docs/failures/tempting-but-wrong.md` — refuted simplifications that passed
   review but failed pins.
-- `docs/harness/gates.md` — how `AGENTS.md` recipes,
-  `bench/profile-inference.mjs`, and `test/*.test.mjs` enforce the laws.
+- `docs/harness/gates.md` — how `AGENTS.md` recipes, the meter's public path
+  (`profile: true` → `mind.lastCost`), and `test/*.test.mjs` enforce the laws.
 - `docs/architecture/` — per-law derivation: each file says why, not how.