@hviana/sema 0.1.5 → 0.1.7

package/test/13-conversation.test.mjs

@@ -14,14 +14,10 @@
 // The assertions describe BEHAVIOUR only — they never mention how context is
 // represented — so they stay valid for any implementation.
 //
-// Note: Sema trains on the accumulated context string ("turn0\nturn1\nturn2")
-// and queries the same accumulated string at inference. This is not a
-// weakness — LLMs work the same way: a chat model receives the full
-// conversation history as its prompt, and that same history must be
-// provided at inference to produce the next turn. The difference is in
-// how the answer is produced: Sema composes it from learned graph forms;
-// an LLM samples it from a parametric distribution. Neither is "just a
-// lookup."
+// Sema trains on the raw concatenation of prior turns and queries the same
+// accumulated bytes at inference.  The Conversation API tracks turn-boundary
+// offsets explicitly so no separator character is needed — the geometry never
+// inspects content to find turn boundaries.
 // ─────────────────────────────────────────────────────────────────────────
 
 import { test } from "node:test";
@@ -34,16 +30,14 @@ const newMind = () => new Mind({ seed: 7 });
 // ═══════════════════════════════════════════════════════════════════════
 // teachConversation — store one conversation (an ordered list of turns).
 //
-// Accumulate every prior turn into the context so each episode carries the
-// full conversation history:  (t₀ → t₁), (t₀+t₁ → t₂), (t₀+t₁+t₂ → t₃) …
-// A pivot turn ("what is its name?") that appears in two conversations now
-// produces different episode vectors because the context side encodes which
-// conversation it belongs to.  All SEMA operations remain sublinear — the
-// river cuts any context into O(log N) chunks regardless of length.
+// Accumulate prior turns by raw concatenation — no separator character.
+// Each episode carries the full conversation history: (t₀ → t₁),
+// (t₀+t₁ → t₂), (t₀+t₁+t₂ → t₃) … where + is byte concatenation.
 // ═══════════════════════════════════════════════════════════════════════
 async function teachConversation(mind, turns) {
+  let context = "";
   for (let i = 0; i + 1 < turns.length; i++) {
-    const context = turns.slice(0, i + 1).join("\n");
+    context += turns[i];
     await mind.ingest(context, turns[i + 1]);
   }
 }
@@ -51,13 +45,22 @@ async function teachConversation(mind, turns) {
 // ═══════════════════════════════════════════════════════════════════════
 // predictNext — given the turns spoken so far, predict the next turn.
 //
-// Join every prior turn into one accumulated context, mirroring the storage
-// pattern in teachConversation.  The resulting query string is the exact
-// context side of the matching episode, so recall resolves unambiguously.
+// Uses the Conversation API: beginConversation → respondTurn for each
+// prior turn → respondTurnText for the query → endConversation.
+// Turns are raw strings, concatenated by the Mind — no separator.
 // ═══════════════════════════════════════════════════════════════════════
 async function predictNext(mind, priorTurns) {
-  const context = priorTurns.join("\n");
-  return await mind.respondText(context);
+  if (priorTurns.length === 0) return "";
+  const conv = mind.beginConversation();
+  for (let i = 0; i < priorTurns.length - 1; i++) {
+    await mind.respondTurn(conv, priorTurns[i]);
+  }
+  const { response } = await mind.respondTurnText(
+    conv,
+    priorTurns[priorTurns.length - 1],
+  );
+  mind.endConversation(conv);
+  return response;
 }
 
 // A small convenience: teach a conversation, then ask for the continuation
@@ -226,3 +229,170 @@ test("D2: prediction is deterministic across runs", async () => {
   };
   assert.equal(await run(), await run());
 });
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section E — Conversation API lifecycle & cache management
+//
+// Tests for the beginConversation / respondTurn / endConversation API
+// itself, independent of the conversation-training pattern above.
+// ═══════════════════════════════════════════════════════════════════════
+
+test("E1: begin → respondTurn → end completes a single-turn conversation", async () => {
+  const mind = newMind();
+  await mind.ingest("hello", "world");
+
+  const conv = mind.beginConversation();
+  const { response, state } = await mind.respondTurnText(conv, "hello");
+  assert.equal(response, "world");
+  // Single turn — no boundaries yet.
+  assert.equal(state.boundaries.length, 0);
+  mind.endConversation(conv);
+  await mind.store.close();
+});
+
+test("E2: multi-turn conversation accumulates context and boundaries", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+
+  const conv = mind.beginConversation();
+  // First turn establishes the subject.
+  await mind.respondTurn(conv, "I adopted a cat");
+
+  // Second turn is the pivot query.
+  const t2 = await mind.respondTurnText(conv, "what is its name?");
+  // Now we have one boundary: the byte position after the first turn.
+  assert.equal(t2.state.boundaries.length, 1);
+  assert.equal(t2.response, "her name is Whiskers");
+
+  mind.endConversation(conv);
+  await mind.store.close();
+});
+
+test("E3: save → end → restore → continue works", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+
+  // First two turns.
+  const conv = mind.beginConversation();
+  await mind.respondTurn(conv, "I adopted a cat");
+  const { state: saved } = await mind.respondTurnText(
+    conv,
+    "what is its name?",
+  );
+  assert.equal(saved.boundaries.length, 1);
+
+  // Save and end.
+  mind.endConversation(conv);
+
+  // Restore from the saved state into a new handle.
+  const conv2 = mind.beginConversation(saved);
+  const { response, state: state2 } = await mind.respondTurnText(
+    conv2,
+    "her name is Whiskers",
+  );
+  // The restored conversation continues from where it left off.
+  assert.ok(response.length > 0 || response === "");
+  // Boundaries are intact from the restore.
+  assert.equal(state2.boundaries.length, 2);
+
+  mind.endConversation(conv2);
+  await mind.store.close();
+});
+
+test("E4: endConversation is idempotent", async () => {
+  const mind = newMind();
+  const conv = mind.beginConversation();
+  mind.endConversation(conv);
+  // Second end on the same handle — must not throw.
+  mind.endConversation(conv);
+  await mind.store.close();
+});
+
+test("E5: respondTurn on an ended conversation throws", async () => {
+  const mind = newMind();
+  const conv = mind.beginConversation();
+  mind.endConversation(conv);
+  await assert.rejects(
+    () => mind.respondTurn(conv, "hello"),
+    /not found/,
+  );
+  await mind.store.close();
+});
+
+test("E6: conversationState returns null after endConversation", async () => {
+  const mind = newMind();
+  const conv = mind.beginConversation();
+  mind.endConversation(conv);
+  assert.equal(mind.conversationState(conv), null);
+  await mind.store.close();
+});
+
+test("E7: multiple concurrent conversations are independent", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+  await teachConversation(mind, DOG);
+
+  const catConv = mind.beginConversation();
+  const dogConv = mind.beginConversation();
+
+  // Feed the distinguishing context to each.
+  await mind.respondTurn(catConv, "I adopted a cat");
+  await mind.respondTurn(dogConv, "I adopted a dog");
+
+  // The same pivot turn — different answers.
+  const catR = await mind.respondTurnText(catConv, "what is its name?");
+  const dogR = await mind.respondTurnText(dogConv, "what is its name?");
+
+  assert.equal(catR.response, "her name is Whiskers");
+  assert.equal(dogR.response, "his name is Rex");
+  assert.notEqual(catR.response, dogR.response);
+
+  // Each conversation has its own boundaries.
+  assert.equal(catR.state.boundaries.length, 1);
+  assert.equal(dogR.state.boundaries.length, 1);
+
+  // Ending one does not affect the other.
+  mind.endConversation(catConv);
+  assert.equal(mind.conversationState(catConv), null);
+  assert.notEqual(mind.conversationState(dogConv), null);
+
+  // End the second — both are now gone.
+  mind.endConversation(dogConv);
+  assert.equal(mind.conversationState(dogConv), null);
+
+  // Ending again is idempotent.
+  mind.endConversation(dogConv);
+  await mind.store.close();
+});
+
+test("E8: respondTurn with a forged handle throws", async () => {
+  const mind = newMind();
+  // { id: 999 } was never returned by beginConversation.
+  await assert.rejects(
+    () => mind.respondTurn({ id: 999 }, "hello"),
+    /not found/,
+  );
+  await mind.store.close();
+});
+
+test("E9: respond and respondTurn give the same answer for the same cumulative bytes", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+
+  // Via respond() — raw concatenation, same as respondTurn.
+  const viaRespond = await mind.respondText(
+    "I adopted a catwhat is its name?",
+  );
+
+  // Via respondTurn — the new way.
+  const conv = mind.beginConversation();
+  await mind.respondTurnText(conv, "I adopted a cat");
+  const { response: viaConv } = await mind.respondTurnText(
+    conv,
+    "what is its name?",
+  );
+  mind.endConversation(conv);
+
+  assert.equal(viaRespond, viaConv);
+  await mind.store.close();
+});

package/test/14-scaling.test.mjs

@@ -112,7 +112,7 @@ function unknownInput(targetBytes) {
 //      jitter swamp the signal over a few thousand deposits, so any strict
 //      degradation bound is either flaky or so loose it catches nothing.
 //
-// The real degradation lived in the vector index (rabitq-hnsw) and is now guarded
+// The real degradation lived in the vector index (rabitq-ivf) and is now guarded
 // DETERMINISTICALLY at its own layer (testScalabilityWithoutCache, on the
 // cache-independent storage-read count). HERE we assert the same contract end to
 // end through the Mind, also by STORAGE READS rather than time: the work one
@@ -170,7 +170,7 @@ test("training: recall work does NOT grow with the store (storage reads, not tim
 
   // 6x the corpus must not cost anywhere near 6x the reads. A genuinely
   // sublinear (~log N) lookup barely moves; a per-recall cost that tracked the
-  // corpus would roughly 6x. Allow a generous 3x band for HNSW's log-N growth
+  // corpus would roughly 6x. Allow a generous 3x band for estimator noise
   // and graph-shape variation, far below the ~6x a true O(N) regression shows.
   assert.ok(
     large < small * 3 + 50,

package/test/35-ivf.test.mjs

@@ -0,0 +1,263 @@
+// 35-ivf.test.mjs — the partitioned (IVF) vector index, at its own layer.
+//
+// VectorDatabase is an adaptive IVF index over 1-bit RaBitQ codes in SQLite
+// (src/rabitq-ivf).  These tests verify the index's OWN contract, below the
+// Sema store:
+//
+//   1. CRUD          — insert/has/get/update/delete, id checking.
+//   2. Recall        — clustered data resonates to its own cluster; a stored
+//                      vector finds itself.
+//   3. Splits        — the index partitions past SPLIT_MAX and stays correct.
+//   4. Persistence   — close/reopen preserves entries, config, and results.
+//   5. Determinism   — same insert sequence ⇒ identical results (no RNG).
+//   6. Compaction    — tombstones are reclaimed; internal ids (the keysSince
+//                      watermark) survive.
+//   7. Scaling       — per-query STORAGE READS are bounded once the
+//                      collection is past its first splits: 2x the corpus
+//                      must not move the reads (the honest witness the old
+//                      graph index also swore to).
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { rmSync } from "node:fs";
+import { VectorDatabase } from "../dist/src/rabitq-ivf/src/index.js";
+
+// Deterministic PRNG for test vectors.
+function rng(seed) {
+  let s = seed >>> 0;
+  return () => {
+    s ^= s << 13;
+    s ^= s >>> 17;
+    s ^= s << 5;
+    s >>>= 0;
+    return s / 0x100000000;
+  };
+}
+
+/** A unit vector near `center` with per-coordinate jitter. */
+function near(center, jitter, r) {
+  const v = new Float32Array(center.length);
+  for (let i = 0; i < v.length; i++) {
+    v[i] = center[i] + (r() * 2 - 1) * jitter;
+  }
+  return v;
+}
+
+function randVec(dim, r) {
+  const v = new Float32Array(dim);
+  for (let i = 0; i < dim; i++) v[i] = r() * 2 - 1;
+  return v;
+}
+
+test("1: CRUD — insert, has, get, update, delete", () => {
+  const db = new VectorDatabase({ dbPath: ":memory:", dim: 64 });
+  const r = rng(1);
+  const v1 = randVec(64, r);
+  const v2 = randVec(64, r);
+
+  db.insert(10, v1);
+  assert.equal(db.size, 1);
+  assert.ok(db.has(10));
+  assert.ok(!db.has(11));
+  assert.throws(() => db.insert(10, v2), /already exists/);
+  assert.throws(() => db.insert(1.5, v2), /integer/);
+
+  const code = db.get(10);
+  assert.ok(code instanceof Uint32Array);
+
+  // update to a genuinely different vector: same ext still resolves
+  db.update(10, v2);
+  assert.equal(db.size, 1);
+  assert.ok(db.has(10));
+
+  // byte-identical update is a no-op (no new tombstone)
+  const phys = db.physicalSize;
+  db.update(10, v2);
+  assert.equal(db.physicalSize, phys);
+
+  assert.ok(db.delete(10));
+  assert.ok(!db.has(10));
+  assert.equal(db.size, 0);
+  assert.ok(!db.delete(10));
+  db.close();
+});
+
+test("2: recall — clustered data finds its own cluster; self-recall", () => {
+  const dim = 128;
+  const db = new VectorDatabase({ dbPath: ":memory:", dim });
+  const r = rng(2);
+  // 8 well-separated centers, 100 members each.
+  const centers = [];
+  for (let c = 0; c < 8; c++) centers.push(randVec(dim, r));
+  const vecs = new Map();
+  let id = 0;
+  const batch = [];
+  for (let c = 0; c < 8; c++) {
+    for (let m = 0; m < 100; m++) {
+      const v = near(centers[c], 0.15, r);
+      vecs.set(id, { v, c });
+      batch.push({ id, vector: v });
+      id++;
+    }
+  }
+  db.upsertMany(batch);
+  assert.equal(db.size, 800);
+
+  // Query each center: top-10 should come from that center's members.
+  for (let c = 0; c < 8; c++) {
+    const hits = db.query(centers[c], 10);
+    assert.equal(hits.length, 10);
+    let own = 0;
+    for (const h of hits) if (vecs.get(h.id).c === c) own++;
+    assert.ok(own >= 8, `center ${c}: only ${own}/10 hits from own cluster`);
+  }
+
+  // Self-recall: a stored vector should find its own ext in the top 5.
+  let self = 0;
+  for (let probe = 0; probe < 100; probe += 7) {
+    const hits = db.query(vecs.get(probe).v, 5);
+    if (hits.some((h) => h.id === probe)) self++;
+  }
+  assert.ok(self >= 12, `self-recall ${self}/15 too low`);
+  db.close();
+});
+
+test("3: splits — collections past SPLIT_MAX partition and stay correct", () => {
+  const dim = 32;
+  const db = new VectorDatabase({ dbPath: ":memory:", dim });
+  const r = rng(3);
+  const N = 10_000; // > 2 × SPLIT_MAX (4096) — forces several splits
+  const batch = [];
+  for (let i = 0; i < N; i++) batch.push({ id: i, vector: randVec(dim, r) });
+  db.upsertMany(batch);
+  assert.equal(db.size, N);
+  assert.ok(
+    db.clusterCount >= 3,
+    `expected several clusters after ${N} inserts, got ${db.clusterCount}`,
+  );
+  // Every ext still resolves and queries still return k results.
+  assert.ok(db.has(0) && db.has(N - 1) && db.has(N >> 1));
+  const hits = db.query(randVec(dim, r), 20);
+  assert.equal(hits.length, 20);
+  db.close();
+});
+
+test("4: persistence — close/reopen preserves entries and results", (t) => {
+  const path = `/tmp/ivf-test-${process.pid}.vec`;
+  t.after(() => {
+    for (const s of ["", "-wal", "-shm"]) {
+      try {
+        rmSync(path + s);
+      } catch {}
+    }
+  });
+  const dim = 64;
+  const r = rng(4);
+  const vecs = [];
+  for (let i = 0; i < 500; i++) vecs.push(randVec(dim, r));
+
+  let db = new VectorDatabase({ dbPath: path, dim });
+  db.upsertMany(vecs.map((v, i) => ({ id: i, vector: v })));
+  const probe = vecs[123];
+  const before = db.query(probe, 10);
+  db.close();
+
+  db = new VectorDatabase({ dbPath: path });
+  assert.equal(db.dim, dim);
+  assert.equal(db.size, 500);
+  const after = db.query(probe, 10);
+  assert.deepEqual(after, before);
+  db.close();
+});
+
+test("5: determinism — same insert sequence, identical results", () => {
+  const dim = 64;
+  const r1 = rng(5), r2 = rng(5);
+  const a = new VectorDatabase({ dbPath: ":memory:", dim });
+  const b = new VectorDatabase({ dbPath: ":memory:", dim });
+  const N = 6000; // crosses a split
+  const batchA = [], batchB = [];
+  for (let i = 0; i < N; i++) {
+    batchA.push({ id: i, vector: randVec(dim, r1) });
+    batchB.push({ id: i, vector: randVec(dim, r2) });
+  }
+  a.upsertMany(batchA);
+  b.upsertMany(batchB);
+  assert.equal(a.clusterCount, b.clusterCount);
+  const probe = randVec(dim, r1);
+  assert.deepEqual(a.query(probe, 20), b.query(probe, 20));
+  a.close();
+  b.close();
+});
+
+test("6: compaction — tombstones reclaimed, watermark ids preserved", () => {
+  const dim = 32;
+  const db = new VectorDatabase({ dbPath: ":memory:", dim });
+  const r = rng(6);
+  const N = 2000;
+  db.upsertMany(
+    Array.from({ length: N }, (_, i) => ({ id: i, vector: randVec(dim, r) })),
+  );
+
+  // Watermark before deletion.
+  let maxInternal = 0;
+  for (const { internal } of db.keysSince(0)) {
+    maxInternal = Math.max(maxInternal, internal);
+  }
+
+  // Delete every third entry.
+  const dead = [];
+  for (let i = 0; i < N; i += 3) dead.push(i);
+  assert.equal(db.deleteMany(dead), dead.length);
+  assert.equal(db.size, N - dead.length);
+  assert.ok(db.physicalSize > db.size);
+
+  db.compact();
+  assert.equal(db.physicalSize, db.size);
+  for (const i of dead) assert.ok(!db.has(i));
+  assert.ok(db.has(1) && db.has(2));
+
+  // Internal ids survive compaction: entries added AFTER the old watermark
+  // are exactly the new inserts.
+  db.upsertMany([{ id: 99999, vector: randVec(dim, r) }]);
+  const fresh = [...db.keysSince(maxInternal)];
+  assert.equal(fresh.length, 1);
+  assert.equal(fresh[0].ext, 99999);
+  db.close();
+});
+
+test("7: scaling — per-query storage reads are bounded past the first splits", () => {
+  const dim = 32;
+  // cacheSizeMb 0: no page cache to hide behind; `reads` counts blob rows.
+  const db = new VectorDatabase({ dbPath: ":memory:", dim, cacheSizeMb: 0 });
+  const r = rng(7);
+  const probe = randVec(dim, r);
+  const readsNow = () => {
+    db.query(probe, 10);
+    return db.lastQueryStorageReads;
+  };
+
+  const grow = (n) => {
+    const batch = [];
+    for (let i = 0; i < n; i++) {
+      batch.push({ id: db.size + i, vector: randVec(dim, r) });
+    }
+    db.upsertMany(batch);
+  };
+
+  // Past ~nprobe × SPLIT_MAX entries the probed set is a fixed number of
+  // bounded clusters — reads must plateau.
+  grow(80_000);
+  const small = readsNow();
+  grow(80_000); // 2x the corpus
+  const large = readsNow();
+  console.log(
+    `    ivf reads for one query: N=80k → ${small}, N=160k → ${large}`,
+  );
+  assert.ok(
+    large <= small * 1.5 + 8,
+    `reads grew ${small} → ${large} when the corpus doubled — probes are ` +
+      `not bounded`,
+  );
+  db.close();
+});

package/test/36-bloom.test.mjs

@@ -0,0 +1,123 @@
+// 36-bloom.test.mjs — the negative dedup filter (store-sqlite's Bloom layer).
+//
+// The filter answers "this content hash is definitely not in the node table"
+// in RAM, sparing the training hot path its dominant SQLite probe (profiled:
+// 38.7% of ingest wall at 2.9M nodes).  Its ONE hazard is a false negative,
+// which would mint a duplicate node and silently break hash-consing.  These
+// tests pin the invariant on the three lifecycle paths:
+//
+//   1. live session   — content minted then re-probed dedups (filter sees
+//                       every insert synchronously);
+//   2. clean close    — reopen loads the persisted filter (or rebuilds) and
+//                       dedup still holds;
+//   3. CRASH          — a process that exits without close() leaves no
+//                       persisted filter (or a stale one); reopen must
+//                       rebuild/top-up from the table and STILL dedup all
+//                       previously-minted content, with zero duplicates.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { rmSync } from "node:fs";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+const cleanup = (path) => {
+  for (
+    const s of [
+      ".sqlite",
+      ".sqlite-wal",
+      ".sqlite-shm",
+      ".content.vec",
+      ".content.vec-wal",
+      ".content.vec-shm",
+      ".halo.vec",
+      ".halo.vec-wal",
+      ".halo.vec-shm",
+    ]
+  ) {
+    try {
+      rmSync(path + s);
+    } catch {}
+  }
+};
+
+test("live session: re-probing minted content dedups (no false negatives)", async () => {
+  const s = new SQliteStore({ path: ":memory:", D: 64 });
+  const enc = new TextEncoder();
+  const g = new Float32Array(64).fill(0.1);
+  const ids = [];
+  for (let i = 0; i < 300; i++) {
+    ids.push(await s.putLeaf(enc.encode("bloom-live-" + i), g));
+  }
+  for (let i = 0; i < 300; i++) {
+    assert.equal(await s.putLeaf(enc.encode("bloom-live-" + i), g), ids[i]);
+  }
+  // Novel probes are answered by the filter without SQLite (the point).
+  const skipsBefore = s.bloomSkips;
+  s.findLeaf(enc.encode("definitely-not-present-xyzzy"));
+  assert.ok(s.bloomSkips >= skipsBefore, "bloomSkips must be observable");
+  await s.close();
+});
+
+test("clean close: reopen dedups against the persisted/rebuilt filter", async (t) => {
+  const path = `/tmp/bloom-clean-${process.pid}`;
+  t.after(() => cleanup(path));
+  const enc = new TextEncoder();
+  const g = new Float32Array(64).fill(0.1);
+
+  let s = new SQliteStore({ path, D: 64 });
+  const ids = [];
+  for (let i = 0; i < 300; i++) {
+    ids.push(await s.putLeaf(enc.encode("bloom-clean-" + i), g));
+  }
+  await s.close();
+
+  s = new SQliteStore({ path, D: 64 });
+  const before = s.nodeCount();
+  for (let i = 0; i < 300; i++) {
+    const id = await s.putLeaf(enc.encode("bloom-clean-" + i), g);
+    assert.equal(id, ids[i], `content ${i} re-minted after clean reopen`);
+  }
+  assert.equal(s.nodeCount(), before, "no duplicate mints after clean reopen");
+  await s.close();
+});
+
+test("crash: reopen after an unclean exit still dedups everything", (t) => {
+  const path = `/tmp/bloom-crash-${process.pid}`;
+  t.after(() => cleanup(path));
+
+  // Phase 1 in a SUBPROCESS that exits WITHOUT close() — a real crash as far
+  // as the store is concerned (WAL holds the rows; no filter was persisted).
+  const phase1 = `
+    import("${process.cwd()}/dist/src/store-sqlite.js").then(async ({ SQliteStore }) => {
+      const s = new SQliteStore({ path: "${path}", D: 64 });
+      const enc = new TextEncoder();
+      const g = new Float32Array(64).fill(0.1);
+      for (let i = 0; i < 400; i++) {
+        await s.putLeaf(enc.encode("bloom-crash-" + i), g);
+      }
+      s.commit();
+      process.exit(0); // no close()
+    });`;
+  execFileSync(process.execPath, ["-e", phase1], { stdio: "pipe" });
+
+  // Phase 2 in a second subprocess: every previously-minted content must
+  // resolve to an existing id — zero duplicates.
+  const phase2 = `
+    import("${process.cwd()}/dist/src/store-sqlite.js").then(async ({ SQliteStore }) => {
+      const s = new SQliteStore({ path: "${path}", D: 64 });
+      await s.size();
+      const enc = new TextEncoder();
+      const g = new Float32Array(64).fill(0.1);
+      const before = s.nodeCount();
+      for (let i = 0; i < 400; i++) {
+        const id = await s.putLeaf(enc.encode("bloom-crash-" + i), g);
+        if (id >= before) { console.error("DUP " + i); process.exit(1); }
+      }
+      if (s.nodeCount() !== before) { console.error("GREW"); process.exit(1); }
+      await s.close();
+      process.exit(0);
+    });`;
+  execFileSync(process.execPath, ["-e", phase2], { stdio: "pipe" });
+  assert.ok(true);
+});