@rotorsoft/act-tck 1.13.3 → 1.14.0

package/dist/index.cjs

@@ -43,6 +43,7 @@ __export(index_exports, {
   runCacheTck: () => runCacheTck,
   runLoggerTck: () => runLoggerTck,
   runStabilityTck: () => runStabilityTck,
+  runStorePropertyTck: () => runStorePropertyTck,
   runStoreTck: () => runStoreTck,
   uid: () => uid
 });
@@ -278,40 +279,242 @@ ${content}`;
   }).join("\n");
 }
 
+// src/store-property-tck.ts
+var import_vitest4 = require("@fast-check/vitest");
+var import_vitest5 = require("vitest");
+var streamArb = import_vitest4.fc.constantFrom("s1", "s2", "s3");
+var commitArb = import_vitest4.fc.record({
+  stream: streamArb,
+  count: import_vitest4.fc.integer({ min: 1, max: 3 })
+});
+var claimStreamArb = import_vitest4.fc.constantFrom("a", "b", "c");
+var opArb = import_vitest4.fc.oneof(
+  import_vitest4.fc.record({ kind: import_vitest4.fc.constant("commit"), stream: claimStreamArb }),
+  import_vitest4.fc.record({ kind: import_vitest4.fc.constant("claim") }),
+  import_vitest4.fc.record({ kind: import_vitest4.fc.constant("ack-all") }),
+  import_vitest4.fc.record({ kind: import_vitest4.fc.constant("block-all") })
+);
+var events = (count) => Array.from({ length: count }, () => inc(1));
+var runStorePropertyTck = (options) => {
+  const numRuns = options.numRuns ?? 100;
+  (0, import_vitest5.describe)(`TCK / Store properties / ${options.name}`, () => {
+    let store;
+    (0, import_vitest5.beforeAll)(async () => {
+      store = await options.factory();
+      await store.seed();
+    });
+    (0, import_vitest5.afterAll)(async () => {
+      await store.dispose();
+    });
+    const reset2 = async () => {
+      await store.drop();
+      await store.seed();
+    };
+    (0, import_vitest5.describe)("commit version invariants", () => {
+      import_vitest4.test.prop([import_vitest4.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) => {
+              (0, import_vitest5.expect)(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) => {
+              (0, import_vitest5.expect)(e.version).toBe(i);
+            });
+          }
+        }
+      );
+      import_vitest4.test.prop([import_vitest4.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 (0, import_vitest5.expect)(
+            store.commit(
+              stream,
+              [inc(1)],
+              make_meta({ stream }),
+              before.length
+            )
+          ).rejects.toThrow();
+          const after = await collect(store, { stream, stream_exact: true });
+          (0, import_vitest5.expect)(after.length).toBe(before.length);
+        }
+      );
+    });
+    (0, import_vitest5.describe)("claim/lease lifecycle invariants", () => {
+      import_vitest4.test.prop([import_vitest4.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)
+              );
+            }
+          }
+          (0, import_vitest5.expect)(totalResolved + pending.length).toBe(totalClaims);
+        }
+      );
+      import_vitest4.test.prop(
+        [
+          import_vitest4.fc.array(claimStreamArb, { minLength: 1, maxLength: 5 }),
+          import_vitest4.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) {
+            (0, import_vitest5.expect)(lease.at).toBeGreaterThanOrEqual(
+              watermark1.get(lease.stream)
+            );
+          }
+        }
+      );
+      import_vitest4.test.prop([import_vitest4.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) (0, import_vitest5.expect)(blockedSet.has(l.stream)).toBe(false);
+      });
+    });
+  });
+};
+
 // src/store-tck.ts
 var import_act = require("@rotorsoft/act");
-var import_vitest4 = require("vitest");
+var import_vitest6 = require("vitest");
 var runStoreTck = (options) => {
-  (0, import_vitest4.describe)(`TCK / Store / ${options.name}`, () => {
+  (0, import_vitest6.describe)(`TCK / Store / ${options.name}`, () => {
     let store;
     const caps = { ...options.capabilities };
-    (0, import_vitest4.beforeAll)(async () => {
+    (0, import_vitest6.beforeAll)(async () => {
       store = await options.factory();
       await store.drop();
       await store.seed();
     });
-    (0, import_vitest4.afterAll)(async () => {
+    (0, import_vitest6.afterAll)(async () => {
       await store.dispose();
     });
-    (0, import_vitest4.describe)("commit", () => {
-      (0, import_vitest4.it)("returns committed events with sequenced ids and versions", async () => {
+    (0, import_vitest6.describe)("commit", () => {
+      (0, import_vitest6.it)("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)],
           make_meta({ stream: s })
         );
-        (0, import_vitest4.expect)(committed).toHaveLength(3);
-        (0, import_vitest4.expect)(committed[0].version).toBe(0);
-        (0, import_vitest4.expect)(committed[1].version).toBe(1);
-        (0, import_vitest4.expect)(committed[2].version).toBe(2);
-        (0, import_vitest4.expect)(committed[0].name).toBe("Incremented");
-        (0, import_vitest4.expect)(committed[2].data).toEqual({ amount: 3 });
+        (0, import_vitest6.expect)(committed).toHaveLength(3);
+        (0, import_vitest6.expect)(committed[0].version).toBe(0);
+        (0, import_vitest6.expect)(committed[1].version).toBe(1);
+        (0, import_vitest6.expect)(committed[2].version).toBe(2);
+        (0, import_vitest6.expect)(committed[0].name).toBe("Incremented");
+        (0, import_vitest6.expect)(committed[2].data).toEqual({ amount: 3 });
         for (let i = 1; i < committed.length; i++) {
-          (0, import_vitest4.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          (0, import_vitest6.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
-      (0, import_vitest4.it)("attaches correlation and stream metadata", async () => {
+      (0, import_vitest6.it)("attaches correlation and stream metadata", async () => {
         const s = `commit-meta-${uid()}`;
         const correlation = `cor-${uid()}`;
         const committed = await store.commit(
@@ -319,10 +522,10 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s, correlation })
         );
-        (0, import_vitest4.expect)(committed[0].stream).toBe(s);
-        (0, import_vitest4.expect)(committed[0].meta.correlation).toBe(correlation);
+        (0, import_vitest6.expect)(committed[0].stream).toBe(s);
+        (0, import_vitest6.expect)(committed[0].meta.correlation).toBe(correlation);
       });
-      (0, import_vitest4.it)("throws ConcurrencyError when expectedVersion is wrong", async () => {
+      (0, import_vitest6.it)("throws ConcurrencyError when expectedVersion is wrong", async () => {
         const s = `commit-cc-${uid()}`;
         await store.commit(
           s,
@@ -335,26 +538,26 @@ var runStoreTck = (options) => {
           make_meta({ stream: s }),
           0
         );
-        await (0, import_vitest4.expect)(
+        await (0, import_vitest6.expect)(
           store.commit(s, [inc(1)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(import_act.ConcurrencyError);
       });
-      (0, import_vitest4.it)("preserves prior events when a concurrent commit is rejected", async () => {
+      (0, import_vitest6.it)("preserves prior events when a concurrent commit is rejected", async () => {
         const s = `commit-cc-preserve-${uid()}`;
         await store.commit(
           s,
           [inc(1), inc(2)],
           make_meta({ stream: s })
         );
-        await (0, import_vitest4.expect)(
+        await (0, import_vitest6.expect)(
           store.commit(s, [inc(3)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(import_act.ConcurrencyError);
         const found = await collect(store, { stream: s, stream_exact: true });
-        (0, import_vitest4.expect)(found).toHaveLength(2);
+        (0, import_vitest6.expect)(found).toHaveLength(2);
       });
     });
-    (0, import_vitest4.describe)("query", () => {
-      (0, import_vitest4.it)("filters by stream, names, correlation, limit, with_snaps", async () => {
+    (0, import_vitest6.describe)("query", () => {
+      (0, import_vitest6.it)("filters by stream, names, correlation, limit, with_snaps", async () => {
         const s1 = `q-s1-${uid()}`;
         const s2 = `q-s2-${uid()}`;
         const cor = `q-cor-${uid()}`;
@@ -372,23 +575,23 @@ var runStoreTck = (options) => {
           stream: s1,
           stream_exact: true
         });
-        (0, import_vitest4.expect)(by_stream).toHaveLength(2);
+        (0, import_vitest6.expect)(by_stream).toHaveLength(2);
         const by_name = await collect(store, {
           stream: s2,
           stream_exact: true,
           names: ["Reset"]
         });
-        (0, import_vitest4.expect)(by_name).toHaveLength(1);
-        (0, import_vitest4.expect)(by_name[0].name).toBe("Reset");
+        (0, import_vitest6.expect)(by_name).toHaveLength(1);
+        (0, import_vitest6.expect)(by_name[0].name).toBe("Reset");
         const by_correlation = await collect(store, { correlation: cor });
-        (0, import_vitest4.expect)(by_correlation).toHaveLength(5);
+        (0, import_vitest6.expect)(by_correlation).toHaveLength(5);
         const limited = await collect(store, {
           correlation: cor,
           limit: 2
         });
-        (0, import_vitest4.expect)(limited).toHaveLength(2);
+        (0, import_vitest6.expect)(limited).toHaveLength(2);
       });
-      (0, import_vitest4.it)("supports backward traversal", async () => {
+      (0, import_vitest6.it)("supports backward traversal", async () => {
         const s = `q-back-${uid()}`;
         const committed = await store.commit(
           s,
@@ -401,8 +604,8 @@ var runStoreTck = (options) => {
           stream_exact: true,
           backward: true
         });
-        (0, import_vitest4.expect)(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
-        (0, import_vitest4.expect)(backward.map((e) => e.id)).toEqual(
+        (0, import_vitest6.expect)(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        (0, import_vitest6.expect)(backward.map((e) => e.id)).toEqual(
           [...committed].reverse().map((c) => c.id)
         );
         const latest = await collect(store, {
@@ -411,10 +614,10 @@ var runStoreTck = (options) => {
           backward: true,
           limit: 1
         });
-        (0, import_vitest4.expect)(latest).toHaveLength(1);
-        (0, import_vitest4.expect)(latest[0].id).toBe(committed.at(-1).id);
+        (0, import_vitest6.expect)(latest).toHaveLength(1);
+        (0, import_vitest6.expect)(latest[0].id).toBe(committed.at(-1).id);
       });
-      (0, import_vitest4.it)("after/before bound the id range", async () => {
+      (0, import_vitest6.it)("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
         const committed = await store.commit(
           s,
@@ -426,7 +629,7 @@ var runStoreTck = (options) => {
           stream_exact: true,
           after: committed[0].id
         });
-        (0, import_vitest4.expect)(after_first.map((e) => e.id)).toEqual(
+        (0, import_vitest6.expect)(after_first.map((e) => e.id)).toEqual(
           committed.slice(1).map((c) => c.id)
         );
         const before_last = await collect(store, {
@@ -434,11 +637,11 @@ var runStoreTck = (options) => {
           stream_exact: true,
           before: committed[committed.length - 1].id
         });
-        (0, import_vitest4.expect)(before_last.map((e) => e.id)).toEqual(
+        (0, import_vitest6.expect)(before_last.map((e) => e.id)).toEqual(
           committed.slice(0, -1).map((c) => c.id)
         );
       });
-      (0, import_vitest4.it)("created_after/created_before filter by timestamp", async () => {
+      (0, import_vitest6.it)("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);
@@ -453,15 +656,15 @@ var runStoreTck = (options) => {
           created_after: before,
           created_before: future
         });
-        (0, import_vitest4.expect)(in_window.length).toBe(1);
+        (0, import_vitest6.expect)(in_window.length).toBe(1);
         const out_of_window = await collect(store, {
           stream: s,
           stream_exact: true,
           created_after: future
         });
-        (0, import_vitest4.expect)(out_of_window.length).toBe(0);
+        (0, import_vitest6.expect)(out_of_window.length).toBe(0);
       });
-      (0, import_vitest4.it)("backward traversal short-circuits at `after` id boundary", async () => {
+      (0, import_vitest6.it)("backward traversal short-circuits at `after` id boundary", async () => {
         const s = `q-back-after-${uid()}`;
         const committed = await store.commit(
           s,
@@ -474,12 +677,12 @@ var runStoreTck = (options) => {
           backward: true,
           after: committed[0].id
         });
-        (0, import_vitest4.expect)(got.map((e) => e.id)).toEqual([
+        (0, import_vitest6.expect)(got.map((e) => e.id)).toEqual([
           committed[2].id,
           committed[1].id
         ]);
       });
-      (0, import_vitest4.it)("backward traversal short-circuits at `created_after` boundary", async () => {
+      (0, import_vitest6.it)("backward traversal short-circuits at `created_after` boundary", async () => {
         const s = `q-back-cafter-${uid()}`;
         await store.commit(
           s,
@@ -493,9 +696,9 @@ var runStoreTck = (options) => {
           backward: true,
           created_after: future
         });
-        (0, import_vitest4.expect)(got).toHaveLength(0);
+        (0, import_vitest6.expect)(got).toHaveLength(0);
       });
-      (0, import_vitest4.it)("backward traversal honors created_before by skipping newer events", async () => {
+      (0, import_vitest6.it)("backward traversal honors created_before by skipping newer events", async () => {
         const s = `q-back-ts-${uid()}`;
         await store.commit(s, [inc(1)], make_meta());
         const past = new Date(Date.now() - 6e4);
@@ -505,9 +708,9 @@ var runStoreTck = (options) => {
           backward: true,
           created_before: past
         });
-        (0, import_vitest4.expect)(got).toHaveLength(0);
+        (0, import_vitest6.expect)(got).toHaveLength(0);
       });
-      (0, import_vitest4.it)("stream_exact disables regex matching", async () => {
+      (0, import_vitest6.it)("stream_exact disables regex matching", async () => {
         const tag = uid();
         const a = `q-exact-${tag}`;
         const b = `q-exact-${tag}-extra`;
@@ -522,10 +725,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: b })
         );
         const exact = await collect(store, { stream: a, stream_exact: true });
-        (0, import_vitest4.expect)(exact).toHaveLength(1);
-        (0, import_vitest4.expect)(exact[0].data).toEqual({ amount: 1 });
+        (0, import_vitest6.expect)(exact).toHaveLength(1);
+        (0, import_vitest6.expect)(exact[0].data).toEqual({ amount: 1 });
       });
-      (0, import_vitest4.it)("plain regex without anchors is a substring match", async () => {
+      (0, import_vitest6.it)("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qr-${tag}-inner`;
         const longer = `qr-${tag}-inner-extra`;
@@ -540,9 +743,9 @@ var runStoreTck = (options) => {
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `qr-${tag}-inner` });
-        (0, import_vitest4.expect)(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
+        (0, import_vitest6.expect)(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
       });
-      (0, import_vitest4.it)("caller-anchored `^name$` matches only the whole string", async () => {
+      (0, import_vitest6.it)("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qr-${tag}-anchor`;
         const longer = `qr-${tag}-anchor-extra`;
@@ -557,10 +760,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `^qr-${tag}-anchor$` });
-        (0, import_vitest4.expect)(got).toHaveLength(1);
-        (0, import_vitest4.expect)(got[0].stream).toBe(inner);
+        (0, import_vitest6.expect)(got).toHaveLength(1);
+        (0, import_vitest6.expect)(got[0].stream).toBe(inner);
       });
-      (0, import_vitest4.it)("caller-anchored `^prefix` matches by prefix", async () => {
+      (0, import_vitest6.it)("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qr-${tag}-pfx-a`;
         const b = `qr-${tag}-pfx-b`;
@@ -581,18 +784,18 @@ var runStoreTck = (options) => {
           make_meta({ stream: other })
         );
         const got = await collect(store, { stream: `^qr-${tag}-pfx-` });
-        (0, import_vitest4.expect)(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
+        (0, import_vitest6.expect)(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
       });
     });
-    (0, import_vitest4.describe)("subscribe + claim + ack", () => {
-      (0, import_vitest4.it)("subscribes new streams and is idempotent on repeat", async () => {
+    (0, import_vitest6.describe)("subscribe + claim + ack", () => {
+      (0, import_vitest6.it)("subscribes new streams and is idempotent on repeat", async () => {
         const s = `sub-${uid()}`;
         const first = await store.subscribe([{ stream: s }]);
-        (0, import_vitest4.expect)(first.subscribed).toBe(1);
+        (0, import_vitest6.expect)(first.subscribed).toBe(1);
         const second = await store.subscribe([{ stream: s }]);
-        (0, import_vitest4.expect)(second.subscribed).toBe(0);
+        (0, import_vitest6.expect)(second.subscribed).toBe(0);
       });
-      (0, import_vitest4.it)("claims a subscribed stream and ack releases the lease", async () => {
+      (0, import_vitest6.it)("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -603,11 +806,11 @@ var runStoreTck = (options) => {
         const by = `worker-${uid()}`;
         const leased = await store.claim(100, 0, by, 1e4);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest4.expect)(mine).toBeDefined();
-        (0, import_vitest4.expect)(mine.by).toBe(by);
+        (0, import_vitest6.expect)(mine).toBeDefined();
+        (0, import_vitest6.expect)(mine.by).toBe(by);
         await store.ack([{ ...mine, at: mine.at + 1 }]);
       });
-      (0, import_vitest4.it)("does not double-claim a held lease", async () => {
+      (0, import_vitest6.it)("does not double-claim a held lease", async () => {
         const s = `claim-held-${uid()}`;
         const other = `claim-other-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -618,7 +821,7 @@ var runStoreTck = (options) => {
         );
         const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1e5);
         const targetA = leasedA.find((l) => l.stream === s);
-        (0, import_vitest4.expect)(targetA).toBeDefined();
+        (0, import_vitest6.expect)(targetA).toBeDefined();
         await store.subscribe([{ stream: other }]);
         await store.commit(
           other,
@@ -626,11 +829,11 @@ var runStoreTck = (options) => {
           make_meta({ stream: other })
         );
         const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
-        (0, import_vitest4.expect)(leasedB.length).toBeGreaterThan(0);
-        (0, import_vitest4.expect)(leasedB.find((l) => l.stream === s)).toBeUndefined();
-        (0, import_vitest4.expect)(leasedB.find((l) => l.stream === other)).toBeDefined();
+        (0, import_vitest6.expect)(leasedB.length).toBeGreaterThan(0);
+        (0, import_vitest6.expect)(leasedB.find((l) => l.stream === s)).toBeUndefined();
+        (0, import_vitest6.expect)(leasedB.find((l) => l.stream === other)).toBeDefined();
       });
-      (0, import_vitest4.it)("supports dual frontiers (lagging + leading)", async () => {
+      (0, import_vitest6.it)("supports dual frontiers (lagging + leading)", async () => {
         const s = `claim-dual-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -640,12 +843,12 @@ var runStoreTck = (options) => {
         );
         const first = await store.claim(100, 0, `w-${uid()}`, 1);
         const mine = first.find((l) => l.stream === s);
-        (0, import_vitest4.expect)(mine).toBeDefined();
+        (0, import_vitest6.expect)(mine).toBeDefined();
         await store.ack([{ ...mine, at: mine.at + 1 }]);
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
-        (0, import_vitest4.expect)(second.find((l) => l.stream === s)).toBeDefined();
+        (0, import_vitest6.expect)(second.find((l) => l.stream === s)).toBeDefined();
       });
-      (0, import_vitest4.it)("dedupes when both frontiers would return the same stream", async () => {
+      (0, import_vitest6.it)("dedupes when both frontiers would return the same stream", async () => {
         const s = `claim-dedup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -655,9 +858,9 @@ var runStoreTck = (options) => {
         );
         const claimed = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const matches = claimed.filter((l) => l.stream === s);
-        (0, import_vitest4.expect)(matches).toHaveLength(1);
+        (0, import_vitest6.expect)(matches).toHaveLength(1);
       });
-      (0, import_vitest4.it)("silently ignores ack from the wrong holder", async () => {
+      (0, import_vitest6.it)("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 }]);
@@ -674,40 +877,40 @@ 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);
-        (0, import_vitest4.expect)(mine).toBeDefined();
-        (0, import_vitest4.expect)(sibling_lease).toBeDefined();
+        (0, import_vitest6.expect)(mine).toBeDefined();
+        (0, import_vitest6.expect)(sibling_lease).toBeDefined();
         const acked = await store.ack([
           { ...mine, by: "imposter" },
           sibling_lease
         ]);
-        (0, import_vitest4.expect)(acked.length).toBeGreaterThan(0);
-        (0, import_vitest4.expect)(acked.find((l) => l.stream === s)).toBeUndefined();
+        (0, import_vitest6.expect)(acked.length).toBeGreaterThan(0);
+        (0, import_vitest6.expect)(acked.find((l) => l.stream === s)).toBeUndefined();
       });
-      (0, import_vitest4.it)("ack with a stale (lower) watermark does not throw", async () => {
+      (0, import_vitest6.it)("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);
-        (0, import_vitest4.expect)(mine).toBeDefined();
-        await (0, import_vitest4.expect)(
+        (0, import_vitest6.expect)(mine).toBeDefined();
+        await (0, import_vitest6.expect)(
           store.ack([{ ...mine, at: -5 }])
         ).resolves.toBeDefined();
       });
-      (0, import_vitest4.it)("claim with no subscribed streams returns an empty array", async () => {
+      (0, import_vitest6.it)("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);
-          (0, import_vitest4.expect)(claimed).toEqual([]);
+          (0, import_vitest6.expect)(claimed).toEqual([]);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    (0, import_vitest4.describe)("lease semantics", () => {
-      (0, import_vitest4.it)("returns retry=0 on first claim and increments on re-claim without ack", async () => {
+    (0, import_vitest6.describe)("lease semantics", () => {
+      (0, import_vitest6.it)("returns retry=0 on first claim and increments on re-claim without ack", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -721,17 +924,17 @@ var runStoreTck = (options) => {
           );
           const first = await fresh.claim(1, 0, `w-${uid()}`, 0);
           const f = first.find((l) => l.stream === s);
-          (0, import_vitest4.expect)(f).toBeDefined();
-          (0, import_vitest4.expect)(f.retry).toBe(0);
+          (0, import_vitest6.expect)(f).toBeDefined();
+          (0, import_vitest6.expect)(f.retry).toBe(0);
           const second = await fresh.claim(1, 0, `w-${uid()}`, 1e5);
           const sec = second.find((l) => l.stream === s);
-          (0, import_vitest4.expect)(sec).toBeDefined();
-          (0, import_vitest4.expect)(sec.retry).toBe(1);
+          (0, import_vitest6.expect)(sec).toBeDefined();
+          (0, import_vitest6.expect)(sec.retry).toBe(1);
         } finally {
           await fresh.dispose();
         }
       });
-      (0, import_vitest4.it)("reports lagging=true from the lagging frontier and false from the leading frontier", async () => {
+      (0, import_vitest6.it)("reports lagging=true from the lagging frontier and false from the leading frontier", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -744,16 +947,47 @@ var runStoreTck = (options) => {
             make_meta({ stream: s })
           );
           const lag = await fresh.claim(1, 0, `w-${uid()}`, 0);
-          (0, import_vitest4.expect)(lag.find((l) => l.stream === s)?.lagging).toBe(true);
+          (0, import_vitest6.expect)(lag.find((l) => l.stream === s)?.lagging).toBe(true);
           const lead = await fresh.claim(0, 1, `w-${uid()}`, 1e5);
-          (0, import_vitest4.expect)(lead.find((l) => l.stream === s)?.lagging).toBe(false);
+          (0, import_vitest6.expect)(lead.find((l) => l.stream === s)?.lagging).toBe(false);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+    });
+    import_vitest6.describe.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
+      (0, import_vitest6.it)("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));
+          (0, import_vitest6.expect)(new Set(claimed).size).toBe(claimed.length);
+          (0, import_vitest6.expect)(claimed.length).toBe(owned.size);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    (0, import_vitest4.describe)("block", () => {
-      (0, import_vitest4.it)("hides blocked streams from claim", async () => {
+    (0, import_vitest6.describe)("block", () => {
+      (0, import_vitest6.it)("hides blocked streams from claim", async () => {
         const s = `block-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -763,18 +997,18 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest4.expect)(mine).toBeDefined();
+        (0, import_vitest6.expect)(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         const blocked = await store.block([
           { ...mine, error: "boom" }
         ]);
-        (0, import_vitest4.expect)(blocked).toHaveLength(1);
-        (0, import_vitest4.expect)(blocked[0].error).toBe("boom");
+        (0, import_vitest6.expect)(blocked).toHaveLength(1);
+        (0, import_vitest6.expect)(blocked[0].error).toBe("boom");
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
-        (0, import_vitest4.expect)(again.find((l) => l.stream === s)).toBeUndefined();
+        (0, import_vitest6.expect)(again.find((l) => l.stream === s)).toBeUndefined();
       });
-      (0, import_vitest4.it)("rejects block calls from a different holder", async () => {
+      (0, import_vitest6.it)("rejects block calls from a different holder", async () => {
         const s = `block-wrong-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -784,17 +1018,17 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest4.expect)(mine).toBeDefined();
+        (0, import_vitest6.expect)(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         const blocked = await store.block([
           { ...mine, by: "imposter", error: "no" }
         ]);
-        (0, import_vitest4.expect)(blocked).toHaveLength(0);
+        (0, import_vitest6.expect)(blocked).toHaveLength(0);
       });
     });
-    (0, import_vitest4.describe)("reset", () => {
-      (0, import_vitest4.it)("rewinds a stream watermark to -1", async () => {
+    (0, import_vitest6.describe)("reset", () => {
+      (0, import_vitest6.it)("rewinds a stream watermark to -1", async () => {
         const s = `reset-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -804,15 +1038,15 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest4.expect)(mine).toBeDefined();
+        (0, import_vitest6.expect)(mine).toBeDefined();
         await store.ack([{ ...mine, at: 99 }]);
-        (0, import_vitest4.expect)(await store.reset([s])).toBe(1);
+        (0, import_vitest6.expect)(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
-        (0, import_vitest4.expect)(back).toBeDefined();
-        (0, import_vitest4.expect)(back.at).toBe(-1);
+        (0, import_vitest6.expect)(back).toBeDefined();
+        (0, import_vitest6.expect)(back.at).toBe(-1);
       });
-      (0, import_vitest4.it)("clears blocked status when resetting", async () => {
+      (0, import_vitest6.it)("clears blocked status when resetting", async () => {
         const s = `reset-blk-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -825,17 +1059,17 @@ var runStoreTck = (options) => {
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
-        (0, import_vitest4.expect)(await store.reset([s])).toBe(1);
+        (0, import_vitest6.expect)(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
-        (0, import_vitest4.expect)(after.find((l) => l.stream === s)).toBeDefined();
+        (0, import_vitest6.expect)(after.find((l) => l.stream === s)).toBeDefined();
       });
-      (0, import_vitest4.it)("returns 0 for unknown streams and empty input", async () => {
-        (0, import_vitest4.expect)(await store.reset([`missing-${uid()}`])).toBe(0);
-        (0, import_vitest4.expect)(await store.reset([])).toBe(0);
+      (0, import_vitest6.it)("returns 0 for unknown streams and empty input", async () => {
+        (0, import_vitest6.expect)(await store.reset([`missing-${uid()}`])).toBe(0);
+        (0, import_vitest6.expect)(await store.reset([])).toBe(0);
       });
     });
-    (0, import_vitest4.describe)("unblock", () => {
-      (0, import_vitest4.it)("clears blocked flag and preserves the watermark", async () => {
+    (0, import_vitest6.describe)("unblock", () => {
+      (0, import_vitest6.it)("clears blocked flag and preserves the watermark", async () => {
         const s = `unblock-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -853,7 +1087,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);
-        (0, import_vitest4.expect)(m2).toBeDefined();
+        (0, import_vitest6.expect)(m2).toBeDefined();
         const watermark_before = m2.at;
         await store.block([{ ...m2, error: "permanent" }]);
         let blocked_flag;
@@ -863,15 +1097,15 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, limit: 1 }
         );
-        (0, import_vitest4.expect)(blocked_flag).toBe(true);
-        (0, import_vitest4.expect)(await store.unblock([s])).toBe(1);
+        (0, import_vitest6.expect)(blocked_flag).toBe(true);
+        (0, import_vitest6.expect)(await store.unblock([s])).toBe(1);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
-        (0, import_vitest4.expect)(back).toBeDefined();
-        (0, import_vitest4.expect)(back.at).toBe(watermark_before);
-        (0, import_vitest4.expect)(back.retry).toBe(0);
+        (0, import_vitest6.expect)(back).toBeDefined();
+        (0, import_vitest6.expect)(back.at).toBe(watermark_before);
+        (0, import_vitest6.expect)(back.retry).toBe(0);
       });
-      (0, import_vitest4.it)("returns 0 when the stream is not blocked", async () => {
+      (0, import_vitest6.it)("returns 0 when the stream is not blocked", async () => {
         const s = `unblock-noop-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -879,13 +1113,13 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
-        (0, import_vitest4.expect)(await store.unblock([s])).toBe(0);
+        (0, import_vitest6.expect)(await store.unblock([s])).toBe(0);
       });
-      (0, import_vitest4.it)("returns 0 for unknown streams and empty input", async () => {
-        (0, import_vitest4.expect)(await store.unblock([`missing-${uid()}`])).toBe(0);
-        (0, import_vitest4.expect)(await store.unblock([])).toBe(0);
+      (0, import_vitest6.it)("returns 0 for unknown streams and empty input", async () => {
+        (0, import_vitest6.expect)(await store.unblock([`missing-${uid()}`])).toBe(0);
+        (0, import_vitest6.expect)(await store.unblock([])).toBe(0);
       });
-      (0, import_vitest4.it)("only counts streams that were actually blocked", async () => {
+      (0, import_vitest6.it)("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 }]);
@@ -904,9 +1138,9 @@ var runStoreTck = (options) => {
         const others = leased.filter((l) => l.stream !== s1);
         await store.ack(others);
         await store.block([{ ...m1, error: "boom" }]);
-        (0, import_vitest4.expect)(await store.unblock([s1, s2])).toBe(1);
+        (0, import_vitest6.expect)(await store.unblock([s1, s2])).toBe(1);
       });
-      (0, import_vitest4.it)("filter form: unblocks by stream pattern", async () => {
+      (0, import_vitest6.it)("filter form: unblocks by stream pattern", async () => {
         const tag = uid();
         const s1 = `unblock-filter-${tag}-a`;
         const s2 = `unblock-filter-${tag}-b`;
@@ -938,13 +1172,13 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-filter-${tag}-`
         });
-        (0, import_vitest4.expect)(count).toBe(2);
+        (0, import_vitest6.expect)(count).toBe(2);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
-        (0, import_vitest4.expect)(after.find((l) => l.stream === s3)).toBeUndefined();
-        (0, import_vitest4.expect)(after.find((l) => l.stream === s1)).toBeDefined();
-        (0, import_vitest4.expect)(after.find((l) => l.stream === s2)).toBeDefined();
+        (0, import_vitest6.expect)(after.find((l) => l.stream === s3)).toBeUndefined();
+        (0, import_vitest6.expect)(after.find((l) => l.stream === s1)).toBeDefined();
+        (0, import_vitest6.expect)(after.find((l) => l.stream === s2)).toBeDefined();
       });
-      (0, import_vitest4.it)("filter form: empty filter unblocks every blocked stream", async () => {
+      (0, import_vitest6.it)("filter form: empty filter unblocks every blocked stream", async () => {
         const tag = uid();
         const s1 = `unblock-empty-${tag}-a`;
         const s2 = `unblock-empty-${tag}-b`;
@@ -968,9 +1202,9 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-empty-${tag}-`
         });
-        (0, import_vitest4.expect)(count).toBe(2);
+        (0, import_vitest6.expect)(count).toBe(2);
       });
-      (0, import_vitest4.it)("filter form: explicit blocked:false matches nothing", async () => {
+      (0, import_vitest6.it)("filter form: explicit blocked:false matches nothing", async () => {
         const tag = uid();
         const s = `unblock-blocked-false-${tag}`;
         await store.subscribe([{ stream: s }]);
@@ -979,7 +1213,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
-        (0, import_vitest4.expect)(
+        (0, import_vitest6.expect)(
           await store.unblock({
             stream: `^unblock-blocked-false-${tag}`,
             blocked: false
@@ -987,8 +1221,8 @@ var runStoreTck = (options) => {
         ).toBe(0);
       });
     });
-    (0, import_vitest4.describe)("reset filter form", () => {
-      (0, import_vitest4.it)("resets streams matching a stream pattern", async () => {
+    (0, import_vitest6.describe)("reset filter form", () => {
+      (0, import_vitest6.it)("resets streams matching a stream pattern", async () => {
         const tag = uid();
         const s1 = `reset-filter-${tag}-a`;
         const s2 = `reset-filter-${tag}-b`;
@@ -1019,7 +1253,7 @@ var runStoreTck = (options) => {
         );
         await store.ack(mine.map((l) => ({ ...l, at: l.at + 100 })));
         const count = await store.reset({ stream: `^reset-filter-${tag}-` });
-        (0, import_vitest4.expect)(count).toBe(2);
+        (0, import_vitest6.expect)(count).toBe(2);
         const position_for = async (name) => {
           let at = null;
           await store.query_streams(
@@ -1030,11 +1264,11 @@ var runStoreTck = (options) => {
           );
           return at;
         };
-        (0, import_vitest4.expect)(await position_for(s1)).toBe(-1);
-        (0, import_vitest4.expect)(await position_for(s2)).toBe(-1);
-        (0, import_vitest4.expect)(await position_for(other)).toBeGreaterThan(-1);
+        (0, import_vitest6.expect)(await position_for(s1)).toBe(-1);
+        (0, import_vitest6.expect)(await position_for(s2)).toBe(-1);
+        (0, import_vitest6.expect)(await position_for(other)).toBeGreaterThan(-1);
       });
-      (0, import_vitest4.it)("filter form: resets only blocked streams when blocked:true", async () => {
+      (0, import_vitest6.it)("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`;
@@ -1057,11 +1291,11 @@ var runStoreTck = (options) => {
           stream: `^reset-blocked-${tag}-`,
           blocked: true
         });
-        (0, import_vitest4.expect)(count).toBe(1);
+        (0, import_vitest6.expect)(count).toBe(1);
       });
     });
-    (0, import_vitest4.describe)("prioritize", () => {
-      (0, import_vitest4.it)("sets priority directly, overriding subscribe's max() rule", async () => {
+    (0, import_vitest6.describe)("prioritize", () => {
+      (0, import_vitest6.it)("sets priority directly, overriding subscribe's max() rule", async () => {
         const tag = uid();
         const s1 = `pri-${tag}-a`;
         const s2 = `pri-${tag}-b`;
@@ -1073,7 +1307,7 @@ var runStoreTck = (options) => {
           { stream: s1, stream_exact: true },
           3
         );
-        (0, import_vitest4.expect)(updated).toBe(1);
+        (0, import_vitest6.expect)(updated).toBe(1);
         const got1 = {};
         const got2 = {};
         await store.query_streams(
@@ -1083,12 +1317,12 @@ var runStoreTck = (options) => {
           },
           { stream: `pri-${tag}-.*`, limit: 100 }
         );
-        (0, import_vitest4.expect)(got1.priority).toBe(3);
-        (0, import_vitest4.expect)(got2.priority).toBe(5);
+        (0, import_vitest6.expect)(got1.priority).toBe(3);
+        (0, import_vitest6.expect)(got2.priority).toBe(5);
       });
     });
-    (0, import_vitest4.describe)("lanes", () => {
-      (0, import_vitest4.it)("subscribe defaults lane to 'default' when omitted", async () => {
+    (0, import_vitest6.describe)("lanes", () => {
+      (0, import_vitest6.it)("subscribe defaults lane to 'default' when omitted", async () => {
         const s = `lane-default-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const seen = [];
@@ -1096,9 +1330,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest4.expect)(seen).toEqual(["default"]);
+        (0, import_vitest6.expect)(seen).toEqual(["default"]);
       });
-      (0, import_vitest4.it)("subscribe records the lane passed in", async () => {
+      (0, import_vitest6.it)("subscribe records the lane passed in", async () => {
         const s = `lane-set-${uid()}`;
         await store.subscribe([{ stream: s, lane: "slow" }]);
         const seen = [];
@@ -1106,9 +1340,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest4.expect)(seen).toEqual(["slow"]);
+        (0, import_vitest6.expect)(seen).toEqual(["slow"]);
       });
-      (0, import_vitest4.it)("subscribe re-lanes existing streams on subsequent calls", async () => {
+      (0, import_vitest6.it)("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" }]);
@@ -1117,9 +1351,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest4.expect)(seen).toEqual(["fast"]);
+        (0, import_vitest6.expect)(seen).toEqual(["fast"]);
       });
-      (0, import_vitest4.it)("claim() filters by lane when supplied and returns lane on the Lease", async () => {
+      (0, import_vitest6.it)("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}`;
@@ -1143,19 +1377,19 @@ var runStoreTck = (options) => {
         const slow_mine = slow.filter(
           (l) => l.stream === sub_default || l.stream === sub_slow
         );
-        (0, import_vitest4.expect)(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
-        (0, import_vitest4.expect)(slow_mine[0]?.lane).toBe("slow");
+        (0, import_vitest6.expect)(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
+        (0, import_vitest6.expect)(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 }));
-        (0, import_vitest4.expect)(all_mine).toEqual(
-          import_vitest4.expect.arrayContaining([
+        (0, import_vitest6.expect)(all_mine).toEqual(
+          import_vitest6.expect.arrayContaining([
             { stream: sub_default, lane: "default" },
             { stream: sub_slow, lane: "slow" }
           ])
         );
       });
-      (0, import_vitest4.it)("query_streams filters by lane", async () => {
+      (0, import_vitest6.it)("query_streams filters by lane", async () => {
         const tag = uid();
         const a = `lane-q-a-${tag}`;
         const b = `lane-q-b-${tag}`;
@@ -1171,9 +1405,9 @@ var runStoreTck = (options) => {
           stream: `lane-q-.*-${tag}`,
           limit: 100
         });
-        (0, import_vitest4.expect)(seen.sort()).toEqual([a, c]);
+        (0, import_vitest6.expect)(seen.sort()).toEqual([a, c]);
       });
-      (0, import_vitest4.it)("prioritize filters by lane", async () => {
+      (0, import_vitest6.it)("prioritize filters by lane", async () => {
         const tag = uid();
         const a = `lane-pri-a-${tag}`;
         const b = `lane-pri-b-${tag}`;
@@ -1182,16 +1416,16 @@ var runStoreTck = (options) => {
           { stream: b, lane: `pfast-${tag}` }
         ]);
         const updated = await store.prioritize({ lane: `pslow-${tag}` }, 7);
-        (0, import_vitest4.expect)(updated).toBe(1);
+        (0, import_vitest6.expect)(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
         });
-        (0, import_vitest4.expect)(seen.get(a)).toBe(7);
-        (0, import_vitest4.expect)(seen.get(b)).toBe(0);
+        (0, import_vitest6.expect)(seen.get(a)).toBe(7);
+        (0, import_vitest6.expect)(seen.get(b)).toBe(0);
       });
-      (0, import_vitest4.it)("reset filters by lane", async () => {
+      (0, import_vitest6.it)("reset filters by lane", async () => {
         const tag = uid();
         const src = `lane-reset-src-${tag}`;
         const a = `lane-reset-a-${tag}`;
@@ -1209,7 +1443,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}` });
-        (0, import_vitest4.expect)(count).toBe(1);
+        (0, import_vitest6.expect)(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), {
@@ -1217,10 +1451,10 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        (0, import_vitest4.expect)(ats.get(a)).toBe(-1);
-        (0, import_vitest4.expect)(ats.get(b)).toBeGreaterThanOrEqual(0);
+        (0, import_vitest6.expect)(ats.get(a)).toBe(-1);
+        (0, import_vitest6.expect)(ats.get(b)).toBeGreaterThanOrEqual(0);
       });
-      (0, import_vitest4.it)("unblock filters by lane", async () => {
+      (0, import_vitest6.it)("unblock filters by lane", async () => {
         const tag = uid();
         const src = `lane-ub-src-${tag}`;
         const a = `lane-ub-a-${tag}`;
@@ -1238,7 +1472,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}` });
-        (0, import_vitest4.expect)(count).toBe(1);
+        (0, import_vitest6.expect)(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), {
@@ -1246,12 +1480,12 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        (0, import_vitest4.expect)(blocked.get(a)).toBe(false);
-        (0, import_vitest4.expect)(blocked.get(b)).toBe(true);
+        (0, import_vitest6.expect)(blocked.get(a)).toBe(false);
+        (0, import_vitest6.expect)(blocked.get(b)).toBe(true);
       });
     });
-    (0, import_vitest4.describe)("truncate", () => {
-      (0, import_vitest4.it)("seeds a tombstone when no snapshot is provided", async () => {
+    (0, import_vitest6.describe)("truncate", () => {
+      (0, import_vitest6.it)("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
         await store.commit(
           s,
@@ -1259,7 +1493,7 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const result = await store.truncate([{ stream: s }]);
-        (0, import_vitest4.expect)(result.get(s)?.deleted).toBe(2);
+        (0, import_vitest6.expect)(result.get(s)?.deleted).toBe(2);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1267,12 +1501,12 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest4.expect)(remaining).toHaveLength(1);
-        (0, import_vitest4.expect)(remaining[0].name).toBe(
+        (0, import_vitest6.expect)(remaining).toHaveLength(1);
+        (0, import_vitest6.expect)(remaining[0].name).toBe(
           "__tombstone__"
         );
       });
-      (0, import_vitest4.it)("seeds a snapshot when one is provided", async () => {
+      (0, import_vitest6.it)("seeds a snapshot when one is provided", async () => {
         const s = `trunc-snap-${uid()}`;
         await store.commit(
           s,
@@ -1282,7 +1516,7 @@ var runStoreTck = (options) => {
         const result = await store.truncate([
           { stream: s, snapshot: { count: 7 } }
         ]);
-        (0, import_vitest4.expect)(result.get(s)?.deleted).toBe(1);
+        (0, import_vitest6.expect)(result.get(s)?.deleted).toBe(1);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1290,24 +1524,24 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, with_snaps: true }
         );
-        (0, import_vitest4.expect)(remaining).toHaveLength(1);
-        (0, import_vitest4.expect)(remaining[0].name).toBe(
+        (0, import_vitest6.expect)(remaining).toHaveLength(1);
+        (0, import_vitest6.expect)(remaining[0].name).toBe(
           "__snapshot__"
         );
-        (0, import_vitest4.expect)(remaining[0].data).toEqual({ count: 7 });
+        (0, import_vitest6.expect)(remaining[0].data).toEqual({ count: 7 });
       });
-      (0, import_vitest4.it)("returns an empty map for empty input", async () => {
+      (0, import_vitest6.it)("returns an empty map for empty input", async () => {
         const result = await store.truncate([]);
-        (0, import_vitest4.expect)(result.size).toBe(0);
+        (0, import_vitest6.expect)(result.size).toBe(0);
       });
-      (0, import_vitest4.it)("returns 0 deleted for streams that don't exist", async () => {
+      (0, import_vitest6.it)("returns 0 deleted for streams that don't exist", async () => {
         const s = `trunc-missing-${uid()}`;
         const result = await store.truncate([{ stream: s }]);
-        (0, import_vitest4.expect)(result.get(s)?.deleted).toBe(0);
+        (0, import_vitest6.expect)(result.get(s)?.deleted).toBe(0);
       });
     });
-    (0, import_vitest4.describe)("query_streams", () => {
-      (0, import_vitest4.it)("returns positions filtered by stream regex, exact, source, and source_exact", async () => {
+    (0, import_vitest6.describe)("query_streams", () => {
+      (0, import_vitest6.it)("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`;
@@ -1326,37 +1560,37 @@ var runStoreTck = (options) => {
           (p) => all.push({ stream: p.stream, source: p.source }),
           { stream: `qs-${tag}-.*` }
         );
-        (0, import_vitest4.expect)(all_result.count).toBe(4);
-        (0, import_vitest4.expect)(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
-        (0, import_vitest4.expect)(all.map((p) => p.stream).sort()).toEqual(
+        (0, import_vitest6.expect)(all_result.count).toBe(4);
+        (0, import_vitest6.expect)(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
+        (0, import_vitest6.expect)(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-.*`
         });
-        (0, import_vitest4.expect)(projections.sort()).toEqual([proj1, proj2].sort());
+        (0, import_vitest6.expect)(projections.sort()).toEqual([proj1, proj2].sort());
         const exact = [];
         await store.query_streams((p) => exact.push(p.stream), {
           stream: dyn1,
           stream_exact: true
         });
-        (0, import_vitest4.expect)(exact).toEqual([dyn1]);
+        (0, import_vitest6.expect)(exact).toEqual([dyn1]);
         const by_source = [];
         await store.query_streams((p) => by_source.push(p.stream), {
           stream: `qs-${tag}-.*`,
           source: `qs-${tag}-src-.*`
         });
-        (0, import_vitest4.expect)(by_source.sort()).toEqual([dyn1, dyn2].sort());
+        (0, import_vitest6.expect)(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
         });
-        (0, import_vitest4.expect)(exact_source).toEqual([dyn2]);
+        (0, import_vitest6.expect)(exact_source).toEqual([dyn2]);
       });
-      (0, import_vitest4.it)("paginates with limit + after (keyset)", async () => {
+      (0, import_vitest6.it)("paginates with limit + after (keyset)", async () => {
         const tag = uid();
         const streams = [
           `qp-${tag}-a`,
@@ -1370,17 +1604,17 @@ var runStoreTck = (options) => {
           stream: `qp-${tag}-.*`,
           limit: 2
         });
-        (0, import_vitest4.expect)(page1).toHaveLength(2);
+        (0, import_vitest6.expect)(page1).toHaveLength(2);
         const page2 = [];
         await store.query_streams((p) => page2.push(p.stream), {
           stream: `qp-${tag}-.*`,
           limit: 2,
           after: page1.at(-1)
         });
-        (0, import_vitest4.expect)(page2).toHaveLength(2);
-        (0, import_vitest4.expect)([...page1, ...page2].sort()).toEqual([...streams].sort());
+        (0, import_vitest6.expect)(page2).toHaveLength(2);
+        (0, import_vitest6.expect)([...page1, ...page2].sort()).toEqual([...streams].sort());
       });
-      (0, import_vitest4.it)("filters by blocked status", async () => {
+      (0, import_vitest6.it)("filters by blocked status", async () => {
         const tag = uid();
         const s = `qb-${tag}`;
         const sibling = `qb-${tag}-other`;
@@ -1400,18 +1634,18 @@ var runStoreTck = (options) => {
           (p) => blocked.push({ stream: p.stream, error: p.error }),
           { stream: `qb-${tag}.*`, blocked: true }
         );
-        (0, import_vitest4.expect)(blocked).toHaveLength(1);
-        (0, import_vitest4.expect)(blocked[0].error).toBe("boom");
+        (0, import_vitest6.expect)(blocked).toHaveLength(1);
+        (0, import_vitest6.expect)(blocked[0].error).toBe("boom");
         const unblocked = [];
         await store.query_streams((p) => unblocked.push(p.stream), {
           stream: `qb-${tag}.*`,
           blocked: false
         });
-        (0, import_vitest4.expect)(unblocked).toEqual([sibling]);
+        (0, import_vitest6.expect)(unblocked).toEqual([sibling]);
       });
     });
-    (0, import_vitest4.describe)("query_stats", () => {
-      (0, import_vitest4.it)("array input \u2014 returns head per stream, absent when not in input", async () => {
+    (0, import_vitest6.describe)("query_stats", () => {
+      (0, import_vitest6.it)("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`;
@@ -1432,18 +1666,18 @@ var runStoreTck = (options) => {
           make_meta({ stream: sUnasked })
         );
         const stats = await store.query_stats([sA, sB]);
-        (0, import_vitest4.expect)(stats.size).toBe(2);
-        (0, import_vitest4.expect)(stats.get(sA)?.head.name).toBe("Incremented");
-        (0, import_vitest4.expect)((stats.get(sA)?.head.data).amount).toBe(2);
-        (0, import_vitest4.expect)(stats.get(sB)?.head.name).toBe("Decremented");
-        (0, import_vitest4.expect)((stats.get(sB)?.head.data).amount).toBe(5);
-        (0, import_vitest4.expect)(stats.has(sUnasked)).toBe(false);
+        (0, import_vitest6.expect)(stats.size).toBe(2);
+        (0, import_vitest6.expect)(stats.get(sA)?.head.name).toBe("Incremented");
+        (0, import_vitest6.expect)((stats.get(sA)?.head.data).amount).toBe(2);
+        (0, import_vitest6.expect)(stats.get(sB)?.head.name).toBe("Decremented");
+        (0, import_vitest6.expect)((stats.get(sB)?.head.data).amount).toBe(5);
+        (0, import_vitest6.expect)(stats.has(sUnasked)).toBe(false);
         const empty = await store.query_stats([]);
-        (0, import_vitest4.expect)(empty.size).toBe(0);
+        (0, import_vitest6.expect)(empty.size).toBe(0);
         const unknown = await store.query_stats([`qst-${tag}-missing`]);
-        (0, import_vitest4.expect)(unknown.size).toBe(0);
+        (0, import_vitest6.expect)(unknown.size).toBe(0);
       });
-      (0, import_vitest4.it)("tail returns the earliest event per stream", async () => {
+      (0, import_vitest6.it)("tail returns the earliest event per stream", async () => {
         const tag = uid();
         const s = `qst-tail-${tag}`;
         await store.commit(
@@ -1465,12 +1699,12 @@ var runStoreTck = (options) => {
           tail: true
         });
         const r = stats.get(s);
-        (0, import_vitest4.expect)(r?.head.name).toBe("Incremented");
-        (0, import_vitest4.expect)((r?.head.data).amount).toBe(3);
-        (0, import_vitest4.expect)(r?.tail?.name).toBe("Incremented");
-        (0, import_vitest4.expect)((r?.tail?.data).amount).toBe(1);
+        (0, import_vitest6.expect)(r?.head.name).toBe("Incremented");
+        (0, import_vitest6.expect)((r?.head.data).amount).toBe(3);
+        (0, import_vitest6.expect)(r?.tail?.name).toBe("Incremented");
+        (0, import_vitest6.expect)((r?.tail?.data).amount).toBe(1);
       });
-      (0, import_vitest4.it)("count + names \u2014 full aggregates including framework markers", async () => {
+      (0, import_vitest6.it)("count + names \u2014 full aggregates including framework markers", async () => {
         const tag = uid();
         const s = `qst-cn-${tag}`;
         await store.commit(
@@ -1489,13 +1723,13 @@ var runStoreTck = (options) => {
           names: true
         });
         const r = stats.get(s);
-        (0, import_vitest4.expect)(r?.count).toBe(4);
-        (0, import_vitest4.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
-        (0, import_vitest4.expect)(r?.names?.Incremented).toBe(2);
-        (0, import_vitest4.expect)(r?.names?.Decremented).toBe(1);
-        (0, import_vitest4.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
+        (0, import_vitest6.expect)(r?.count).toBe(4);
+        (0, import_vitest6.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
+        (0, import_vitest6.expect)(r?.names?.Incremented).toBe(2);
+        (0, import_vitest6.expect)(r?.names?.Decremented).toBe(1);
+        (0, import_vitest6.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
       });
-      (0, import_vitest4.it)("exclude shifts head past filtered events; stream absent when all filtered", async () => {
+      (0, import_vitest6.it)("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}`;
@@ -1510,23 +1744,23 @@ var runStoreTck = (options) => {
           make_meta({ stream: sAllOut })
         );
         const all = await store.query_stats([s]);
-        (0, import_vitest4.expect)(all.get(s)?.head.name).toBe("Incremented");
-        (0, import_vitest4.expect)((all.get(s)?.head.data).amount).toBe(3);
+        (0, import_vitest6.expect)(all.get(s)?.head.name).toBe("Incremented");
+        (0, import_vitest6.expect)((all.get(s)?.head.data).amount).toBe(3);
         const excl = await store.query_stats([s], {
           exclude: ["Incremented"]
         });
-        (0, import_vitest4.expect)(excl.get(s)?.head.name).toBe("Decremented");
-        (0, import_vitest4.expect)((excl.get(s)?.head.data).amount).toBe(2);
+        (0, import_vitest6.expect)(excl.get(s)?.head.name).toBe("Decremented");
+        (0, import_vitest6.expect)((excl.get(s)?.head.data).amount).toBe(2);
         const wipe = await store.query_stats([sAllOut], {
           exclude: ["Incremented", "Decremented", "Reset"]
         });
-        (0, import_vitest4.expect)(wipe.has(sAllOut)).toBe(false);
+        (0, import_vitest6.expect)(wipe.has(sAllOut)).toBe(false);
         const no_tomb = await store.query_stats([s], {
           exclude: [import_act.TOMBSTONE_EVENT]
         });
-        (0, import_vitest4.expect)(no_tomb.get(s)?.head.name).toBe("Incremented");
+        (0, import_vitest6.expect)(no_tomb.get(s)?.head.name).toBe("Incremented");
       });
-      (0, import_vitest4.it)("before \u2014 time travel narrows head/tail/count", async () => {
+      (0, import_vitest6.it)("before \u2014 time travel narrows head/tail/count", async () => {
         const tag = uid();
         const s = `qst-tt-${tag}`;
         const c1 = await store.commit(
@@ -1551,15 +1785,15 @@ var runStoreTck = (options) => {
           before
         });
         const r = stats.get(s);
-        (0, import_vitest4.expect)(r?.count).toBe(1);
-        (0, import_vitest4.expect)(r?.head.id).toBe(c1[0].id);
-        (0, import_vitest4.expect)(r?.tail?.id).toBe(c1[0].id);
+        (0, import_vitest6.expect)(r?.count).toBe(1);
+        (0, import_vitest6.expect)(r?.head.id).toBe(c1[0].id);
+        (0, import_vitest6.expect)(r?.tail?.id).toBe(c1[0].id);
         const empty = await store.query_stats([s], {
           before: 0
         });
-        (0, import_vitest4.expect)(empty.has(s)).toBe(false);
+        (0, import_vitest6.expect)(empty.has(s)).toBe(false);
       });
-      (0, import_vitest4.it)("filter form \u2014 stream regex, stream_exact, empty {} match", async () => {
+      (0, import_vitest6.it)("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`;
@@ -1582,18 +1816,18 @@ var runStoreTck = (options) => {
         const orders = await store.query_stats({
           stream: `^qsf-${tag}-orders-`
         });
-        (0, import_vitest4.expect)([...orders.keys()].sort()).toEqual([sA, sB].sort());
+        (0, import_vitest6.expect)([...orders.keys()].sort()).toEqual([sA, sB].sort());
         const exact = await store.query_stats({
           stream: sA,
           stream_exact: true
         });
-        (0, import_vitest4.expect)([...exact.keys()]).toEqual([sA]);
+        (0, import_vitest6.expect)([...exact.keys()]).toEqual([sA]);
         const all = await store.query_stats({
           stream: `^qsf-${tag}-`
         });
-        (0, import_vitest4.expect)([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
+        (0, import_vitest6.expect)([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
       });
-      (0, import_vitest4.it)("compose with query_streams for subscription-level filters", async () => {
+      (0, import_vitest6.it)("compose with query_streams for subscription-level filters", async () => {
         const tag = uid();
         const a = `qsc-${tag}-a`;
         const b = `qsc-${tag}-b`;
@@ -1610,7 +1844,7 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === a);
-        (0, import_vitest4.expect)(mine).toBeDefined();
+        (0, import_vitest6.expect)(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== a);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
@@ -1619,12 +1853,12 @@ var runStoreTck = (options) => {
           stream: `^qsc-${tag}-`,
           blocked: true
         });
-        (0, import_vitest4.expect)(blocked_names).toEqual([a]);
+        (0, import_vitest6.expect)(blocked_names).toEqual([a]);
         const stats = await store.query_stats(blocked_names);
-        (0, import_vitest4.expect)(stats.get(a)?.head.name).toBe("Incremented");
-        (0, import_vitest4.expect)(stats.has(b)).toBe(false);
+        (0, import_vitest6.expect)(stats.get(a)?.head.name).toBe("Incremented");
+        (0, import_vitest6.expect)(stats.has(b)).toBe(false);
       });
-      (0, import_vitest4.it)("empty filter {} \u2014 matches every event-bearing stream", async () => {
+      (0, import_vitest6.it)("empty filter {} \u2014 matches every event-bearing stream", async () => {
         const tag = uid();
         const a = `qse-${tag}-a`;
         const b = `qse-${tag}-b`;
@@ -1639,10 +1873,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: b })
         );
         const all = await store.query_stats({});
-        (0, import_vitest4.expect)(all.has(a)).toBe(true);
-        (0, import_vitest4.expect)(all.has(b)).toBe(true);
+        (0, import_vitest6.expect)(all.has(a)).toBe(true);
+        (0, import_vitest6.expect)(all.has(b)).toBe(true);
       });
-      (0, import_vitest4.it)("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
+      (0, import_vitest6.it)("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
         const tag = uid();
         const s = `qsfl-${tag}`;
         await store.commit(
@@ -1653,24 +1887,24 @@ var runStoreTck = (options) => {
         const c = await store.query_stats([s], {
           count: true
         });
-        (0, import_vitest4.expect)(c.get(s)?.count).toBe(3);
-        (0, import_vitest4.expect)(c.get(s)?.names).toBeUndefined();
-        (0, import_vitest4.expect)(c.get(s)?.tail).toBeUndefined();
+        (0, import_vitest6.expect)(c.get(s)?.count).toBe(3);
+        (0, import_vitest6.expect)(c.get(s)?.names).toBeUndefined();
+        (0, import_vitest6.expect)(c.get(s)?.tail).toBeUndefined();
         const n = await store.query_stats([s], {
           names: true
         });
-        (0, import_vitest4.expect)(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
-        (0, import_vitest4.expect)(n.get(s)?.count).toBeUndefined();
-        (0, import_vitest4.expect)(n.get(s)?.tail).toBeUndefined();
+        (0, import_vitest6.expect)(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
+        (0, import_vitest6.expect)(n.get(s)?.count).toBeUndefined();
+        (0, import_vitest6.expect)(n.get(s)?.tail).toBeUndefined();
         const t = await store.query_stats([s], { tail: true });
-        (0, import_vitest4.expect)(t.get(s)?.tail?.name).toBe("Incremented");
-        (0, import_vitest4.expect)((t.get(s)?.tail?.data).amount).toBe(1);
-        (0, import_vitest4.expect)(t.get(s)?.count).toBeUndefined();
-        (0, import_vitest4.expect)(t.get(s)?.names).toBeUndefined();
+        (0, import_vitest6.expect)(t.get(s)?.tail?.name).toBe("Incremented");
+        (0, import_vitest6.expect)((t.get(s)?.tail?.data).amount).toBe(1);
+        (0, import_vitest6.expect)(t.get(s)?.count).toBeUndefined();
+        (0, import_vitest6.expect)(t.get(s)?.names).toBeUndefined();
       });
     });
-    (0, import_vitest4.describe)("query_streams anchor contract", () => {
-      (0, import_vitest4.it)("plain regex without anchors is a substring match", async () => {
+    (0, import_vitest6.describe)("query_streams anchor contract", () => {
+      (0, import_vitest6.it)("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-inner`;
         const longer = `qsr-${tag}-inner-extra`;
@@ -1684,9 +1918,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `qsr-${tag}-inner`
         });
-        (0, import_vitest4.expect)(seen.sort()).toEqual([inner, longer].sort());
+        (0, import_vitest6.expect)(seen.sort()).toEqual([inner, longer].sort());
       });
-      (0, import_vitest4.it)("caller-anchored `^name$` matches only the whole string", async () => {
+      (0, import_vitest6.it)("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-anchor`;
         const longer = `qsr-${tag}-anchor-extra`;
@@ -1695,9 +1929,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-anchor$`
         });
-        (0, import_vitest4.expect)(seen).toEqual([inner]);
+        (0, import_vitest6.expect)(seen).toEqual([inner]);
       });
-      (0, import_vitest4.it)("caller-anchored `^prefix` matches by prefix", async () => {
+      (0, import_vitest6.it)("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qsr-${tag}-pfx-a`;
         const b = `qsr-${tag}-pfx-b`;
@@ -1711,11 +1945,11 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-pfx-`
         });
-        (0, import_vitest4.expect)(seen.sort()).toEqual([a, b].sort());
+        (0, import_vitest6.expect)(seen.sort()).toEqual([a, b].sort());
       });
     });
-    (0, import_vitest4.describe)("prioritize anchor contract", () => {
-      (0, import_vitest4.it)("caller-anchored `^name$` filter matches only the whole string", async () => {
+    (0, import_vitest6.describe)("prioritize anchor contract", () => {
+      (0, import_vitest6.it)("caller-anchored `^name$` filter matches only the whole string", async () => {
         const tag = uid();
         const inner = `pr-${tag}-anchor`;
         const longer = `pr-${tag}-anchor-extra`;
@@ -1727,17 +1961,17 @@ var runStoreTck = (options) => {
           { stream: `^pr-${tag}-anchor$` },
           7
         );
-        (0, import_vitest4.expect)(updated).toBe(1);
+        (0, import_vitest6.expect)(updated).toBe(1);
         const seen = /* @__PURE__ */ new Map();
         await store.query_streams((p) => seen.set(p.stream, p.priority), {
           stream: `pr-${tag}-anchor`
         });
-        (0, import_vitest4.expect)(seen.get(inner)).toBe(7);
-        (0, import_vitest4.expect)(seen.get(longer)).toBe(0);
+        (0, import_vitest6.expect)(seen.get(inner)).toBe(7);
+        (0, import_vitest6.expect)(seen.get(longer)).toBe(0);
       });
     });
-    (0, import_vitest4.describe)("query_streams head", () => {
-      (0, import_vitest4.it)("maxEventId tracks the highest committed id", async () => {
+    (0, import_vitest6.describe)("query_streams head", () => {
+      (0, import_vitest6.it)("maxEventId tracks the highest committed id", async () => {
         const s = `head-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1750,34 +1984,34 @@ var runStoreTck = (options) => {
           (p) => positions.push(p.stream),
           { stream: s, stream_exact: true, limit: 1 }
         );
-        (0, import_vitest4.expect)(maxEventId).toBeGreaterThanOrEqual(0);
-        (0, import_vitest4.expect)(positions).toEqual([s]);
+        (0, import_vitest6.expect)(maxEventId).toBeGreaterThanOrEqual(0);
+        (0, import_vitest6.expect)(positions).toEqual([s]);
       });
     });
-    (0, import_vitest4.describe)("seed_stream helper coverage", () => {
-      (0, import_vitest4.it)("commits N events with monotonically increasing ids", async () => {
+    (0, import_vitest6.describe)("seed_stream helper coverage", () => {
+      (0, import_vitest6.it)("commits N events with monotonically increasing ids", async () => {
         const s = `seed-${uid()}`;
         const committed = await seed_stream(store, s, 3);
-        (0, import_vitest4.expect)(committed).toHaveLength(3);
+        (0, import_vitest6.expect)(committed).toHaveLength(3);
         for (let i = 1; i < committed.length; i++) {
-          (0, import_vitest4.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          (0, import_vitest6.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
     });
-    import_vitest4.describe.skipIf(!caps.restore)("restore (capability)", () => {
+    import_vitest6.describe.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() {
         }
@@ -1801,29 +2035,29 @@ var runStoreTck = (options) => {
           await cache.dispose();
         }
       };
-      (0, import_vitest4.it)("returns kept=0 on an empty source", async () => {
+      (0, import_vitest6.it)("returns kept=0 on an empty source", async () => {
         const result = await restore(as_source([]));
-        (0, import_vitest4.expect)(result.kept).toBe(0);
-        (0, import_vitest4.expect)(result.duration_ms).toBeGreaterThanOrEqual(0);
-        (0, import_vitest4.expect)(result.dropped).toEqual({
+        (0, import_vitest6.expect)(result.kept).toBe(0);
+        (0, import_vitest6.expect)(result.duration_ms).toBeGreaterThanOrEqual(0);
+        (0, import_vitest6.expect)(result.dropped).toEqual({
           closed_streams: 0,
           snapshots: 0
         });
-        const events = await collect(store, { limit: 10 });
-        (0, import_vitest4.expect)(events).toHaveLength(0);
+        const events2 = await collect(store, { limit: 10 });
+        (0, import_vitest6.expect)(events2).toHaveLength(0);
       });
-      (0, import_vitest4.it)("rebuilds a single stream and preserves `created` verbatim", async () => {
+      (0, import_vitest6.it)("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));
-        (0, import_vitest4.expect)(result.kept).toBe(3);
+        const result = await restore(as_source(events2));
+        (0, import_vitest6.expect)(result.kept).toBe(3);
         const back = [];
         await store.query(
           (e) => {
@@ -1831,8 +2065,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest4.expect)(back).toHaveLength(3);
-        (0, import_vitest4.expect)(
+        (0, import_vitest6.expect)(back).toHaveLength(3);
+        (0, import_vitest6.expect)(
           back.map((e) => ({
             stream: e.stream,
             version: e.version,
@@ -1864,18 +2098,18 @@ var runStoreTck = (options) => {
           }
         ]);
       });
-      (0, import_vitest4.it)("rebuilds multiple streams interleaved", async () => {
+      (0, import_vitest6.it)("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");
-        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));
-        (0, import_vitest4.expect)(result.kept).toBe(4);
+        const result = await restore(as_source(events2));
+        (0, import_vitest6.expect)(result.kept).toBe(4);
         const aBack = [];
         const bBack = [];
         await store.query(
@@ -1890,10 +2124,10 @@ var runStoreTck = (options) => {
           },
           { stream: b, stream_exact: true }
         );
-        (0, import_vitest4.expect)(aBack.map((e) => e.version)).toEqual([0, 1]);
-        (0, import_vitest4.expect)(bBack.map((e) => e.version)).toEqual([0, 1]);
+        (0, import_vitest6.expect)(aBack.map((e) => e.version)).toEqual([0, 1]);
+        (0, import_vitest6.expect)(bBack.map((e) => e.version)).toEqual([0, 1]);
       });
-      (0, import_vitest4.it)("preserves Date `created` verbatim", async () => {
+      (0, import_vitest6.it)("preserves Date `created` verbatim", async () => {
         const s = `restore-isoc-${uid()}`;
         const iso = "2021-07-15T12:34:56.789Z";
         await restore(
@@ -1916,10 +2150,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest4.expect)(back).toHaveLength(1);
-        (0, import_vitest4.expect)(back[0].created.toISOString()).toBe(iso);
+        (0, import_vitest6.expect)(back).toHaveLength(1);
+        (0, import_vitest6.expect)(back[0].created.toISOString()).toBe(iso);
       });
-      (0, import_vitest4.it)("wipes pre-existing events before inserting", async () => {
+      (0, import_vitest6.it)("wipes pre-existing events before inserting", async () => {
         const old = `restore-old-${uid()}`;
         await store.commit(
           old,
@@ -1935,14 +2169,14 @@ var runStoreTck = (options) => {
           stream: old,
           stream_exact: true
         });
-        (0, import_vitest4.expect)(old_back).toHaveLength(0);
+        (0, import_vitest6.expect)(old_back).toHaveLength(0);
         const fresh_back = await collect(store, {
           stream: fresh,
           stream_exact: true
         });
-        (0, import_vitest4.expect)(fresh_back).toHaveLength(1);
+        (0, import_vitest6.expect)(fresh_back).toHaveLength(1);
       });
-      (0, import_vitest4.it)("clears subscription/stream-position metadata", async () => {
+      (0, import_vitest6.it)("clears subscription/stream-position metadata", async () => {
         const sub = `restore-sub-${uid()}`;
         await store.subscribe([{ stream: sub, source: "anything" }]);
         const collect_streams = async () => {
@@ -1953,12 +2187,12 @@ var runStoreTck = (options) => {
           return out;
         };
         const before = await collect_streams();
-        (0, import_vitest4.expect)(before.includes(sub)).toBe(true);
+        (0, import_vitest6.expect)(before.includes(sub)).toBe(true);
         await restore(as_source([]));
         const after = await collect_streams();
-        (0, import_vitest4.expect)(after.includes(sub)).toBe(false);
+        (0, import_vitest6.expect)(after.includes(sub)).toBe(false);
       });
-      (0, import_vitest4.it)("preserves snapshot events through restore", async () => {
+      (0, import_vitest6.it)("preserves snapshot events through restore", async () => {
         const s = `restore-snap-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-04-01T00:00:00.000Z");
         await restore(
@@ -1979,13 +2213,13 @@ var runStoreTck = (options) => {
           stream_exact: true,
           with_snaps: true
         });
-        (0, import_vitest4.expect)(back).toHaveLength(1);
-        (0, import_vitest4.expect)(back[0].name).toBe(import_act.SNAP_EVENT);
+        (0, import_vitest6.expect)(back).toHaveLength(1);
+        (0, import_vitest6.expect)(back[0].name).toBe(import_act.SNAP_EVENT);
       });
-      (0, import_vitest4.it)("rewrites causation refs through the old\u2192new id map", async () => {
+      (0, import_vitest6.it)("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,
@@ -2024,7 +2258,7 @@ var runStoreTck = (options) => {
             }
           }
         ];
-        await restore(as_source(events));
+        await restore(as_source(events2));
         const back = [];
         await store.query(
           (e) => {
@@ -2032,12 +2266,12 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest4.expect)(back).toHaveLength(3);
-        (0, import_vitest4.expect)(back[0].meta.causation.event).toBeUndefined();
-        (0, import_vitest4.expect)(back[1].meta.causation.event?.id).toBe(back[0].id);
-        (0, import_vitest4.expect)(back[2].meta.causation.event?.id).toBe(back[1].id);
+        (0, import_vitest6.expect)(back).toHaveLength(3);
+        (0, import_vitest6.expect)(back[0].meta.causation.event).toBeUndefined();
+        (0, import_vitest6.expect)(back[1].meta.causation.event?.id).toBe(back[0].id);
+        (0, import_vitest6.expect)(back[2].meta.causation.event?.id).toBe(back[1].id);
       });
-      (0, import_vitest4.it)("leaves causation refs unmapped when the target isn't in the source", async () => {
+      (0, import_vitest6.it)("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(
@@ -2065,9 +2299,9 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest4.expect)(back[0].meta.causation.event?.id).toBe(999);
+        (0, import_vitest6.expect)(back[0].meta.causation.event?.id).toBe(999);
       });
-      (0, import_vitest4.it)("rolls back atomically when the source throws mid-iteration", async () => {
+      (0, import_vitest6.it)("rolls back atomically when the source throws mid-iteration", async () => {
         const original = `restore-pre-${uid()}`;
         const committed = await store.commit(
           original,
@@ -2093,7 +2327,7 @@ var runStoreTck = (options) => {
           async dispose() {
           }
         };
-        await (0, import_vitest4.expect)(restore(explosive)).rejects.toThrow("boom");
+        await (0, import_vitest6.expect)(restore(explosive)).rejects.toThrow("boom");
         const back = [];
         await store.query(
           (e) => {
@@ -2101,10 +2335,10 @@ var runStoreTck = (options) => {
           },
           { stream: original, stream_exact: true }
         );
-        (0, import_vitest4.expect)(back).toHaveLength(3);
-        (0, import_vitest4.expect)(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        (0, import_vitest6.expect)(back).toHaveLength(3);
+        (0, import_vitest6.expect)(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
       });
-      (0, import_vitest4.it)("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
+      (0, import_vitest6.it)("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(
@@ -2123,19 +2357,19 @@ var runStoreTck = (options) => {
           ]),
           { drop_snapshots: true }
         );
-        (0, import_vitest4.expect)(result.kept).toBe(2);
-        (0, import_vitest4.expect)(result.dropped.snapshots).toBe(1);
+        (0, import_vitest6.expect)(result.kept).toBe(2);
+        (0, import_vitest6.expect)(result.dropped.snapshots).toBe(1);
         const back = await collect(store, {
           stream: s,
           stream_exact: true,
           with_snaps: true
         });
-        (0, import_vitest4.expect)(back).toHaveLength(2);
-        (0, import_vitest4.expect)(
+        (0, import_vitest6.expect)(back).toHaveLength(2);
+        (0, import_vitest6.expect)(
           back.every((e) => e.name !== import_act.SNAP_EVENT)
         ).toBe(true);
       });
-      (0, import_vitest4.it)("on_progress fires once per event (caller throttles)", async () => {
+      (0, import_vitest6.it)("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");
@@ -2146,11 +2380,11 @@ var runStoreTck = (options) => {
           ]),
           { on_progress: (p) => calls.push(p.processed) }
         );
-        (0, import_vitest4.expect)(calls).toEqual([1, 2]);
+        (0, import_vitest6.expect)(calls).toEqual([1, 2]);
       });
     });
-    import_vitest4.describe.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
-      (0, import_vitest4.it)("commits and loads pii alongside data", async () => {
+    import_vitest6.describe.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
+      (0, import_vitest6.it)("commits and loads pii alongside data", async () => {
         const s = `pii-roundtrip-${uid()}`;
         const committed = await store.commit(
           s,
@@ -2163,8 +2397,8 @@ var runStoreTck = (options) => {
           ],
           make_meta({ stream: s })
         );
-        (0, import_vitest4.expect)(committed).toHaveLength(1);
-        (0, import_vitest4.expect)(committed[0].pii).toEqual({
+        (0, import_vitest6.expect)(committed).toHaveLength(1);
+        (0, import_vitest6.expect)(committed[0].pii).toEqual({
           email: "u@example.com",
           name: "Ursula"
         });
@@ -2175,11 +2409,11 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest4.expect)(seen).toHaveLength(1);
-        (0, import_vitest4.expect)(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
-        (0, import_vitest4.expect)(seen[0].data).toEqual({ amount: 1 });
+        (0, import_vitest6.expect)(seen).toHaveLength(1);
+        (0, import_vitest6.expect)(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
+        (0, import_vitest6.expect)(seen[0].data).toEqual({ amount: 1 });
       });
-      (0, import_vitest4.it)("passes through events without pii (pii is null or undefined on load)", async () => {
+      (0, import_vitest6.it)("passes through events without pii (pii is null or undefined on load)", async () => {
         const s = `pii-none-${uid()}`;
         await store.commit(
           s,
@@ -2193,10 +2427,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest4.expect)(seen).toHaveLength(1);
-        (0, import_vitest4.expect)(seen[0].pii == null).toBe(true);
+        (0, import_vitest6.expect)(seen).toHaveLength(1);
+        (0, import_vitest6.expect)(seen[0].pii == null).toBe(true);
       });
-      (0, import_vitest4.it)("wipes pii for every event on the stream via forget_pii", async () => {
+      (0, import_vitest6.it)("wipes pii for every event on the stream via forget_pii", async () => {
         const s = `pii-forget-${uid()}`;
         await store.commit(
           s,
@@ -2215,9 +2449,9 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const forget = store.forget_pii;
-        (0, import_vitest4.expect)(forget).toBeDefined();
+        (0, import_vitest6.expect)(forget).toBeDefined();
         const wiped = await forget.call(store, s);
-        (0, import_vitest4.expect)(wiped).toBe(2);
+        (0, import_vitest6.expect)(wiped).toBe(2);
         const seen = [];
         await store.query(
           (e) => {
@@ -2225,13 +2459,13 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest4.expect)(seen).toHaveLength(2);
+        (0, import_vitest6.expect)(seen).toHaveLength(2);
         for (const e of seen) {
-          (0, import_vitest4.expect)(e.pii == null).toBe(true);
-          (0, import_vitest4.expect)(e.data).toBeDefined();
+          (0, import_vitest6.expect)(e.pii == null).toBe(true);
+          (0, import_vitest6.expect)(e.data).toBeDefined();
         }
       });
-      (0, import_vitest4.it)("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
+      (0, import_vitest6.it)("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
         const s = `pii-forget-idem-${uid()}`;
         await store.commit(
           s,
@@ -2246,11 +2480,11 @@ var runStoreTck = (options) => {
         );
         const forget = store.forget_pii;
         const first = await forget.call(store, s);
-        (0, import_vitest4.expect)(first).toBe(1);
+        (0, import_vitest6.expect)(first).toBe(1);
         const second = await forget.call(store, s);
-        (0, import_vitest4.expect)(second).toBe(0);
+        (0, import_vitest6.expect)(second).toBe(0);
       });
-      (0, import_vitest4.it)("only wipes the targeted stream \u2014 siblings untouched", async () => {
+      (0, import_vitest6.it)("only wipes the targeted stream \u2014 siblings untouched", async () => {
         const sA = `pii-iso-a-${uid()}`;
         const sB = `pii-iso-b-${uid()}`;
         await store.commit(
@@ -2283,7 +2517,7 @@ var runStoreTck = (options) => {
           },
           { stream: sA, stream_exact: true }
         );
-        (0, import_vitest4.expect)(a[0].pii == null).toBe(true);
+        (0, import_vitest6.expect)(a[0].pii == null).toBe(true);
         const b = [];
         await store.query(
           (e) => {
@@ -2291,9 +2525,9 @@ var runStoreTck = (options) => {
           },
           { stream: sB, stream_exact: true }
         );
-        (0, import_vitest4.expect)(b[0].pii).toEqual({ email: "bob@example.com" });
+        (0, import_vitest6.expect)(b[0].pii).toEqual({ email: "bob@example.com" });
       });
-      (0, import_vitest4.it)("forget_pii on a stream with no pii events returns 0", async () => {
+      (0, import_vitest6.it)("forget_pii on a stream with no pii events returns 0", async () => {
         const s = `pii-forget-empty-${uid()}`;
         await store.commit(
           s,
@@ -2301,14 +2535,14 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const wiped = await store.forget_pii.call(store, s);
-        (0, import_vitest4.expect)(wiped).toBe(0);
+        (0, import_vitest6.expect)(wiped).toBe(0);
       });
     });
     if (caps.notify) {
-      (0, import_vitest4.describe)("notify (capability)", () => {
-        (0, import_vitest4.it)("delivers a notification when a different instance commits", async () => {
+      (0, import_vitest6.describe)("notify (capability)", () => {
+        (0, import_vitest6.it)("delivers a notification when a different instance commits", async () => {
           const notify = store.notify;
-          (0, import_vitest4.expect)(notify).toBeDefined();
+          (0, import_vitest6.expect)(notify).toBeDefined();
           const received = [];
           let resolve_arrived;
           const arrived = new Promise((res) => {
@@ -2327,9 +2561,9 @@ var runStoreTck = (options) => {
               make_meta({ stream })
             );
             await arrived;
-            (0, import_vitest4.expect)(received.length).toBeGreaterThanOrEqual(1);
-            (0, import_vitest4.expect)(received[0].stream).toBe(stream);
-            (0, import_vitest4.expect)(received[0].events.length).toBeGreaterThanOrEqual(1);
+            (0, import_vitest6.expect)(received.length).toBeGreaterThanOrEqual(1);
+            (0, import_vitest6.expect)(received[0].stream).toBe(stream);
+            (0, import_vitest6.expect)(received[0].events.length).toBeGreaterThanOrEqual(1);
           } finally {
             await writer.dispose();
             await Promise.resolve(disposer());
@@ -2354,6 +2588,7 @@ var runStoreTck = (options) => {
   runCacheTck,
   runLoggerTck,
   runStabilityTck,
+  runStorePropertyTck,
   runStoreTck,
   uid
 });