@hviana/sema 0.1.4 → 0.1.6

package/dist/src/{rabitq-hnsw → rabitq-ivf}/src/prng.d.ts

@@ -2,7 +2,7 @@
  * Small deterministic pseudo-random number generator (mulberry32).
  *
  * Pure ECMAScript. It is used so that the random orthogonal rotation of the
- * RaBitQ quantizer and the HNSW level assignment are reproducible and can be
+ * RaBitQ quantizer rotation is reproducible and can be
  * regenerated after (de)serialization without storing large matrices.
  */
 export declare class Prng {

package/dist/src/{rabitq-hnsw → rabitq-ivf}/src/prng.js

@@ -2,7 +2,7 @@
  * Small deterministic pseudo-random number generator (mulberry32).
  *
  * Pure ECMAScript. It is used so that the random orthogonal rotation of the
- * RaBitQ quantizer and the HNSW level assignment are reproducible and can be
+ * RaBitQ quantizer rotation is reproducible and can be
  * regenerated after (de)serialization without storing large matrices.
  */
 export class Prng {

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

@@ -13,11 +13,21 @@ export interface SQliteStoreOptions extends Partial<StoreConfig> {
 export declare class SQliteStore extends AbstractStore implements Store {
     private readonly opts;
     private readonly vectorCacheMb;
+    private readonly sqliteCacheMb;
     private readonly vectorSeed;
     private content;
     private halos;
     private sqlite;
     private _inTx;
+    /** Bloom filter over every node row's content hash `h`.  The dedup probes
+     *  consult it first: "definitely absent" answers the training hot path's
+     *  dominant miss case in RAM (profiled: the SQLite probes were 38.7% of
+     *  ingest wall at 2.9M nodes).  INVARIANT: every inserted h is added
+     *  before the probe that could see it — a false negative would mint a
+     *  duplicate node and silently break hash-consing. */
+    private _bloom;
+    /** Dedup probes answered by the filter alone this session (observability). */
+    bloomSkips: number;
     private _insertNode;
     private _insertKid;
     private _selContain;
@@ -40,6 +50,22 @@ export declare class SQliteStore extends AbstractStore implements Store {
     private vectorDbPath;
     private openVectorDB;
     protected _dbOpen(): Promise<void>;
+    /** Restore the persisted filter and top up the rows a crash left uncovered
+     *  (id ≥ stored `upto`); a missing/undersized blob forces a full rebuild.
+     *  Clean-close sessions restart with a 0-row top-up. */
+    private _bloomLoad;
+    /** Re-add the hashes of rows with id ≥ `from` (the tail a crash cut off).
+     *  Re-adding a hash twice only re-sets its bits — never a correctness
+     *  issue — so overlap with the persisted coverage is harmless. */
+    private _bloomTopUp;
+    /** Build a fresh filter sized for the current node count from one
+     *  sequential scan of the h column.  Called at open when no usable blob is
+     *  stored, and again whenever growth saturates the bits-per-key budget. */
+    private _bloomRebuild;
+    /** Persist the filter with its coverage watermark.  Runs inside the
+     *  caller's transaction when one is open (checkpoint/close both flush
+     *  first). */
+    private _bloomPersist;
     protected _dbClose(): void;
     protected _dbBeginTx(): void;
     protected _dbCommitTx(): void;
@@ -109,7 +135,6 @@ export declare class SQliteStore extends AbstractStore implements Store {
     protected _vecContentUpsert(entries: Array<{
         id: NodeId;
         vector: Float32Array;
-        ef?: number;
     }>): void;
     protected _vecContentQuery(v: Float32Array, k: number, ef: number): Array<{
         id: number;

package/dist/src/store-sqlite.js

@@ -1,4 +1,4 @@
-// store-sqlite.ts — SQLite + rabitq-hnsw persistence adapter.
+// store-sqlite.ts — SQLite + rabitq-ivf persistence adapter.
 //
 // SQliteStore extends AbstractStore and implements only the bare essentials
 // required for database communication: SQL schema, prepared statements, and
@@ -29,7 +29,7 @@
 import { DatabaseSync } from "node:sqlite";
 import { AbstractStore, flatBytesKids, packKids, unpackKids, } from "./store.js";
 import { DEFAULT_CONFIG } from "./config.js";
-import { VectorDatabase } from "./rabitq-hnsw/src/index.js";
+import { VectorDatabase } from "./rabitq-ivf/src/index.js";
 const SCHEMA = `
 -- Content-addressed lookup goes through ONE small integer index: h is the
 -- FNV-1a hash of the row's content key (leaf bytes, or the packed kid ids of a
@@ -44,6 +44,21 @@ CREATE TABLE IF NOT EXISTS node (
   h    INTEGER NOT NULL
 );
 CREATE INDEX IF NOT EXISTS idx_node_h ON node(h);
+-- Negative-lookup BLOOM FILTER over node.h — the RAM structure that lets the
+-- content-addressed dedup probes (findLeaf/findBranch, the training hot path)
+-- answer "definitely new content" without an idx_node_h descent.  Persisted
+-- here at checkpoint/close with upto = the next node id NOT covered; on
+-- open, rows with id >= upto (a crash's tail) are re-added by an incremental
+-- rowid-range scan, so the filter can NEVER be missing an inserted hash — a
+-- false negative would silently break hash-consing (duplicate mints), while
+-- a false positive only costs the SQLite probe that was paid on every call
+-- before the filter existed.
+CREATE TABLE IF NOT EXISTS bloom (
+  id   INTEGER PRIMARY KEY CHECK (id = 1),
+  bits BLOB NOT NULL,
+  n    INTEGER NOT NULL,
+  upto INTEGER NOT NULL
+);
 -- The reverse structural edge child→parent. A WITHOUT ROWID table clustered on
 -- (child, parent) IS the lookup index: parents(child) is one B-tree descent to a
 -- contiguous run, with no separate rowid heap and no secondary index to maintain
@@ -106,9 +121,65 @@ CREATE TABLE IF NOT EXISTS meta (
   val TEXT NOT NULL
 );
 `;
+/** Blocked Bloom filter over 32-bit content hashes.  k=4 bit positions per
+ *  key via double hashing; at the maintained ≥12 bits/key the false-positive
+ *  rate stays under ~1%, so ≥99% of miss-probes skip SQLite entirely.
+ *  No deletions (nodes are never deleted), so growth is a rebuild. */
+class NodeBloom {
+    bits;
+    mask;
+    n = 0;
+    constructor(log2bits) {
+        this.bits = new Uint8Array(1 << (log2bits - 3));
+        this.mask = (1 << log2bits) - 1 >>> 0;
+    }
+    add(h) {
+        const h2 = (Math.imul(h, 0x9e3779b1) | 1) >>> 0;
+        let x = h >>> 0;
+        const bits = this.bits;
+        const mask = this.mask;
+        for (let i = 0; i < 4; i++) {
+            const b = x & mask;
+            bits[b >> 3] |= 1 << (b & 7);
+            x = (x + h2) >>> 0;
+        }
+        this.n++;
+    }
+    mightContain(h) {
+        const h2 = (Math.imul(h, 0x9e3779b1) | 1) >>> 0;
+        let x = h >>> 0;
+        const bits = this.bits;
+        const mask = this.mask;
+        for (let i = 0; i < 4; i++) {
+            const b = x & mask;
+            if ((bits[b >> 3] & (1 << (b & 7))) === 0)
+                return false;
+            x = (x + h2) >>> 0;
+        }
+        return true;
+    }
+    /** Whether the filter is due for a bigger rebuild (< 12 bits/key). */
+    get saturated() {
+        return this.n * 12 > this.bits.length * 8;
+    }
+}
+/** log2 of the bloom bit count sized for `n` keys at 16 bits/key, clamped to
+ *  [17, 30] — 16 KiB floor, 128 MiB ceiling (past ~90M nodes the FPR is
+ *  allowed to drift up rather than RAM). */
+function bloomLog2For(n) {
+    let log2 = 17;
+    while (log2 < 30 && (1 << log2) < n * 16)
+        log2++;
+    return log2;
+}
+/** Below this node count the filter is NOT persisted: a rebuild scan at open
+ *  is instant at this size, and the blob would dominate a small store's
+ *  on-disk footprint. */
+const BLOOM_PERSIST_MIN_NODES = 65_536;
 export class SQliteStore extends AbstractStore {
     opts;
     vectorCacheMb;
+    sqliteCacheMb;
     vectorSeed;
     // ── the two SEPARATE vector indices ───────────────────────────────────
     content = null; // STORAGE: node gists
@@ -116,6 +187,16 @@ export class SQliteStore extends AbstractStore {
     sqlite = null;
     // Deferred write transaction guard.
     _inTx = false;
+    // ── negative dedup filter ──────────────────────────────────────────────
+    /** Bloom filter over every node row's content hash `h`.  The dedup probes
+     *  consult it first: "definitely absent" answers the training hot path's
+     *  dominant miss case in RAM (profiled: the SQLite probes were 38.7% of
+     *  ingest wall at 2.9M nodes).  INVARIANT: every inserted h is added
+     *  before the probe that could see it — a false negative would mint a
+     *  duplicate node and silently break hash-consing. */
+    _bloom = null;
+    /** Dedup probes answered by the filter alone this session (observability). */
+    bloomSkips = 0;
     _insertNode = null;
     _insertKid = null;
     _selContain = null;
@@ -139,10 +220,6 @@ export class SQliteStore extends AbstractStore {
         // Resolve config from opts, falling back to defaults.
         const config = {
             minHaloMass: opts.minHaloMass ?? d.minHaloMass,
-            m: opts.m ?? d.m,
-            efConstruction: opts.efConstruction ?? d.efConstruction,
-            efConstructionInterior: opts.efConstructionInterior ??
-                d.efConstructionInterior,
             efSearch: opts.efSearch ?? d.efSearch,
             compactEveryNWrites: opts.compactEveryNWrites ?? d.compactEveryNWrites,
             overfetch: opts.overfetch ?? d.overfetch,
@@ -154,6 +231,7 @@ export class SQliteStore extends AbstractStore {
             pendingGistBytes: opts.pendingGistBytes ?? d.pendingGistBytes,
             haloCacheBytes: opts.haloCacheBytes ?? d.haloCacheBytes,
             vectorCacheMb: opts.vectorCacheMb ?? d.vectorCacheMb,
+            sqliteCacheMb: opts.sqliteCacheMb ?? d.sqliteCacheMb,
             coveredIdsMax: opts.coveredIdsMax ?? d.coveredIdsMax,
             chainCacheBytes: opts.chainCacheBytes ?? d.chainCacheBytes,
         };
@@ -162,6 +240,7 @@ export class SQliteStore extends AbstractStore {
         super(config, D, maxGroup);
         this.opts = opts;
         this.vectorCacheMb = opts.vectorCacheMb ?? d.vectorCacheMb;
+        this.sqliteCacheMb = opts.sqliteCacheMb ?? d.sqliteCacheMb;
         this.vectorSeed = (0x51f15e ^ 0x9e3779b9) >>> 0;
         this._ready = this._dbOpen();
     }
@@ -176,8 +255,6 @@ export class SQliteStore extends AbstractStore {
         return new VectorDatabase({
             dbPath: this.vectorDbPath(name),
             dim: this.D,
-            M: this.m,
-            efConstruction: this.efConstruction,
             efSearch: this.efSearch,
             // Query-side estimator precision.  8 bits: 4 bits measurably misranks
             // tight gist clusters (mixture recall@10 37.5% vs 39.0%, self-recall
@@ -207,6 +284,26 @@ export class SQliteStore extends AbstractStore {
         // WAL + NORMAL sync: crash-safe (WAL commits are atomic) without a full
         // fsync per commit — the same discipline the vector databases use.
         this.sqlite.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;");
+        // SQLite's autocheckpoint default is 1000 PAGES — 1 MiB at this store's
+        // 1 KiB page size — so at training write rates nearly every batch commit
+        // crossed the threshold and paid a synchronous checkpoint: random writes
+        // into a GB-scale main file, with the hottest B-tree pages copied out on
+        // every commit instead of being coalesced across commits in the WAL.
+        // Profiled on a 7.5M-node store: ~114 ms PER COMMIT, ~19% of ingest
+        // wall-clock.  16 MiB of WAL between checkpoints coalesces hot-page
+        // rewrites and amortizes the checkpoint's fixed cost; crash-safety is
+        // unchanged (WAL recovery replays it), the only trade is a bounded,
+        // fixed-size WAL file.
+        this.sqlite.exec("PRAGMA wal_autocheckpoint = 65536;");
+        // Page cache for the DAG tables.  Content-addressed dedup (findLeaf /
+        // findBranch), parent probes and contain appends are millions of point
+        // queries per session against a file that outgrows SQLite's ~2 MiB
+        // default cache almost immediately; every miss is a file read on the
+        // ingest hot path.  Negative = KiB budget (size-based, page-size
+        // independent).  Latency only — results identical at any value.
+        const cacheKb = Math.max(0, Math.floor(this.sqliteCacheMb * 1024));
+        if (cacheKb > 0)
+            this.sqlite.exec(`PRAGMA cache_size = -${cacheKb};`);
         this.sqlite.exec(SCHEMA);
         // Recover D from a previous run so loadFromStore() can bootstrap with any
         // default — the real value is read from meta before vector indices load.
@@ -244,8 +341,71 @@ export class SQliteStore extends AbstractStore {
         // the same value but scans every leaf page, so open time grew linearly
         // with the store; a per-row scan into a Set was worse still.)
         this._nextId = (this.sqlite.prepare("SELECT MAX(id) AS m FROM node").get().m ?? -1) + 1;
+        this._bloomLoad();
+    }
+    // ── negative dedup filter: load / rebuild / persist ────────────────────
+    /** Restore the persisted filter and top up the rows a crash left uncovered
+     *  (id ≥ stored `upto`); a missing/undersized blob forces a full rebuild.
+     *  Clean-close sessions restart with a 0-row top-up. */
+    _bloomLoad() {
+        const row = this.sqlite.prepare("SELECT bits, n, upto FROM bloom WHERE id = 1").get();
+        const wantLog2 = bloomLog2For(this._nextId);
+        if (row && row.bits.length * 8 >= (1 << wantLog2)) {
+            const log2 = 31 - Math.clz32(row.bits.length * 8);
+            const b = new NodeBloom(log2);
+            b.bits.set(row.bits);
+            b.n = row.n;
+            this._bloom = b;
+            this._bloomTopUp(row.upto);
+        }
+        else {
+            this._bloomRebuild();
+        }
+    }
+    /** Re-add the hashes of rows with id ≥ `from` (the tail a crash cut off).
+     *  Re-adding a hash twice only re-sets its bits — never a correctness
+     *  issue — so overlap with the persisted coverage is harmless. */
+    _bloomTopUp(from) {
+        if (from >= this._nextId)
+            return;
+        const b = this._bloom;
+        const scan = this.sqlite.prepare("SELECT h FROM node WHERE id >= ?");
+        scan.setReturnArrays(true);
+        for (const r of scan.iterate(from)) {
+            b.add(r[0]);
+        }
+    }
+    /** Build a fresh filter sized for the current node count from one
+     *  sequential scan of the h column.  Called at open when no usable blob is
+     *  stored, and again whenever growth saturates the bits-per-key budget. */
+    _bloomRebuild() {
+        const b = new NodeBloom(bloomLog2For(this._nextId));
+        b.n = 0;
+        if (this._nextId > 0) {
+            const scan = this.sqlite.prepare("SELECT h FROM node");
+            scan.setReturnArrays(true);
+            for (const r of scan.iterate()) {
+                // add() counts n itself.
+                b.add(r[0]);
+            }
+        }
+        this._bloom = b;
+    }
+    /** Persist the filter with its coverage watermark.  Runs inside the
+     *  caller's transaction when one is open (checkpoint/close both flush
+     *  first). */
+    _bloomPersist() {
+        if (!this._bloom || !this.sqlite)
+            return;
+        if (this._nextId < BLOOM_PERSIST_MIN_NODES)
+            return;
+        this.sqlite.prepare("INSERT INTO bloom (id, bits, n, upto) VALUES (1, ?, ?, ?) " +
+            "ON CONFLICT(id) DO UPDATE SET bits = excluded.bits, " +
+            "n = excluded.n, upto = excluded.upto").run(this._bloom.bits, this._bloom.n, this._nextId);
     }
     _dbClose() {
+        if (this.sqlite)
+            this._bloomPersist();
         if (this.content) {
             this.content.close();
             this.content = null;
@@ -278,6 +438,12 @@ export class SQliteStore extends AbstractStore {
             this._insertNode = this.sqlite.prepare("INSERT INTO node (id, leaf, kids, h) VALUES (?, ?, ?, ?)");
         }
         this._insertNode.run(id, leaf, kids, h);
+        // The filter must see every inserted hash BEFORE any probe could — the
+        // add sits in the same synchronous call as the row insert.
+        const b = this._bloom;
+        b.add(h);
+        if (b.saturated)
+            this._bloomRebuild();
     }
     _dbGetNode(id) {
         if (!this._selNode) {
@@ -298,6 +464,10 @@ export class SQliteStore extends AbstractStore {
         };
     }
     _dbFindLeaf(h, bytes) {
+        if (this._bloom && !this._bloom.mightContain(h)) {
+            this.bloomSkips++;
+            return null;
+        }
         if (!this._selLeaf) {
             this._selLeaf = this.sqlite.prepare("SELECT id FROM node WHERE h = ? AND leaf = ? AND kids IS NULL LIMIT 1");
         }
@@ -305,6 +475,10 @@ export class SQliteStore extends AbstractStore {
         return row ? row.id : null;
     }
     _dbFindBranchByLeaf(h, bytes) {
+        if (this._bloom && !this._bloom.mightContain(h)) {
+            this.bloomSkips++;
+            return null;
+        }
         if (!this._selFlat) {
             this._selFlat = this.sqlite.prepare("SELECT id FROM node WHERE h = ? AND leaf = ? AND kids IS NOT NULL LIMIT 1");
         }
@@ -312,6 +486,10 @@ export class SQliteStore extends AbstractStore {
         return row ? row.id : null;
     }
     _dbFindBranchByKids(h, packed) {
+        if (this._bloom && !this._bloom.mightContain(h)) {
+            this.bloomSkips++;
+            return null;
+        }
         if (!this._selKids) {
             this._selKids = this.sqlite.prepare("SELECT id FROM node WHERE h = ? AND kids = ? LIMIT 1");
         }
@@ -626,6 +804,10 @@ export class SQliteStore extends AbstractStore {
                 "ON CONFLICT(id) DO UPDATE SET data = excluded.data");
         }
         this._insSnapshot.run(bytes);
+        // Checkpoint cadence: persisting the dedup filter here keeps the crash
+        // top-up (the id ≥ upto rescan at next open) bounded by one checkpoint
+        // interval instead of the whole session.
+        this._bloomPersist();
     }
     _dbLoadSnapshot() {
         if (!this._selSnapshot) {

package/dist/src/store.d.ts

@@ -324,7 +324,6 @@ export declare abstract class AbstractStore implements Store {
     protected abstract _vecContentUpsert(entries: Array<{
         id: NodeId;
         vector: Float32Array;
-        ef?: number;
     }>): void;
     protected abstract _vecContentQuery(v: Float32Array, k: number, ef: number): Array<{
         id: number;
@@ -376,9 +375,6 @@ export declare abstract class AbstractStore implements Store {
     protected _maxGroup: number;
     protected readonly minHaloMass: number;
     protected readonly efSearch: number;
-    protected readonly m: number;
-    protected readonly efConstruction: number;
-    protected readonly efConstructionInterior: number;
     protected readonly overfetch: number;
     protected readonly batchSize: number;
     protected readonly compactEveryNWrites: number;
@@ -429,20 +425,17 @@ export declare abstract class AbstractStore implements Store {
     protected _coveredIds: BoundedMap<NodeId, true>;
     /** Live content-index id set, LRU-bounded so a massive ingest never leaks
      *  memory; an evicted entry is still indexed (the row is durable), so the
-     *  only cost of an eviction is a duplicate HNSW probe on next visit. */
+     *  only cost of an eviction is a duplicate index probe on next visit. */
     protected _indexedIds: BoundedMap<NodeId, true>;
     /** ANN read cache for {@link resonate} — keyed by vecKey(v) + ":" + k;
      *  lazily initialised, dropped on any index mutation. */
     protected _resonateCache: Map<string, Hit[]> | null;
     /** ANN read cache for {@link resonateHalo} — same scheme. */
     protected _resonateHaloCache: Map<string, Hit[]> | null;
-    /** Content (gist) index write buffer.  `ef` is the per-entry HNSW
-     *  construction budget: reach-only interiors carry the reduced
-     *  `efConstructionInterior`; dedup targets omit it (full budget). */
+    /** Content (gist) index write buffer. */
     protected _contentBuffer: Array<{
         id: NodeId;
         vector: Float32Array;
-        ef?: number;
     }>;
     /** Halo index write buffer — keyed by id so repeats within a batch coalesce. */
     protected _haloBuffer: Map<number, Float32Array<ArrayBufferLike>>;

package/dist/src/store.js

@@ -364,9 +364,6 @@ export class AbstractStore {
     _maxGroup;
     minHaloMass;
     efSearch;
-    m;
-    efConstruction;
-    efConstructionInterior;
     overfetch;
     batchSize;
     compactEveryNWrites;
@@ -419,7 +416,7 @@ export class AbstractStore {
     _coveredIds;
     /** Live content-index id set, LRU-bounded so a massive ingest never leaks
      *  memory; an evicted entry is still indexed (the row is durable), so the
-     *  only cost of an eviction is a duplicate HNSW probe on next visit. */
+     *  only cost of an eviction is a duplicate index probe on next visit. */
     _indexedIds;
     // ── ANN read cache ─────────────────────────────────────────────────────
     // The index is read-only between writes, so the same (v,k) always returns
@@ -432,9 +429,7 @@ export class AbstractStore {
     /** ANN read cache for {@link resonateHalo} — same scheme. */
     _resonateHaloCache = null;
     // ── Write buffers ──────────────────────────────────────────────────────
-    /** Content (gist) index write buffer.  `ef` is the per-entry HNSW
-     *  construction budget: reach-only interiors carry the reduced
-     *  `efConstructionInterior`; dedup targets omit it (full budget). */
+    /** Content (gist) index write buffer. */
     _contentBuffer = [];
     /** Halo index write buffer — keyed by id so repeats within a batch coalesce. */
     _haloBuffer = new Map();
@@ -466,9 +461,6 @@ export class AbstractStore {
         this._maxGroup = maxGroup;
         this.minHaloMass = config.minHaloMass;
         this.efSearch = config.efSearch;
-        this.m = config.m;
-        this.efConstruction = config.efConstruction;
-        this.efConstructionInterior = Math.max(1, Math.min(config.efConstructionInterior, config.efConstruction));
         this.overfetch = config.overfetch;
         this.batchSize = config.batchSize;
         this.compactEveryNWrites = config.compactEveryNWrites;
@@ -875,7 +867,7 @@ export class AbstractStore {
         //    leaf, and near-merging distinct leaves only corrupts bytes for no real
         //    saving. Real near-dedup compression lives in subtree (branch) fusion.
         //
-        //    There is deliberately NO HNSW probe of the FLUSHED index here. It used
+        //    There is deliberately NO ANN probe of the FLUSHED index here. It used
         //    to fire for EVERY new branch that the buffer scan didn't settle — i.e.
         //    ~every interior branch, since interiors are never dedup targets —
         //    making one ANN query per branch the dominant training cost (it dwarfed
@@ -981,7 +973,7 @@ export class AbstractStore {
         // Capture the gist; it is pushed into the content index lazily, the first
         // time this node becomes a resonance target (link / pourHalo). A node that
         // never does (a pure intermediate DAG node — ~99.5% of them) is never
-        // indexed: it costs one persistence row, no HNSW slot and no merge probe.
+        // indexed: it costs one persistence row, no vector-index slot and no merge probe.
         this._pendingGist.set(id, normalize(copy(gist)));
         await this.maybeFlush();
         return id;
@@ -1056,12 +1048,7 @@ export class AbstractStore {
             return;
         }
         this._indexedIds.set(id, true);
-        // Reach-only interiors build with the reduced construction budget — the
-        // one deliberate speed-for-quality trade of ingestion (see
-        // {@link StoreConfig.efConstructionInterior}); targets keep the full one.
-        this._contentBuffer.push(dedupTarget
-            ? { id, vector: v }
-            : { id, vector: v, ef: this.efConstructionInterior });
+        this._contentBuffer.push({ id, vector: v });
         this._bufferedIds.add(id);
         // A node indexed AS a dedup target enters the candidate set immediately.
         if (dedupTarget)
@@ -1344,11 +1331,7 @@ export class AbstractStore {
             // Index it — same code path as indexGist, but the vector is injected
             // directly rather than read from the (empty) pending-gist cache.
             this._indexedIds.set(id, true);
-            this._contentBuffer.push({
-                id,
-                vector: gist,
-                ef: this.efConstructionInterior,
-            });
+            this._contentBuffer.push({ id, vector: gist });
             this._bufferedIds.add(id);
             // Repaired nodes are reach-indexed, never dedup targets: their gist is
             // regenerated (may differ numerically from the original) and they are

package/example/train_base.ts

@@ -1610,20 +1610,23 @@ async function saveProgress(store: Store, p: SavedProgress): Promise<void> {
 // ═══════════════════════════════════════════════════════════════════════
 
 async function main(): Promise<void> {
-  // The vector indices' single memory knob (MiB) — sizes both the SQLite page
-  // cache and the decoded-code LRU of each index.  Training is HNSW-insert
-  // bound at scale (profiled at >80% of ingest wall-clock on a 5.5M-vector
-  // store, nearly all of it cache-missing code reads), and inserts walk the
-  // graph, so a cache that covers the indexed codes cuts wall-clock directly
-  // (measured ~1.6× at 1 GB vs 64 MB on a 2M-node store).  1 GB caches ~5.8M
-  // D=1024 codes — the whole content index of a 350 MB-corpus store — and is
-  // the default; override with VECTOR_CACHE_MB (e.g. 256 on a small-RAM
-  // machine, 64 for the library default).
-  const VECTOR_CACHE_MB = Math.max(0, Number(env("VECTOR_CACHE_MB", "1024")));
+  // The vector indices' memory knob (MiB) — each index's SQLite page cache.
+  // The IVF index routes inserts through a RAM-resident pivot table and
+  // appends to chunk blobs, so this cache mostly serves query-time cluster
+  // scans; 256 MiB comfortably covers the probed working set of a trained
+  // store.  Override with VECTOR_CACHE_MB (64 is the library default).
+  const VECTOR_CACHE_MB = Math.max(0, Number(env("VECTOR_CACHE_MB", "256")));
+  // Page cache for the MAIN DAG database (node/kid/edge/contain tables).
+  // Training issues millions of content-addressed point probes per session
+  // against a GB-scale file; the library default (64 MiB) is sized for a
+  // small machine — a training box affords more.  Override with
+  // SQLITE_CACHE_MB.
+  const SQLITE_CACHE_MB = Math.max(0, Number(env("SQLITE_CACHE_MB", "256")));
   const store = new SQliteStore({
     path: DB_PATH,
     D,
     vectorCacheMb: VECTOR_CACHE_MB,
+    sqliteCacheMb: SQLITE_CACHE_MB,
   });
 
   // The store IS the model: memories, progress, and metadata all persist in

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hviana/sema",
-  "version": "0.1.4",
-  "description": "An elementary, recursive, weight-free multimodal mind: one structure, two verbs, one memory. Zero runtime dependencies, pure web standards.",
+  "version": "0.1.6",
+  "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

package/src/alu/README.md

@@ -15,7 +15,7 @@ search as authoritative axioms (at `STEP` cost, like a learned edge).
 
 It has no dependency on the rest of the codebase except the pure byte helpers in
 `../bytes.ts`, and is intended to be reused as a self-contained sublibrary in
-the spirit of `derive/` and `rabitq-hnsw/`.
+the spirit of `derive/` and `rabitq-ivf/`.
 
 ## The thesis: one tiny kernel, everything else is a rewrite
 

package/src/alu/src/index.ts

@@ -1,7 +1,7 @@
 // alu — the ALU sub-library: a tiny irreducible kernel from which arithmetic,
 // logic, and numerical computation are all DERIVED.
 //
-// Self-contained in the spirit of derive/ and rabitq-hnsw/: it imports only the
+// Self-contained in the spirit of derive/ and rabitq-ivf/: it imports only the
 // pure byte helpers (../../bytes.js) and nothing else from SEMA.  The host
 // reaches meaning (operator synonymy, the symbolic inverse) through the injected
 // AluResonance, pre-resolved into a synchronous snapshot before the search runs.