@rotorsoft/act-tck 1.5.0 → 1.5.2

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -29,12 +39,11 @@ __export(index_exports, {
   collect: () => collect,
   dec: () => dec,
   inc: () => inc,
-  makeMeta: () => makeMeta,
   reset: () => reset,
   runCacheTck: () => runCacheTck,
   runLoggerTck: () => runLoggerTck,
+  runStabilityTck: () => runStabilityTck,
   runStoreTck: () => runStoreTck,
-  seedStream: () => seedStream,
   uid: () => uid
 });
 module.exports = __toCommonJS(index_exports);
@@ -130,7 +139,7 @@ var COUNTER_EVENT_NAMES = [
 var import_node_crypto = require("crypto");
 var uid = () => (0, import_node_crypto.randomUUID)().slice(0, 8);
 var actor = (name = "tester") => ({ id: (0, import_node_crypto.randomUUID)(), name });
-var makeMeta = (opts = {}) => ({
+var make_meta = (opts = {}) => ({
   correlation: opts.correlation ?? (0, import_node_crypto.randomUUID)(),
   causation: opts.stream ? {
     action: {
@@ -149,13 +158,13 @@ var dec = (amount = 1) => ({
   data: { amount }
 });
 var reset = () => ({ name: "Reset", data: {} });
-var seedStream = async (store, stream, count, correlation) => {
+var seed_stream = async (store, stream, count, correlation) => {
   const out = [];
   for (let i = 0; i < count; i++) {
     const committed = await store.commit(
       stream,
       [inc(1)],
-      makeMeta({ correlation, stream })
+      make_meta({ correlation, stream })
     );
     out.push(...committed);
   }
@@ -175,14 +184,14 @@ var LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
 var runLoggerTck = (options) => {
   (0, import_vitest2.describe)(`TCK / Logger / ${options.name}`, () => {
     let logger;
-    let originalStdout;
+    let original_stdout;
     (0, import_vitest2.beforeEach)(() => {
       logger = options.factory();
-      originalStdout = process.stdout.write.bind(process.stdout);
+      original_stdout = process.stdout.write.bind(process.stdout);
       process.stdout.write = (() => true);
     });
     (0, import_vitest2.afterEach)(async () => {
-      process.stdout.write = originalStdout;
+      process.stdout.write = original_stdout;
       await logger.dispose();
     });
     (0, import_vitest2.it)("exposes a non-empty `level` string", () => {
@@ -209,7 +218,7 @@ var runLoggerTck = (options) => {
       (0, import_vitest2.expect)(() => logger.info(cyclic, "cycle")).not.toThrow();
     });
     (0, import_vitest2.it)("child(bindings) returns a Logger satisfying the same contract", () => {
-      const child = logger.child({ requestId: "abc" });
+      const child = logger.child({ request_id: "abc" });
       (0, import_vitest2.expect)(typeof child.level).toBe("string");
       for (const level of LEVELS) {
         (0, import_vitest2.expect)(typeof child[level]).toBe("function");
@@ -229,118 +238,162 @@ var runLoggerTck = (options) => {
   });
 };
 
+// src/stability-tck.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+var import_vitest3 = require("vitest");
+function runStabilityTck(options) {
+  (0, import_vitest3.describe)(`${options.name} \u2014 public API stability`, () => {
+    for (const [subpath, entry2] of Object.entries(options.entryPoints)) {
+      const label = subpath || "(root)";
+      (0, import_vitest3.it)(`stable public surface for ${label}`, async () => {
+        const surface = await load_surface(entry2);
+        (0, import_vitest3.expect)(surface).toMatchSnapshot();
+      });
+    }
+  });
+}
+async function load_surface(entry2) {
+  const visited = /* @__PURE__ */ new Map();
+  async function walk(file) {
+    const abs = import_node_path.default.resolve(file);
+    if (visited.has(abs)) return;
+    const content = await import_node_fs.promises.readFile(abs, "utf8");
+    visited.set(abs, content);
+    const re_export = /^\s*(?:import|export)\b[^"';]*\bfrom\s+["'](\.[^"']+)["']/gm;
+    for (const m of content.matchAll(re_export)) {
+      const rel = m[1].replace(/\.js$/, ".ts");
+      const target = import_node_path.default.resolve(import_node_path.default.dirname(abs), rel);
+      await walk(target);
+    }
+  }
+  await walk(entry2);
+  const sorted = [...visited.entries()].sort(
+    ([a], [b]) => import_node_path.default.basename(a).localeCompare(import_node_path.default.basename(b))
+  );
+  return sorted.map(([abs, content]) => {
+    const rel = import_node_path.default.basename(abs);
+    return `// === ${rel} ===
+${content}`;
+  }).join("\n");
+}
+
 // src/store-tck.ts
 var import_act = require("@rotorsoft/act");
-var import_vitest3 = require("vitest");
+var import_vitest4 = require("vitest");
 var runStoreTck = (options) => {
-  (0, import_vitest3.describe)(`TCK / Store / ${options.name}`, () => {
+  (0, import_vitest4.describe)(`TCK / Store / ${options.name}`, () => {
     let store;
     const caps = { ...options.capabilities };
-    (0, import_vitest3.beforeAll)(async () => {
+    (0, import_vitest4.beforeAll)(async () => {
       store = await options.factory();
       await store.drop();
       await store.seed();
     });
-    (0, import_vitest3.afterAll)(async () => {
+    (0, import_vitest4.afterAll)(async () => {
       await store.dispose();
     });
-    (0, import_vitest3.describe)("commit", () => {
-      (0, import_vitest3.it)("returns committed events with sequenced ids and versions", async () => {
+    (0, import_vitest4.describe)("commit", () => {
+      (0, import_vitest4.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)],
-          makeMeta({ stream: s })
-        );
-        (0, import_vitest3.expect)(committed).toHaveLength(3);
-        (0, import_vitest3.expect)(committed[0].version).toBe(0);
-        (0, import_vitest3.expect)(committed[1].version).toBe(1);
-        (0, import_vitest3.expect)(committed[2].version).toBe(2);
-        (0, import_vitest3.expect)(committed[0].name).toBe("Incremented");
-        (0, import_vitest3.expect)(committed[2].data).toEqual({ amount: 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 });
         for (let i = 1; i < committed.length; i++) {
-          (0, import_vitest3.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          (0, import_vitest4.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
-      (0, import_vitest3.it)("attaches correlation and stream metadata", async () => {
+      (0, import_vitest4.it)("attaches correlation and stream metadata", async () => {
         const s = `commit-meta-${uid()}`;
         const correlation = `cor-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1)],
-          makeMeta({ stream: s, correlation })
+          make_meta({ stream: s, correlation })
         );
-        (0, import_vitest3.expect)(committed[0].stream).toBe(s);
-        (0, import_vitest3.expect)(committed[0].meta.correlation).toBe(correlation);
+        (0, import_vitest4.expect)(committed[0].stream).toBe(s);
+        (0, import_vitest4.expect)(committed[0].meta.correlation).toBe(correlation);
       });
-      (0, import_vitest3.it)("throws ConcurrencyError when expectedVersion is wrong", async () => {
+      (0, import_vitest4.it)("throws ConcurrencyError when expectedVersion is wrong", async () => {
         const s = `commit-cc-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
         await store.commit(
           s,
           [inc(1)],
-          makeMeta({ stream: s }),
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s }),
           0
         );
-        await (0, import_vitest3.expect)(
-          store.commit(s, [inc(1)], makeMeta({ stream: s }), 0)
+        await (0, import_vitest4.expect)(
+          store.commit(s, [inc(1)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(import_act.ConcurrencyError);
       });
-      (0, import_vitest3.it)("preserves prior events when a concurrent commit is rejected", async () => {
+      (0, import_vitest4.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)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
-        await (0, import_vitest3.expect)(
-          store.commit(s, [inc(3)], makeMeta({ stream: s }), 0)
+        await (0, import_vitest4.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_vitest3.expect)(found).toHaveLength(2);
+        (0, import_vitest4.expect)(found).toHaveLength(2);
       });
     });
-    (0, import_vitest3.describe)("query", () => {
-      (0, import_vitest3.it)("filters by stream, names, correlation, limit, with_snaps", async () => {
+    (0, import_vitest4.describe)("query", () => {
+      (0, import_vitest4.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()}`;
         await store.commit(
           s1,
           [inc(1), dec(1)],
-          makeMeta({ stream: s1, correlation: cor })
+          make_meta({ stream: s1, correlation: cor })
         );
         await store.commit(
           s2,
           [inc(2), dec(2), reset()],
-          makeMeta({ stream: s2, correlation: cor })
+          make_meta({ stream: s2, correlation: cor })
         );
-        const byStream = await collect(store, {
+        const by_stream = await collect(store, {
           stream: s1,
           stream_exact: true
         });
-        (0, import_vitest3.expect)(byStream).toHaveLength(2);
-        const byName = await collect(store, {
+        (0, import_vitest4.expect)(by_stream).toHaveLength(2);
+        const by_name = await collect(store, {
           stream: s2,
           stream_exact: true,
           names: ["Reset"]
         });
-        (0, import_vitest3.expect)(byName).toHaveLength(1);
-        (0, import_vitest3.expect)(byName[0].name).toBe("Reset");
-        const byCorrelation = await collect(store, { correlation: cor });
-        (0, import_vitest3.expect)(byCorrelation).toHaveLength(5);
+        (0, import_vitest4.expect)(by_name).toHaveLength(1);
+        (0, import_vitest4.expect)(by_name[0].name).toBe("Reset");
+        const by_correlation = await collect(store, { correlation: cor });
+        (0, import_vitest4.expect)(by_correlation).toHaveLength(5);
         const limited = await collect(store, {
           correlation: cor,
           limit: 2
         });
-        (0, import_vitest3.expect)(limited).toHaveLength(2);
+        (0, import_vitest4.expect)(limited).toHaveLength(2);
       });
-      (0, import_vitest3.it)("supports backward traversal", async () => {
+      (0, import_vitest4.it)("supports backward traversal", async () => {
         const s = `q-back-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1), inc(2), inc(3)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const forward = await collect(store, { stream: s, stream_exact: true });
         const backward = await collect(store, {
@@ -348,8 +401,8 @@ var runStoreTck = (options) => {
           stream_exact: true,
           backward: true
         });
-        (0, import_vitest3.expect)(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
-        (0, import_vitest3.expect)(backward.map((e) => e.id)).toEqual(
+        (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(
           [...committed].reverse().map((c) => c.id)
         );
         const latest = await collect(store, {
@@ -358,58 +411,62 @@ var runStoreTck = (options) => {
           backward: true,
           limit: 1
         });
-        (0, import_vitest3.expect)(latest).toHaveLength(1);
-        (0, import_vitest3.expect)(latest[0].id).toBe(committed.at(-1).id);
+        (0, import_vitest4.expect)(latest).toHaveLength(1);
+        (0, import_vitest4.expect)(latest[0].id).toBe(committed.at(-1).id);
       });
-      (0, import_vitest3.it)("after/before bound the id range", async () => {
+      (0, import_vitest4.it)("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1), inc(2), inc(3), inc(4)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
-        const afterFirst = await collect(store, {
+        const after_first = await collect(store, {
           stream: s,
           stream_exact: true,
           after: committed[0].id
         });
-        (0, import_vitest3.expect)(afterFirst.map((e) => e.id)).toEqual(
+        (0, import_vitest4.expect)(after_first.map((e) => e.id)).toEqual(
           committed.slice(1).map((c) => c.id)
         );
-        const beforeLast = await collect(store, {
+        const before_last = await collect(store, {
           stream: s,
           stream_exact: true,
           before: committed[committed.length - 1].id
         });
-        (0, import_vitest3.expect)(beforeLast.map((e) => e.id)).toEqual(
+        (0, import_vitest4.expect)(before_last.map((e) => e.id)).toEqual(
           committed.slice(0, -1).map((c) => c.id)
         );
       });
-      (0, import_vitest3.it)("created_after/created_before filter by timestamp", async () => {
+      (0, import_vitest4.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);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        const inWindow = await collect(store, {
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        const in_window = await collect(store, {
           stream: s,
           stream_exact: true,
           created_after: before,
           created_before: future
         });
-        (0, import_vitest3.expect)(inWindow.length).toBe(1);
-        const outOfWindow = await collect(store, {
+        (0, import_vitest4.expect)(in_window.length).toBe(1);
+        const out_of_window = await collect(store, {
           stream: s,
           stream_exact: true,
           created_after: future
         });
-        (0, import_vitest3.expect)(outOfWindow.length).toBe(0);
+        (0, import_vitest4.expect)(out_of_window.length).toBe(0);
       });
-      (0, import_vitest3.it)("backward traversal short-circuits at `after` id boundary", async () => {
+      (0, import_vitest4.it)("backward traversal short-circuits at `after` id boundary", async () => {
         const s = `q-back-after-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1), inc(2), inc(3)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const got = await collect(store, {
           stream: s,
@@ -417,14 +474,18 @@ var runStoreTck = (options) => {
           backward: true,
           after: committed[0].id
         });
-        (0, import_vitest3.expect)(got.map((e) => e.id)).toEqual([
+        (0, import_vitest4.expect)(got.map((e) => e.id)).toEqual([
           committed[2].id,
           committed[1].id
         ]);
       });
-      (0, import_vitest3.it)("backward traversal short-circuits at `created_after` boundary", async () => {
+      (0, import_vitest4.it)("backward traversal short-circuits at `created_after` boundary", async () => {
         const s = `q-back-cafter-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const future = new Date(Date.now() + 6e4);
         const got = await collect(store, {
           stream: s,
@@ -432,11 +493,11 @@ var runStoreTck = (options) => {
           backward: true,
           created_after: future
         });
-        (0, import_vitest3.expect)(got).toHaveLength(0);
+        (0, import_vitest4.expect)(got).toHaveLength(0);
       });
-      (0, import_vitest3.it)("backward traversal honors created_before by skipping newer events", async () => {
+      (0, import_vitest4.it)("backward traversal honors created_before by skipping newer events", async () => {
         const s = `q-back-ts-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta());
+        await store.commit(s, [inc(1)], make_meta());
         const past = new Date(Date.now() - 6e4);
         const got = await collect(store, {
           stream: s,
@@ -444,302 +505,362 @@ var runStoreTck = (options) => {
           backward: true,
           created_before: past
         });
-        (0, import_vitest3.expect)(got).toHaveLength(0);
+        (0, import_vitest4.expect)(got).toHaveLength(0);
       });
-      (0, import_vitest3.it)("stream_exact disables regex matching", async () => {
+      (0, import_vitest4.it)("stream_exact disables regex matching", async () => {
         const tag = uid();
         const a = `q-exact-${tag}`;
         const b = `q-exact-${tag}-extra`;
-        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
-        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        await store.commit(
+          a,
+          [inc(1)],
+          make_meta({ stream: a })
+        );
+        await store.commit(
+          b,
+          [inc(2)],
+          make_meta({ stream: b })
+        );
         const exact = await collect(store, { stream: a, stream_exact: true });
-        (0, import_vitest3.expect)(exact).toHaveLength(1);
-        (0, import_vitest3.expect)(exact[0].data).toEqual({ amount: 1 });
+        (0, import_vitest4.expect)(exact).toHaveLength(1);
+        (0, import_vitest4.expect)(exact[0].data).toEqual({ amount: 1 });
       });
-      (0, import_vitest3.it)("plain regex without anchors is a substring match", async () => {
+      (0, import_vitest4.it)("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qr-${tag}-inner`;
         const longer = `qr-${tag}-inner-extra`;
         await store.commit(
           inner,
           [inc(1)],
-          makeMeta({ stream: inner })
+          make_meta({ stream: inner })
         );
         await store.commit(
           longer,
           [inc(2)],
-          makeMeta({ stream: longer })
+          make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `qr-${tag}-inner` });
-        (0, import_vitest3.expect)(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
+        (0, import_vitest4.expect)(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
       });
-      (0, import_vitest3.it)("caller-anchored `^name$` matches only the whole string", async () => {
+      (0, import_vitest4.it)("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qr-${tag}-anchor`;
         const longer = `qr-${tag}-anchor-extra`;
         await store.commit(
           inner,
           [inc(1)],
-          makeMeta({ stream: inner })
+          make_meta({ stream: inner })
         );
         await store.commit(
           longer,
           [inc(2)],
-          makeMeta({ stream: longer })
+          make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `^qr-${tag}-anchor$` });
-        (0, import_vitest3.expect)(got).toHaveLength(1);
-        (0, import_vitest3.expect)(got[0].stream).toBe(inner);
+        (0, import_vitest4.expect)(got).toHaveLength(1);
+        (0, import_vitest4.expect)(got[0].stream).toBe(inner);
       });
-      (0, import_vitest3.it)("caller-anchored `^prefix` matches by prefix", async () => {
+      (0, import_vitest4.it)("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qr-${tag}-pfx-a`;
         const b = `qr-${tag}-pfx-b`;
         const other = `zz-${tag}-other`;
-        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
-        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        await store.commit(
+          a,
+          [inc(1)],
+          make_meta({ stream: a })
+        );
+        await store.commit(
+          b,
+          [inc(2)],
+          make_meta({ stream: b })
+        );
         await store.commit(
           other,
           [inc(3)],
-          makeMeta({ stream: other })
+          make_meta({ stream: other })
         );
         const got = await collect(store, { stream: `^qr-${tag}-pfx-` });
-        (0, import_vitest3.expect)(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
+        (0, import_vitest4.expect)(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
       });
     });
-    (0, import_vitest3.describe)("subscribe + claim + ack", () => {
-      (0, import_vitest3.it)("subscribes new streams and is idempotent on repeat", async () => {
+    (0, import_vitest4.describe)("subscribe + claim + ack", () => {
+      (0, import_vitest4.it)("subscribes new streams and is idempotent on repeat", async () => {
         const s = `sub-${uid()}`;
         const first = await store.subscribe([{ stream: s }]);
-        (0, import_vitest3.expect)(first.subscribed).toBe(1);
+        (0, import_vitest4.expect)(first.subscribed).toBe(1);
         const second = await store.subscribe([{ stream: s }]);
-        (0, import_vitest3.expect)(second.subscribed).toBe(0);
+        (0, import_vitest4.expect)(second.subscribed).toBe(0);
       });
-      (0, import_vitest3.it)("claims a subscribed stream and ack releases the lease", async () => {
+      (0, import_vitest4.it)("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const by = `worker-${uid()}`;
         const leased = await store.claim(100, 0, by, 1e4);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest3.expect)(mine).toBeDefined();
-        (0, import_vitest3.expect)(mine.by).toBe(by);
+        (0, import_vitest4.expect)(mine).toBeDefined();
+        (0, import_vitest4.expect)(mine.by).toBe(by);
         await store.ack([{ ...mine, at: mine.at + 1 }]);
       });
-      (0, import_vitest3.it)("does not double-claim a held lease", async () => {
+      (0, import_vitest4.it)("does not double-claim a held lease", async () => {
         const s = `claim-held-${uid()}`;
         const other = `claim-other-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1e5);
         const targetA = leasedA.find((l) => l.stream === s);
-        (0, import_vitest3.expect)(targetA).toBeDefined();
+        (0, import_vitest4.expect)(targetA).toBeDefined();
         await store.subscribe([{ stream: other }]);
         await store.commit(
           other,
           [inc(2)],
-          makeMeta({ stream: other })
+          make_meta({ stream: other })
         );
         const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
-        (0, import_vitest3.expect)(leasedB.length).toBeGreaterThan(0);
-        (0, import_vitest3.expect)(leasedB.find((l) => l.stream === s)).toBeUndefined();
-        (0, import_vitest3.expect)(leasedB.find((l) => l.stream === other)).toBeDefined();
+        (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_vitest3.it)("supports dual frontiers (lagging + leading)", async () => {
+      (0, import_vitest4.it)("supports dual frontiers (lagging + leading)", async () => {
         const s = `claim-dual-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
           s,
           [inc(1), inc(2)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const first = await store.claim(100, 0, `w-${uid()}`, 1);
         const mine = first.find((l) => l.stream === s);
-        (0, import_vitest3.expect)(mine).toBeDefined();
+        (0, import_vitest4.expect)(mine).toBeDefined();
         await store.ack([{ ...mine, at: mine.at + 1 }]);
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
-        (0, import_vitest3.expect)(second.find((l) => l.stream === s)).toBeDefined();
+        (0, import_vitest4.expect)(second.find((l) => l.stream === s)).toBeDefined();
       });
-      (0, import_vitest3.it)("dedupes when both frontiers would return the same stream", async () => {
+      (0, import_vitest4.it)("dedupes when both frontiers would return the same stream", async () => {
         const s = `claim-dedup-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const claimed = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const matches = claimed.filter((l) => l.stream === s);
-        (0, import_vitest3.expect)(matches).toHaveLength(1);
+        (0, import_vitest4.expect)(matches).toHaveLength(1);
       });
-      (0, import_vitest3.it)("silently ignores ack from the wrong holder", async () => {
+      (0, import_vitest4.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 }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         await store.commit(
           sibling,
           [inc(2)],
-          makeMeta({ stream: sibling })
+          make_meta({ stream: sibling })
         );
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        const siblingLease = leased.find((l) => l.stream === sibling);
-        (0, import_vitest3.expect)(mine).toBeDefined();
-        (0, import_vitest3.expect)(siblingLease).toBeDefined();
+        const sibling_lease = leased.find((l) => l.stream === sibling);
+        (0, import_vitest4.expect)(mine).toBeDefined();
+        (0, import_vitest4.expect)(sibling_lease).toBeDefined();
         const acked = await store.ack([
           { ...mine, by: "imposter" },
-          siblingLease
+          sibling_lease
         ]);
-        (0, import_vitest3.expect)(acked.length).toBeGreaterThan(0);
-        (0, import_vitest3.expect)(acked.find((l) => l.stream === s)).toBeUndefined();
+        (0, import_vitest4.expect)(acked.length).toBeGreaterThan(0);
+        (0, import_vitest4.expect)(acked.find((l) => l.stream === s)).toBeUndefined();
       });
-      (0, import_vitest3.it)("ack with a stale (lower) watermark does not throw", async () => {
+      (0, import_vitest4.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_vitest3.expect)(mine).toBeDefined();
-        await (0, import_vitest3.expect)(
+        (0, import_vitest4.expect)(mine).toBeDefined();
+        await (0, import_vitest4.expect)(
           store.ack([{ ...mine, at: -5 }])
         ).resolves.toBeDefined();
       });
-      (0, import_vitest3.it)("claim with no subscribed streams returns an empty array", async () => {
+      (0, import_vitest4.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_vitest3.expect)(claimed).toEqual([]);
+          (0, import_vitest4.expect)(claimed).toEqual([]);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    (0, import_vitest3.describe)("block", () => {
-      (0, import_vitest3.it)("hides blocked streams from claim", async () => {
+    (0, import_vitest4.describe)("block", () => {
+      (0, import_vitest4.it)("hides blocked streams from claim", async () => {
         const s = `block-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest3.expect)(mine).toBeDefined();
+        (0, import_vitest4.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_vitest3.expect)(blocked).toHaveLength(1);
-        (0, import_vitest3.expect)(blocked[0].error).toBe("boom");
+        (0, import_vitest4.expect)(blocked).toHaveLength(1);
+        (0, import_vitest4.expect)(blocked[0].error).toBe("boom");
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
-        (0, import_vitest3.expect)(again.find((l) => l.stream === s)).toBeUndefined();
+        (0, import_vitest4.expect)(again.find((l) => l.stream === s)).toBeUndefined();
       });
-      (0, import_vitest3.it)("rejects block calls from a different holder", async () => {
+      (0, import_vitest4.it)("rejects block calls from a different holder", async () => {
         const s = `block-wrong-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest3.expect)(mine).toBeDefined();
+        (0, import_vitest4.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_vitest3.expect)(blocked).toHaveLength(0);
+        (0, import_vitest4.expect)(blocked).toHaveLength(0);
       });
     });
-    (0, import_vitest3.describe)("reset", () => {
-      (0, import_vitest3.it)("rewinds a stream watermark to -1", async () => {
+    (0, import_vitest4.describe)("reset", () => {
+      (0, import_vitest4.it)("rewinds a stream watermark to -1", async () => {
         const s = `reset-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest3.expect)(mine).toBeDefined();
+        (0, import_vitest4.expect)(mine).toBeDefined();
         await store.ack([{ ...mine, at: 99 }]);
-        (0, import_vitest3.expect)(await store.reset([s])).toBe(1);
+        (0, import_vitest4.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_vitest3.expect)(back).toBeDefined();
-        (0, import_vitest3.expect)(back.at).toBe(-1);
+        (0, import_vitest4.expect)(back).toBeDefined();
+        (0, import_vitest4.expect)(back.at).toBe(-1);
       });
-      (0, import_vitest3.it)("clears blocked status when resetting", async () => {
+      (0, import_vitest4.it)("clears blocked status when resetting", async () => {
         const s = `reset-blk-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
-        (0, import_vitest3.expect)(await store.reset([s])).toBe(1);
+        (0, import_vitest4.expect)(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
-        (0, import_vitest3.expect)(after.find((l) => l.stream === s)).toBeDefined();
+        (0, import_vitest4.expect)(after.find((l) => l.stream === s)).toBeDefined();
       });
-      (0, import_vitest3.it)("returns 0 for unknown streams and empty input", async () => {
-        (0, import_vitest3.expect)(await store.reset([`missing-${uid()}`])).toBe(0);
-        (0, import_vitest3.expect)(await store.reset([])).toBe(0);
+      (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_vitest3.describe)("unblock", () => {
-      (0, import_vitest3.it)("clears blocked flag and preserves the watermark", async () => {
+    (0, import_vitest4.describe)("unblock", () => {
+      (0, import_vitest4.it)("clears blocked flag and preserves the watermark", async () => {
         const s = `unblock-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        await store.commit(s, [inc(2)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(2)],
+          make_meta({ stream: s })
+        );
         const first = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = first.find((l) => l.stream === s);
         await store.ack([{ ...m1, at: m1.at }]);
-        const beforeBlock = await store.claim(100, 0, `w-${uid()}`, 1e5);
-        const m2 = beforeBlock.find((l) => l.stream === s);
-        (0, import_vitest3.expect)(m2).toBeDefined();
-        const watermarkBefore = m2.at;
+        const before_block = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const m2 = before_block.find((l) => l.stream === s);
+        (0, import_vitest4.expect)(m2).toBeDefined();
+        const watermark_before = m2.at;
         await store.block([{ ...m2, error: "permanent" }]);
-        let blockedFlag;
+        let blocked_flag;
         await store.query_streams(
           (p) => {
-            blockedFlag = p.blocked;
+            blocked_flag = p.blocked;
           },
           { stream: s, stream_exact: true, limit: 1 }
         );
-        (0, import_vitest3.expect)(blockedFlag).toBe(true);
-        (0, import_vitest3.expect)(await store.unblock([s])).toBe(1);
+        (0, import_vitest4.expect)(blocked_flag).toBe(true);
+        (0, import_vitest4.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_vitest3.expect)(back).toBeDefined();
-        (0, import_vitest3.expect)(back.at).toBe(watermarkBefore);
-        (0, import_vitest3.expect)(back.retry).toBe(0);
+        (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_vitest3.it)("returns 0 when the stream is not blocked", async () => {
+      (0, import_vitest4.it)("returns 0 when the stream is not blocked", async () => {
         const s = `unblock-noop-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        (0, import_vitest3.expect)(await store.unblock([s])).toBe(0);
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        (0, import_vitest4.expect)(await store.unblock([s])).toBe(0);
       });
-      (0, import_vitest3.it)("returns 0 for unknown streams and empty input", async () => {
-        (0, import_vitest3.expect)(await store.unblock([`missing-${uid()}`])).toBe(0);
-        (0, import_vitest3.expect)(await store.unblock([])).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_vitest3.it)("only counts streams that were actually blocked", async () => {
+      (0, import_vitest4.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 }]);
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = leased.find((l) => l.stream === s1);
         const others = leased.filter((l) => l.stream !== s1);
         await store.ack(others);
         await store.block([{ ...m1, error: "boom" }]);
-        (0, import_vitest3.expect)(await store.unblock([s1, s2])).toBe(1);
+        (0, import_vitest4.expect)(await store.unblock([s1, s2])).toBe(1);
       });
-      (0, import_vitest3.it)("filter form: unblocks by stream pattern", async () => {
+      (0, import_vitest4.it)("filter form: unblocks by stream pattern", async () => {
         const tag = uid();
         const s1 = `unblock-filter-${tag}-a`;
         const s2 = `unblock-filter-${tag}-b`;
@@ -748,17 +869,17 @@ var runStoreTck = (options) => {
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         await store.commit(
           s3,
           [inc(1)],
-          makeMeta({ stream: s3 })
+          make_meta({ stream: s3 })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const blockable = leased.filter((l) => l.stream === s1 || l.stream === s2 || l.stream === s3).map((l) => ({ ...l, error: "boom" }));
@@ -771,13 +892,13 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-filter-${tag}-`
         });
-        (0, import_vitest3.expect)(count).toBe(2);
+        (0, import_vitest4.expect)(count).toBe(2);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
-        (0, import_vitest3.expect)(after.find((l) => l.stream === s3)).toBeUndefined();
-        (0, import_vitest3.expect)(after.find((l) => l.stream === s1)).toBeDefined();
-        (0, import_vitest3.expect)(after.find((l) => l.stream === s2)).toBeDefined();
+        (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_vitest3.it)("filter form: empty filter unblocks every blocked stream", async () => {
+      (0, import_vitest4.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`;
@@ -785,12 +906,12 @@ var runStoreTck = (options) => {
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.filter((l) => l.stream === s1 || l.stream === s2);
@@ -801,14 +922,18 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-empty-${tag}-`
         });
-        (0, import_vitest3.expect)(count).toBe(2);
+        (0, import_vitest4.expect)(count).toBe(2);
       });
-      (0, import_vitest3.it)("filter form: explicit blocked:false matches nothing", async () => {
+      (0, import_vitest4.it)("filter form: explicit blocked:false matches nothing", async () => {
         const tag = uid();
         const s = `unblock-blocked-false-${tag}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        (0, import_vitest3.expect)(
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        (0, import_vitest4.expect)(
           await store.unblock({
             stream: `^unblock-blocked-false-${tag}`,
             blocked: false
@@ -816,8 +941,8 @@ var runStoreTck = (options) => {
         ).toBe(0);
       });
     });
-    (0, import_vitest3.describe)("reset filter form", () => {
-      (0, import_vitest3.it)("resets streams matching a stream pattern", async () => {
+    (0, import_vitest4.describe)("reset filter form", () => {
+      (0, import_vitest4.it)("resets streams matching a stream pattern", async () => {
         const tag = uid();
         const s1 = `reset-filter-${tag}-a`;
         const s2 = `reset-filter-${tag}-b`;
@@ -830,17 +955,17 @@ var runStoreTck = (options) => {
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         await store.commit(
           other,
           [inc(1)],
-          makeMeta({ stream: other })
+          make_meta({ stream: other })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.filter(
@@ -848,8 +973,8 @@ 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_vitest3.expect)(count).toBe(2);
-        const positionFor = async (name) => {
+        (0, import_vitest4.expect)(count).toBe(2);
+        const position_for = async (name) => {
           let at = null;
           await store.query_streams(
             (p) => {
@@ -859,11 +984,11 @@ var runStoreTck = (options) => {
           );
           return at;
         };
-        (0, import_vitest3.expect)(await positionFor(s1)).toBe(-1);
-        (0, import_vitest3.expect)(await positionFor(s2)).toBe(-1);
-        (0, import_vitest3.expect)(await positionFor(other)).toBeGreaterThan(-1);
+        (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_vitest3.it)("filter form: resets only blocked streams when blocked:true", async () => {
+      (0, import_vitest4.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`;
@@ -871,12 +996,12 @@ var runStoreTck = (options) => {
         await store.commit(
           s1,
           [inc(1)],
-          makeMeta({ stream: s1 })
+          make_meta({ stream: s1 })
         );
         await store.commit(
           s2,
           [inc(1)],
-          makeMeta({ stream: s2 })
+          make_meta({ stream: s2 })
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = leased.find((l) => l.stream === s1);
@@ -886,11 +1011,11 @@ var runStoreTck = (options) => {
           stream: `^reset-blocked-${tag}-`,
           blocked: true
         });
-        (0, import_vitest3.expect)(count).toBe(1);
+        (0, import_vitest4.expect)(count).toBe(1);
       });
     });
-    (0, import_vitest3.describe)("prioritize", () => {
-      (0, import_vitest3.it)("sets priority directly, overriding subscribe's max() rule", async () => {
+    (0, import_vitest4.describe)("prioritize", () => {
+      (0, import_vitest4.it)("sets priority directly, overriding subscribe's max() rule", async () => {
         const tag = uid();
         const s1 = `pri-${tag}-a`;
         const s2 = `pri-${tag}-b`;
@@ -902,7 +1027,7 @@ var runStoreTck = (options) => {
           { stream: s1, stream_exact: true },
           3
         );
-        (0, import_vitest3.expect)(updated).toBe(1);
+        (0, import_vitest4.expect)(updated).toBe(1);
         const got1 = {};
         const got2 = {};
         await store.query_streams(
@@ -912,12 +1037,12 @@ var runStoreTck = (options) => {
           },
           { stream: `pri-${tag}-.*`, limit: 100 }
         );
-        (0, import_vitest3.expect)(got1.priority).toBe(3);
-        (0, import_vitest3.expect)(got2.priority).toBe(5);
+        (0, import_vitest4.expect)(got1.priority).toBe(3);
+        (0, import_vitest4.expect)(got2.priority).toBe(5);
       });
     });
-    (0, import_vitest3.describe)("lanes", () => {
-      (0, import_vitest3.it)("subscribe defaults lane to 'default' when omitted", async () => {
+    (0, import_vitest4.describe)("lanes", () => {
+      (0, import_vitest4.it)("subscribe defaults lane to 'default' when omitted", async () => {
         const s = `lane-default-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const seen = [];
@@ -925,9 +1050,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest3.expect)(seen).toEqual(["default"]);
+        (0, import_vitest4.expect)(seen).toEqual(["default"]);
       });
-      (0, import_vitest3.it)("subscribe records the lane passed in", async () => {
+      (0, import_vitest4.it)("subscribe records the lane passed in", async () => {
         const s = `lane-set-${uid()}`;
         await store.subscribe([{ stream: s, lane: "slow" }]);
         const seen = [];
@@ -935,9 +1060,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest3.expect)(seen).toEqual(["slow"]);
+        (0, import_vitest4.expect)(seen).toEqual(["slow"]);
       });
-      (0, import_vitest3.it)("subscribe re-lanes existing streams on subsequent calls", async () => {
+      (0, import_vitest4.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" }]);
@@ -946,45 +1071,45 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest3.expect)(seen).toEqual(["fast"]);
+        (0, import_vitest4.expect)(seen).toEqual(["fast"]);
       });
-      (0, import_vitest3.it)("claim() filters by lane when supplied and returns lane on the Lease", async () => {
+      (0, import_vitest4.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}`;
-        const subDefault = `lane-claim-def-${tag}`;
-        const subSlow = `lane-claim-slow-${tag}`;
+        const sub_default = `lane-claim-def-${tag}`;
+        const sub_slow = `lane-claim-slow-${tag}`;
         await store.commit(
           src1,
           [inc(1)],
-          makeMeta({ stream: src1 })
+          make_meta({ stream: src1 })
         );
         await store.commit(
           src2,
           [inc(1)],
-          makeMeta({ stream: src2 })
+          make_meta({ stream: src2 })
         );
         await store.subscribe([
-          { stream: subDefault, source: src1 },
-          { stream: subSlow, source: src2, lane: "slow" }
+          { stream: sub_default, source: src1 },
+          { stream: sub_slow, source: src2, lane: "slow" }
         ]);
         const slow = await store.claim(50, 0, `w-slow-${tag}`, 1e3, "slow");
-        const slowMine = slow.filter(
-          (l) => l.stream === subDefault || l.stream === subSlow
+        const slow_mine = slow.filter(
+          (l) => l.stream === sub_default || l.stream === sub_slow
         );
-        (0, import_vitest3.expect)(slowMine.map((l) => l.stream)).toEqual([subSlow]);
-        (0, import_vitest3.expect)(slowMine[0]?.lane).toBe("slow");
-        await store.ack(slowMine.map((l) => ({ ...l, at: l.at + 1 })));
+        (0, import_vitest4.expect)(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
+        (0, import_vitest4.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 allMine = all.filter((l) => l.stream === subDefault || l.stream === subSlow).map((l) => ({ stream: l.stream, lane: l.lane }));
-        (0, import_vitest3.expect)(allMine).toEqual(
-          import_vitest3.expect.arrayContaining([
-            { stream: subDefault, lane: "default" },
-            { stream: subSlow, lane: "slow" }
+        const all_mine = all.filter((l) => l.stream === sub_default || l.stream === sub_slow).map((l) => ({ stream: l.stream, lane: l.lane }));
+        (0, import_vitest4.expect)(all_mine).toEqual(
+          import_vitest4.expect.arrayContaining([
+            { stream: sub_default, lane: "default" },
+            { stream: sub_slow, lane: "slow" }
           ])
         );
       });
-      (0, import_vitest3.it)("query_streams filters by lane", async () => {
+      (0, import_vitest4.it)("query_streams filters by lane", async () => {
         const tag = uid();
         const a = `lane-q-a-${tag}`;
         const b = `lane-q-b-${tag}`;
@@ -1000,9 +1125,9 @@ var runStoreTck = (options) => {
           stream: `lane-q-.*-${tag}`,
           limit: 100
         });
-        (0, import_vitest3.expect)(seen.sort()).toEqual([a, c]);
+        (0, import_vitest4.expect)(seen.sort()).toEqual([a, c]);
       });
-      (0, import_vitest3.it)("prioritize filters by lane", async () => {
+      (0, import_vitest4.it)("prioritize filters by lane", async () => {
         const tag = uid();
         const a = `lane-pri-a-${tag}`;
         const b = `lane-pri-b-${tag}`;
@@ -1011,16 +1136,16 @@ var runStoreTck = (options) => {
           { stream: b, lane: `pfast-${tag}` }
         ]);
         const updated = await store.prioritize({ lane: `pslow-${tag}` }, 7);
-        (0, import_vitest3.expect)(updated).toBe(1);
+        (0, import_vitest4.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_vitest3.expect)(seen.get(a)).toBe(7);
-        (0, import_vitest3.expect)(seen.get(b)).toBe(0);
+        (0, import_vitest4.expect)(seen.get(a)).toBe(7);
+        (0, import_vitest4.expect)(seen.get(b)).toBe(0);
       });
-      (0, import_vitest3.it)("reset filters by lane", async () => {
+      (0, import_vitest4.it)("reset filters by lane", async () => {
         const tag = uid();
         const src = `lane-reset-src-${tag}`;
         const a = `lane-reset-a-${tag}`;
@@ -1028,7 +1153,7 @@ var runStoreTck = (options) => {
         await store.commit(
           src,
           [inc(1)],
-          makeMeta({ stream: src })
+          make_meta({ stream: src })
         );
         await store.subscribe([
           { stream: a, source: src, lane: `rslow-${tag}` },
@@ -1038,7 +1163,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_vitest3.expect)(count).toBe(1);
+        (0, import_vitest4.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), {
@@ -1046,10 +1171,10 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        (0, import_vitest3.expect)(ats.get(a)).toBe(-1);
-        (0, import_vitest3.expect)(ats.get(b)).toBeGreaterThanOrEqual(0);
+        (0, import_vitest4.expect)(ats.get(a)).toBe(-1);
+        (0, import_vitest4.expect)(ats.get(b)).toBeGreaterThanOrEqual(0);
       });
-      (0, import_vitest3.it)("unblock filters by lane", async () => {
+      (0, import_vitest4.it)("unblock filters by lane", async () => {
         const tag = uid();
         const src = `lane-ub-src-${tag}`;
         const a = `lane-ub-a-${tag}`;
@@ -1057,7 +1182,7 @@ var runStoreTck = (options) => {
         await store.commit(
           src,
           [inc(1)],
-          makeMeta({ stream: src })
+          make_meta({ stream: src })
         );
         await store.subscribe([
           { stream: a, source: src, lane: `uslow-${tag}` },
@@ -1067,7 +1192,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_vitest3.expect)(count).toBe(1);
+        (0, import_vitest4.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), {
@@ -1075,20 +1200,20 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        (0, import_vitest3.expect)(blocked.get(a)).toBe(false);
-        (0, import_vitest3.expect)(blocked.get(b)).toBe(true);
+        (0, import_vitest4.expect)(blocked.get(a)).toBe(false);
+        (0, import_vitest4.expect)(blocked.get(b)).toBe(true);
       });
     });
-    (0, import_vitest3.describe)("truncate", () => {
-      (0, import_vitest3.it)("seeds a tombstone when no snapshot is provided", async () => {
+    (0, import_vitest4.describe)("truncate", () => {
+      (0, import_vitest4.it)("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
         await store.commit(
           s,
           [inc(1), inc(2)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const result = await store.truncate([{ stream: s }]);
-        (0, import_vitest3.expect)(result.get(s)?.deleted).toBe(2);
+        (0, import_vitest4.expect)(result.get(s)?.deleted).toBe(2);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1096,18 +1221,22 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest3.expect)(remaining).toHaveLength(1);
-        (0, import_vitest3.expect)(remaining[0].name).toBe(
+        (0, import_vitest4.expect)(remaining).toHaveLength(1);
+        (0, import_vitest4.expect)(remaining[0].name).toBe(
           "__tombstone__"
         );
       });
-      (0, import_vitest3.it)("seeds a snapshot when one is provided", async () => {
+      (0, import_vitest4.it)("seeds a snapshot when one is provided", async () => {
         const s = `trunc-snap-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const result = await store.truncate([
           { stream: s, snapshot: { count: 7 } }
         ]);
-        (0, import_vitest3.expect)(result.get(s)?.deleted).toBe(1);
+        (0, import_vitest4.expect)(result.get(s)?.deleted).toBe(1);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1115,24 +1244,24 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, with_snaps: true }
         );
-        (0, import_vitest3.expect)(remaining).toHaveLength(1);
-        (0, import_vitest3.expect)(remaining[0].name).toBe(
+        (0, import_vitest4.expect)(remaining).toHaveLength(1);
+        (0, import_vitest4.expect)(remaining[0].name).toBe(
           "__snapshot__"
         );
-        (0, import_vitest3.expect)(remaining[0].data).toEqual({ count: 7 });
+        (0, import_vitest4.expect)(remaining[0].data).toEqual({ count: 7 });
       });
-      (0, import_vitest3.it)("returns an empty map for empty input", async () => {
+      (0, import_vitest4.it)("returns an empty map for empty input", async () => {
         const result = await store.truncate([]);
-        (0, import_vitest3.expect)(result.size).toBe(0);
+        (0, import_vitest4.expect)(result.size).toBe(0);
       });
-      (0, import_vitest3.it)("returns 0 deleted for streams that don't exist", async () => {
+      (0, import_vitest4.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_vitest3.expect)(result.get(s)?.deleted).toBe(0);
+        (0, import_vitest4.expect)(result.get(s)?.deleted).toBe(0);
       });
     });
-    (0, import_vitest3.describe)("query_streams", () => {
-      (0, import_vitest3.it)("returns positions filtered by stream regex, exact, source, and source_exact", async () => {
+    (0, import_vitest4.describe)("query_streams", () => {
+      (0, import_vitest4.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`;
@@ -1147,41 +1276,41 @@ var runStoreTck = (options) => {
           { stream: dyn2, source: src2 }
         ]);
         const all = [];
-        const allResult = await store.query_streams(
+        const all_result = await store.query_streams(
           (p) => all.push({ stream: p.stream, source: p.source }),
           { stream: `qs-${tag}-.*` }
         );
-        (0, import_vitest3.expect)(allResult.count).toBe(4);
-        (0, import_vitest3.expect)(allResult.maxEventId).toBeGreaterThanOrEqual(-1);
-        (0, import_vitest3.expect)(all.map((p) => p.stream).sort()).toEqual(
+        (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(
           [proj1, proj2, dyn1, dyn2].sort()
         );
         const projections = [];
         await store.query_streams((p) => projections.push(p.stream), {
           stream: `qs-${tag}-projection-.*`
         });
-        (0, import_vitest3.expect)(projections.sort()).toEqual([proj1, proj2].sort());
+        (0, import_vitest4.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_vitest3.expect)(exact).toEqual([dyn1]);
-        const bySource = [];
-        await store.query_streams((p) => bySource.push(p.stream), {
+        (0, import_vitest4.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_vitest3.expect)(bySource.sort()).toEqual([dyn1, dyn2].sort());
-        const exactSource = [];
-        await store.query_streams((p) => exactSource.push(p.stream), {
+        (0, import_vitest4.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_vitest3.expect)(exactSource).toEqual([dyn2]);
+        (0, import_vitest4.expect)(exact_source).toEqual([dyn2]);
       });
-      (0, import_vitest3.it)("paginates with limit + after (keyset)", async () => {
+      (0, import_vitest4.it)("paginates with limit + after (keyset)", async () => {
         const tag = uid();
         const streams = [
           `qp-${tag}-a`,
@@ -1195,22 +1324,26 @@ var runStoreTck = (options) => {
           stream: `qp-${tag}-.*`,
           limit: 2
         });
-        (0, import_vitest3.expect)(page1).toHaveLength(2);
+        (0, import_vitest4.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_vitest3.expect)(page2).toHaveLength(2);
-        (0, import_vitest3.expect)([...page1, ...page2].sort()).toEqual([...streams].sort());
+        (0, import_vitest4.expect)(page2).toHaveLength(2);
+        (0, import_vitest4.expect)([...page1, ...page2].sort()).toEqual([...streams].sort());
       });
-      (0, import_vitest3.it)("filters by blocked status", async () => {
+      (0, import_vitest4.it)("filters by blocked status", async () => {
         const tag = uid();
         const s = `qb-${tag}`;
         const sibling = `qb-${tag}-other`;
         await store.subscribe([{ stream: s }, { stream: sibling }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const others = leased.filter((l) => l.stream !== s);
@@ -1221,18 +1354,18 @@ var runStoreTck = (options) => {
           (p) => blocked.push({ stream: p.stream, error: p.error }),
           { stream: `qb-${tag}.*`, blocked: true }
         );
-        (0, import_vitest3.expect)(blocked).toHaveLength(1);
-        (0, import_vitest3.expect)(blocked[0].error).toBe("boom");
+        (0, import_vitest4.expect)(blocked).toHaveLength(1);
+        (0, import_vitest4.expect)(blocked[0].error).toBe("boom");
         const unblocked = [];
         await store.query_streams((p) => unblocked.push(p.stream), {
           stream: `qb-${tag}.*`,
           blocked: false
         });
-        (0, import_vitest3.expect)(unblocked).toEqual([sibling]);
+        (0, import_vitest4.expect)(unblocked).toEqual([sibling]);
       });
     });
-    (0, import_vitest3.describe)("query_stats", () => {
-      (0, import_vitest3.it)("array input \u2014 returns head per stream, absent when not in input", async () => {
+    (0, import_vitest4.describe)("query_stats", () => {
+      (0, import_vitest4.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`;
@@ -1240,111 +1373,131 @@ var runStoreTck = (options) => {
         await store.commit(
           sA,
           [inc(1), inc(2)],
-          makeMeta({ stream: sA })
+          make_meta({ stream: sA })
         );
         await store.commit(
           sB,
           [dec(5)],
-          makeMeta({ stream: sB })
+          make_meta({ stream: sB })
         );
         await store.commit(
           sUnasked,
           [inc(99)],
-          makeMeta({ stream: sUnasked })
+          make_meta({ stream: sUnasked })
         );
         const stats = await store.query_stats([sA, sB]);
-        (0, import_vitest3.expect)(stats.size).toBe(2);
-        (0, import_vitest3.expect)(stats.get(sA)?.head.name).toBe("Incremented");
-        (0, import_vitest3.expect)((stats.get(sA)?.head.data).amount).toBe(2);
-        (0, import_vitest3.expect)(stats.get(sB)?.head.name).toBe("Decremented");
-        (0, import_vitest3.expect)((stats.get(sB)?.head.data).amount).toBe(5);
-        (0, import_vitest3.expect)(stats.has(sUnasked)).toBe(false);
+        (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);
         const empty = await store.query_stats([]);
-        (0, import_vitest3.expect)(empty.size).toBe(0);
+        (0, import_vitest4.expect)(empty.size).toBe(0);
         const unknown = await store.query_stats([`qst-${tag}-missing`]);
-        (0, import_vitest3.expect)(unknown.size).toBe(0);
+        (0, import_vitest4.expect)(unknown.size).toBe(0);
       });
-      (0, import_vitest3.it)("tail returns the earliest event per stream", async () => {
+      (0, import_vitest4.it)("tail returns the earliest event per stream", async () => {
         const tag = uid();
         const s = `qst-tail-${tag}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
-        await store.commit(s, [inc(2)], makeMeta({ stream: s }));
-        await store.commit(s, [inc(3)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(2)],
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(3)],
+          make_meta({ stream: s })
+        );
         const stats = await store.query_stats([s], {
           tail: true
         });
         const r = stats.get(s);
-        (0, import_vitest3.expect)(r?.head.name).toBe("Incremented");
-        (0, import_vitest3.expect)((r?.head.data).amount).toBe(3);
-        (0, import_vitest3.expect)(r?.tail?.name).toBe("Incremented");
-        (0, import_vitest3.expect)((r?.tail?.data).amount).toBe(1);
+        (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_vitest3.it)("count + names \u2014 full aggregates including framework markers", async () => {
+      (0, import_vitest4.it)("count + names \u2014 full aggregates including framework markers", async () => {
         const tag = uid();
         const s = `qst-cn-${tag}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         await store.truncate([{ stream: s, snapshot: { count: 99 } }]);
         await store.commit(
           s,
           [inc(2), inc(3), dec(1)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const stats = await store.query_stats([s], {
           count: true,
           names: true
         });
         const r = stats.get(s);
-        (0, import_vitest3.expect)(r?.count).toBe(4);
-        (0, import_vitest3.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
-        (0, import_vitest3.expect)(r?.names?.Incremented).toBe(2);
-        (0, import_vitest3.expect)(r?.names?.Decremented).toBe(1);
-        (0, import_vitest3.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
+        (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_vitest3.it)("exclude shifts head past filtered events; stream absent when all filtered", async () => {
+      (0, import_vitest4.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}`;
         await store.commit(
           s,
           [inc(1), dec(2), inc(3)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         await store.commit(
           sAllOut,
           [inc(7)],
-          makeMeta({ stream: sAllOut })
+          make_meta({ stream: sAllOut })
         );
         const all = await store.query_stats([s]);
-        (0, import_vitest3.expect)(all.get(s)?.head.name).toBe("Incremented");
-        (0, import_vitest3.expect)((all.get(s)?.head.data).amount).toBe(3);
+        (0, import_vitest4.expect)(all.get(s)?.head.name).toBe("Incremented");
+        (0, import_vitest4.expect)((all.get(s)?.head.data).amount).toBe(3);
         const excl = await store.query_stats([s], {
           exclude: ["Incremented"]
         });
-        (0, import_vitest3.expect)(excl.get(s)?.head.name).toBe("Decremented");
-        (0, import_vitest3.expect)((excl.get(s)?.head.data).amount).toBe(2);
+        (0, import_vitest4.expect)(excl.get(s)?.head.name).toBe("Decremented");
+        (0, import_vitest4.expect)((excl.get(s)?.head.data).amount).toBe(2);
         const wipe = await store.query_stats([sAllOut], {
           exclude: ["Incremented", "Decremented", "Reset"]
         });
-        (0, import_vitest3.expect)(wipe.has(sAllOut)).toBe(false);
-        const noTomb = await store.query_stats([s], {
+        (0, import_vitest4.expect)(wipe.has(sAllOut)).toBe(false);
+        const no_tomb = await store.query_stats([s], {
           exclude: [import_act.TOMBSTONE_EVENT]
         });
-        (0, import_vitest3.expect)(noTomb.get(s)?.head.name).toBe("Incremented");
+        (0, import_vitest4.expect)(no_tomb.get(s)?.head.name).toBe("Incremented");
       });
-      (0, import_vitest3.it)("before \u2014 time travel narrows head/tail/count", async () => {
+      (0, import_vitest4.it)("before \u2014 time travel narrows head/tail/count", async () => {
         const tag = uid();
         const s = `qst-tt-${tag}`;
         const c1 = await store.commit(
           s,
           [inc(1)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const c2 = await store.commit(
           s,
           [inc(2)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(3)],
+          make_meta({ stream: s })
         );
-        await store.commit(s, [inc(3)], makeMeta({ stream: s }));
         const before = c2[0].id;
         const stats = await store.query_stats([s], {
           tail: true,
@@ -1352,15 +1505,15 @@ var runStoreTck = (options) => {
           before
         });
         const r = stats.get(s);
-        (0, import_vitest3.expect)(r?.count).toBe(1);
-        (0, import_vitest3.expect)(r?.head.id).toBe(c1[0].id);
-        (0, import_vitest3.expect)(r?.tail?.id).toBe(c1[0].id);
+        (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);
         const empty = await store.query_stats([s], {
           before: 0
         });
-        (0, import_vitest3.expect)(empty.has(s)).toBe(false);
+        (0, import_vitest4.expect)(empty.has(s)).toBe(false);
       });
-      (0, import_vitest3.it)("filter form \u2014 stream regex, stream_exact, empty {} match", async () => {
+      (0, import_vitest4.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`;
@@ -1368,94 +1521,110 @@ var runStoreTck = (options) => {
         await store.commit(
           sA,
           [inc(1)],
-          makeMeta({ stream: sA })
+          make_meta({ stream: sA })
         );
         await store.commit(
           sB,
           [inc(2)],
-          makeMeta({ stream: sB })
+          make_meta({ stream: sB })
         );
         await store.commit(
           sOther,
           [inc(3)],
-          makeMeta({ stream: sOther })
+          make_meta({ stream: sOther })
         );
         const orders = await store.query_stats({
           stream: `^qsf-${tag}-orders-`
         });
-        (0, import_vitest3.expect)([...orders.keys()].sort()).toEqual([sA, sB].sort());
+        (0, import_vitest4.expect)([...orders.keys()].sort()).toEqual([sA, sB].sort());
         const exact = await store.query_stats({
           stream: sA,
           stream_exact: true
         });
-        (0, import_vitest3.expect)([...exact.keys()]).toEqual([sA]);
+        (0, import_vitest4.expect)([...exact.keys()]).toEqual([sA]);
         const all = await store.query_stats({
           stream: `^qsf-${tag}-`
         });
-        (0, import_vitest3.expect)([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
+        (0, import_vitest4.expect)([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
       });
-      (0, import_vitest3.it)("compose with query_streams for subscription-level filters", async () => {
+      (0, import_vitest4.it)("compose with query_streams for subscription-level filters", async () => {
         const tag = uid();
         const a = `qsc-${tag}-a`;
         const b = `qsc-${tag}-b`;
         await store.subscribe([{ stream: a }, { stream: b }]);
-        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
-        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        await store.commit(
+          a,
+          [inc(1)],
+          make_meta({ stream: a })
+        );
+        await store.commit(
+          b,
+          [inc(2)],
+          make_meta({ stream: b })
+        );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === a);
-        (0, import_vitest3.expect)(mine).toBeDefined();
+        (0, import_vitest4.expect)(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== a);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
-        const blockedNames = [];
-        await store.query_streams((p) => blockedNames.push(p.stream), {
+        const blocked_names = [];
+        await store.query_streams((p) => blocked_names.push(p.stream), {
           stream: `^qsc-${tag}-`,
           blocked: true
         });
-        (0, import_vitest3.expect)(blockedNames).toEqual([a]);
-        const stats = await store.query_stats(blockedNames);
-        (0, import_vitest3.expect)(stats.get(a)?.head.name).toBe("Incremented");
-        (0, import_vitest3.expect)(stats.has(b)).toBe(false);
+        (0, import_vitest4.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_vitest3.it)("empty filter {} \u2014 matches every event-bearing stream", async () => {
+      (0, import_vitest4.it)("empty filter {} \u2014 matches every event-bearing stream", async () => {
         const tag = uid();
         const a = `qse-${tag}-a`;
         const b = `qse-${tag}-b`;
-        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
-        await store.commit(b, [dec(2)], makeMeta({ stream: b }));
+        await store.commit(
+          a,
+          [inc(1)],
+          make_meta({ stream: a })
+        );
+        await store.commit(
+          b,
+          [dec(2)],
+          make_meta({ stream: b })
+        );
         const all = await store.query_stats({});
-        (0, import_vitest3.expect)(all.has(a)).toBe(true);
-        (0, import_vitest3.expect)(all.has(b)).toBe(true);
+        (0, import_vitest4.expect)(all.has(a)).toBe(true);
+        (0, import_vitest4.expect)(all.has(b)).toBe(true);
       });
-      (0, import_vitest3.it)("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
+      (0, import_vitest4.it)("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
         const tag = uid();
         const s = `qsfl-${tag}`;
         await store.commit(
           s,
           [inc(1), inc(2), dec(3)],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const c = await store.query_stats([s], {
           count: true
         });
-        (0, import_vitest3.expect)(c.get(s)?.count).toBe(3);
-        (0, import_vitest3.expect)(c.get(s)?.names).toBeUndefined();
-        (0, import_vitest3.expect)(c.get(s)?.tail).toBeUndefined();
+        (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();
         const n = await store.query_stats([s], {
           names: true
         });
-        (0, import_vitest3.expect)(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
-        (0, import_vitest3.expect)(n.get(s)?.count).toBeUndefined();
-        (0, import_vitest3.expect)(n.get(s)?.tail).toBeUndefined();
+        (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();
         const t = await store.query_stats([s], { tail: true });
-        (0, import_vitest3.expect)(t.get(s)?.tail?.name).toBe("Incremented");
-        (0, import_vitest3.expect)((t.get(s)?.tail?.data).amount).toBe(1);
-        (0, import_vitest3.expect)(t.get(s)?.count).toBeUndefined();
-        (0, import_vitest3.expect)(t.get(s)?.names).toBeUndefined();
+        (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_vitest3.describe)("query_streams anchor contract", () => {
-      (0, import_vitest3.it)("plain regex without anchors is a substring match", async () => {
+    (0, import_vitest4.describe)("query_streams anchor contract", () => {
+      (0, import_vitest4.it)("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-inner`;
         const longer = `qsr-${tag}-inner-extra`;
@@ -1469,9 +1638,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `qsr-${tag}-inner`
         });
-        (0, import_vitest3.expect)(seen.sort()).toEqual([inner, longer].sort());
+        (0, import_vitest4.expect)(seen.sort()).toEqual([inner, longer].sort());
       });
-      (0, import_vitest3.it)("caller-anchored `^name$` matches only the whole string", async () => {
+      (0, import_vitest4.it)("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-anchor`;
         const longer = `qsr-${tag}-anchor-extra`;
@@ -1480,9 +1649,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-anchor$`
         });
-        (0, import_vitest3.expect)(seen).toEqual([inner]);
+        (0, import_vitest4.expect)(seen).toEqual([inner]);
       });
-      (0, import_vitest3.it)("caller-anchored `^prefix` matches by prefix", async () => {
+      (0, import_vitest4.it)("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qsr-${tag}-pfx-a`;
         const b = `qsr-${tag}-pfx-b`;
@@ -1496,11 +1665,11 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-pfx-`
         });
-        (0, import_vitest3.expect)(seen.sort()).toEqual([a, b].sort());
+        (0, import_vitest4.expect)(seen.sort()).toEqual([a, b].sort());
       });
     });
-    (0, import_vitest3.describe)("prioritize anchor contract", () => {
-      (0, import_vitest3.it)("caller-anchored `^name$` filter matches only the whole string", async () => {
+    (0, import_vitest4.describe)("prioritize anchor contract", () => {
+      (0, import_vitest4.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`;
@@ -1512,45 +1681,49 @@ var runStoreTck = (options) => {
           { stream: `^pr-${tag}-anchor$` },
           7
         );
-        (0, import_vitest3.expect)(updated).toBe(1);
+        (0, import_vitest4.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_vitest3.expect)(seen.get(inner)).toBe(7);
-        (0, import_vitest3.expect)(seen.get(longer)).toBe(0);
+        (0, import_vitest4.expect)(seen.get(inner)).toBe(7);
+        (0, import_vitest4.expect)(seen.get(longer)).toBe(0);
       });
     });
-    (0, import_vitest3.describe)("query_streams head", () => {
-      (0, import_vitest3.it)("maxEventId tracks the highest committed id", async () => {
+    (0, import_vitest4.describe)("query_streams head", () => {
+      (0, import_vitest4.it)("maxEventId tracks the highest committed id", async () => {
         const s = `head-${uid()}`;
         await store.subscribe([{ stream: s }]);
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const positions = [];
         const { maxEventId } = await store.query_streams(
           (p) => positions.push(p.stream),
           { stream: s, stream_exact: true, limit: 1 }
         );
-        (0, import_vitest3.expect)(maxEventId).toBeGreaterThanOrEqual(0);
-        (0, import_vitest3.expect)(positions).toEqual([s]);
+        (0, import_vitest4.expect)(maxEventId).toBeGreaterThanOrEqual(0);
+        (0, import_vitest4.expect)(positions).toEqual([s]);
       });
     });
-    (0, import_vitest3.describe)("seedStream helper coverage", () => {
-      (0, import_vitest3.it)("commits N events with monotonically increasing ids", async () => {
+    (0, import_vitest4.describe)("seed_stream helper coverage", () => {
+      (0, import_vitest4.it)("commits N events with monotonically increasing ids", async () => {
         const s = `seed-${uid()}`;
-        const committed = await seedStream(store, s, 3);
-        (0, import_vitest3.expect)(committed).toHaveLength(3);
+        const committed = await seed_stream(store, s, 3);
+        (0, import_vitest4.expect)(committed).toHaveLength(3);
         for (let i = 1; i < committed.length; i++) {
-          (0, import_vitest3.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          (0, import_vitest4.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
     });
-    import_vitest3.describe.skipIf(!caps.restore)("restore (capability)", () => {
+    import_vitest4.describe.skipIf(!caps.restore)("restore (capability)", () => {
       beforeEach(async () => {
         await store.drop();
         await store.seed();
       });
-      const asSource = (events) => ({
+      const as_source = (events) => ({
         async query(callback) {
           for (const e of events)
             await Promise.resolve(
@@ -1563,8 +1736,8 @@ var runStoreTck = (options) => {
         async dispose() {
         }
       });
-      const event = (originalId, stream, version, name, created, data = {}) => ({
-        id: originalId,
+      const event = (original_id, stream, version, name, created, data = {}) => ({
+        id: original_id,
         name,
         data,
         stream,
@@ -1582,18 +1755,18 @@ var runStoreTck = (options) => {
           await cache.dispose();
         }
       };
-      (0, import_vitest3.it)("returns kept=0 on an empty source", async () => {
-        const result = await restore(asSource([]));
-        (0, import_vitest3.expect)(result.kept).toBe(0);
-        (0, import_vitest3.expect)(result.duration_ms).toBeGreaterThanOrEqual(0);
-        (0, import_vitest3.expect)(result.dropped).toEqual({
+      (0, import_vitest4.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({
           closed_streams: 0,
           snapshots: 0
         });
         const events = await collect(store, { limit: 10 });
-        (0, import_vitest3.expect)(events).toHaveLength(0);
+        (0, import_vitest4.expect)(events).toHaveLength(0);
       });
-      (0, import_vitest3.it)("rebuilds a single stream and preserves `created` verbatim", async () => {
+      (0, import_vitest4.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");
@@ -1603,8 +1776,8 @@ var runStoreTck = (options) => {
           event(2, s, 1, "Incremented", t1, { amount: 2 }),
           event(3, s, 2, "Decremented", t2, { amount: 1 })
         ];
-        const result = await restore(asSource(events));
-        (0, import_vitest3.expect)(result.kept).toBe(3);
+        const result = await restore(as_source(events));
+        (0, import_vitest4.expect)(result.kept).toBe(3);
         const back = [];
         await store.query(
           (e) => {
@@ -1612,8 +1785,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest3.expect)(back).toHaveLength(3);
-        (0, import_vitest3.expect)(
+        (0, import_vitest4.expect)(back).toHaveLength(3);
+        (0, import_vitest4.expect)(
           back.map((e) => ({
             stream: e.stream,
             version: e.version,
@@ -1645,7 +1818,7 @@ var runStoreTck = (options) => {
           }
         ]);
       });
-      (0, import_vitest3.it)("rebuilds multiple streams interleaved", async () => {
+      (0, import_vitest4.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");
@@ -1655,8 +1828,8 @@ var runStoreTck = (options) => {
           event(3, a, 1, "Decremented", t, { amount: 5 }),
           event(4, b, 1, "Incremented", t, { amount: 30 })
         ];
-        const result = await restore(asSource(events));
-        (0, import_vitest3.expect)(result.kept).toBe(4);
+        const result = await restore(as_source(events));
+        (0, import_vitest4.expect)(result.kept).toBe(4);
         const aBack = [];
         const bBack = [];
         await store.query(
@@ -1671,14 +1844,14 @@ var runStoreTck = (options) => {
           },
           { stream: b, stream_exact: true }
         );
-        (0, import_vitest3.expect)(aBack.map((e) => e.version)).toEqual([0, 1]);
-        (0, import_vitest3.expect)(bBack.map((e) => e.version)).toEqual([0, 1]);
+        (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_vitest3.it)("preserves Date `created` verbatim", async () => {
+      (0, import_vitest4.it)("preserves Date `created` verbatim", async () => {
         const s = `restore-isoc-${uid()}`;
         const iso = "2021-07-15T12:34:56.789Z";
         await restore(
-          asSource([
+          as_source([
             {
               id: 1,
               stream: s,
@@ -1697,53 +1870,53 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest3.expect)(back).toHaveLength(1);
-        (0, import_vitest3.expect)(back[0].created.toISOString()).toBe(iso);
+        (0, import_vitest4.expect)(back).toHaveLength(1);
+        (0, import_vitest4.expect)(back[0].created.toISOString()).toBe(iso);
       });
-      (0, import_vitest3.it)("wipes pre-existing events before inserting", async () => {
+      (0, import_vitest4.it)("wipes pre-existing events before inserting", async () => {
         const old = `restore-old-${uid()}`;
         await store.commit(
           old,
           [inc(1), inc(2)],
-          makeMeta({ stream: old })
+          make_meta({ stream: old })
         );
         const fresh = `restore-fresh-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
         await restore(
-          asSource([event(1, fresh, 0, "Incremented", t, { amount: 99 })])
+          as_source([event(1, fresh, 0, "Incremented", t, { amount: 99 })])
         );
-        const oldBack = await collect(store, {
+        const old_back = await collect(store, {
           stream: old,
           stream_exact: true
         });
-        (0, import_vitest3.expect)(oldBack).toHaveLength(0);
-        const freshBack = await collect(store, {
+        (0, import_vitest4.expect)(old_back).toHaveLength(0);
+        const fresh_back = await collect(store, {
           stream: fresh,
           stream_exact: true
         });
-        (0, import_vitest3.expect)(freshBack).toHaveLength(1);
+        (0, import_vitest4.expect)(fresh_back).toHaveLength(1);
       });
-      (0, import_vitest3.it)("clears subscription/stream-position metadata", async () => {
+      (0, import_vitest4.it)("clears subscription/stream-position metadata", async () => {
         const sub = `restore-sub-${uid()}`;
         await store.subscribe([{ stream: sub, source: "anything" }]);
-        const collectStreams = async () => {
+        const collect_streams = async () => {
           const out = [];
           await store.query_streams((p) => {
             out.push(p.stream);
           });
           return out;
         };
-        const before = await collectStreams();
-        (0, import_vitest3.expect)(before.includes(sub)).toBe(true);
-        await restore(asSource([]));
-        const after = await collectStreams();
-        (0, import_vitest3.expect)(after.includes(sub)).toBe(false);
+        const before = await collect_streams();
+        (0, import_vitest4.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_vitest3.it)("preserves snapshot events through restore", async () => {
+      (0, import_vitest4.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(
-          asSource([
+          as_source([
             {
               id: 1,
               stream: s,
@@ -1760,10 +1933,10 @@ var runStoreTck = (options) => {
           stream_exact: true,
           with_snaps: true
         });
-        (0, import_vitest3.expect)(back).toHaveLength(1);
-        (0, import_vitest3.expect)(back[0].name).toBe(import_act.SNAP_EVENT);
+        (0, import_vitest4.expect)(back).toHaveLength(1);
+        (0, import_vitest4.expect)(back[0].name).toBe(import_act.SNAP_EVENT);
       });
-      (0, import_vitest3.it)("rewrites causation refs through the old\u2192new id map", async () => {
+      (0, import_vitest4.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 = [
@@ -1805,7 +1978,7 @@ var runStoreTck = (options) => {
             }
           }
         ];
-        await restore(asSource(events));
+        await restore(as_source(events));
         const back = [];
         await store.query(
           (e) => {
@@ -1813,16 +1986,16 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest3.expect)(back).toHaveLength(3);
-        (0, import_vitest3.expect)(back[0].meta.causation.event).toBeUndefined();
-        (0, import_vitest3.expect)(back[1].meta.causation.event?.id).toBe(back[0].id);
-        (0, import_vitest3.expect)(back[2].meta.causation.event?.id).toBe(back[1].id);
+        (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_vitest3.it)("leaves causation refs unmapped when the target isn't in the source", async () => {
+      (0, import_vitest4.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(
-          asSource([
+          as_source([
             {
               id: 1,
               stream: s,
@@ -1846,14 +2019,14 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest3.expect)(back[0].meta.causation.event?.id).toBe(999);
+        (0, import_vitest4.expect)(back[0].meta.causation.event?.id).toBe(999);
       });
-      (0, import_vitest3.it)("rolls back atomically when the source throws mid-iteration", async () => {
+      (0, import_vitest4.it)("rolls back atomically when the source throws mid-iteration", async () => {
         const original = `restore-pre-${uid()}`;
         const committed = await store.commit(
           original,
           [inc(1), inc(2), inc(3)],
-          makeMeta({ stream: original })
+          make_meta({ stream: original })
         );
         const explosive = {
           async query(callback) {
@@ -1874,7 +2047,7 @@ var runStoreTck = (options) => {
           async dispose() {
           }
         };
-        await (0, import_vitest3.expect)(restore(explosive)).rejects.toThrow("boom");
+        await (0, import_vitest4.expect)(restore(explosive)).rejects.toThrow("boom");
         const back = [];
         await store.query(
           (e) => {
@@ -1882,14 +2055,14 @@ var runStoreTck = (options) => {
           },
           { stream: original, stream_exact: true }
         );
-        (0, import_vitest3.expect)(back).toHaveLength(3);
-        (0, import_vitest3.expect)(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        (0, import_vitest4.expect)(back).toHaveLength(3);
+        (0, import_vitest4.expect)(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
       });
-      (0, import_vitest3.it)("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
+      (0, import_vitest4.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(
-          asSource([
+          as_source([
             event(1, s, 0, "Incremented", t, { amount: 1 }),
             {
               id: 2,
@@ -1904,34 +2077,34 @@ var runStoreTck = (options) => {
           ]),
           { drop_snapshots: true }
         );
-        (0, import_vitest3.expect)(result.kept).toBe(2);
-        (0, import_vitest3.expect)(result.dropped.snapshots).toBe(1);
+        (0, import_vitest4.expect)(result.kept).toBe(2);
+        (0, import_vitest4.expect)(result.dropped.snapshots).toBe(1);
         const back = await collect(store, {
           stream: s,
           stream_exact: true,
           with_snaps: true
         });
-        (0, import_vitest3.expect)(back).toHaveLength(2);
-        (0, import_vitest3.expect)(
+        (0, import_vitest4.expect)(back).toHaveLength(2);
+        (0, import_vitest4.expect)(
           back.every((e) => e.name !== import_act.SNAP_EVENT)
         ).toBe(true);
       });
-      (0, import_vitest3.it)("on_progress fires once per event (caller throttles)", async () => {
+      (0, import_vitest4.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");
         await restore(
-          asSource([
+          as_source([
             event(1, s, 0, "Incremented", t, { amount: 1 }),
             event(2, s, 1, "Incremented", t, { amount: 2 })
           ]),
           { on_progress: (p) => calls.push(p.processed) }
         );
-        (0, import_vitest3.expect)(calls).toEqual([1, 2]);
+        (0, import_vitest4.expect)(calls).toEqual([1, 2]);
       });
     });
-    import_vitest3.describe.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
-      (0, import_vitest3.it)("commits and loads pii alongside data", async () => {
+    import_vitest4.describe.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
+      (0, import_vitest4.it)("commits and loads pii alongside data", async () => {
         const s = `pii-roundtrip-${uid()}`;
         const committed = await store.commit(
           s,
@@ -1942,10 +2115,10 @@ var runStoreTck = (options) => {
               pii: { email: "u@example.com", name: "Ursula" }
             }
           ],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
-        (0, import_vitest3.expect)(committed).toHaveLength(1);
-        (0, import_vitest3.expect)(committed[0].pii).toEqual({
+        (0, import_vitest4.expect)(committed).toHaveLength(1);
+        (0, import_vitest4.expect)(committed[0].pii).toEqual({
           email: "u@example.com",
           name: "Ursula"
         });
@@ -1956,13 +2129,17 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest3.expect)(seen).toHaveLength(1);
-        (0, import_vitest3.expect)(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
-        (0, import_vitest3.expect)(seen[0].data).toEqual({ amount: 1 });
+        (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_vitest3.it)("passes through events without pii (pii is null or undefined on load)", async () => {
+      (0, import_vitest4.it)("passes through events without pii (pii is null or undefined on load)", async () => {
         const s = `pii-none-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const seen = [];
         await store.query(
           (e) => {
@@ -1970,10 +2147,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest3.expect)(seen).toHaveLength(1);
-        (0, import_vitest3.expect)(seen[0].pii == null).toBe(true);
+        (0, import_vitest4.expect)(seen).toHaveLength(1);
+        (0, import_vitest4.expect)(seen[0].pii == null).toBe(true);
       });
-      (0, import_vitest3.it)("wipes pii for every event on the stream via forget_pii", async () => {
+      (0, import_vitest4.it)("wipes pii for every event on the stream via forget_pii", async () => {
         const s = `pii-forget-${uid()}`;
         await store.commit(
           s,
@@ -1989,12 +2166,12 @@ var runStoreTck = (options) => {
               pii: { email: "b@example.com" }
             }
           ],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const forget = store.forget_pii;
-        (0, import_vitest3.expect)(forget).toBeDefined();
+        (0, import_vitest4.expect)(forget).toBeDefined();
         const wiped = await forget.call(store, s);
-        (0, import_vitest3.expect)(wiped).toBe(2);
+        (0, import_vitest4.expect)(wiped).toBe(2);
         const seen = [];
         await store.query(
           (e) => {
@@ -2002,13 +2179,13 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest3.expect)(seen).toHaveLength(2);
+        (0, import_vitest4.expect)(seen).toHaveLength(2);
         for (const e of seen) {
-          (0, import_vitest3.expect)(e.pii == null).toBe(true);
-          (0, import_vitest3.expect)(e.data).toBeDefined();
+          (0, import_vitest4.expect)(e.pii == null).toBe(true);
+          (0, import_vitest4.expect)(e.data).toBeDefined();
         }
       });
-      (0, import_vitest3.it)("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
+      (0, import_vitest4.it)("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
         const s = `pii-forget-idem-${uid()}`;
         await store.commit(
           s,
@@ -2019,15 +2196,15 @@ var runStoreTck = (options) => {
               pii: { email: "u@example.com" }
             }
           ],
-          makeMeta({ stream: s })
+          make_meta({ stream: s })
         );
         const forget = store.forget_pii;
         const first = await forget.call(store, s);
-        (0, import_vitest3.expect)(first).toBe(1);
+        (0, import_vitest4.expect)(first).toBe(1);
         const second = await forget.call(store, s);
-        (0, import_vitest3.expect)(second).toBe(0);
+        (0, import_vitest4.expect)(second).toBe(0);
       });
-      (0, import_vitest3.it)("only wipes the targeted stream \u2014 siblings untouched", async () => {
+      (0, import_vitest4.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(
@@ -2039,7 +2216,7 @@ var runStoreTck = (options) => {
               pii: { email: "alice@example.com" }
             }
           ],
-          makeMeta({ stream: sA })
+          make_meta({ stream: sA })
         );
         await store.commit(
           sB,
@@ -2050,7 +2227,7 @@ var runStoreTck = (options) => {
               pii: { email: "bob@example.com" }
             }
           ],
-          makeMeta({ stream: sB })
+          make_meta({ stream: sB })
         );
         await store.forget_pii.call(store, sA);
         const a = [];
@@ -2060,7 +2237,7 @@ var runStoreTck = (options) => {
           },
           { stream: sA, stream_exact: true }
         );
-        (0, import_vitest3.expect)(a[0].pii == null).toBe(true);
+        (0, import_vitest4.expect)(a[0].pii == null).toBe(true);
         const b = [];
         await store.query(
           (e) => {
@@ -2068,28 +2245,32 @@ var runStoreTck = (options) => {
           },
           { stream: sB, stream_exact: true }
         );
-        (0, import_vitest3.expect)(b[0].pii).toEqual({ email: "bob@example.com" });
+        (0, import_vitest4.expect)(b[0].pii).toEqual({ email: "bob@example.com" });
       });
-      (0, import_vitest3.it)("forget_pii on a stream with no pii events returns 0", async () => {
+      (0, import_vitest4.it)("forget_pii on a stream with no pii events returns 0", async () => {
         const s = `pii-forget-empty-${uid()}`;
-        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
         const wiped = await store.forget_pii.call(store, s);
-        (0, import_vitest3.expect)(wiped).toBe(0);
+        (0, import_vitest4.expect)(wiped).toBe(0);
       });
     });
     if (caps.notify) {
-      (0, import_vitest3.describe)("notify (capability)", () => {
-        (0, import_vitest3.it)("delivers a notification when a different instance commits", async () => {
+      (0, import_vitest4.describe)("notify (capability)", () => {
+        (0, import_vitest4.it)("delivers a notification when a different instance commits", async () => {
           const notify = store.notify;
-          (0, import_vitest3.expect)(notify).toBeDefined();
+          (0, import_vitest4.expect)(notify).toBeDefined();
           const received = [];
-          let resolveArrived;
+          let resolve_arrived;
           const arrived = new Promise((res) => {
-            resolveArrived = res;
+            resolve_arrived = res;
           });
           const disposer = await notify.call(store, (n) => {
             received.push(n);
-            resolveArrived();
+            resolve_arrived();
           });
           const writer = await options.factory();
           try {
@@ -2097,12 +2278,12 @@ var runStoreTck = (options) => {
             await writer.commit(
               stream,
               [inc(1)],
-              makeMeta({ stream })
+              make_meta({ stream })
             );
             await arrived;
-            (0, import_vitest3.expect)(received.length).toBeGreaterThanOrEqual(1);
-            (0, import_vitest3.expect)(received[0].stream).toBe(stream);
-            (0, import_vitest3.expect)(received[0].events.length).toBeGreaterThanOrEqual(1);
+            (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);
           } finally {
             await writer.dispose();
             await Promise.resolve(disposer());
@@ -2123,12 +2304,11 @@ var runStoreTck = (options) => {
   collect,
   dec,
   inc,
-  makeMeta,
   reset,
   runCacheTck,
   runLoggerTck,
+  runStabilityTck,
   runStoreTck,
-  seedStream,
   uid
 });
 //# sourceMappingURL=index.cjs.map