@rotorsoft/act-tck 1.5.0 → 1.5.2

package/dist/index.js

@@ -89,7 +89,7 @@ var COUNTER_EVENT_NAMES = [
 import { randomUUID } from "crypto";
 var uid = () => randomUUID().slice(0, 8);
 var actor = (name = "tester") => ({ id: randomUUID(), name });
-var makeMeta = (opts = {}) => ({
+var make_meta = (opts = {}) => ({
   correlation: opts.correlation ?? randomUUID(),
   causation: opts.stream ? {
     action: {
@@ -108,13 +108,13 @@ var dec = (amount = 1) => ({
   data: { amount }
 });
 var reset = () => ({ name: "Reset", data: {} });
-var seedStream = async (store, stream, count, correlation) => {
+var seed_stream = async (store, stream, count, correlation) => {
   const out = [];
   for (let i = 0; i < count; i++) {
     const committed = await store.commit(
       stream,
       [inc(1)],
-      makeMeta({ correlation, stream })
+      make_meta({ correlation, stream })
     );
     out.push(...committed);
   }
@@ -134,14 +134,14 @@ var LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
 var runLoggerTck = (options) => {
   describe2(`TCK / Logger / ${options.name}`, () => {
     let logger;
-    let originalStdout;
+    let original_stdout;
     beforeEach3(() => {
       logger = options.factory();
-      originalStdout = process.stdout.write.bind(process.stdout);
+      original_stdout = process.stdout.write.bind(process.stdout);
       process.stdout.write = (() => true);
     });
     afterEach2(async () => {
-      process.stdout.write = originalStdout;
+      process.stdout.write = original_stdout;
       await logger.dispose();
     });
     it2("exposes a non-empty `level` string", () => {
@@ -168,7 +168,7 @@ var runLoggerTck = (options) => {
       expect2(() => logger.info(cyclic, "cycle")).not.toThrow();
     });
     it2("child(bindings) returns a Logger satisfying the same contract", () => {
-      const child = logger.child({ requestId: "abc" });
+      const child = logger.child({ request_id: "abc" });
       expect2(typeof child.level).toBe("string");
       for (const level of LEVELS) {
         expect2(typeof child[level]).toBe("function");
@@ -188,6 +188,46 @@ var runLoggerTck = (options) => {
   });
 };
 
+// src/stability-tck.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { describe as describe3, expect as expect3, it as it3 } from "vitest";
+function runStabilityTck(options) {
+  describe3(`${options.name} \u2014 public API stability`, () => {
+    for (const [subpath, entry2] of Object.entries(options.entryPoints)) {
+      const label = subpath || "(root)";
+      it3(`stable public surface for ${label}`, async () => {
+        const surface = await load_surface(entry2);
+        expect3(surface).toMatchSnapshot();
+      });
+    }
+  });
+}
+async function load_surface(entry2) {
+  const visited = /* @__PURE__ */ new Map();
+  async function walk(file) {
+    const abs = path.resolve(file);
+    if (visited.has(abs)) return;
+    const content = await fs.readFile(abs, "utf8");
+    visited.set(abs, content);
+    const re_export = /^\s*(?:import|export)\b[^"';]*\bfrom\s+["'](\.[^"']+)["']/gm;
+    for (const m of content.matchAll(re_export)) {
+      const rel = m[1].replace(/\.js$/, ".ts");
+      const target = path.resolve(path.dirname(abs), rel);
+      await walk(target);
+    }
+  }
+  await walk(entry2);
+  const sorted = [...visited.entries()].sort(
+    ([a], [b]) => path.basename(a).localeCompare(path.basename(b))
+  );
+  return sorted.map(([abs, content]) => {
+    const rel = path.basename(abs);
+    return `// === ${rel} ===
+${content}`;
+  }).join("\n");
+}
+
 // src/store-tck.ts
 import {
   act,
@@ -196,9 +236,9 @@ import {
   SNAP_EVENT,
   TOMBSTONE_EVENT
 } from "@rotorsoft/act";
-import { afterAll, beforeAll, describe as describe3, expect as expect3, it as it3 } from "vitest";
+import { afterAll, beforeAll, describe as describe4, expect as expect4, it as it4 } from "vitest";
 var runStoreTck = (options) => {
-  describe3(`TCK / Store / ${options.name}`, () => {
+  describe4(`TCK / Store / ${options.name}`, () => {
     let store;
     const caps = { ...options.capabilities };
     beforeAll(async () => {
@@ -209,103 +249,107 @@ var runStoreTck = (options) => {
     afterAll(async () => {
       await store.dispose();
     });
-    describe3("commit", () => {
-      it3("returns committed events with sequenced ids and versions", async () => {
+    describe4("commit", () => {
+      it4("returns committed events with sequenced ids and versions", async () => {
         const s = `commit-seq-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1), inc(2), dec(3)],
-          makeMeta({ stream: s })
-        );
-        expect3(committed).toHaveLength(3);
-        expect3(committed[0].version).toBe(0);
-        expect3(committed[1].version).toBe(1);
-        expect3(committed[2].version).toBe(2);
-        expect3(committed[0].name).toBe("Incremented");
-        expect3(committed[2].data).toEqual({ amount: 3 });
+          make_meta({ stream: s })
+        );
+        expect4(committed).toHaveLength(3);
+        expect4(committed[0].version).toBe(0);
+        expect4(committed[1].version).toBe(1);
+        expect4(committed[2].version).toBe(2);
+        expect4(committed[0].name).toBe("Incremented");
+        expect4(committed[2].data).toEqual({ amount: 3 });
         for (let i = 1; i < committed.length; i++) {
-          expect3(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          expect4(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
-      it3("attaches correlation and stream metadata", async () => {
+      it4("attaches correlation and stream metadata", async () => {
         const s = `commit-meta-${uid()}`;
         const correlation = `cor-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1)],
-          makeMeta({ stream: s, correlation })
+          make_meta({ stream: s, correlation })
         );
-        expect3(committed[0].stream).toBe(s);
-        expect3(committed[0].meta.correlation).toBe(correlation);
+        expect4(committed[0].stream).toBe(s);
+        expect4(committed[0].meta.correlation).toBe(correlation);
       });
-      it3("throws ConcurrencyError when expectedVersion is wrong", async () => {
+      it4("throws ConcurrencyError when expectedVersion is wrong", async () => {
         const s = `commit-cc-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
         await store.commit(
           s,
           [inc(1)],
-          makeMeta({ stream: s }),
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s }),
           0
         );
-        await expect3(
-          store.commit(s, [inc(1)], makeMeta({ stream: s }), 0)
+        await expect4(
+          store.commit(s, [inc(1)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(ConcurrencyError);
       });
-      it3("preserves prior events when a concurrent commit is rejected", async () => {
+      it4("preserves prior events when a concurrent commit is rejected", async () => {
         const s = `commit-cc-preserve-${uid()}`;
         await store.commit(
           s,
           [inc(1), inc(2)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
-        await expect3(
-          store.commit(s, [inc(3)], makeMeta({ stream: s }), 0)
+        await expect4(
+          store.commit(s, [inc(3)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(ConcurrencyError);
         const found = await collect(store, { stream: s, stream_exact: true });
-        expect3(found).toHaveLength(2);
+        expect4(found).toHaveLength(2);
       });
     });
-    describe3("query", () => {
-      it3("filters by stream, names, correlation, limit, with_snaps", async () => {
+    describe4("query", () => {
+      it4("filters by stream, names, correlation, limit, with_snaps", async () => {
         const s1 = `q-s1-${uid()}`;
         const s2 = `q-s2-${uid()}`;
         const cor = `q-cor-${uid()}`;
         await store.commit(
           s1,
           [inc(1), dec(1)],
-          makeMeta({ stream: s1, correlation: cor })
+          make_meta({ stream: s1, correlation: cor })
         );
         await store.commit(
           s2,
           [inc(2), dec(2), reset()],
-          makeMeta({ stream: s2, correlation: cor })
+          make_meta({ stream: s2, correlation: cor })
         );
-        const byStream = await collect(store, {
+        const by_stream = await collect(store, {
           stream: s1,
           stream_exact: true
         });
-        expect3(byStream).toHaveLength(2);
-        const byName = await collect(store, {
+        expect4(by_stream).toHaveLength(2);
+        const by_name = await collect(store, {
           stream: s2,
           stream_exact: true,
           names: ["Reset"]
         });
-        expect3(byName).toHaveLength(1);
-        expect3(byName[0].name).toBe("Reset");
-        const byCorrelation = await collect(store, { correlation: cor });
-        expect3(byCorrelation).toHaveLength(5);
+        expect4(by_name).toHaveLength(1);
+        expect4(by_name[0].name).toBe("Reset");
+        const by_correlation = await collect(store, { correlation: cor });
+        expect4(by_correlation).toHaveLength(5);
         const limited = await collect(store, {
           correlation: cor,
           limit: 2
         });
-        expect3(limited).toHaveLength(2);
+        expect4(limited).toHaveLength(2);
       });
-      it3("supports backward traversal", async () => {
+      it4("supports backward traversal", async () => {
         const s = `q-back-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1), inc(2), inc(3)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const forward = await collect(store, { stream: s, stream_exact: true });
         const backward = await collect(store, {
@@ -313,8 +357,8 @@ var runStoreTck = (options) => {
           stream_exact: true,
           backward: true
         });
-        expect3(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
-        expect3(backward.map((e) => e.id)).toEqual(
+        expect4(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        expect4(backward.map((e) => e.id)).toEqual(
           [...committed].reverse().map((c) => c.id)
         );
         const latest = await collect(store, {
@@ -323,58 +367,62 @@ var runStoreTck = (options) => {
           backward: true,
           limit: 1
         });
-        expect3(latest).toHaveLength(1);
-        expect3(latest[0].id).toBe(committed.at(-1).id);
+        expect4(latest).toHaveLength(1);
+        expect4(latest[0].id).toBe(committed.at(-1).id);
       });
-      it3("after/before bound the id range", async () => {
+      it4("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1), inc(2), inc(3), inc(4)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
-        const afterFirst = await collect(store, {
+        const after_first = await collect(store, {
           stream: s,
           stream_exact: true,
           after: committed[0].id
         });
-        expect3(afterFirst.map((e) => e.id)).toEqual(
+        expect4(after_first.map((e) => e.id)).toEqual(
           committed.slice(1).map((c) => c.id)
         );
-        const beforeLast = await collect(store, {
+        const before_last = await collect(store, {
           stream: s,
           stream_exact: true,
           before: committed[committed.length - 1].id
         });
-        expect3(beforeLast.map((e) => e.id)).toEqual(
+        expect4(before_last.map((e) => e.id)).toEqual(
           committed.slice(0, -1).map((c) => c.id)
         );
       });
-      it3("created_after/created_before filter by timestamp", async () => {
+      it4("created_after/created_before filter by timestamp", async () => {
         const s = `q-ts-${uid()}`;
         const before = new Date(Date.now() - 6e4);
         const future = new Date(Date.now() + 6e4);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        const inWindow = await collect(store, {
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        const in_window = await collect(store, {
           stream: s,
           stream_exact: true,
           created_after: before,
           created_before: future
         });
-        expect3(inWindow.length).toBe(1);
-        const outOfWindow = await collect(store, {
+        expect4(in_window.length).toBe(1);
+        const out_of_window = await collect(store, {
           stream: s,
           stream_exact: true,
           created_after: future
         });
-        expect3(outOfWindow.length).toBe(0);
+        expect4(out_of_window.length).toBe(0);
       });
-      it3("backward traversal short-circuits at `after` id boundary", async () => {
+      it4("backward traversal short-circuits at `after` id boundary", async () => {
         const s = `q-back-after-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1), inc(2), inc(3)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const got = await collect(store, {
           stream: s,
@@ -382,14 +430,18 @@ var runStoreTck = (options) => {
           backward: true,
           after: committed[0].id
         });
-        expect3(got.map((e) => e.id)).toEqual([
+        expect4(got.map((e) => e.id)).toEqual([
           committed[2].id,
           committed[1].id
         ]);
       });
-      it3("backward traversal short-circuits at `created_after` boundary", async () => {
+      it4("backward traversal short-circuits at `created_after` boundary", async () => {
         const s = `q-back-cafter-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const future = new Date(Date.now() + 6e4);
         const got = await collect(store, {
           stream: s,
@@ -397,11 +449,11 @@ var runStoreTck = (options) => {
           backward: true,
           created_after: future
         });
-        expect3(got).toHaveLength(0);
+        expect4(got).toHaveLength(0);
       });
-      it3("backward traversal honors created_before by skipping newer events", async () => {
+      it4("backward traversal honors created_before by skipping newer events", async () => {
         const s = `q-back-ts-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta());
+        await store.commit(s, [inc(1)], make_meta());
         const past = new Date(Date.now() - 6e4);
         const got = await collect(store, {
           stream: s,
@@ -409,302 +461,362 @@ var runStoreTck = (options) => {
           backward: true,
           created_before: past
         });
-        expect3(got).toHaveLength(0);
+        expect4(got).toHaveLength(0);
       });
-      it3("stream_exact disables regex matching", async () => {
+      it4("stream_exact disables regex matching", async () => {
         const tag = uid();
         const a = `q-exact-${tag}`;
         const b = `q-exact-${tag}-extra`;
-        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
-        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        await store.commit(
+          a,
+          [inc(1)],
+          make_meta({ stream: a })
+        );
+        await store.commit(
+          b,
+          [inc(2)],
+          make_meta({ stream: b })
+        );
         const exact = await collect(store, { stream: a, stream_exact: true });
-        expect3(exact).toHaveLength(1);
-        expect3(exact[0].data).toEqual({ amount: 1 });
+        expect4(exact).toHaveLength(1);
+        expect4(exact[0].data).toEqual({ amount: 1 });
       });
-      it3("plain regex without anchors is a substring match", async () => {
+      it4("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qr-${tag}-inner`;
         const longer = `qr-${tag}-inner-extra`;
         await store.commit(
           inner,
           [inc(1)],
-          makeMeta({ stream: inner })
+          make_meta({ stream: inner })
         );
         await store.commit(
           longer,
           [inc(2)],
-          makeMeta({ stream: longer })
+          make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `qr-${tag}-inner` });
-        expect3(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
+        expect4(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
       });
-      it3("caller-anchored `^name$` matches only the whole string", async () => {
+      it4("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qr-${tag}-anchor`;
         const longer = `qr-${tag}-anchor-extra`;
         await store.commit(
           inner,
           [inc(1)],
-          makeMeta({ stream: inner })
+          make_meta({ stream: inner })
         );
         await store.commit(
           longer,
           [inc(2)],
-          makeMeta({ stream: longer })
+          make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `^qr-${tag}-anchor$` });
-        expect3(got).toHaveLength(1);
-        expect3(got[0].stream).toBe(inner);
+        expect4(got).toHaveLength(1);
+        expect4(got[0].stream).toBe(inner);
       });
-      it3("caller-anchored `^prefix` matches by prefix", async () => {
+      it4("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qr-${tag}-pfx-a`;
         const b = `qr-${tag}-pfx-b`;
         const other = `zz-${tag}-other`;
-        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
-        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        await store.commit(
+          a,
+          [inc(1)],
+          make_meta({ stream: a })
+        );
+        await store.commit(
+          b,
+          [inc(2)],
+          make_meta({ stream: b })
+        );
         await store.commit(
           other,
           [inc(3)],
-          makeMeta({ stream: other })
+          make_meta({ stream: other })
         );
         const got = await collect(store, { stream: `^qr-${tag}-pfx-` });
-        expect3(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
+        expect4(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
       });
     });
-    describe3("subscribe + claim + ack", () => {
-      it3("subscribes new streams and is idempotent on repeat", async () => {
+    describe4("subscribe + claim + ack", () => {
+      it4("subscribes new streams and is idempotent on repeat", async () => {
         const s = `sub-${uid()}`;
         const first = await store.subscribe([{ stream: s }]);
-        expect3(first.subscribed).toBe(1);
+        expect4(first.subscribed).toBe(1);
         const second = await store.subscribe([{ stream: s }]);
-        expect3(second.subscribed).toBe(0);
+        expect4(second.subscribed).toBe(0);
       });
-      it3("claims a subscribed stream and ack releases the lease", async () => {
+      it4("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const by = `worker-${uid()}`;
         const leased = await store.claim(100, 0, by, 1e4);
         const mine = leased.find((l) => l.stream === s);
-        expect3(mine).toBeDefined();
-        expect3(mine.by).toBe(by);
+        expect4(mine).toBeDefined();
+        expect4(mine.by).toBe(by);
         await store.ack([{ ...mine, at: mine.at + 1 }]);
       });
-      it3("does not double-claim a held lease", async () => {
+      it4("does not double-claim a held lease", async () => {
         const s = `claim-held-${uid()}`;
         const other = `claim-other-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1e5);
         const targetA = leasedA.find((l) => l.stream === s);
-        expect3(targetA).toBeDefined();
+        expect4(targetA).toBeDefined();
         await store.subscribe([{ stream: other }]);
         await store.commit(
           other,
           [inc(2)],
-          makeMeta({ stream: other })
+          make_meta({ stream: other })
         );
         const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
-        expect3(leasedB.length).toBeGreaterThan(0);
-        expect3(leasedB.find((l) => l.stream === s)).toBeUndefined();
-        expect3(leasedB.find((l) => l.stream === other)).toBeDefined();
+        expect4(leasedB.length).toBeGreaterThan(0);
+        expect4(leasedB.find((l) => l.stream === s)).toBeUndefined();
+        expect4(leasedB.find((l) => l.stream === other)).toBeDefined();
       });
-      it3("supports dual frontiers (lagging + leading)", async () => {
+      it4("supports dual frontiers (lagging + leading)", async () => {
         const s = `claim-dual-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
           s,
           [inc(1), inc(2)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const first = await store.claim(100, 0, `w-${uid()}`, 1);
         const mine = first.find((l) => l.stream === s);
-        expect3(mine).toBeDefined();
+        expect4(mine).toBeDefined();
         await store.ack([{ ...mine, at: mine.at + 1 }]);
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
-        expect3(second.find((l) => l.stream === s)).toBeDefined();
+        expect4(second.find((l) => l.stream === s)).toBeDefined();
       });
-      it3("dedupes when both frontiers would return the same stream", async () => {
+      it4("dedupes when both frontiers would return the same stream", async () => {
         const s = `claim-dedup-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const claimed = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const matches = claimed.filter((l) => l.stream === s);
-        expect3(matches).toHaveLength(1);
+        expect4(matches).toHaveLength(1);
       });
-      it3("silently ignores ack from the wrong holder", async () => {
+      it4("silently ignores ack from the wrong holder", async () => {
         const s = `ack-wrong-${uid()}`;
         const sibling = `ack-sibling-${uid()}`;
         await store.subscribe([{ stream: s }, { stream: sibling }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         await store.commit(
           sibling,
           [inc(2)],
-          makeMeta({ stream: sibling })
+          make_meta({ stream: sibling })
         );
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        const siblingLease = leased.find((l) => l.stream === sibling);
-        expect3(mine).toBeDefined();
-        expect3(siblingLease).toBeDefined();
+        const sibling_lease = leased.find((l) => l.stream === sibling);
+        expect4(mine).toBeDefined();
+        expect4(sibling_lease).toBeDefined();
         const acked = await store.ack([
           { ...mine, by: "imposter" },
-          siblingLease
+          sibling_lease
         ]);
-        expect3(acked.length).toBeGreaterThan(0);
-        expect3(acked.find((l) => l.stream === s)).toBeUndefined();
+        expect4(acked.length).toBeGreaterThan(0);
+        expect4(acked.find((l) => l.stream === s)).toBeUndefined();
       });
-      it3("ack with a stale (lower) watermark does not throw", async () => {
+      it4("ack with a stale (lower) watermark does not throw", async () => {
         const s = `ack-stale-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const by = `w-${uid()}`;
         const leased = await store.claim(100, 0, by, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect3(mine).toBeDefined();
-        await expect3(
+        expect4(mine).toBeDefined();
+        await expect4(
           store.ack([{ ...mine, at: -5 }])
         ).resolves.toBeDefined();
       });
-      it3("claim with no subscribed streams returns an empty array", async () => {
+      it4("claim with no subscribed streams returns an empty array", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
           await fresh.seed();
           const claimed = await fresh.claim(1, 1, `w-${uid()}`, 1e3);
-          expect3(claimed).toEqual([]);
+          expect4(claimed).toEqual([]);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    describe3("block", () => {
-      it3("hides blocked streams from claim", async () => {
+    describe4("block", () => {
+      it4("hides blocked streams from claim", async () => {
         const s = `block-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect3(mine).toBeDefined();
+        expect4(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         const blocked = await store.block([
           { ...mine, error: "boom" }
         ]);
-        expect3(blocked).toHaveLength(1);
-        expect3(blocked[0].error).toBe("boom");
+        expect4(blocked).toHaveLength(1);
+        expect4(blocked[0].error).toBe("boom");
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
-        expect3(again.find((l) => l.stream === s)).toBeUndefined();
+        expect4(again.find((l) => l.stream === s)).toBeUndefined();
       });
-      it3("rejects block calls from a different holder", async () => {
+      it4("rejects block calls from a different holder", async () => {
         const s = `block-wrong-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect3(mine).toBeDefined();
+        expect4(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         const blocked = await store.block([
           { ...mine, by: "imposter", error: "no" }
         ]);
-        expect3(blocked).toHaveLength(0);
+        expect4(blocked).toHaveLength(0);
       });
     });
-    describe3("reset", () => {
-      it3("rewinds a stream watermark to -1", async () => {
+    describe4("reset", () => {
+      it4("rewinds a stream watermark to -1", async () => {
         const s = `reset-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect3(mine).toBeDefined();
+        expect4(mine).toBeDefined();
         await store.ack([{ ...mine, at: 99 }]);
-        expect3(await store.reset([s])).toBe(1);
+        expect4(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
-        expect3(back).toBeDefined();
-        expect3(back.at).toBe(-1);
+        expect4(back).toBeDefined();
+        expect4(back.at).toBe(-1);
       });
-      it3("clears blocked status when resetting", async () => {
+      it4("clears blocked status when resetting", async () => {
         const s = `reset-blk-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
-        expect3(await store.reset([s])).toBe(1);
+        expect4(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
-        expect3(after.find((l) => l.stream === s)).toBeDefined();
+        expect4(after.find((l) => l.stream === s)).toBeDefined();
       });
-      it3("returns 0 for unknown streams and empty input", async () => {
-        expect3(await store.reset([`missing-${uid()}`])).toBe(0);
-        expect3(await store.reset([])).toBe(0);
+      it4("returns 0 for unknown streams and empty input", async () => {
+        expect4(await store.reset([`missing-${uid()}`])).toBe(0);
+        expect4(await store.reset([])).toBe(0);
       });
     });
-    describe3("unblock", () => {
-      it3("clears blocked flag and preserves the watermark", async () => {
+    describe4("unblock", () => {
+      it4("clears blocked flag and preserves the watermark", async () => {
         const s = `unblock-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        await store.commit(s, [inc(2)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(2)],
+          make_meta({ stream: s })
+        );
         const first = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = first.find((l) => l.stream === s);
         await store.ack([{ ...m1, at: m1.at }]);
-        const beforeBlock = await store.claim(100, 0, `w-${uid()}`, 1e5);
-        const m2 = beforeBlock.find((l) => l.stream === s);
-        expect3(m2).toBeDefined();
-        const watermarkBefore = m2.at;
+        const before_block = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const m2 = before_block.find((l) => l.stream === s);
+        expect4(m2).toBeDefined();
+        const watermark_before = m2.at;
         await store.block([{ ...m2, error: "permanent" }]);
-        let blockedFlag;
+        let blocked_flag;
         await store.query_streams(
           (p) => {
-            blockedFlag = p.blocked;
+            blocked_flag = p.blocked;
           },
           { stream: s, stream_exact: true, limit: 1 }
         );
-        expect3(blockedFlag).toBe(true);
-        expect3(await store.unblock([s])).toBe(1);
+        expect4(blocked_flag).toBe(true);
+        expect4(await store.unblock([s])).toBe(1);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
-        expect3(back).toBeDefined();
-        expect3(back.at).toBe(watermarkBefore);
-        expect3(back.retry).toBe(0);
+        expect4(back).toBeDefined();
+        expect4(back.at).toBe(watermark_before);
+        expect4(back.retry).toBe(0);
       });
-      it3("returns 0 when the stream is not blocked", async () => {
+      it4("returns 0 when the stream is not blocked", async () => {
         const s = `unblock-noop-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        expect3(await store.unblock([s])).toBe(0);
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        expect4(await store.unblock([s])).toBe(0);
       });
-      it3("returns 0 for unknown streams and empty input", async () => {
-        expect3(await store.unblock([`missing-${uid()}`])).toBe(0);
-        expect3(await store.unblock([])).toBe(0);
+      it4("returns 0 for unknown streams and empty input", async () => {
+        expect4(await store.unblock([`missing-${uid()}`])).toBe(0);
+        expect4(await store.unblock([])).toBe(0);
       });
-      it3("only counts streams that were actually blocked", async () => {
+      it4("only counts streams that were actually blocked", async () => {
         const s1 = `unblock-mix-a-${uid()}`;
         const s2 = `unblock-mix-b-${uid()}`;
         await store.subscribe([{ stream: s1 }, { stream: s2 }]);
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = leased.find((l) => l.stream === s1);
         const others = leased.filter((l) => l.stream !== s1);
         await store.ack(others);
         await store.block([{ ...m1, error: "boom" }]);
-        expect3(await store.unblock([s1, s2])).toBe(1);
+        expect4(await store.unblock([s1, s2])).toBe(1);
       });
-      it3("filter form: unblocks by stream pattern", async () => {
+      it4("filter form: unblocks by stream pattern", async () => {
         const tag = uid();
         const s1 = `unblock-filter-${tag}-a`;
         const s2 = `unblock-filter-${tag}-b`;
@@ -713,17 +825,17 @@ var runStoreTck = (options) => {
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         await store.commit(
           s3,
           [inc(1)],
-          makeMeta({ stream: s3 })
+          make_meta({ stream: s3 })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const blockable = leased.filter((l) => l.stream === s1 || l.stream === s2 || l.stream === s3).map((l) => ({ ...l, error: "boom" }));
@@ -736,13 +848,13 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-filter-${tag}-`
         });
-        expect3(count).toBe(2);
+        expect4(count).toBe(2);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
-        expect3(after.find((l) => l.stream === s3)).toBeUndefined();
-        expect3(after.find((l) => l.stream === s1)).toBeDefined();
-        expect3(after.find((l) => l.stream === s2)).toBeDefined();
+        expect4(after.find((l) => l.stream === s3)).toBeUndefined();
+        expect4(after.find((l) => l.stream === s1)).toBeDefined();
+        expect4(after.find((l) => l.stream === s2)).toBeDefined();
       });
-      it3("filter form: empty filter unblocks every blocked stream", async () => {
+      it4("filter form: empty filter unblocks every blocked stream", async () => {
         const tag = uid();
         const s1 = `unblock-empty-${tag}-a`;
         const s2 = `unblock-empty-${tag}-b`;
@@ -750,12 +862,12 @@ var runStoreTck = (options) => {
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.filter((l) => l.stream === s1 || l.stream === s2);
@@ -766,14 +878,18 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-empty-${tag}-`
         });
-        expect3(count).toBe(2);
+        expect4(count).toBe(2);
       });
-      it3("filter form: explicit blocked:false matches nothing", async () => {
+      it4("filter form: explicit blocked:false matches nothing", async () => {
         const tag = uid();
         const s = `unblock-blocked-false-${tag}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        expect3(
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        expect4(
           await store.unblock({
             stream: `^unblock-blocked-false-${tag}`,
             blocked: false
@@ -781,8 +897,8 @@ var runStoreTck = (options) => {
         ).toBe(0);
       });
     });
-    describe3("reset filter form", () => {
-      it3("resets streams matching a stream pattern", async () => {
+    describe4("reset filter form", () => {
+      it4("resets streams matching a stream pattern", async () => {
         const tag = uid();
         const s1 = `reset-filter-${tag}-a`;
         const s2 = `reset-filter-${tag}-b`;
@@ -795,17 +911,17 @@ var runStoreTck = (options) => {
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         await store.commit(
           other,
           [inc(1)],
-          makeMeta({ stream: other })
+          make_meta({ stream: other })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.filter(
@@ -813,8 +929,8 @@ var runStoreTck = (options) => {
         );
         await store.ack(mine.map((l) => ({ ...l, at: l.at + 100 })));
         const count = await store.reset({ stream: `^reset-filter-${tag}-` });
-        expect3(count).toBe(2);
-        const positionFor = async (name) => {
+        expect4(count).toBe(2);
+        const position_for = async (name) => {
           let at = null;
           await store.query_streams(
             (p) => {
@@ -824,11 +940,11 @@ var runStoreTck = (options) => {
           );
           return at;
         };
-        expect3(await positionFor(s1)).toBe(-1);
-        expect3(await positionFor(s2)).toBe(-1);
-        expect3(await positionFor(other)).toBeGreaterThan(-1);
+        expect4(await position_for(s1)).toBe(-1);
+        expect4(await position_for(s2)).toBe(-1);
+        expect4(await position_for(other)).toBeGreaterThan(-1);
       });
-      it3("filter form: resets only blocked streams when blocked:true", async () => {
+      it4("filter form: resets only blocked streams when blocked:true", async () => {
         const tag = uid();
         const s1 = `reset-blocked-${tag}-blocked`;
         const s2 = `reset-blocked-${tag}-fine`;
@@ -836,12 +952,12 @@ var runStoreTck = (options) => {
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = leased.find((l) => l.stream === s1);
@@ -851,11 +967,11 @@ var runStoreTck = (options) => {
           stream: `^reset-blocked-${tag}-`,
           blocked: true
         });
-        expect3(count).toBe(1);
+        expect4(count).toBe(1);
       });
     });
-    describe3("prioritize", () => {
-      it3("sets priority directly, overriding subscribe's max() rule", async () => {
+    describe4("prioritize", () => {
+      it4("sets priority directly, overriding subscribe's max() rule", async () => {
         const tag = uid();
         const s1 = `pri-${tag}-a`;
         const s2 = `pri-${tag}-b`;
@@ -867,7 +983,7 @@ var runStoreTck = (options) => {
           { stream: s1, stream_exact: true },
           3
         );
-        expect3(updated).toBe(1);
+        expect4(updated).toBe(1);
         const got1 = {};
         const got2 = {};
         await store.query_streams(
@@ -877,12 +993,12 @@ var runStoreTck = (options) => {
           },
           { stream: `pri-${tag}-.*`, limit: 100 }
         );
-        expect3(got1.priority).toBe(3);
-        expect3(got2.priority).toBe(5);
+        expect4(got1.priority).toBe(3);
+        expect4(got2.priority).toBe(5);
       });
     });
-    describe3("lanes", () => {
-      it3("subscribe defaults lane to 'default' when omitted", async () => {
+    describe4("lanes", () => {
+      it4("subscribe defaults lane to 'default' when omitted", async () => {
         const s = `lane-default-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const seen = [];
@@ -890,9 +1006,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect3(seen).toEqual(["default"]);
+        expect4(seen).toEqual(["default"]);
       });
-      it3("subscribe records the lane passed in", async () => {
+      it4("subscribe records the lane passed in", async () => {
         const s = `lane-set-${uid()}`;
         await store.subscribe([{ stream: s, lane: "slow" }]);
         const seen = [];
@@ -900,9 +1016,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect3(seen).toEqual(["slow"]);
+        expect4(seen).toEqual(["slow"]);
       });
-      it3("subscribe re-lanes existing streams on subsequent calls", async () => {
+      it4("subscribe re-lanes existing streams on subsequent calls", async () => {
         const s = `lane-upsert-${uid()}`;
         await store.subscribe([{ stream: s, lane: "slow" }]);
         await store.subscribe([{ stream: s, lane: "fast" }]);
@@ -911,45 +1027,45 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect3(seen).toEqual(["fast"]);
+        expect4(seen).toEqual(["fast"]);
       });
-      it3("claim() filters by lane when supplied and returns lane on the Lease", async () => {
+      it4("claim() filters by lane when supplied and returns lane on the Lease", async () => {
         const tag = uid();
         const src1 = `lane-claim-src1-${tag}`;
         const src2 = `lane-claim-src2-${tag}`;
-        const subDefault = `lane-claim-def-${tag}`;
-        const subSlow = `lane-claim-slow-${tag}`;
+        const sub_default = `lane-claim-def-${tag}`;
+        const sub_slow = `lane-claim-slow-${tag}`;
         await store.commit(
           src1,
           [inc(1)],
-          makeMeta({ stream: src1 })
+          make_meta({ stream: src1 })
         );
         await store.commit(
           src2,
           [inc(1)],
-          makeMeta({ stream: src2 })
+          make_meta({ stream: src2 })
         );
         await store.subscribe([
-          { stream: subDefault, source: src1 },
-          { stream: subSlow, source: src2, lane: "slow" }
+          { stream: sub_default, source: src1 },
+          { stream: sub_slow, source: src2, lane: "slow" }
         ]);
         const slow = await store.claim(50, 0, `w-slow-${tag}`, 1e3, "slow");
-        const slowMine = slow.filter(
-          (l) => l.stream === subDefault || l.stream === subSlow
+        const slow_mine = slow.filter(
+          (l) => l.stream === sub_default || l.stream === sub_slow
         );
-        expect3(slowMine.map((l) => l.stream)).toEqual([subSlow]);
-        expect3(slowMine[0]?.lane).toBe("slow");
-        await store.ack(slowMine.map((l) => ({ ...l, at: l.at + 1 })));
+        expect4(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
+        expect4(slow_mine[0]?.lane).toBe("slow");
+        await store.ack(slow_mine.map((l) => ({ ...l, at: l.at + 1 })));
         const all = await store.claim(50, 0, `w-all-${tag}`, 1e3);
-        const allMine = all.filter((l) => l.stream === subDefault || l.stream === subSlow).map((l) => ({ stream: l.stream, lane: l.lane }));
-        expect3(allMine).toEqual(
-          expect3.arrayContaining([
-            { stream: subDefault, lane: "default" },
-            { stream: subSlow, lane: "slow" }
+        const all_mine = all.filter((l) => l.stream === sub_default || l.stream === sub_slow).map((l) => ({ stream: l.stream, lane: l.lane }));
+        expect4(all_mine).toEqual(
+          expect4.arrayContaining([
+            { stream: sub_default, lane: "default" },
+            { stream: sub_slow, lane: "slow" }
           ])
         );
       });
-      it3("query_streams filters by lane", async () => {
+      it4("query_streams filters by lane", async () => {
         const tag = uid();
         const a = `lane-q-a-${tag}`;
         const b = `lane-q-b-${tag}`;
@@ -965,9 +1081,9 @@ var runStoreTck = (options) => {
           stream: `lane-q-.*-${tag}`,
           limit: 100
         });
-        expect3(seen.sort()).toEqual([a, c]);
+        expect4(seen.sort()).toEqual([a, c]);
       });
-      it3("prioritize filters by lane", async () => {
+      it4("prioritize filters by lane", async () => {
         const tag = uid();
         const a = `lane-pri-a-${tag}`;
         const b = `lane-pri-b-${tag}`;
@@ -976,16 +1092,16 @@ var runStoreTck = (options) => {
           { stream: b, lane: `pfast-${tag}` }
         ]);
         const updated = await store.prioritize({ lane: `pslow-${tag}` }, 7);
-        expect3(updated).toBe(1);
+        expect4(updated).toBe(1);
         const seen = /* @__PURE__ */ new Map();
         await store.query_streams((p) => seen.set(p.stream, p.priority), {
           stream: `lane-pri-.*-${tag}`,
           limit: 100
         });
-        expect3(seen.get(a)).toBe(7);
-        expect3(seen.get(b)).toBe(0);
+        expect4(seen.get(a)).toBe(7);
+        expect4(seen.get(b)).toBe(0);
       });
-      it3("reset filters by lane", async () => {
+      it4("reset filters by lane", async () => {
         const tag = uid();
         const src = `lane-reset-src-${tag}`;
         const a = `lane-reset-a-${tag}`;
@@ -993,7 +1109,7 @@ var runStoreTck = (options) => {
         await store.commit(
           src,
           [inc(1)],
-          makeMeta({ stream: src })
+          make_meta({ stream: src })
         );
         await store.subscribe([
           { stream: a, source: src, lane: `rslow-${tag}` },
@@ -1003,7 +1119,7 @@ var runStoreTck = (options) => {
         const mine = leases.filter((l) => l.stream === a || l.stream === b);
         await store.ack(mine.map((l) => ({ ...l, at: l.at + 1 })));
         const count = await store.reset({ lane: `rslow-${tag}` });
-        expect3(count).toBe(1);
+        expect4(count).toBe(1);
         const ats = /* @__PURE__ */ new Map();
         for (const name of [a, b]) {
           await store.query_streams((p) => ats.set(p.stream, p.at), {
@@ -1011,10 +1127,10 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        expect3(ats.get(a)).toBe(-1);
-        expect3(ats.get(b)).toBeGreaterThanOrEqual(0);
+        expect4(ats.get(a)).toBe(-1);
+        expect4(ats.get(b)).toBeGreaterThanOrEqual(0);
       });
-      it3("unblock filters by lane", async () => {
+      it4("unblock filters by lane", async () => {
         const tag = uid();
         const src = `lane-ub-src-${tag}`;
         const a = `lane-ub-a-${tag}`;
@@ -1022,7 +1138,7 @@ var runStoreTck = (options) => {
         await store.commit(
           src,
           [inc(1)],
-          makeMeta({ stream: src })
+          make_meta({ stream: src })
         );
         await store.subscribe([
           { stream: a, source: src, lane: `uslow-${tag}` },
@@ -1032,7 +1148,7 @@ var runStoreTck = (options) => {
         const mine = leases.filter((l) => l.stream === a || l.stream === b);
         await store.block(mine.map((l) => ({ ...l, error: "boom" })));
         const count = await store.unblock({ lane: `uslow-${tag}` });
-        expect3(count).toBe(1);
+        expect4(count).toBe(1);
         const blocked = /* @__PURE__ */ new Map();
         for (const name of [a, b]) {
           await store.query_streams((p) => blocked.set(p.stream, p.blocked), {
@@ -1040,20 +1156,20 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        expect3(blocked.get(a)).toBe(false);
-        expect3(blocked.get(b)).toBe(true);
+        expect4(blocked.get(a)).toBe(false);
+        expect4(blocked.get(b)).toBe(true);
       });
     });
-    describe3("truncate", () => {
-      it3("seeds a tombstone when no snapshot is provided", async () => {
+    describe4("truncate", () => {
+      it4("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
         await store.commit(
           s,
           [inc(1), inc(2)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const result = await store.truncate([{ stream: s }]);
-        expect3(result.get(s)?.deleted).toBe(2);
+        expect4(result.get(s)?.deleted).toBe(2);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1061,18 +1177,22 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect3(remaining).toHaveLength(1);
-        expect3(remaining[0].name).toBe(
+        expect4(remaining).toHaveLength(1);
+        expect4(remaining[0].name).toBe(
           "__tombstone__"
         );
       });
-      it3("seeds a snapshot when one is provided", async () => {
+      it4("seeds a snapshot when one is provided", async () => {
         const s = `trunc-snap-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const result = await store.truncate([
           { stream: s, snapshot: { count: 7 } }
         ]);
-        expect3(result.get(s)?.deleted).toBe(1);
+        expect4(result.get(s)?.deleted).toBe(1);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1080,24 +1200,24 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, with_snaps: true }
         );
-        expect3(remaining).toHaveLength(1);
-        expect3(remaining[0].name).toBe(
+        expect4(remaining).toHaveLength(1);
+        expect4(remaining[0].name).toBe(
           "__snapshot__"
         );
-        expect3(remaining[0].data).toEqual({ count: 7 });
+        expect4(remaining[0].data).toEqual({ count: 7 });
       });
-      it3("returns an empty map for empty input", async () => {
+      it4("returns an empty map for empty input", async () => {
         const result = await store.truncate([]);
-        expect3(result.size).toBe(0);
+        expect4(result.size).toBe(0);
       });
-      it3("returns 0 deleted for streams that don't exist", async () => {
+      it4("returns 0 deleted for streams that don't exist", async () => {
         const s = `trunc-missing-${uid()}`;
         const result = await store.truncate([{ stream: s }]);
-        expect3(result.get(s)?.deleted).toBe(0);
+        expect4(result.get(s)?.deleted).toBe(0);
       });
     });
-    describe3("query_streams", () => {
-      it3("returns positions filtered by stream regex, exact, source, and source_exact", async () => {
+    describe4("query_streams", () => {
+      it4("returns positions filtered by stream regex, exact, source, and source_exact", async () => {
         const tag = uid();
         const proj1 = `qs-${tag}-projection-tickets`;
         const proj2 = `qs-${tag}-projection-users`;
@@ -1112,41 +1232,41 @@ var runStoreTck = (options) => {
           { stream: dyn2, source: src2 }
         ]);
         const all = [];
-        const allResult = await store.query_streams(
+        const all_result = await store.query_streams(
           (p) => all.push({ stream: p.stream, source: p.source }),
           { stream: `qs-${tag}-.*` }
         );
-        expect3(allResult.count).toBe(4);
-        expect3(allResult.maxEventId).toBeGreaterThanOrEqual(-1);
-        expect3(all.map((p) => p.stream).sort()).toEqual(
+        expect4(all_result.count).toBe(4);
+        expect4(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
+        expect4(all.map((p) => p.stream).sort()).toEqual(
           [proj1, proj2, dyn1, dyn2].sort()
         );
         const projections = [];
         await store.query_streams((p) => projections.push(p.stream), {
           stream: `qs-${tag}-projection-.*`
         });
-        expect3(projections.sort()).toEqual([proj1, proj2].sort());
+        expect4(projections.sort()).toEqual([proj1, proj2].sort());
         const exact = [];
         await store.query_streams((p) => exact.push(p.stream), {
           stream: dyn1,
           stream_exact: true
         });
-        expect3(exact).toEqual([dyn1]);
-        const bySource = [];
-        await store.query_streams((p) => bySource.push(p.stream), {
+        expect4(exact).toEqual([dyn1]);
+        const by_source = [];
+        await store.query_streams((p) => by_source.push(p.stream), {
           stream: `qs-${tag}-.*`,
           source: `qs-${tag}-src-.*`
         });
-        expect3(bySource.sort()).toEqual([dyn1, dyn2].sort());
-        const exactSource = [];
-        await store.query_streams((p) => exactSource.push(p.stream), {
+        expect4(by_source.sort()).toEqual([dyn1, dyn2].sort());
+        const exact_source = [];
+        await store.query_streams((p) => exact_source.push(p.stream), {
           stream: `qs-${tag}-.*`,
           source: src2,
           source_exact: true
         });
-        expect3(exactSource).toEqual([dyn2]);
+        expect4(exact_source).toEqual([dyn2]);
       });
-      it3("paginates with limit + after (keyset)", async () => {
+      it4("paginates with limit + after (keyset)", async () => {
         const tag = uid();
         const streams = [
           `qp-${tag}-a`,
@@ -1160,22 +1280,26 @@ var runStoreTck = (options) => {
           stream: `qp-${tag}-.*`,
           limit: 2
         });
-        expect3(page1).toHaveLength(2);
+        expect4(page1).toHaveLength(2);
         const page2 = [];
         await store.query_streams((p) => page2.push(p.stream), {
           stream: `qp-${tag}-.*`,
           limit: 2,
           after: page1.at(-1)
         });
-        expect3(page2).toHaveLength(2);
-        expect3([...page1, ...page2].sort()).toEqual([...streams].sort());
+        expect4(page2).toHaveLength(2);
+        expect4([...page1, ...page2].sort()).toEqual([...streams].sort());
       });
-      it3("filters by blocked status", async () => {
+      it4("filters by blocked status", async () => {
         const tag = uid();
         const s = `qb-${tag}`;
         const sibling = `qb-${tag}-other`;
         await store.subscribe([{ stream: s }, { stream: sibling }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const others = leased.filter((l) => l.stream !== s);
@@ -1186,18 +1310,18 @@ var runStoreTck = (options) => {
           (p) => blocked.push({ stream: p.stream, error: p.error }),
           { stream: `qb-${tag}.*`, blocked: true }
         );
-        expect3(blocked).toHaveLength(1);
-        expect3(blocked[0].error).toBe("boom");
+        expect4(blocked).toHaveLength(1);
+        expect4(blocked[0].error).toBe("boom");
         const unblocked = [];
         await store.query_streams((p) => unblocked.push(p.stream), {
           stream: `qb-${tag}.*`,
           blocked: false
         });
-        expect3(unblocked).toEqual([sibling]);
+        expect4(unblocked).toEqual([sibling]);
       });
     });
-    describe3("query_stats", () => {
-      it3("array input \u2014 returns head per stream, absent when not in input", async () => {
+    describe4("query_stats", () => {
+      it4("array input \u2014 returns head per stream, absent when not in input", async () => {
         const tag = uid();
         const sA = `qst-${tag}-a`;
         const sB = `qst-${tag}-b`;
@@ -1205,111 +1329,131 @@ var runStoreTck = (options) => {
         await store.commit(
           sA,
           [inc(1), inc(2)],
-          makeMeta({ stream: sA })
+          make_meta({ stream: sA })
         );
         await store.commit(
           sB,
           [dec(5)],
-          makeMeta({ stream: sB })
+          make_meta({ stream: sB })
         );
         await store.commit(
           sUnasked,
           [inc(99)],
-          makeMeta({ stream: sUnasked })
+          make_meta({ stream: sUnasked })
         );
         const stats = await store.query_stats([sA, sB]);
-        expect3(stats.size).toBe(2);
-        expect3(stats.get(sA)?.head.name).toBe("Incremented");
-        expect3((stats.get(sA)?.head.data).amount).toBe(2);
-        expect3(stats.get(sB)?.head.name).toBe("Decremented");
-        expect3((stats.get(sB)?.head.data).amount).toBe(5);
-        expect3(stats.has(sUnasked)).toBe(false);
+        expect4(stats.size).toBe(2);
+        expect4(stats.get(sA)?.head.name).toBe("Incremented");
+        expect4((stats.get(sA)?.head.data).amount).toBe(2);
+        expect4(stats.get(sB)?.head.name).toBe("Decremented");
+        expect4((stats.get(sB)?.head.data).amount).toBe(5);
+        expect4(stats.has(sUnasked)).toBe(false);
         const empty = await store.query_stats([]);
-        expect3(empty.size).toBe(0);
+        expect4(empty.size).toBe(0);
         const unknown = await store.query_stats([`qst-${tag}-missing`]);
-        expect3(unknown.size).toBe(0);
+        expect4(unknown.size).toBe(0);
       });
-      it3("tail returns the earliest event per stream", async () => {
+      it4("tail returns the earliest event per stream", async () => {
         const tag = uid();
         const s = `qst-tail-${tag}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        await store.commit(s, [inc(2)], makeMeta({ stream: s }));
-        await store.commit(s, [inc(3)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(2)],
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(3)],
+          make_meta({ stream: s })
+        );
         const stats = await store.query_stats([s], {
           tail: true
         });
         const r = stats.get(s);
-        expect3(r?.head.name).toBe("Incremented");
-        expect3((r?.head.data).amount).toBe(3);
-        expect3(r?.tail?.name).toBe("Incremented");
-        expect3((r?.tail?.data).amount).toBe(1);
+        expect4(r?.head.name).toBe("Incremented");
+        expect4((r?.head.data).amount).toBe(3);
+        expect4(r?.tail?.name).toBe("Incremented");
+        expect4((r?.tail?.data).amount).toBe(1);
       });
-      it3("count + names \u2014 full aggregates including framework markers", async () => {
+      it4("count + names \u2014 full aggregates including framework markers", async () => {
         const tag = uid();
         const s = `qst-cn-${tag}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         await store.truncate([{ stream: s, snapshot: { count: 99 } }]);
         await store.commit(
           s,
           [inc(2), inc(3), dec(1)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const stats = await store.query_stats([s], {
           count: true,
           names: true
         });
         const r = stats.get(s);
-        expect3(r?.count).toBe(4);
-        expect3(r?.names?.[SNAP_EVENT]).toBe(1);
-        expect3(r?.names?.Incremented).toBe(2);
-        expect3(r?.names?.Decremented).toBe(1);
-        expect3(r?.names?.[SNAP_EVENT]).toBe(1);
+        expect4(r?.count).toBe(4);
+        expect4(r?.names?.[SNAP_EVENT]).toBe(1);
+        expect4(r?.names?.Incremented).toBe(2);
+        expect4(r?.names?.Decremented).toBe(1);
+        expect4(r?.names?.[SNAP_EVENT]).toBe(1);
       });
-      it3("exclude shifts head past filtered events; stream absent when all filtered", async () => {
+      it4("exclude shifts head past filtered events; stream absent when all filtered", async () => {
         const tag = uid();
         const s = `qst-excl-${tag}`;
         const sAllOut = `qst-allout-${tag}`;
         await store.commit(
           s,
           [inc(1), dec(2), inc(3)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         await store.commit(
           sAllOut,
           [inc(7)],
-          makeMeta({ stream: sAllOut })
+          make_meta({ stream: sAllOut })
         );
         const all = await store.query_stats([s]);
-        expect3(all.get(s)?.head.name).toBe("Incremented");
-        expect3((all.get(s)?.head.data).amount).toBe(3);
+        expect4(all.get(s)?.head.name).toBe("Incremented");
+        expect4((all.get(s)?.head.data).amount).toBe(3);
         const excl = await store.query_stats([s], {
           exclude: ["Incremented"]
         });
-        expect3(excl.get(s)?.head.name).toBe("Decremented");
-        expect3((excl.get(s)?.head.data).amount).toBe(2);
+        expect4(excl.get(s)?.head.name).toBe("Decremented");
+        expect4((excl.get(s)?.head.data).amount).toBe(2);
         const wipe = await store.query_stats([sAllOut], {
           exclude: ["Incremented", "Decremented", "Reset"]
         });
-        expect3(wipe.has(sAllOut)).toBe(false);
-        const noTomb = await store.query_stats([s], {
+        expect4(wipe.has(sAllOut)).toBe(false);
+        const no_tomb = await store.query_stats([s], {
           exclude: [TOMBSTONE_EVENT]
         });
-        expect3(noTomb.get(s)?.head.name).toBe("Incremented");
+        expect4(no_tomb.get(s)?.head.name).toBe("Incremented");
       });
-      it3("before \u2014 time travel narrows head/tail/count", async () => {
+      it4("before \u2014 time travel narrows head/tail/count", async () => {
         const tag = uid();
         const s = `qst-tt-${tag}`;
         const c1 = await store.commit(
           s,
           [inc(1)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const c2 = await store.commit(
           s,
           [inc(2)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(3)],
+          make_meta({ stream: s })
         );
-        await store.commit(s, [inc(3)], makeMeta({ stream: s }));
         const before = c2[0].id;
         const stats = await store.query_stats([s], {
           tail: true,
@@ -1317,15 +1461,15 @@ var runStoreTck = (options) => {
           before
         });
         const r = stats.get(s);
-        expect3(r?.count).toBe(1);
-        expect3(r?.head.id).toBe(c1[0].id);
-        expect3(r?.tail?.id).toBe(c1[0].id);
+        expect4(r?.count).toBe(1);
+        expect4(r?.head.id).toBe(c1[0].id);
+        expect4(r?.tail?.id).toBe(c1[0].id);
         const empty = await store.query_stats([s], {
           before: 0
         });
-        expect3(empty.has(s)).toBe(false);
+        expect4(empty.has(s)).toBe(false);
       });
-      it3("filter form \u2014 stream regex, stream_exact, empty {} match", async () => {
+      it4("filter form \u2014 stream regex, stream_exact, empty {} match", async () => {
         const tag = uid();
         const sA = `qsf-${tag}-orders-1`;
         const sB = `qsf-${tag}-orders-2`;
@@ -1333,94 +1477,110 @@ var runStoreTck = (options) => {
         await store.commit(
           sA,
           [inc(1)],
-          makeMeta({ stream: sA })
+          make_meta({ stream: sA })
         );
         await store.commit(
           sB,
           [inc(2)],
-          makeMeta({ stream: sB })
+          make_meta({ stream: sB })
         );
         await store.commit(
           sOther,
           [inc(3)],
-          makeMeta({ stream: sOther })
+          make_meta({ stream: sOther })
         );
         const orders = await store.query_stats({
           stream: `^qsf-${tag}-orders-`
         });
-        expect3([...orders.keys()].sort()).toEqual([sA, sB].sort());
+        expect4([...orders.keys()].sort()).toEqual([sA, sB].sort());
         const exact = await store.query_stats({
           stream: sA,
           stream_exact: true
         });
-        expect3([...exact.keys()]).toEqual([sA]);
+        expect4([...exact.keys()]).toEqual([sA]);
         const all = await store.query_stats({
           stream: `^qsf-${tag}-`
         });
-        expect3([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
+        expect4([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
       });
-      it3("compose with query_streams for subscription-level filters", async () => {
+      it4("compose with query_streams for subscription-level filters", async () => {
         const tag = uid();
         const a = `qsc-${tag}-a`;
         const b = `qsc-${tag}-b`;
         await store.subscribe([{ stream: a }, { stream: b }]);
-        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
-        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        await store.commit(
+          a,
+          [inc(1)],
+          make_meta({ stream: a })
+        );
+        await store.commit(
+          b,
+          [inc(2)],
+          make_meta({ stream: b })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === a);
-        expect3(mine).toBeDefined();
+        expect4(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== a);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
-        const blockedNames = [];
-        await store.query_streams((p) => blockedNames.push(p.stream), {
+        const blocked_names = [];
+        await store.query_streams((p) => blocked_names.push(p.stream), {
           stream: `^qsc-${tag}-`,
           blocked: true
         });
-        expect3(blockedNames).toEqual([a]);
-        const stats = await store.query_stats(blockedNames);
-        expect3(stats.get(a)?.head.name).toBe("Incremented");
-        expect3(stats.has(b)).toBe(false);
+        expect4(blocked_names).toEqual([a]);
+        const stats = await store.query_stats(blocked_names);
+        expect4(stats.get(a)?.head.name).toBe("Incremented");
+        expect4(stats.has(b)).toBe(false);
       });
-      it3("empty filter {} \u2014 matches every event-bearing stream", async () => {
+      it4("empty filter {} \u2014 matches every event-bearing stream", async () => {
         const tag = uid();
         const a = `qse-${tag}-a`;
         const b = `qse-${tag}-b`;
-        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
-        await store.commit(b, [dec(2)], makeMeta({ stream: b }));
+        await store.commit(
+          a,
+          [inc(1)],
+          make_meta({ stream: a })
+        );
+        await store.commit(
+          b,
+          [dec(2)],
+          make_meta({ stream: b })
+        );
         const all = await store.query_stats({});
-        expect3(all.has(a)).toBe(true);
-        expect3(all.has(b)).toBe(true);
+        expect4(all.has(a)).toBe(true);
+        expect4(all.has(b)).toBe(true);
       });
-      it3("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
+      it4("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
         const tag = uid();
         const s = `qsfl-${tag}`;
         await store.commit(
           s,
           [inc(1), inc(2), dec(3)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const c = await store.query_stats([s], {
           count: true
         });
-        expect3(c.get(s)?.count).toBe(3);
-        expect3(c.get(s)?.names).toBeUndefined();
-        expect3(c.get(s)?.tail).toBeUndefined();
+        expect4(c.get(s)?.count).toBe(3);
+        expect4(c.get(s)?.names).toBeUndefined();
+        expect4(c.get(s)?.tail).toBeUndefined();
         const n = await store.query_stats([s], {
           names: true
         });
-        expect3(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
-        expect3(n.get(s)?.count).toBeUndefined();
-        expect3(n.get(s)?.tail).toBeUndefined();
+        expect4(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
+        expect4(n.get(s)?.count).toBeUndefined();
+        expect4(n.get(s)?.tail).toBeUndefined();
         const t = await store.query_stats([s], { tail: true });
-        expect3(t.get(s)?.tail?.name).toBe("Incremented");
-        expect3((t.get(s)?.tail?.data).amount).toBe(1);
-        expect3(t.get(s)?.count).toBeUndefined();
-        expect3(t.get(s)?.names).toBeUndefined();
+        expect4(t.get(s)?.tail?.name).toBe("Incremented");
+        expect4((t.get(s)?.tail?.data).amount).toBe(1);
+        expect4(t.get(s)?.count).toBeUndefined();
+        expect4(t.get(s)?.names).toBeUndefined();
       });
     });
-    describe3("query_streams anchor contract", () => {
-      it3("plain regex without anchors is a substring match", async () => {
+    describe4("query_streams anchor contract", () => {
+      it4("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-inner`;
         const longer = `qsr-${tag}-inner-extra`;
@@ -1434,9 +1594,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `qsr-${tag}-inner`
         });
-        expect3(seen.sort()).toEqual([inner, longer].sort());
+        expect4(seen.sort()).toEqual([inner, longer].sort());
       });
-      it3("caller-anchored `^name$` matches only the whole string", async () => {
+      it4("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-anchor`;
         const longer = `qsr-${tag}-anchor-extra`;
@@ -1445,9 +1605,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-anchor$`
         });
-        expect3(seen).toEqual([inner]);
+        expect4(seen).toEqual([inner]);
       });
-      it3("caller-anchored `^prefix` matches by prefix", async () => {
+      it4("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qsr-${tag}-pfx-a`;
         const b = `qsr-${tag}-pfx-b`;
@@ -1461,11 +1621,11 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-pfx-`
         });
-        expect3(seen.sort()).toEqual([a, b].sort());
+        expect4(seen.sort()).toEqual([a, b].sort());
       });
     });
-    describe3("prioritize anchor contract", () => {
-      it3("caller-anchored `^name$` filter matches only the whole string", async () => {
+    describe4("prioritize anchor contract", () => {
+      it4("caller-anchored `^name$` filter matches only the whole string", async () => {
         const tag = uid();
         const inner = `pr-${tag}-anchor`;
         const longer = `pr-${tag}-anchor-extra`;
@@ -1477,45 +1637,49 @@ var runStoreTck = (options) => {
           { stream: `^pr-${tag}-anchor$` },
           7
         );
-        expect3(updated).toBe(1);
+        expect4(updated).toBe(1);
         const seen = /* @__PURE__ */ new Map();
         await store.query_streams((p) => seen.set(p.stream, p.priority), {
           stream: `pr-${tag}-anchor`
         });
-        expect3(seen.get(inner)).toBe(7);
-        expect3(seen.get(longer)).toBe(0);
+        expect4(seen.get(inner)).toBe(7);
+        expect4(seen.get(longer)).toBe(0);
       });
     });
-    describe3("query_streams head", () => {
-      it3("maxEventId tracks the highest committed id", async () => {
+    describe4("query_streams head", () => {
+      it4("maxEventId tracks the highest committed id", async () => {
         const s = `head-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const positions = [];
         const { maxEventId } = await store.query_streams(
           (p) => positions.push(p.stream),
           { stream: s, stream_exact: true, limit: 1 }
         );
-        expect3(maxEventId).toBeGreaterThanOrEqual(0);
-        expect3(positions).toEqual([s]);
+        expect4(maxEventId).toBeGreaterThanOrEqual(0);
+        expect4(positions).toEqual([s]);
       });
     });
-    describe3("seedStream helper coverage", () => {
-      it3("commits N events with monotonically increasing ids", async () => {
+    describe4("seed_stream helper coverage", () => {
+      it4("commits N events with monotonically increasing ids", async () => {
         const s = `seed-${uid()}`;
-        const committed = await seedStream(store, s, 3);
-        expect3(committed).toHaveLength(3);
+        const committed = await seed_stream(store, s, 3);
+        expect4(committed).toHaveLength(3);
         for (let i = 1; i < committed.length; i++) {
-          expect3(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          expect4(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
     });
-    describe3.skipIf(!caps.restore)("restore (capability)", () => {
+    describe4.skipIf(!caps.restore)("restore (capability)", () => {
       beforeEach(async () => {
         await store.drop();
         await store.seed();
       });
-      const asSource = (events) => ({
+      const as_source = (events) => ({
         async query(callback) {
           for (const e of events)
             await Promise.resolve(
@@ -1528,8 +1692,8 @@ var runStoreTck = (options) => {
         async dispose() {
         }
       });
-      const event = (originalId, stream, version, name, created, data = {}) => ({
-        id: originalId,
+      const event = (original_id, stream, version, name, created, data = {}) => ({
+        id: original_id,
         name,
         data,
         stream,
@@ -1547,18 +1711,18 @@ var runStoreTck = (options) => {
           await cache.dispose();
         }
       };
-      it3("returns kept=0 on an empty source", async () => {
-        const result = await restore(asSource([]));
-        expect3(result.kept).toBe(0);
-        expect3(result.duration_ms).toBeGreaterThanOrEqual(0);
-        expect3(result.dropped).toEqual({
+      it4("returns kept=0 on an empty source", async () => {
+        const result = await restore(as_source([]));
+        expect4(result.kept).toBe(0);
+        expect4(result.duration_ms).toBeGreaterThanOrEqual(0);
+        expect4(result.dropped).toEqual({
           closed_streams: 0,
           snapshots: 0
         });
         const events = await collect(store, { limit: 10 });
-        expect3(events).toHaveLength(0);
+        expect4(events).toHaveLength(0);
       });
-      it3("rebuilds a single stream and preserves `created` verbatim", async () => {
+      it4("rebuilds a single stream and preserves `created` verbatim", async () => {
         const s = `restore-single-${uid()}`;
         const t0 = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
         const t1 = /* @__PURE__ */ new Date("2020-01-02T00:00:00.000Z");
@@ -1568,8 +1732,8 @@ var runStoreTck = (options) => {
           event(2, s, 1, "Incremented", t1, { amount: 2 }),
           event(3, s, 2, "Decremented", t2, { amount: 1 })
         ];
-        const result = await restore(asSource(events));
-        expect3(result.kept).toBe(3);
+        const result = await restore(as_source(events));
+        expect4(result.kept).toBe(3);
         const back = [];
         await store.query(
           (e) => {
@@ -1577,8 +1741,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect3(back).toHaveLength(3);
-        expect3(
+        expect4(back).toHaveLength(3);
+        expect4(
           back.map((e) => ({
             stream: e.stream,
             version: e.version,
@@ -1610,7 +1774,7 @@ var runStoreTck = (options) => {
           }
         ]);
       });
-      it3("rebuilds multiple streams interleaved", async () => {
+      it4("rebuilds multiple streams interleaved", async () => {
         const a = `restore-multi-a-${uid()}`;
         const b = `restore-multi-b-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-06-01T00:00:00.000Z");
@@ -1620,8 +1784,8 @@ var runStoreTck = (options) => {
           event(3, a, 1, "Decremented", t, { amount: 5 }),
           event(4, b, 1, "Incremented", t, { amount: 30 })
         ];
-        const result = await restore(asSource(events));
-        expect3(result.kept).toBe(4);
+        const result = await restore(as_source(events));
+        expect4(result.kept).toBe(4);
         const aBack = [];
         const bBack = [];
         await store.query(
@@ -1636,14 +1800,14 @@ var runStoreTck = (options) => {
           },
           { stream: b, stream_exact: true }
         );
-        expect3(aBack.map((e) => e.version)).toEqual([0, 1]);
-        expect3(bBack.map((e) => e.version)).toEqual([0, 1]);
+        expect4(aBack.map((e) => e.version)).toEqual([0, 1]);
+        expect4(bBack.map((e) => e.version)).toEqual([0, 1]);
       });
-      it3("preserves Date `created` verbatim", async () => {
+      it4("preserves Date `created` verbatim", async () => {
         const s = `restore-isoc-${uid()}`;
         const iso = "2021-07-15T12:34:56.789Z";
         await restore(
-          asSource([
+          as_source([
             {
               id: 1,
               stream: s,
@@ -1662,53 +1826,53 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect3(back).toHaveLength(1);
-        expect3(back[0].created.toISOString()).toBe(iso);
+        expect4(back).toHaveLength(1);
+        expect4(back[0].created.toISOString()).toBe(iso);
       });
-      it3("wipes pre-existing events before inserting", async () => {
+      it4("wipes pre-existing events before inserting", async () => {
         const old = `restore-old-${uid()}`;
         await store.commit(
           old,
           [inc(1), inc(2)],
-          makeMeta({ stream: old })
+          make_meta({ stream: old })
         );
         const fresh = `restore-fresh-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
         await restore(
-          asSource([event(1, fresh, 0, "Incremented", t, { amount: 99 })])
+          as_source([event(1, fresh, 0, "Incremented", t, { amount: 99 })])
         );
-        const oldBack = await collect(store, {
+        const old_back = await collect(store, {
           stream: old,
           stream_exact: true
         });
-        expect3(oldBack).toHaveLength(0);
-        const freshBack = await collect(store, {
+        expect4(old_back).toHaveLength(0);
+        const fresh_back = await collect(store, {
           stream: fresh,
           stream_exact: true
         });
-        expect3(freshBack).toHaveLength(1);
+        expect4(fresh_back).toHaveLength(1);
       });
-      it3("clears subscription/stream-position metadata", async () => {
+      it4("clears subscription/stream-position metadata", async () => {
         const sub = `restore-sub-${uid()}`;
         await store.subscribe([{ stream: sub, source: "anything" }]);
-        const collectStreams = async () => {
+        const collect_streams = async () => {
           const out = [];
           await store.query_streams((p) => {
             out.push(p.stream);
           });
           return out;
         };
-        const before = await collectStreams();
-        expect3(before.includes(sub)).toBe(true);
-        await restore(asSource([]));
-        const after = await collectStreams();
-        expect3(after.includes(sub)).toBe(false);
+        const before = await collect_streams();
+        expect4(before.includes(sub)).toBe(true);
+        await restore(as_source([]));
+        const after = await collect_streams();
+        expect4(after.includes(sub)).toBe(false);
       });
-      it3("preserves snapshot events through restore", async () => {
+      it4("preserves snapshot events through restore", async () => {
         const s = `restore-snap-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-04-01T00:00:00.000Z");
         await restore(
-          asSource([
+          as_source([
             {
               id: 1,
               stream: s,
@@ -1725,10 +1889,10 @@ var runStoreTck = (options) => {
           stream_exact: true,
           with_snaps: true
         });
-        expect3(back).toHaveLength(1);
-        expect3(back[0].name).toBe(SNAP_EVENT);
+        expect4(back).toHaveLength(1);
+        expect4(back[0].name).toBe(SNAP_EVENT);
       });
-      it3("rewrites causation refs through the old\u2192new id map", async () => {
+      it4("rewrites causation refs through the old\u2192new id map", async () => {
         const s = `restore-caus-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-08-01T00:00:00.000Z");
         const events = [
@@ -1770,7 +1934,7 @@ var runStoreTck = (options) => {
             }
           }
         ];
-        await restore(asSource(events));
+        await restore(as_source(events));
         const back = [];
         await store.query(
           (e) => {
@@ -1778,16 +1942,16 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect3(back).toHaveLength(3);
-        expect3(back[0].meta.causation.event).toBeUndefined();
-        expect3(back[1].meta.causation.event?.id).toBe(back[0].id);
-        expect3(back[2].meta.causation.event?.id).toBe(back[1].id);
+        expect4(back).toHaveLength(3);
+        expect4(back[0].meta.causation.event).toBeUndefined();
+        expect4(back[1].meta.causation.event?.id).toBe(back[0].id);
+        expect4(back[2].meta.causation.event?.id).toBe(back[1].id);
       });
-      it3("leaves causation refs unmapped when the target isn't in the source", async () => {
+      it4("leaves causation refs unmapped when the target isn't in the source", async () => {
         const s = `restore-orphan-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-09-01T00:00:00.000Z");
         await restore(
-          asSource([
+          as_source([
             {
               id: 1,
               stream: s,
@@ -1811,14 +1975,14 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect3(back[0].meta.causation.event?.id).toBe(999);
+        expect4(back[0].meta.causation.event?.id).toBe(999);
       });
-      it3("rolls back atomically when the source throws mid-iteration", async () => {
+      it4("rolls back atomically when the source throws mid-iteration", async () => {
         const original = `restore-pre-${uid()}`;
         const committed = await store.commit(
           original,
           [inc(1), inc(2), inc(3)],
-          makeMeta({ stream: original })
+          make_meta({ stream: original })
         );
         const explosive = {
           async query(callback) {
@@ -1839,7 +2003,7 @@ var runStoreTck = (options) => {
           async dispose() {
           }
         };
-        await expect3(restore(explosive)).rejects.toThrow("boom");
+        await expect4(restore(explosive)).rejects.toThrow("boom");
         const back = [];
         await store.query(
           (e) => {
@@ -1847,14 +2011,14 @@ var runStoreTck = (options) => {
           },
           { stream: original, stream_exact: true }
         );
-        expect3(back).toHaveLength(3);
-        expect3(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        expect4(back).toHaveLength(3);
+        expect4(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
       });
-      it3("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
+      it4("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
         const s = `restore-drop-snap-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-10-01T00:00:00.000Z");
         const result = await restore(
-          asSource([
+          as_source([
             event(1, s, 0, "Incremented", t, { amount: 1 }),
             {
               id: 2,
@@ -1869,34 +2033,34 @@ var runStoreTck = (options) => {
           ]),
           { drop_snapshots: true }
         );
-        expect3(result.kept).toBe(2);
-        expect3(result.dropped.snapshots).toBe(1);
+        expect4(result.kept).toBe(2);
+        expect4(result.dropped.snapshots).toBe(1);
         const back = await collect(store, {
           stream: s,
           stream_exact: true,
           with_snaps: true
         });
-        expect3(back).toHaveLength(2);
-        expect3(
+        expect4(back).toHaveLength(2);
+        expect4(
           back.every((e) => e.name !== SNAP_EVENT)
         ).toBe(true);
       });
-      it3("on_progress fires once per event (caller throttles)", async () => {
+      it4("on_progress fires once per event (caller throttles)", async () => {
         const calls = [];
         const s = `restore-progress-${uid()}`;
         const t = /* @__PURE__ */ new Date("2021-02-01T00:00:00.000Z");
         await restore(
-          asSource([
+          as_source([
             event(1, s, 0, "Incremented", t, { amount: 1 }),
             event(2, s, 1, "Incremented", t, { amount: 2 })
           ]),
           { on_progress: (p) => calls.push(p.processed) }
         );
-        expect3(calls).toEqual([1, 2]);
+        expect4(calls).toEqual([1, 2]);
       });
     });
-    describe3.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
-      it3("commits and loads pii alongside data", async () => {
+    describe4.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
+      it4("commits and loads pii alongside data", async () => {
         const s = `pii-roundtrip-${uid()}`;
         const committed = await store.commit(
           s,
@@ -1907,10 +2071,10 @@ var runStoreTck = (options) => {
               pii: { email: "u@example.com", name: "Ursula" }
             }
           ],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
-        expect3(committed).toHaveLength(1);
-        expect3(committed[0].pii).toEqual({
+        expect4(committed).toHaveLength(1);
+        expect4(committed[0].pii).toEqual({
           email: "u@example.com",
           name: "Ursula"
         });
@@ -1921,13 +2085,17 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect3(seen).toHaveLength(1);
-        expect3(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
-        expect3(seen[0].data).toEqual({ amount: 1 });
+        expect4(seen).toHaveLength(1);
+        expect4(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
+        expect4(seen[0].data).toEqual({ amount: 1 });
       });
-      it3("passes through events without pii (pii is null or undefined on load)", async () => {
+      it4("passes through events without pii (pii is null or undefined on load)", async () => {
         const s = `pii-none-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const seen = [];
         await store.query(
           (e) => {
@@ -1935,10 +2103,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect3(seen).toHaveLength(1);
-        expect3(seen[0].pii == null).toBe(true);
+        expect4(seen).toHaveLength(1);
+        expect4(seen[0].pii == null).toBe(true);
       });
-      it3("wipes pii for every event on the stream via forget_pii", async () => {
+      it4("wipes pii for every event on the stream via forget_pii", async () => {
         const s = `pii-forget-${uid()}`;
         await store.commit(
           s,
@@ -1954,12 +2122,12 @@ var runStoreTck = (options) => {
               pii: { email: "b@example.com" }
             }
           ],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const forget = store.forget_pii;
-        expect3(forget).toBeDefined();
+        expect4(forget).toBeDefined();
         const wiped = await forget.call(store, s);
-        expect3(wiped).toBe(2);
+        expect4(wiped).toBe(2);
         const seen = [];
         await store.query(
           (e) => {
@@ -1967,13 +2135,13 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect3(seen).toHaveLength(2);
+        expect4(seen).toHaveLength(2);
         for (const e of seen) {
-          expect3(e.pii == null).toBe(true);
-          expect3(e.data).toBeDefined();
+          expect4(e.pii == null).toBe(true);
+          expect4(e.data).toBeDefined();
         }
       });
-      it3("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
+      it4("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
         const s = `pii-forget-idem-${uid()}`;
         await store.commit(
           s,
@@ -1984,15 +2152,15 @@ var runStoreTck = (options) => {
               pii: { email: "u@example.com" }
             }
           ],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const forget = store.forget_pii;
         const first = await forget.call(store, s);
-        expect3(first).toBe(1);
+        expect4(first).toBe(1);
         const second = await forget.call(store, s);
-        expect3(second).toBe(0);
+        expect4(second).toBe(0);
       });
-      it3("only wipes the targeted stream \u2014 siblings untouched", async () => {
+      it4("only wipes the targeted stream \u2014 siblings untouched", async () => {
         const sA = `pii-iso-a-${uid()}`;
         const sB = `pii-iso-b-${uid()}`;
         await store.commit(
@@ -2004,7 +2172,7 @@ var runStoreTck = (options) => {
               pii: { email: "alice@example.com" }
             }
           ],
-          makeMeta({ stream: sA })
+          make_meta({ stream: sA })
         );
         await store.commit(
           sB,
@@ -2015,7 +2183,7 @@ var runStoreTck = (options) => {
               pii: { email: "bob@example.com" }
             }
           ],
-          makeMeta({ stream: sB })
+          make_meta({ stream: sB })
         );
         await store.forget_pii.call(store, sA);
         const a = [];
@@ -2025,7 +2193,7 @@ var runStoreTck = (options) => {
           },
           { stream: sA, stream_exact: true }
         );
-        expect3(a[0].pii == null).toBe(true);
+        expect4(a[0].pii == null).toBe(true);
         const b = [];
         await store.query(
           (e) => {
@@ -2033,28 +2201,32 @@ var runStoreTck = (options) => {
           },
           { stream: sB, stream_exact: true }
         );
-        expect3(b[0].pii).toEqual({ email: "bob@example.com" });
+        expect4(b[0].pii).toEqual({ email: "bob@example.com" });
       });
-      it3("forget_pii on a stream with no pii events returns 0", async () => {
+      it4("forget_pii on a stream with no pii events returns 0", async () => {
         const s = `pii-forget-empty-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const wiped = await store.forget_pii.call(store, s);
-        expect3(wiped).toBe(0);
+        expect4(wiped).toBe(0);
       });
     });
     if (caps.notify) {
-      describe3("notify (capability)", () => {
-        it3("delivers a notification when a different instance commits", async () => {
+      describe4("notify (capability)", () => {
+        it4("delivers a notification when a different instance commits", async () => {
           const notify = store.notify;
-          expect3(notify).toBeDefined();
+          expect4(notify).toBeDefined();
           const received = [];
-          let resolveArrived;
+          let resolve_arrived;
           const arrived = new Promise((res) => {
-            resolveArrived = res;
+            resolve_arrived = res;
           });
           const disposer = await notify.call(store, (n) => {
             received.push(n);
-            resolveArrived();
+            resolve_arrived();
           });
           const writer = await options.factory();
           try {
@@ -2062,12 +2234,12 @@ var runStoreTck = (options) => {
             await writer.commit(
               stream,
               [inc(1)],
-              makeMeta({ stream })
+              make_meta({ stream })
             );
             await arrived;
-            expect3(received.length).toBeGreaterThanOrEqual(1);
-            expect3(received[0].stream).toBe(stream);
-            expect3(received[0].events.length).toBeGreaterThanOrEqual(1);
+            expect4(received.length).toBeGreaterThanOrEqual(1);
+            expect4(received[0].stream).toBe(stream);
+            expect4(received[0].events.length).toBeGreaterThanOrEqual(1);
           } finally {
             await writer.dispose();
             await Promise.resolve(disposer());
@@ -2087,12 +2259,11 @@ export {
   collect,
   dec,
   inc,
-  makeMeta,
   reset,
   runCacheTck,
   runLoggerTck,
+  runStabilityTck,
   runStoreTck,
-  seedStream,
   uid
 };
 //# sourceMappingURL=index.js.map