@rotorsoft/act-tck 1.13.2 → 1.14.0

package/dist/index.js

@@ -228,6 +228,208 @@ ${content}`;
   }).join("\n");
 }
 
+// src/store-property-tck.ts
+import { fc, test } from "@fast-check/vitest";
+import { afterAll, beforeAll, describe as describe4, expect as expect4 } from "vitest";
+var streamArb = fc.constantFrom("s1", "s2", "s3");
+var commitArb = fc.record({
+  stream: streamArb,
+  count: fc.integer({ min: 1, max: 3 })
+});
+var claimStreamArb = fc.constantFrom("a", "b", "c");
+var opArb = fc.oneof(
+  fc.record({ kind: fc.constant("commit"), stream: claimStreamArb }),
+  fc.record({ kind: fc.constant("claim") }),
+  fc.record({ kind: fc.constant("ack-all") }),
+  fc.record({ kind: fc.constant("block-all") })
+);
+var events = (count) => Array.from({ length: count }, () => inc(1));
+var runStorePropertyTck = (options) => {
+  const numRuns = options.numRuns ?? 100;
+  describe4(`TCK / Store properties / ${options.name}`, () => {
+    let store;
+    beforeAll(async () => {
+      store = await options.factory();
+      await store.seed();
+    });
+    afterAll(async () => {
+      await store.dispose();
+    });
+    const reset2 = async () => {
+      await store.drop();
+      await store.seed();
+    };
+    describe4("commit version invariants", () => {
+      test.prop([fc.array(commitArb, { minLength: 0, maxLength: 30 })], {
+        numRuns
+      })(
+        "per-stream versions are 0..N-1 in commit order, regardless of interleaving",
+        async (commits) => {
+          await reset2();
+          const expected = /* @__PURE__ */ new Map();
+          for (const { stream, count } of commits) {
+            const before = expected.get(stream) ?? -1;
+            const committed = await store.commit(
+              stream,
+              events(count),
+              make_meta({ stream })
+            );
+            committed.forEach((e, i) => {
+              expect4(e.version).toBe(before + 1 + i);
+            });
+            expected.set(stream, before + count);
+          }
+          for (const stream of new Set(commits.map((c) => c.stream))) {
+            const seen = await collect(store, { stream, stream_exact: true });
+            seen.forEach((e, i) => {
+              expect4(e.version).toBe(i);
+            });
+          }
+        }
+      );
+      test.prop([fc.array(commitArb, { minLength: 1, maxLength: 20 })], {
+        numRuns
+      })(
+        "bad expectedVersion throws and commits no events",
+        async (commits) => {
+          await reset2();
+          for (const { stream: stream2, count } of commits) {
+            await store.commit(
+              stream2,
+              events(count),
+              make_meta({ stream: stream2 })
+            );
+          }
+          const stream = commits[0].stream;
+          const before = await collect(store, { stream, stream_exact: true });
+          await expect4(
+            store.commit(
+              stream,
+              [inc(1)],
+              make_meta({ stream }),
+              before.length
+            )
+          ).rejects.toThrow();
+          const after = await collect(store, { stream, stream_exact: true });
+          expect4(after.length).toBe(before.length);
+        }
+      );
+    });
+    describe4("claim/lease lifecycle invariants", () => {
+      test.prop([fc.array(opArb, { minLength: 1, maxLength: 30 })], {
+        numRuns
+      })(
+        "no leaks: claims are always acked or blocked, never lost",
+        async (ops) => {
+          await reset2();
+          await store.subscribe([
+            { stream: "a" },
+            { stream: "b" },
+            { stream: "c" }
+          ]);
+          let totalClaims = 0;
+          let totalResolved = 0;
+          let pending = [];
+          for (const op of ops) {
+            if (op.kind === "commit") {
+              await store.commit(
+                op.stream,
+                [inc(1)],
+                make_meta({ stream: op.stream })
+              );
+            } else if (op.kind === "claim") {
+              const claimed = await store.claim(5, 5, "worker", 6e4);
+              totalClaims += claimed.length;
+              pending = [...pending, ...claimed];
+            } else if (op.kind === "ack-all") {
+              const acked = await store.ack(pending);
+              totalResolved += acked.length;
+              pending = pending.filter(
+                (p) => !acked.find((a) => a.stream === p.stream)
+              );
+            } else {
+              const blocked = await store.block(
+                pending.map((p) => ({ ...p, error: "test" }))
+              );
+              totalResolved += blocked.length;
+              pending = pending.filter(
+                (p) => !blocked.find((b) => b.stream === p.stream)
+              );
+            }
+          }
+          expect4(totalResolved + pending.length).toBe(totalClaims);
+        }
+      );
+      test.prop(
+        [
+          fc.array(claimStreamArb, { minLength: 1, maxLength: 5 }),
+          fc.array(claimStreamArb, { minLength: 0, maxLength: 5 })
+        ],
+        { numRuns }
+      )(
+        "ack advances the watermark monotonically per stream",
+        async (commitsA, commitsB) => {
+          await reset2();
+          const all = [.../* @__PURE__ */ new Set([...commitsA, ...commitsB, "a", "b", "c"])];
+          await store.subscribe(all.map((stream) => ({ stream })));
+          for (const stream of commitsA) {
+            await store.commit(
+              stream,
+              [inc(1)],
+              make_meta({ stream })
+            );
+          }
+          const acked1 = await store.ack(
+            await store.claim(10, 10, "worker", 6e4)
+          );
+          const watermark1 = new Map(all.map((stream) => [stream, -1]));
+          for (const l of acked1) watermark1.set(l.stream, l.at);
+          for (const stream of commitsB) {
+            await store.commit(
+              stream,
+              [inc(1)],
+              make_meta({ stream })
+            );
+          }
+          const acked2 = await store.ack(
+            await store.claim(10, 10, "worker", 6e4)
+          );
+          for (const lease of acked2) {
+            expect4(lease.at).toBeGreaterThanOrEqual(
+              watermark1.get(lease.stream)
+            );
+          }
+        }
+      );
+      test.prop([fc.array(claimStreamArb, { minLength: 1, maxLength: 5 })], {
+        numRuns
+      })("blocked streams cannot be claimed again", async (commits) => {
+        await reset2();
+        const streams = [...new Set(commits)];
+        await store.subscribe(streams.map((stream) => ({ stream })));
+        for (const stream of commits) {
+          await store.commit(
+            stream,
+            [inc(1)],
+            make_meta({ stream })
+          );
+        }
+        const claimed = await store.claim(10, 10, "worker", 6e4);
+        await store.block(claimed.map((l) => ({ ...l, error: "test" })));
+        const blockedSet = new Set(claimed.map((l) => l.stream));
+        await store.subscribe([{ stream: "ctrl" }]);
+        await store.commit(
+          "ctrl",
+          [inc(1)],
+          make_meta({ stream: "ctrl" })
+        );
+        const reclaim = await store.claim(10, 10, "worker2", 6e4);
+        for (const l of reclaim) expect4(blockedSet.has(l.stream)).toBe(false);
+      });
+    });
+  });
+};
+
 // src/store-tck.ts
 import {
   act,
@@ -236,20 +438,20 @@ import {
   SNAP_EVENT,
   TOMBSTONE_EVENT
 } from "@rotorsoft/act";
-import { afterAll, beforeAll, describe as describe4, expect as expect4, it as it4 } from "vitest";
+import { afterAll as afterAll2, beforeAll as beforeAll2, describe as describe5, expect as expect5, it as it4 } from "vitest";
 var runStoreTck = (options) => {
-  describe4(`TCK / Store / ${options.name}`, () => {
+  describe5(`TCK / Store / ${options.name}`, () => {
     let store;
     const caps = { ...options.capabilities };
-    beforeAll(async () => {
+    beforeAll2(async () => {
       store = await options.factory();
       await store.drop();
       await store.seed();
     });
-    afterAll(async () => {
+    afterAll2(async () => {
       await store.dispose();
     });
-    describe4("commit", () => {
+    describe5("commit", () => {
       it4("returns committed events with sequenced ids and versions", async () => {
         const s = `commit-seq-${uid()}`;
         const committed = await store.commit(
@@ -257,14 +459,14 @@ var runStoreTck = (options) => {
           [inc(1), inc(2), dec(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 });
+        expect5(committed).toHaveLength(3);
+        expect5(committed[0].version).toBe(0);
+        expect5(committed[1].version).toBe(1);
+        expect5(committed[2].version).toBe(2);
+        expect5(committed[0].name).toBe("Incremented");
+        expect5(committed[2].data).toEqual({ amount: 3 });
         for (let i = 1; i < committed.length; i++) {
-          expect4(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          expect5(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
       it4("attaches correlation and stream metadata", async () => {
@@ -275,8 +477,8 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s, correlation })
         );
-        expect4(committed[0].stream).toBe(s);
-        expect4(committed[0].meta.correlation).toBe(correlation);
+        expect5(committed[0].stream).toBe(s);
+        expect5(committed[0].meta.correlation).toBe(correlation);
       });
       it4("throws ConcurrencyError when expectedVersion is wrong", async () => {
         const s = `commit-cc-${uid()}`;
@@ -291,7 +493,7 @@ var runStoreTck = (options) => {
           make_meta({ stream: s }),
           0
         );
-        await expect4(
+        await expect5(
           store.commit(s, [inc(1)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(ConcurrencyError);
       });
@@ -302,14 +504,14 @@ var runStoreTck = (options) => {
           [inc(1), inc(2)],
           make_meta({ stream: s })
         );
-        await expect4(
+        await expect5(
           store.commit(s, [inc(3)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(ConcurrencyError);
         const found = await collect(store, { stream: s, stream_exact: true });
-        expect4(found).toHaveLength(2);
+        expect5(found).toHaveLength(2);
       });
     });
-    describe4("query", () => {
+    describe5("query", () => {
       it4("filters by stream, names, correlation, limit, with_snaps", async () => {
         const s1 = `q-s1-${uid()}`;
         const s2 = `q-s2-${uid()}`;
@@ -328,21 +530,21 @@ var runStoreTck = (options) => {
           stream: s1,
           stream_exact: true
         });
-        expect4(by_stream).toHaveLength(2);
+        expect5(by_stream).toHaveLength(2);
         const by_name = await collect(store, {
           stream: s2,
           stream_exact: true,
           names: ["Reset"]
         });
-        expect4(by_name).toHaveLength(1);
-        expect4(by_name[0].name).toBe("Reset");
+        expect5(by_name).toHaveLength(1);
+        expect5(by_name[0].name).toBe("Reset");
         const by_correlation = await collect(store, { correlation: cor });
-        expect4(by_correlation).toHaveLength(5);
+        expect5(by_correlation).toHaveLength(5);
         const limited = await collect(store, {
           correlation: cor,
           limit: 2
         });
-        expect4(limited).toHaveLength(2);
+        expect5(limited).toHaveLength(2);
       });
       it4("supports backward traversal", async () => {
         const s = `q-back-${uid()}`;
@@ -357,8 +559,8 @@ var runStoreTck = (options) => {
           stream_exact: true,
           backward: true
         });
-        expect4(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
-        expect4(backward.map((e) => e.id)).toEqual(
+        expect5(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        expect5(backward.map((e) => e.id)).toEqual(
           [...committed].reverse().map((c) => c.id)
         );
         const latest = await collect(store, {
@@ -367,8 +569,8 @@ var runStoreTck = (options) => {
           backward: true,
           limit: 1
         });
-        expect4(latest).toHaveLength(1);
-        expect4(latest[0].id).toBe(committed.at(-1).id);
+        expect5(latest).toHaveLength(1);
+        expect5(latest[0].id).toBe(committed.at(-1).id);
       });
       it4("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
@@ -382,7 +584,7 @@ var runStoreTck = (options) => {
           stream_exact: true,
           after: committed[0].id
         });
-        expect4(after_first.map((e) => e.id)).toEqual(
+        expect5(after_first.map((e) => e.id)).toEqual(
           committed.slice(1).map((c) => c.id)
         );
         const before_last = await collect(store, {
@@ -390,7 +592,7 @@ var runStoreTck = (options) => {
           stream_exact: true,
           before: committed[committed.length - 1].id
         });
-        expect4(before_last.map((e) => e.id)).toEqual(
+        expect5(before_last.map((e) => e.id)).toEqual(
           committed.slice(0, -1).map((c) => c.id)
         );
       });
@@ -409,13 +611,13 @@ var runStoreTck = (options) => {
           created_after: before,
           created_before: future
         });
-        expect4(in_window.length).toBe(1);
+        expect5(in_window.length).toBe(1);
         const out_of_window = await collect(store, {
           stream: s,
           stream_exact: true,
           created_after: future
         });
-        expect4(out_of_window.length).toBe(0);
+        expect5(out_of_window.length).toBe(0);
       });
       it4("backward traversal short-circuits at `after` id boundary", async () => {
         const s = `q-back-after-${uid()}`;
@@ -430,7 +632,7 @@ var runStoreTck = (options) => {
           backward: true,
           after: committed[0].id
         });
-        expect4(got.map((e) => e.id)).toEqual([
+        expect5(got.map((e) => e.id)).toEqual([
           committed[2].id,
           committed[1].id
         ]);
@@ -449,7 +651,7 @@ var runStoreTck = (options) => {
           backward: true,
           created_after: future
         });
-        expect4(got).toHaveLength(0);
+        expect5(got).toHaveLength(0);
       });
       it4("backward traversal honors created_before by skipping newer events", async () => {
         const s = `q-back-ts-${uid()}`;
@@ -461,7 +663,7 @@ var runStoreTck = (options) => {
           backward: true,
           created_before: past
         });
-        expect4(got).toHaveLength(0);
+        expect5(got).toHaveLength(0);
       });
       it4("stream_exact disables regex matching", async () => {
         const tag = uid();
@@ -478,8 +680,8 @@ var runStoreTck = (options) => {
           make_meta({ stream: b })
         );
         const exact = await collect(store, { stream: a, stream_exact: true });
-        expect4(exact).toHaveLength(1);
-        expect4(exact[0].data).toEqual({ amount: 1 });
+        expect5(exact).toHaveLength(1);
+        expect5(exact[0].data).toEqual({ amount: 1 });
       });
       it4("plain regex without anchors is a substring match", async () => {
         const tag = uid();
@@ -496,7 +698,7 @@ var runStoreTck = (options) => {
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `qr-${tag}-inner` });
-        expect4(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
+        expect5(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
       });
       it4("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
@@ -513,8 +715,8 @@ var runStoreTck = (options) => {
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `^qr-${tag}-anchor$` });
-        expect4(got).toHaveLength(1);
-        expect4(got[0].stream).toBe(inner);
+        expect5(got).toHaveLength(1);
+        expect5(got[0].stream).toBe(inner);
       });
       it4("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
@@ -537,16 +739,16 @@ var runStoreTck = (options) => {
           make_meta({ stream: other })
         );
         const got = await collect(store, { stream: `^qr-${tag}-pfx-` });
-        expect4(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
+        expect5(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
       });
     });
-    describe4("subscribe + claim + ack", () => {
+    describe5("subscribe + claim + ack", () => {
       it4("subscribes new streams and is idempotent on repeat", async () => {
         const s = `sub-${uid()}`;
         const first = await store.subscribe([{ stream: s }]);
-        expect4(first.subscribed).toBe(1);
+        expect5(first.subscribed).toBe(1);
         const second = await store.subscribe([{ stream: s }]);
-        expect4(second.subscribed).toBe(0);
+        expect5(second.subscribed).toBe(0);
       });
       it4("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
@@ -559,8 +761,8 @@ var runStoreTck = (options) => {
         const by = `worker-${uid()}`;
         const leased = await store.claim(100, 0, by, 1e4);
         const mine = leased.find((l) => l.stream === s);
-        expect4(mine).toBeDefined();
-        expect4(mine.by).toBe(by);
+        expect5(mine).toBeDefined();
+        expect5(mine.by).toBe(by);
         await store.ack([{ ...mine, at: mine.at + 1 }]);
       });
       it4("does not double-claim a held lease", async () => {
@@ -574,7 +776,7 @@ var runStoreTck = (options) => {
         );
         const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1e5);
         const targetA = leasedA.find((l) => l.stream === s);
-        expect4(targetA).toBeDefined();
+        expect5(targetA).toBeDefined();
         await store.subscribe([{ stream: other }]);
         await store.commit(
           other,
@@ -582,9 +784,9 @@ var runStoreTck = (options) => {
           make_meta({ stream: other })
         );
         const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
-        expect4(leasedB.length).toBeGreaterThan(0);
-        expect4(leasedB.find((l) => l.stream === s)).toBeUndefined();
-        expect4(leasedB.find((l) => l.stream === other)).toBeDefined();
+        expect5(leasedB.length).toBeGreaterThan(0);
+        expect5(leasedB.find((l) => l.stream === s)).toBeUndefined();
+        expect5(leasedB.find((l) => l.stream === other)).toBeDefined();
       });
       it4("supports dual frontiers (lagging + leading)", async () => {
         const s = `claim-dual-${uid()}`;
@@ -596,10 +798,10 @@ var runStoreTck = (options) => {
         );
         const first = await store.claim(100, 0, `w-${uid()}`, 1);
         const mine = first.find((l) => l.stream === s);
-        expect4(mine).toBeDefined();
+        expect5(mine).toBeDefined();
         await store.ack([{ ...mine, at: mine.at + 1 }]);
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
-        expect4(second.find((l) => l.stream === s)).toBeDefined();
+        expect5(second.find((l) => l.stream === s)).toBeDefined();
       });
       it4("dedupes when both frontiers would return the same stream", async () => {
         const s = `claim-dedup-${uid()}`;
@@ -611,7 +813,7 @@ var runStoreTck = (options) => {
         );
         const claimed = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const matches = claimed.filter((l) => l.stream === s);
-        expect4(matches).toHaveLength(1);
+        expect5(matches).toHaveLength(1);
       });
       it4("silently ignores ack from the wrong holder", async () => {
         const s = `ack-wrong-${uid()}`;
@@ -630,14 +832,14 @@ var runStoreTck = (options) => {
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const sibling_lease = leased.find((l) => l.stream === sibling);
-        expect4(mine).toBeDefined();
-        expect4(sibling_lease).toBeDefined();
+        expect5(mine).toBeDefined();
+        expect5(sibling_lease).toBeDefined();
         const acked = await store.ack([
           { ...mine, by: "imposter" },
           sibling_lease
         ]);
-        expect4(acked.length).toBeGreaterThan(0);
-        expect4(acked.find((l) => l.stream === s)).toBeUndefined();
+        expect5(acked.length).toBeGreaterThan(0);
+        expect5(acked.find((l) => l.stream === s)).toBeUndefined();
       });
       it4("ack with a stale (lower) watermark does not throw", async () => {
         const s = `ack-stale-${uid()}`;
@@ -645,8 +847,8 @@ var runStoreTck = (options) => {
         const by = `w-${uid()}`;
         const leased = await store.claim(100, 0, by, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect4(mine).toBeDefined();
-        await expect4(
+        expect5(mine).toBeDefined();
+        await expect5(
           store.ack([{ ...mine, at: -5 }])
         ).resolves.toBeDefined();
       });
@@ -656,13 +858,13 @@ var runStoreTck = (options) => {
           await fresh.drop();
           await fresh.seed();
           const claimed = await fresh.claim(1, 1, `w-${uid()}`, 1e3);
-          expect4(claimed).toEqual([]);
+          expect5(claimed).toEqual([]);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    describe4("lease semantics", () => {
+    describe5("lease semantics", () => {
       it4("returns retry=0 on first claim and increments on re-claim without ack", async () => {
         const fresh = await options.factory();
         try {
@@ -677,12 +879,12 @@ var runStoreTck = (options) => {
           );
           const first = await fresh.claim(1, 0, `w-${uid()}`, 0);
           const f = first.find((l) => l.stream === s);
-          expect4(f).toBeDefined();
-          expect4(f.retry).toBe(0);
+          expect5(f).toBeDefined();
+          expect5(f.retry).toBe(0);
           const second = await fresh.claim(1, 0, `w-${uid()}`, 1e5);
           const sec = second.find((l) => l.stream === s);
-          expect4(sec).toBeDefined();
-          expect4(sec.retry).toBe(1);
+          expect5(sec).toBeDefined();
+          expect5(sec.retry).toBe(1);
         } finally {
           await fresh.dispose();
         }
@@ -700,15 +902,46 @@ var runStoreTck = (options) => {
             make_meta({ stream: s })
           );
           const lag = await fresh.claim(1, 0, `w-${uid()}`, 0);
-          expect4(lag.find((l) => l.stream === s)?.lagging).toBe(true);
+          expect5(lag.find((l) => l.stream === s)?.lagging).toBe(true);
           const lead = await fresh.claim(0, 1, `w-${uid()}`, 1e5);
-          expect4(lead.find((l) => l.stream === s)?.lagging).toBe(false);
+          expect5(lead.find((l) => l.stream === s)?.lagging).toBe(false);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+    });
+    describe5.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
+      it4("never double-leases a stream across concurrent claimers", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const streams = Array.from(
+            { length: 8 },
+            () => `concurrent-${uid()}`
+          );
+          await fresh.subscribe(streams.map((stream) => ({ stream })));
+          for (const stream of streams) {
+            await fresh.commit(
+              stream,
+              [inc(1)],
+              make_meta({ stream })
+            );
+          }
+          const owned = new Set(streams);
+          const [a, b] = await Promise.all([
+            fresh.claim(100, 100, `wA-${uid()}`, 6e4),
+            fresh.claim(100, 100, `wB-${uid()}`, 6e4)
+          ]);
+          const claimed = [...a, ...b].map((l) => l.stream).filter((stream) => owned.has(stream));
+          expect5(new Set(claimed).size).toBe(claimed.length);
+          expect5(claimed.length).toBe(owned.size);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    describe4("block", () => {
+    describe5("block", () => {
       it4("hides blocked streams from claim", async () => {
         const s = `block-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -719,16 +952,16 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect4(mine).toBeDefined();
+        expect5(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         const blocked = await store.block([
           { ...mine, error: "boom" }
         ]);
-        expect4(blocked).toHaveLength(1);
-        expect4(blocked[0].error).toBe("boom");
+        expect5(blocked).toHaveLength(1);
+        expect5(blocked[0].error).toBe("boom");
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
-        expect4(again.find((l) => l.stream === s)).toBeUndefined();
+        expect5(again.find((l) => l.stream === s)).toBeUndefined();
       });
       it4("rejects block calls from a different holder", async () => {
         const s = `block-wrong-${uid()}`;
@@ -740,16 +973,16 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect4(mine).toBeDefined();
+        expect5(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         const blocked = await store.block([
           { ...mine, by: "imposter", error: "no" }
         ]);
-        expect4(blocked).toHaveLength(0);
+        expect5(blocked).toHaveLength(0);
       });
     });
-    describe4("reset", () => {
+    describe5("reset", () => {
       it4("rewinds a stream watermark to -1", async () => {
         const s = `reset-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -760,13 +993,13 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect4(mine).toBeDefined();
+        expect5(mine).toBeDefined();
         await store.ack([{ ...mine, at: 99 }]);
-        expect4(await store.reset([s])).toBe(1);
+        expect5(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
-        expect4(back).toBeDefined();
-        expect4(back.at).toBe(-1);
+        expect5(back).toBeDefined();
+        expect5(back.at).toBe(-1);
       });
       it4("clears blocked status when resetting", async () => {
         const s = `reset-blk-${uid()}`;
@@ -781,16 +1014,16 @@ var runStoreTck = (options) => {
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
-        expect4(await store.reset([s])).toBe(1);
+        expect5(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
-        expect4(after.find((l) => l.stream === s)).toBeDefined();
+        expect5(after.find((l) => l.stream === s)).toBeDefined();
       });
       it4("returns 0 for unknown streams and empty input", async () => {
-        expect4(await store.reset([`missing-${uid()}`])).toBe(0);
-        expect4(await store.reset([])).toBe(0);
+        expect5(await store.reset([`missing-${uid()}`])).toBe(0);
+        expect5(await store.reset([])).toBe(0);
       });
     });
-    describe4("unblock", () => {
+    describe5("unblock", () => {
       it4("clears blocked flag and preserves the watermark", async () => {
         const s = `unblock-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -809,7 +1042,7 @@ var runStoreTck = (options) => {
         await store.ack([{ ...m1, at: m1.at }]);
         const before_block = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m2 = before_block.find((l) => l.stream === s);
-        expect4(m2).toBeDefined();
+        expect5(m2).toBeDefined();
         const watermark_before = m2.at;
         await store.block([{ ...m2, error: "permanent" }]);
         let blocked_flag;
@@ -819,13 +1052,13 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, limit: 1 }
         );
-        expect4(blocked_flag).toBe(true);
-        expect4(await store.unblock([s])).toBe(1);
+        expect5(blocked_flag).toBe(true);
+        expect5(await store.unblock([s])).toBe(1);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
-        expect4(back).toBeDefined();
-        expect4(back.at).toBe(watermark_before);
-        expect4(back.retry).toBe(0);
+        expect5(back).toBeDefined();
+        expect5(back.at).toBe(watermark_before);
+        expect5(back.retry).toBe(0);
       });
       it4("returns 0 when the stream is not blocked", async () => {
         const s = `unblock-noop-${uid()}`;
@@ -835,11 +1068,11 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
-        expect4(await store.unblock([s])).toBe(0);
+        expect5(await store.unblock([s])).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);
+        expect5(await store.unblock([`missing-${uid()}`])).toBe(0);
+        expect5(await store.unblock([])).toBe(0);
       });
       it4("only counts streams that were actually blocked", async () => {
         const s1 = `unblock-mix-a-${uid()}`;
@@ -860,7 +1093,7 @@ var runStoreTck = (options) => {
         const others = leased.filter((l) => l.stream !== s1);
         await store.ack(others);
         await store.block([{ ...m1, error: "boom" }]);
-        expect4(await store.unblock([s1, s2])).toBe(1);
+        expect5(await store.unblock([s1, s2])).toBe(1);
       });
       it4("filter form: unblocks by stream pattern", async () => {
         const tag = uid();
@@ -894,11 +1127,11 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-filter-${tag}-`
         });
-        expect4(count).toBe(2);
+        expect5(count).toBe(2);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
-        expect4(after.find((l) => l.stream === s3)).toBeUndefined();
-        expect4(after.find((l) => l.stream === s1)).toBeDefined();
-        expect4(after.find((l) => l.stream === s2)).toBeDefined();
+        expect5(after.find((l) => l.stream === s3)).toBeUndefined();
+        expect5(after.find((l) => l.stream === s1)).toBeDefined();
+        expect5(after.find((l) => l.stream === s2)).toBeDefined();
       });
       it4("filter form: empty filter unblocks every blocked stream", async () => {
         const tag = uid();
@@ -924,7 +1157,7 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-empty-${tag}-`
         });
-        expect4(count).toBe(2);
+        expect5(count).toBe(2);
       });
       it4("filter form: explicit blocked:false matches nothing", async () => {
         const tag = uid();
@@ -935,7 +1168,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
-        expect4(
+        expect5(
           await store.unblock({
             stream: `^unblock-blocked-false-${tag}`,
             blocked: false
@@ -943,7 +1176,7 @@ var runStoreTck = (options) => {
         ).toBe(0);
       });
     });
-    describe4("reset filter form", () => {
+    describe5("reset filter form", () => {
       it4("resets streams matching a stream pattern", async () => {
         const tag = uid();
         const s1 = `reset-filter-${tag}-a`;
@@ -975,7 +1208,7 @@ var runStoreTck = (options) => {
         );
         await store.ack(mine.map((l) => ({ ...l, at: l.at + 100 })));
         const count = await store.reset({ stream: `^reset-filter-${tag}-` });
-        expect4(count).toBe(2);
+        expect5(count).toBe(2);
         const position_for = async (name) => {
           let at = null;
           await store.query_streams(
@@ -986,9 +1219,9 @@ var runStoreTck = (options) => {
           );
           return at;
         };
-        expect4(await position_for(s1)).toBe(-1);
-        expect4(await position_for(s2)).toBe(-1);
-        expect4(await position_for(other)).toBeGreaterThan(-1);
+        expect5(await position_for(s1)).toBe(-1);
+        expect5(await position_for(s2)).toBe(-1);
+        expect5(await position_for(other)).toBeGreaterThan(-1);
       });
       it4("filter form: resets only blocked streams when blocked:true", async () => {
         const tag = uid();
@@ -1013,10 +1246,10 @@ var runStoreTck = (options) => {
           stream: `^reset-blocked-${tag}-`,
           blocked: true
         });
-        expect4(count).toBe(1);
+        expect5(count).toBe(1);
       });
     });
-    describe4("prioritize", () => {
+    describe5("prioritize", () => {
       it4("sets priority directly, overriding subscribe's max() rule", async () => {
         const tag = uid();
         const s1 = `pri-${tag}-a`;
@@ -1029,7 +1262,7 @@ var runStoreTck = (options) => {
           { stream: s1, stream_exact: true },
           3
         );
-        expect4(updated).toBe(1);
+        expect5(updated).toBe(1);
         const got1 = {};
         const got2 = {};
         await store.query_streams(
@@ -1039,11 +1272,11 @@ var runStoreTck = (options) => {
           },
           { stream: `pri-${tag}-.*`, limit: 100 }
         );
-        expect4(got1.priority).toBe(3);
-        expect4(got2.priority).toBe(5);
+        expect5(got1.priority).toBe(3);
+        expect5(got2.priority).toBe(5);
       });
     });
-    describe4("lanes", () => {
+    describe5("lanes", () => {
       it4("subscribe defaults lane to 'default' when omitted", async () => {
         const s = `lane-default-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -1052,7 +1285,7 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect4(seen).toEqual(["default"]);
+        expect5(seen).toEqual(["default"]);
       });
       it4("subscribe records the lane passed in", async () => {
         const s = `lane-set-${uid()}`;
@@ -1062,7 +1295,7 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect4(seen).toEqual(["slow"]);
+        expect5(seen).toEqual(["slow"]);
       });
       it4("subscribe re-lanes existing streams on subsequent calls", async () => {
         const s = `lane-upsert-${uid()}`;
@@ -1073,7 +1306,7 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect4(seen).toEqual(["fast"]);
+        expect5(seen).toEqual(["fast"]);
       });
       it4("claim() filters by lane when supplied and returns lane on the Lease", async () => {
         const tag = uid();
@@ -1099,13 +1332,13 @@ var runStoreTck = (options) => {
         const slow_mine = slow.filter(
           (l) => l.stream === sub_default || l.stream === sub_slow
         );
-        expect4(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
-        expect4(slow_mine[0]?.lane).toBe("slow");
+        expect5(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
+        expect5(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 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([
+        expect5(all_mine).toEqual(
+          expect5.arrayContaining([
             { stream: sub_default, lane: "default" },
             { stream: sub_slow, lane: "slow" }
           ])
@@ -1127,7 +1360,7 @@ var runStoreTck = (options) => {
           stream: `lane-q-.*-${tag}`,
           limit: 100
         });
-        expect4(seen.sort()).toEqual([a, c]);
+        expect5(seen.sort()).toEqual([a, c]);
       });
       it4("prioritize filters by lane", async () => {
         const tag = uid();
@@ -1138,14 +1371,14 @@ var runStoreTck = (options) => {
           { stream: b, lane: `pfast-${tag}` }
         ]);
         const updated = await store.prioritize({ lane: `pslow-${tag}` }, 7);
-        expect4(updated).toBe(1);
+        expect5(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
         });
-        expect4(seen.get(a)).toBe(7);
-        expect4(seen.get(b)).toBe(0);
+        expect5(seen.get(a)).toBe(7);
+        expect5(seen.get(b)).toBe(0);
       });
       it4("reset filters by lane", async () => {
         const tag = uid();
@@ -1165,7 +1398,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}` });
-        expect4(count).toBe(1);
+        expect5(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), {
@@ -1173,8 +1406,8 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        expect4(ats.get(a)).toBe(-1);
-        expect4(ats.get(b)).toBeGreaterThanOrEqual(0);
+        expect5(ats.get(a)).toBe(-1);
+        expect5(ats.get(b)).toBeGreaterThanOrEqual(0);
       });
       it4("unblock filters by lane", async () => {
         const tag = uid();
@@ -1194,7 +1427,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}` });
-        expect4(count).toBe(1);
+        expect5(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), {
@@ -1202,11 +1435,11 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        expect4(blocked.get(a)).toBe(false);
-        expect4(blocked.get(b)).toBe(true);
+        expect5(blocked.get(a)).toBe(false);
+        expect5(blocked.get(b)).toBe(true);
       });
     });
-    describe4("truncate", () => {
+    describe5("truncate", () => {
       it4("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
         await store.commit(
@@ -1215,7 +1448,7 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const result = await store.truncate([{ stream: s }]);
-        expect4(result.get(s)?.deleted).toBe(2);
+        expect5(result.get(s)?.deleted).toBe(2);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1223,8 +1456,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect4(remaining).toHaveLength(1);
-        expect4(remaining[0].name).toBe(
+        expect5(remaining).toHaveLength(1);
+        expect5(remaining[0].name).toBe(
           "__tombstone__"
         );
       });
@@ -1238,7 +1471,7 @@ var runStoreTck = (options) => {
         const result = await store.truncate([
           { stream: s, snapshot: { count: 7 } }
         ]);
-        expect4(result.get(s)?.deleted).toBe(1);
+        expect5(result.get(s)?.deleted).toBe(1);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1246,23 +1479,23 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, with_snaps: true }
         );
-        expect4(remaining).toHaveLength(1);
-        expect4(remaining[0].name).toBe(
+        expect5(remaining).toHaveLength(1);
+        expect5(remaining[0].name).toBe(
           "__snapshot__"
         );
-        expect4(remaining[0].data).toEqual({ count: 7 });
+        expect5(remaining[0].data).toEqual({ count: 7 });
       });
       it4("returns an empty map for empty input", async () => {
         const result = await store.truncate([]);
-        expect4(result.size).toBe(0);
+        expect5(result.size).toBe(0);
       });
       it4("returns 0 deleted for streams that don't exist", async () => {
         const s = `trunc-missing-${uid()}`;
         const result = await store.truncate([{ stream: s }]);
-        expect4(result.get(s)?.deleted).toBe(0);
+        expect5(result.get(s)?.deleted).toBe(0);
       });
     });
-    describe4("query_streams", () => {
+    describe5("query_streams", () => {
       it4("returns positions filtered by stream regex, exact, source, and source_exact", async () => {
         const tag = uid();
         const proj1 = `qs-${tag}-projection-tickets`;
@@ -1282,35 +1515,35 @@ var runStoreTck = (options) => {
           (p) => all.push({ stream: p.stream, source: p.source }),
           { stream: `qs-${tag}-.*` }
         );
-        expect4(all_result.count).toBe(4);
-        expect4(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
-        expect4(all.map((p) => p.stream).sort()).toEqual(
+        expect5(all_result.count).toBe(4);
+        expect5(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
+        expect5(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-.*`
         });
-        expect4(projections.sort()).toEqual([proj1, proj2].sort());
+        expect5(projections.sort()).toEqual([proj1, proj2].sort());
         const exact = [];
         await store.query_streams((p) => exact.push(p.stream), {
           stream: dyn1,
           stream_exact: true
         });
-        expect4(exact).toEqual([dyn1]);
+        expect5(exact).toEqual([dyn1]);
         const by_source = [];
         await store.query_streams((p) => by_source.push(p.stream), {
           stream: `qs-${tag}-.*`,
           source: `qs-${tag}-src-.*`
         });
-        expect4(by_source.sort()).toEqual([dyn1, dyn2].sort());
+        expect5(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
         });
-        expect4(exact_source).toEqual([dyn2]);
+        expect5(exact_source).toEqual([dyn2]);
       });
       it4("paginates with limit + after (keyset)", async () => {
         const tag = uid();
@@ -1326,15 +1559,15 @@ var runStoreTck = (options) => {
           stream: `qp-${tag}-.*`,
           limit: 2
         });
-        expect4(page1).toHaveLength(2);
+        expect5(page1).toHaveLength(2);
         const page2 = [];
         await store.query_streams((p) => page2.push(p.stream), {
           stream: `qp-${tag}-.*`,
           limit: 2,
           after: page1.at(-1)
         });
-        expect4(page2).toHaveLength(2);
-        expect4([...page1, ...page2].sort()).toEqual([...streams].sort());
+        expect5(page2).toHaveLength(2);
+        expect5([...page1, ...page2].sort()).toEqual([...streams].sort());
       });
       it4("filters by blocked status", async () => {
         const tag = uid();
@@ -1356,17 +1589,17 @@ var runStoreTck = (options) => {
           (p) => blocked.push({ stream: p.stream, error: p.error }),
           { stream: `qb-${tag}.*`, blocked: true }
         );
-        expect4(blocked).toHaveLength(1);
-        expect4(blocked[0].error).toBe("boom");
+        expect5(blocked).toHaveLength(1);
+        expect5(blocked[0].error).toBe("boom");
         const unblocked = [];
         await store.query_streams((p) => unblocked.push(p.stream), {
           stream: `qb-${tag}.*`,
           blocked: false
         });
-        expect4(unblocked).toEqual([sibling]);
+        expect5(unblocked).toEqual([sibling]);
       });
     });
-    describe4("query_stats", () => {
+    describe5("query_stats", () => {
       it4("array input \u2014 returns head per stream, absent when not in input", async () => {
         const tag = uid();
         const sA = `qst-${tag}-a`;
@@ -1388,16 +1621,16 @@ var runStoreTck = (options) => {
           make_meta({ stream: sUnasked })
         );
         const stats = await store.query_stats([sA, sB]);
-        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);
+        expect5(stats.size).toBe(2);
+        expect5(stats.get(sA)?.head.name).toBe("Incremented");
+        expect5((stats.get(sA)?.head.data).amount).toBe(2);
+        expect5(stats.get(sB)?.head.name).toBe("Decremented");
+        expect5((stats.get(sB)?.head.data).amount).toBe(5);
+        expect5(stats.has(sUnasked)).toBe(false);
         const empty = await store.query_stats([]);
-        expect4(empty.size).toBe(0);
+        expect5(empty.size).toBe(0);
         const unknown = await store.query_stats([`qst-${tag}-missing`]);
-        expect4(unknown.size).toBe(0);
+        expect5(unknown.size).toBe(0);
       });
       it4("tail returns the earliest event per stream", async () => {
         const tag = uid();
@@ -1421,10 +1654,10 @@ var runStoreTck = (options) => {
           tail: true
         });
         const r = stats.get(s);
-        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);
+        expect5(r?.head.name).toBe("Incremented");
+        expect5((r?.head.data).amount).toBe(3);
+        expect5(r?.tail?.name).toBe("Incremented");
+        expect5((r?.tail?.data).amount).toBe(1);
       });
       it4("count + names \u2014 full aggregates including framework markers", async () => {
         const tag = uid();
@@ -1445,11 +1678,11 @@ var runStoreTck = (options) => {
           names: true
         });
         const r = stats.get(s);
-        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);
+        expect5(r?.count).toBe(4);
+        expect5(r?.names?.[SNAP_EVENT]).toBe(1);
+        expect5(r?.names?.Incremented).toBe(2);
+        expect5(r?.names?.Decremented).toBe(1);
+        expect5(r?.names?.[SNAP_EVENT]).toBe(1);
       });
       it4("exclude shifts head past filtered events; stream absent when all filtered", async () => {
         const tag = uid();
@@ -1466,21 +1699,21 @@ var runStoreTck = (options) => {
           make_meta({ stream: sAllOut })
         );
         const all = await store.query_stats([s]);
-        expect4(all.get(s)?.head.name).toBe("Incremented");
-        expect4((all.get(s)?.head.data).amount).toBe(3);
+        expect5(all.get(s)?.head.name).toBe("Incremented");
+        expect5((all.get(s)?.head.data).amount).toBe(3);
         const excl = await store.query_stats([s], {
           exclude: ["Incremented"]
         });
-        expect4(excl.get(s)?.head.name).toBe("Decremented");
-        expect4((excl.get(s)?.head.data).amount).toBe(2);
+        expect5(excl.get(s)?.head.name).toBe("Decremented");
+        expect5((excl.get(s)?.head.data).amount).toBe(2);
         const wipe = await store.query_stats([sAllOut], {
           exclude: ["Incremented", "Decremented", "Reset"]
         });
-        expect4(wipe.has(sAllOut)).toBe(false);
+        expect5(wipe.has(sAllOut)).toBe(false);
         const no_tomb = await store.query_stats([s], {
           exclude: [TOMBSTONE_EVENT]
         });
-        expect4(no_tomb.get(s)?.head.name).toBe("Incremented");
+        expect5(no_tomb.get(s)?.head.name).toBe("Incremented");
       });
       it4("before \u2014 time travel narrows head/tail/count", async () => {
         const tag = uid();
@@ -1507,13 +1740,13 @@ var runStoreTck = (options) => {
           before
         });
         const r = stats.get(s);
-        expect4(r?.count).toBe(1);
-        expect4(r?.head.id).toBe(c1[0].id);
-        expect4(r?.tail?.id).toBe(c1[0].id);
+        expect5(r?.count).toBe(1);
+        expect5(r?.head.id).toBe(c1[0].id);
+        expect5(r?.tail?.id).toBe(c1[0].id);
         const empty = await store.query_stats([s], {
           before: 0
         });
-        expect4(empty.has(s)).toBe(false);
+        expect5(empty.has(s)).toBe(false);
       });
       it4("filter form \u2014 stream regex, stream_exact, empty {} match", async () => {
         const tag = uid();
@@ -1538,16 +1771,16 @@ var runStoreTck = (options) => {
         const orders = await store.query_stats({
           stream: `^qsf-${tag}-orders-`
         });
-        expect4([...orders.keys()].sort()).toEqual([sA, sB].sort());
+        expect5([...orders.keys()].sort()).toEqual([sA, sB].sort());
         const exact = await store.query_stats({
           stream: sA,
           stream_exact: true
         });
-        expect4([...exact.keys()]).toEqual([sA]);
+        expect5([...exact.keys()]).toEqual([sA]);
         const all = await store.query_stats({
           stream: `^qsf-${tag}-`
         });
-        expect4([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
+        expect5([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
       });
       it4("compose with query_streams for subscription-level filters", async () => {
         const tag = uid();
@@ -1566,7 +1799,7 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === a);
-        expect4(mine).toBeDefined();
+        expect5(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== a);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
@@ -1575,10 +1808,10 @@ var runStoreTck = (options) => {
           stream: `^qsc-${tag}-`,
           blocked: true
         });
-        expect4(blocked_names).toEqual([a]);
+        expect5(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);
+        expect5(stats.get(a)?.head.name).toBe("Incremented");
+        expect5(stats.has(b)).toBe(false);
       });
       it4("empty filter {} \u2014 matches every event-bearing stream", async () => {
         const tag = uid();
@@ -1595,8 +1828,8 @@ var runStoreTck = (options) => {
           make_meta({ stream: b })
         );
         const all = await store.query_stats({});
-        expect4(all.has(a)).toBe(true);
-        expect4(all.has(b)).toBe(true);
+        expect5(all.has(a)).toBe(true);
+        expect5(all.has(b)).toBe(true);
       });
       it4("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
         const tag = uid();
@@ -1609,23 +1842,23 @@ var runStoreTck = (options) => {
         const c = await store.query_stats([s], {
           count: true
         });
-        expect4(c.get(s)?.count).toBe(3);
-        expect4(c.get(s)?.names).toBeUndefined();
-        expect4(c.get(s)?.tail).toBeUndefined();
+        expect5(c.get(s)?.count).toBe(3);
+        expect5(c.get(s)?.names).toBeUndefined();
+        expect5(c.get(s)?.tail).toBeUndefined();
         const n = await store.query_stats([s], {
           names: true
         });
-        expect4(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
-        expect4(n.get(s)?.count).toBeUndefined();
-        expect4(n.get(s)?.tail).toBeUndefined();
+        expect5(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
+        expect5(n.get(s)?.count).toBeUndefined();
+        expect5(n.get(s)?.tail).toBeUndefined();
         const t = await store.query_stats([s], { tail: true });
-        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();
+        expect5(t.get(s)?.tail?.name).toBe("Incremented");
+        expect5((t.get(s)?.tail?.data).amount).toBe(1);
+        expect5(t.get(s)?.count).toBeUndefined();
+        expect5(t.get(s)?.names).toBeUndefined();
       });
     });
-    describe4("query_streams anchor contract", () => {
+    describe5("query_streams anchor contract", () => {
       it4("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-inner`;
@@ -1640,7 +1873,7 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `qsr-${tag}-inner`
         });
-        expect4(seen.sort()).toEqual([inner, longer].sort());
+        expect5(seen.sort()).toEqual([inner, longer].sort());
       });
       it4("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
@@ -1651,7 +1884,7 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-anchor$`
         });
-        expect4(seen).toEqual([inner]);
+        expect5(seen).toEqual([inner]);
       });
       it4("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
@@ -1667,10 +1900,10 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-pfx-`
         });
-        expect4(seen.sort()).toEqual([a, b].sort());
+        expect5(seen.sort()).toEqual([a, b].sort());
       });
     });
-    describe4("prioritize anchor contract", () => {
+    describe5("prioritize anchor contract", () => {
       it4("caller-anchored `^name$` filter matches only the whole string", async () => {
         const tag = uid();
         const inner = `pr-${tag}-anchor`;
@@ -1683,16 +1916,16 @@ var runStoreTck = (options) => {
           { stream: `^pr-${tag}-anchor$` },
           7
         );
-        expect4(updated).toBe(1);
+        expect5(updated).toBe(1);
         const seen = /* @__PURE__ */ new Map();
         await store.query_streams((p) => seen.set(p.stream, p.priority), {
           stream: `pr-${tag}-anchor`
         });
-        expect4(seen.get(inner)).toBe(7);
-        expect4(seen.get(longer)).toBe(0);
+        expect5(seen.get(inner)).toBe(7);
+        expect5(seen.get(longer)).toBe(0);
       });
     });
-    describe4("query_streams head", () => {
+    describe5("query_streams head", () => {
       it4("maxEventId tracks the highest committed id", async () => {
         const s = `head-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -1706,34 +1939,34 @@ var runStoreTck = (options) => {
           (p) => positions.push(p.stream),
           { stream: s, stream_exact: true, limit: 1 }
         );
-        expect4(maxEventId).toBeGreaterThanOrEqual(0);
-        expect4(positions).toEqual([s]);
+        expect5(maxEventId).toBeGreaterThanOrEqual(0);
+        expect5(positions).toEqual([s]);
       });
     });
-    describe4("seed_stream helper coverage", () => {
+    describe5("seed_stream helper coverage", () => {
       it4("commits N events with monotonically increasing ids", async () => {
         const s = `seed-${uid()}`;
         const committed = await seed_stream(store, s, 3);
-        expect4(committed).toHaveLength(3);
+        expect5(committed).toHaveLength(3);
         for (let i = 1; i < committed.length; i++) {
-          expect4(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          expect5(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
     });
-    describe4.skipIf(!caps.restore)("restore (capability)", () => {
+    describe5.skipIf(!caps.restore)("restore (capability)", () => {
       beforeEach(async () => {
         await store.drop();
         await store.seed();
       });
-      const as_source = (events) => ({
+      const as_source = (events2) => ({
         async query(callback) {
-          for (const e of events)
+          for (const e of events2)
             await Promise.resolve(
               callback(
                 e
               )
             );
-          return events.length;
+          return events2.length;
         },
         async dispose() {
         }
@@ -1759,27 +1992,27 @@ var runStoreTck = (options) => {
       };
       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({
+        expect5(result.kept).toBe(0);
+        expect5(result.duration_ms).toBeGreaterThanOrEqual(0);
+        expect5(result.dropped).toEqual({
           closed_streams: 0,
           snapshots: 0
         });
-        const events = await collect(store, { limit: 10 });
-        expect4(events).toHaveLength(0);
+        const events2 = await collect(store, { limit: 10 });
+        expect5(events2).toHaveLength(0);
       });
       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");
         const t2 = /* @__PURE__ */ new Date("2020-01-03T00:00:00.000Z");
-        const events = [
+        const events2 = [
           event(1, s, 0, "Incremented", t0, { amount: 1 }),
           event(2, s, 1, "Incremented", t1, { amount: 2 }),
           event(3, s, 2, "Decremented", t2, { amount: 1 })
         ];
-        const result = await restore(as_source(events));
-        expect4(result.kept).toBe(3);
+        const result = await restore(as_source(events2));
+        expect5(result.kept).toBe(3);
         const back = [];
         await store.query(
           (e) => {
@@ -1787,8 +2020,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect4(back).toHaveLength(3);
-        expect4(
+        expect5(back).toHaveLength(3);
+        expect5(
           back.map((e) => ({
             stream: e.stream,
             version: e.version,
@@ -1824,14 +2057,14 @@ var runStoreTck = (options) => {
         const a = `restore-multi-a-${uid()}`;
         const b = `restore-multi-b-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-06-01T00:00:00.000Z");
-        const events = [
+        const events2 = [
           event(1, a, 0, "Incremented", t, { amount: 10 }),
           event(2, b, 0, "Incremented", t, { amount: 20 }),
           event(3, a, 1, "Decremented", t, { amount: 5 }),
           event(4, b, 1, "Incremented", t, { amount: 30 })
         ];
-        const result = await restore(as_source(events));
-        expect4(result.kept).toBe(4);
+        const result = await restore(as_source(events2));
+        expect5(result.kept).toBe(4);
         const aBack = [];
         const bBack = [];
         await store.query(
@@ -1846,8 +2079,8 @@ var runStoreTck = (options) => {
           },
           { stream: b, stream_exact: true }
         );
-        expect4(aBack.map((e) => e.version)).toEqual([0, 1]);
-        expect4(bBack.map((e) => e.version)).toEqual([0, 1]);
+        expect5(aBack.map((e) => e.version)).toEqual([0, 1]);
+        expect5(bBack.map((e) => e.version)).toEqual([0, 1]);
       });
       it4("preserves Date `created` verbatim", async () => {
         const s = `restore-isoc-${uid()}`;
@@ -1872,8 +2105,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect4(back).toHaveLength(1);
-        expect4(back[0].created.toISOString()).toBe(iso);
+        expect5(back).toHaveLength(1);
+        expect5(back[0].created.toISOString()).toBe(iso);
       });
       it4("wipes pre-existing events before inserting", async () => {
         const old = `restore-old-${uid()}`;
@@ -1891,12 +2124,12 @@ var runStoreTck = (options) => {
           stream: old,
           stream_exact: true
         });
-        expect4(old_back).toHaveLength(0);
+        expect5(old_back).toHaveLength(0);
         const fresh_back = await collect(store, {
           stream: fresh,
           stream_exact: true
         });
-        expect4(fresh_back).toHaveLength(1);
+        expect5(fresh_back).toHaveLength(1);
       });
       it4("clears subscription/stream-position metadata", async () => {
         const sub = `restore-sub-${uid()}`;
@@ -1909,10 +2142,10 @@ var runStoreTck = (options) => {
           return out;
         };
         const before = await collect_streams();
-        expect4(before.includes(sub)).toBe(true);
+        expect5(before.includes(sub)).toBe(true);
         await restore(as_source([]));
         const after = await collect_streams();
-        expect4(after.includes(sub)).toBe(false);
+        expect5(after.includes(sub)).toBe(false);
       });
       it4("preserves snapshot events through restore", async () => {
         const s = `restore-snap-${uid()}`;
@@ -1935,13 +2168,13 @@ var runStoreTck = (options) => {
           stream_exact: true,
           with_snaps: true
         });
-        expect4(back).toHaveLength(1);
-        expect4(back[0].name).toBe(SNAP_EVENT);
+        expect5(back).toHaveLength(1);
+        expect5(back[0].name).toBe(SNAP_EVENT);
       });
       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 = [
+        const events2 = [
           {
             id: 5,
             stream: s,
@@ -1980,7 +2213,7 @@ var runStoreTck = (options) => {
             }
           }
         ];
-        await restore(as_source(events));
+        await restore(as_source(events2));
         const back = [];
         await store.query(
           (e) => {
@@ -1988,10 +2221,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        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);
+        expect5(back).toHaveLength(3);
+        expect5(back[0].meta.causation.event).toBeUndefined();
+        expect5(back[1].meta.causation.event?.id).toBe(back[0].id);
+        expect5(back[2].meta.causation.event?.id).toBe(back[1].id);
       });
       it4("leaves causation refs unmapped when the target isn't in the source", async () => {
         const s = `restore-orphan-${uid()}`;
@@ -2021,7 +2254,7 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect4(back[0].meta.causation.event?.id).toBe(999);
+        expect5(back[0].meta.causation.event?.id).toBe(999);
       });
       it4("rolls back atomically when the source throws mid-iteration", async () => {
         const original = `restore-pre-${uid()}`;
@@ -2049,7 +2282,7 @@ var runStoreTck = (options) => {
           async dispose() {
           }
         };
-        await expect4(restore(explosive)).rejects.toThrow("boom");
+        await expect5(restore(explosive)).rejects.toThrow("boom");
         const back = [];
         await store.query(
           (e) => {
@@ -2057,8 +2290,8 @@ var runStoreTck = (options) => {
           },
           { stream: original, stream_exact: true }
         );
-        expect4(back).toHaveLength(3);
-        expect4(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        expect5(back).toHaveLength(3);
+        expect5(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
       });
       it4("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
         const s = `restore-drop-snap-${uid()}`;
@@ -2079,15 +2312,15 @@ var runStoreTck = (options) => {
           ]),
           { drop_snapshots: true }
         );
-        expect4(result.kept).toBe(2);
-        expect4(result.dropped.snapshots).toBe(1);
+        expect5(result.kept).toBe(2);
+        expect5(result.dropped.snapshots).toBe(1);
         const back = await collect(store, {
           stream: s,
           stream_exact: true,
           with_snaps: true
         });
-        expect4(back).toHaveLength(2);
-        expect4(
+        expect5(back).toHaveLength(2);
+        expect5(
           back.every((e) => e.name !== SNAP_EVENT)
         ).toBe(true);
       });
@@ -2102,10 +2335,10 @@ var runStoreTck = (options) => {
           ]),
           { on_progress: (p) => calls.push(p.processed) }
         );
-        expect4(calls).toEqual([1, 2]);
+        expect5(calls).toEqual([1, 2]);
       });
     });
-    describe4.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
+    describe5.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(
@@ -2119,8 +2352,8 @@ var runStoreTck = (options) => {
           ],
           make_meta({ stream: s })
         );
-        expect4(committed).toHaveLength(1);
-        expect4(committed[0].pii).toEqual({
+        expect5(committed).toHaveLength(1);
+        expect5(committed[0].pii).toEqual({
           email: "u@example.com",
           name: "Ursula"
         });
@@ -2131,9 +2364,9 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect4(seen).toHaveLength(1);
-        expect4(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
-        expect4(seen[0].data).toEqual({ amount: 1 });
+        expect5(seen).toHaveLength(1);
+        expect5(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
+        expect5(seen[0].data).toEqual({ amount: 1 });
       });
       it4("passes through events without pii (pii is null or undefined on load)", async () => {
         const s = `pii-none-${uid()}`;
@@ -2149,8 +2382,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect4(seen).toHaveLength(1);
-        expect4(seen[0].pii == null).toBe(true);
+        expect5(seen).toHaveLength(1);
+        expect5(seen[0].pii == null).toBe(true);
       });
       it4("wipes pii for every event on the stream via forget_pii", async () => {
         const s = `pii-forget-${uid()}`;
@@ -2171,9 +2404,9 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const forget = store.forget_pii;
-        expect4(forget).toBeDefined();
+        expect5(forget).toBeDefined();
         const wiped = await forget.call(store, s);
-        expect4(wiped).toBe(2);
+        expect5(wiped).toBe(2);
         const seen = [];
         await store.query(
           (e) => {
@@ -2181,10 +2414,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect4(seen).toHaveLength(2);
+        expect5(seen).toHaveLength(2);
         for (const e of seen) {
-          expect4(e.pii == null).toBe(true);
-          expect4(e.data).toBeDefined();
+          expect5(e.pii == null).toBe(true);
+          expect5(e.data).toBeDefined();
         }
       });
       it4("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
@@ -2202,9 +2435,9 @@ var runStoreTck = (options) => {
         );
         const forget = store.forget_pii;
         const first = await forget.call(store, s);
-        expect4(first).toBe(1);
+        expect5(first).toBe(1);
         const second = await forget.call(store, s);
-        expect4(second).toBe(0);
+        expect5(second).toBe(0);
       });
       it4("only wipes the targeted stream \u2014 siblings untouched", async () => {
         const sA = `pii-iso-a-${uid()}`;
@@ -2239,7 +2472,7 @@ var runStoreTck = (options) => {
           },
           { stream: sA, stream_exact: true }
         );
-        expect4(a[0].pii == null).toBe(true);
+        expect5(a[0].pii == null).toBe(true);
         const b = [];
         await store.query(
           (e) => {
@@ -2247,7 +2480,7 @@ var runStoreTck = (options) => {
           },
           { stream: sB, stream_exact: true }
         );
-        expect4(b[0].pii).toEqual({ email: "bob@example.com" });
+        expect5(b[0].pii).toEqual({ email: "bob@example.com" });
       });
       it4("forget_pii on a stream with no pii events returns 0", async () => {
         const s = `pii-forget-empty-${uid()}`;
@@ -2257,14 +2490,14 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const wiped = await store.forget_pii.call(store, s);
-        expect4(wiped).toBe(0);
+        expect5(wiped).toBe(0);
       });
     });
     if (caps.notify) {
-      describe4("notify (capability)", () => {
+      describe5("notify (capability)", () => {
         it4("delivers a notification when a different instance commits", async () => {
           const notify = store.notify;
-          expect4(notify).toBeDefined();
+          expect5(notify).toBeDefined();
           const received = [];
           let resolve_arrived;
           const arrived = new Promise((res) => {
@@ -2283,9 +2516,9 @@ var runStoreTck = (options) => {
               make_meta({ stream })
             );
             await arrived;
-            expect4(received.length).toBeGreaterThanOrEqual(1);
-            expect4(received[0].stream).toBe(stream);
-            expect4(received[0].events.length).toBeGreaterThanOrEqual(1);
+            expect5(received.length).toBeGreaterThanOrEqual(1);
+            expect5(received[0].stream).toBe(stream);
+            expect5(received[0].events.length).toBeGreaterThanOrEqual(1);
           } finally {
             await writer.dispose();
             await Promise.resolve(disposer());
@@ -2309,6 +2542,7 @@ export {
   runCacheTck,
   runLoggerTck,
   runStabilityTck,
+  runStorePropertyTck,
   runStoreTck,
   uid
 };