@rotorsoft/act-tck 1.16.0 → 1.17.1

package/dist/index.cjs

@@ -40,17 +40,154 @@ __export(index_exports, {
   dec: () => dec,
   inc: () => inc,
   reset: () => reset,
+  runCacheDifferentialTck: () => runCacheDifferentialTck,
   runCacheTck: () => runCacheTck,
+  runLoggerDifferentialTck: () => runLoggerDifferentialTck,
   runLoggerTck: () => runLoggerTck,
   runStabilityTck: () => runStabilityTck,
+  runStoreDifferentialTck: () => runStoreDifferentialTck,
   runStorePropertyTck: () => runStorePropertyTck,
   runStoreTck: () => runStoreTck,
   uid: () => uid
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/cache-tck.ts
+// src/cache-differential-tck.ts
 var import_vitest = require("vitest");
+
+// src/fixtures/helpers.ts
+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 make_meta = (opts = {}) => ({
+  correlation: opts.correlation ?? (0, import_node_crypto.randomUUID)(),
+  causation: opts.stream ? {
+    action: {
+      name: opts.action ?? "Test",
+      stream: opts.stream,
+      actor: actor()
+    }
+  } : {}
+});
+var inc = (amount = 1) => ({
+  name: "Incremented",
+  data: { amount }
+});
+var dec = (amount = 1) => ({
+  name: "Decremented",
+  data: { amount }
+});
+var reset = () => ({ name: "Reset", data: {} });
+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)],
+      make_meta({ correlation, stream })
+    );
+    out.push(...committed);
+  }
+  return out;
+};
+var collect = async (store, query) => {
+  const out = [];
+  await store.query((e) => {
+    out.push(e);
+  }, query);
+  return out;
+};
+
+// src/cache-differential-tck.ts
+var mulberry32 = (seed) => {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+};
+var build_cache_plan = (seed, stream_count) => {
+  const rng = mulberry32(seed);
+  const prefix = `cdiff-${uid()}-`;
+  const streams = Array.from(
+    { length: stream_count },
+    (_, i) => `${prefix}${i}`
+  );
+  const make_entry = () => {
+    const v = Math.floor(rng() * 1e3);
+    return {
+      state: { count: v, label: `k${v % 7}` },
+      version: v,
+      event_id: v,
+      patches: 1 + Math.floor(rng() * 5),
+      snaps: Math.floor(rng() * 3)
+    };
+  };
+  const pick_stream = () => streams[Math.floor(rng() * streams.length)];
+  const ops = [];
+  for (const stream of streams)
+    ops.push({ t: "set", stream, entry: make_entry() });
+  const middle = 6 + Math.floor(rng() * 14);
+  for (let i = 0; i < middle; i++) {
+    const kind = Math.floor(rng() * 3);
+    if (kind === 0)
+      ops.push({ t: "set", stream: pick_stream(), entry: make_entry() });
+    else if (kind === 1) ops.push({ t: "invalidate", stream: pick_stream() });
+    else ops.push({ t: "clear" });
+  }
+  return { streams, ops };
+};
+var apply_op = async (cache, op) => {
+  if (op.t === "set") await cache.set(op.stream, op.entry);
+  else if (op.t === "invalidate") await cache.invalidate(op.stream);
+  else await cache.clear();
+};
+var snapshot = async (cache, streams) => {
+  const out = {};
+  for (const stream of streams)
+    out[stream] = await cache.get(stream);
+  return out;
+};
+var runCacheDifferentialTck = (options) => {
+  (0, import_vitest.describe)(`TCK / Cache differential / ${options.name}`, () => {
+    const base_seed = options.seed ?? 3244;
+    const stream_count = options.streams ?? 6;
+    const plans = Array.from(
+      { length: options.runs ?? 8 },
+      (_, r) => build_cache_plan(base_seed + r, stream_count)
+    );
+    const live = [];
+    (0, import_vitest.beforeAll)(async () => {
+      for (const spec of options.caches) {
+        live.push({ name: spec.name, cache: await spec.factory() });
+      }
+    });
+    (0, import_vitest.afterAll)(async () => {
+      for (const { cache } of live) await cache.dispose();
+    });
+    plans.forEach((plan, run) => {
+      const seed_hex = `0x${(base_seed + run).toString(16)}`;
+      (0, import_vitest.it)(`agrees on get() after every op (workload ${run}, seed ${seed_hex})`, async () => {
+        for (const op of plan.ops) {
+          for (const { cache } of live) await apply_op(cache, op);
+          const reference = await snapshot(live[0].cache, plan.streams);
+          for (let i = 1; i < live.length; i++) {
+            const actual = await snapshot(live[i].cache, plan.streams);
+            (0, import_vitest.expect)(
+              actual,
+              `${live[i].name} diverged from ${live[0].name} after ${op.t}`
+            ).toEqual(reference);
+          }
+        }
+      });
+    });
+  });
+};
+
+// src/cache-tck.ts
+var import_vitest2 = require("vitest");
 var entry = (event_id, state = {}) => ({
   state,
   version: event_id,
@@ -59,63 +196,63 @@ var entry = (event_id, state = {}) => ({
   snaps: 0
 });
 var runCacheTck = (options) => {
-  (0, import_vitest.describe)(`TCK / Cache / ${options.name}`, () => {
+  (0, import_vitest2.describe)(`TCK / Cache / ${options.name}`, () => {
     let cache;
-    (0, import_vitest.beforeEach)(() => {
+    (0, import_vitest2.beforeEach)(() => {
       cache = options.factory();
     });
-    (0, import_vitest.afterEach)(async () => {
+    (0, import_vitest2.afterEach)(async () => {
       await cache.dispose();
     });
-    (0, import_vitest.it)("returns undefined for an unset stream", async () => {
-      (0, import_vitest.expect)(await cache.get("missing")).toBeUndefined();
+    (0, import_vitest2.it)("returns undefined for an unset stream", async () => {
+      (0, import_vitest2.expect)(await cache.get("missing")).toBeUndefined();
     });
-    (0, import_vitest.it)("set then get round-trips an entry", async () => {
+    (0, import_vitest2.it)("set then get round-trips an entry", async () => {
       const e = entry(1, { count: 7 });
       await cache.set("s1", e);
-      (0, import_vitest.expect)(await cache.get("s1")).toEqual(e);
+      (0, import_vitest2.expect)(await cache.get("s1")).toEqual(e);
     });
-    (0, import_vitest.it)("set overwrites a prior entry on the same stream", async () => {
+    (0, import_vitest2.it)("set overwrites a prior entry on the same stream", async () => {
       await cache.set("s1", entry(1, { count: 1 }));
       await cache.set("s1", entry(2, { count: 2 }));
       const got = await cache.get("s1");
-      (0, import_vitest.expect)(got?.event_id).toBe(2);
-      (0, import_vitest.expect)(got?.state).toEqual({ count: 2 });
+      (0, import_vitest2.expect)(got?.event_id).toBe(2);
+      (0, import_vitest2.expect)(got?.state).toEqual({ count: 2 });
     });
-    (0, import_vitest.it)("invalidate removes one stream and leaves others", async () => {
+    (0, import_vitest2.it)("invalidate removes one stream and leaves others", async () => {
       await cache.set("a", entry(1));
       await cache.set("b", entry(2));
       await cache.invalidate("a");
-      (0, import_vitest.expect)(await cache.get("a")).toBeUndefined();
-      (0, import_vitest.expect)(await cache.get("b")).toBeDefined();
+      (0, import_vitest2.expect)(await cache.get("a")).toBeUndefined();
+      (0, import_vitest2.expect)(await cache.get("b")).toBeDefined();
     });
-    (0, import_vitest.it)("invalidate on an unknown stream is a no-op", async () => {
-      await (0, import_vitest.expect)(cache.invalidate("never-set")).resolves.toBeUndefined();
+    (0, import_vitest2.it)("invalidate on an unknown stream is a no-op", async () => {
+      await (0, import_vitest2.expect)(cache.invalidate("never-set")).resolves.toBeUndefined();
     });
-    (0, import_vitest.it)("clear empties every stream", async () => {
+    (0, import_vitest2.it)("clear empties every stream", async () => {
       await cache.set("a", entry(1));
       await cache.set("b", entry(2));
       await cache.set("c", entry(3));
       await cache.clear();
-      (0, import_vitest.expect)(await cache.get("a")).toBeUndefined();
-      (0, import_vitest.expect)(await cache.get("b")).toBeUndefined();
-      (0, import_vitest.expect)(await cache.get("c")).toBeUndefined();
+      (0, import_vitest2.expect)(await cache.get("a")).toBeUndefined();
+      (0, import_vitest2.expect)(await cache.get("b")).toBeUndefined();
+      (0, import_vitest2.expect)(await cache.get("c")).toBeUndefined();
     });
-    (0, import_vitest.it)("clear on an empty cache is a no-op", async () => {
-      await (0, import_vitest.expect)(cache.clear()).resolves.toBeUndefined();
+    (0, import_vitest2.it)("clear on an empty cache is a no-op", async () => {
+      await (0, import_vitest2.expect)(cache.clear()).resolves.toBeUndefined();
     });
-    (0, import_vitest.it)("entries are isolated per stream", async () => {
+    (0, import_vitest2.it)("entries are isolated per stream", async () => {
       const ea = entry(1, { id: "a" });
       const eb = entry(2, { id: "b" });
       await cache.set("a", ea);
       await cache.set("b", eb);
-      (0, import_vitest.expect)(await cache.get("a")).toEqual(ea);
-      (0, import_vitest.expect)(await cache.get("b")).toEqual(eb);
+      (0, import_vitest2.expect)(await cache.get("a")).toEqual(ea);
+      (0, import_vitest2.expect)(await cache.get("b")).toEqual(eb);
     });
-    (0, import_vitest.it)("dispose is idempotent", async () => {
+    (0, import_vitest2.it)("dispose is idempotent", async () => {
       await cache.set("a", entry(1));
       await cache.dispose();
-      await (0, import_vitest.expect)(cache.dispose()).resolves.toBeUndefined();
+      await (0, import_vitest2.expect)(cache.dispose()).resolves.toBeUndefined();
     });
   });
 };
@@ -136,105 +273,122 @@ var COUNTER_EVENT_NAMES = [
   "Reset"
 ];
 
-// src/fixtures/helpers.ts
-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 make_meta = (opts = {}) => ({
-  correlation: opts.correlation ?? (0, import_node_crypto.randomUUID)(),
-  causation: opts.stream ? {
-    action: {
-      name: opts.action ?? "Test",
-      stream: opts.stream,
-      actor: actor()
-    }
-  } : {}
-});
-var inc = (amount = 1) => ({
-  name: "Incremented",
-  data: { amount }
-});
-var dec = (amount = 1) => ({
-  name: "Decremented",
-  data: { amount }
-});
-var reset = () => ({ name: "Reset", data: {} });
-var seed_stream = async (store, stream, count, correlation) => {
+// src/logger-differential-tck.ts
+var import_vitest3 = require("vitest");
+var LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
+var drive = (logger) => {
   const out = [];
-  for (let i = 0; i < count; i++) {
-    const committed = await store.commit(
-      stream,
-      [inc(1)],
-      make_meta({ correlation, stream })
-    );
-    out.push(...committed);
+  const ok = (fn) => {
+    try {
+      fn();
+      out.push(true);
+    } catch {
+      out.push(false);
+    }
+  };
+  out.push(typeof logger.level === "string" && logger.level.length > 0);
+  for (const level of LEVELS) {
+    ok(() => logger[level]("message"));
+    ok(() => logger[level]({ k: "v", n: 1 }));
+    ok(() => logger[level]({ k: "v" }, "context"));
   }
+  ok(() => logger.info(null, "null payload"));
+  ok(() => {
+    const cyclic = { name: "loop" };
+    cyclic.self = cyclic;
+    logger.info(cyclic, "cycle");
+  });
+  const child = logger.child({ request_id: "abc" });
+  out.push(typeof child.level === "string" && child.level.length > 0);
+  out.push(LEVELS.every((level) => typeof child[level] === "function"));
+  out.push(typeof child.child === "function");
+  ok(() => child.child({ nested: true }).info("nested"));
   return out;
 };
-var collect = async (store, query) => {
-  const out = [];
-  await store.query((e) => {
-    out.push(e);
-  }, query);
-  return out;
+var runLoggerDifferentialTck = (options) => {
+  (0, import_vitest3.describe)(`TCK / Logger differential / ${options.name}`, () => {
+    let live = [];
+    let original_stdout;
+    (0, import_vitest3.beforeEach)(() => {
+      live = options.loggers.map((spec) => ({
+        name: spec.name,
+        logger: spec.factory()
+      }));
+      original_stdout = process.stdout.write.bind(process.stdout);
+      process.stdout.write = (() => true);
+    });
+    (0, import_vitest3.afterEach)(async () => {
+      process.stdout.write = original_stdout;
+      for (const { logger } of live) await logger.dispose();
+    });
+    (0, import_vitest3.it)("agrees on robustness and structural parity across the call surface", () => {
+      const reference = drive(live[0].logger);
+      for (let i = 1; i < live.length; i++) {
+        const actual = drive(live[i].logger);
+        (0, import_vitest3.expect)(actual, `${live[i].name} diverged from ${live[0].name}`).toEqual(
+          reference
+        );
+      }
+    });
+  });
 };
 
 // src/logger-tck.ts
-var import_vitest2 = require("vitest");
-var LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
+var import_vitest4 = require("vitest");
+var LEVELS2 = ["fatal", "error", "warn", "info", "debug", "trace"];
 var runLoggerTck = (options) => {
-  (0, import_vitest2.describe)(`TCK / Logger / ${options.name}`, () => {
+  (0, import_vitest4.describe)(`TCK / Logger / ${options.name}`, () => {
     let logger;
     let original_stdout;
-    (0, import_vitest2.beforeEach)(() => {
+    (0, import_vitest4.beforeEach)(() => {
       logger = options.factory();
       original_stdout = process.stdout.write.bind(process.stdout);
       process.stdout.write = (() => true);
     });
-    (0, import_vitest2.afterEach)(async () => {
+    (0, import_vitest4.afterEach)(async () => {
       process.stdout.write = original_stdout;
       await logger.dispose();
     });
-    (0, import_vitest2.it)("exposes a non-empty `level` string", () => {
-      (0, import_vitest2.expect)(typeof logger.level).toBe("string");
-      (0, import_vitest2.expect)(logger.level.length).toBeGreaterThan(0);
+    (0, import_vitest4.it)("exposes a non-empty `level` string", () => {
+      (0, import_vitest4.expect)(typeof logger.level).toBe("string");
+      (0, import_vitest4.expect)(logger.level.length).toBeGreaterThan(0);
     });
-    for (const level of LEVELS) {
-      (0, import_vitest2.it)(`${level}(msg) does not throw`, () => {
-        (0, import_vitest2.expect)(() => logger[level]("hello")).not.toThrow();
+    for (const level of LEVELS2) {
+      (0, import_vitest4.it)(`${level}(msg) does not throw`, () => {
+        (0, import_vitest4.expect)(() => logger[level]("hello")).not.toThrow();
       });
-      (0, import_vitest2.it)(`${level}(obj) does not throw`, () => {
-        (0, import_vitest2.expect)(() => logger[level]({ k: "v" })).not.toThrow();
+      (0, import_vitest4.it)(`${level}(obj) does not throw`, () => {
+        (0, import_vitest4.expect)(() => logger[level]({ k: "v" })).not.toThrow();
       });
-      (0, import_vitest2.it)(`${level}(obj, msg) does not throw`, () => {
-        (0, import_vitest2.expect)(() => logger[level]({ k: "v" }, "context")).not.toThrow();
+      (0, import_vitest4.it)(`${level}(obj, msg) does not throw`, () => {
+        (0, import_vitest4.expect)(() => logger[level]({ k: "v" }, "context")).not.toThrow();
       });
     }
-    (0, import_vitest2.it)("accepts a null payload", () => {
-      (0, import_vitest2.expect)(() => logger.info(null, "null payload")).not.toThrow();
+    (0, import_vitest4.it)("accepts a null payload", () => {
+      (0, import_vitest4.expect)(() => logger.info(null, "null payload")).not.toThrow();
     });
-    (0, import_vitest2.it)("accepts a cyclic payload without throwing", () => {
+    (0, import_vitest4.it)("accepts a cyclic payload without throwing", () => {
       const cyclic = { name: "loop" };
       cyclic.self = cyclic;
-      (0, import_vitest2.expect)(() => logger.info(cyclic, "cycle")).not.toThrow();
+      (0, import_vitest4.expect)(() => logger.info(cyclic, "cycle")).not.toThrow();
     });
-    (0, import_vitest2.it)("child(bindings) returns a Logger satisfying the same contract", () => {
+    (0, import_vitest4.it)("child(bindings) returns a Logger satisfying the same contract", () => {
       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");
+      (0, import_vitest4.expect)(typeof child.level).toBe("string");
+      for (const level of LEVELS2) {
+        (0, import_vitest4.expect)(typeof child[level]).toBe("function");
       }
-      (0, import_vitest2.expect)(typeof child.child).toBe("function");
-      (0, import_vitest2.expect)(typeof child.dispose).toBe("function");
+      (0, import_vitest4.expect)(typeof child.child).toBe("function");
+      (0, import_vitest4.expect)(typeof child.dispose).toBe("function");
     });
-    (0, import_vitest2.it)("child loggers can themselves spawn children", () => {
+    (0, import_vitest4.it)("child loggers can themselves spawn children", () => {
       const c1 = logger.child({ a: 1 });
       const c2 = c1.child({ b: 2 });
-      (0, import_vitest2.expect)(() => c2.info("nested")).not.toThrow();
+      (0, import_vitest4.expect)(() => c2.info("nested")).not.toThrow();
     });
-    (0, import_vitest2.it)("dispose is idempotent and awaitable", async () => {
-      await (0, import_vitest2.expect)(logger.dispose()).resolves.toBeUndefined();
-      await (0, import_vitest2.expect)(logger.dispose()).resolves.toBeUndefined();
+    (0, import_vitest4.it)("dispose is idempotent and awaitable", async () => {
+      await (0, import_vitest4.expect)(logger.dispose()).resolves.toBeUndefined();
+      await (0, import_vitest4.expect)(logger.dispose()).resolves.toBeUndefined();
     });
   });
 };
@@ -242,14 +396,14 @@ 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");
+var import_vitest5 = require("vitest");
 function runStabilityTck(options) {
-  (0, import_vitest3.describe)(`${options.name} \u2014 public API stability`, () => {
+  (0, import_vitest5.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 () => {
+      (0, import_vitest5.it)(`stable public surface for ${label}`, async () => {
         const surface = await load_surface(entry2);
-        (0, import_vitest3.expect)(surface).toMatchSnapshot();
+        (0, import_vitest5.expect)(surface).toMatchSnapshot();
       });
     }
   });
@@ -279,39 +433,250 @@ ${content}`;
   }).join("\n");
 }
 
+// src/store-differential-tck.ts
+var import_act = require("@rotorsoft/act");
+var import_vitest6 = require("vitest");
+var mulberry322 = (seed) => {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+};
+var normalize_event = (e) => ({
+  stream: e.stream,
+  version: e.version,
+  name: e.name,
+  data: e.data
+});
+var build_plan = (seed, stream_count) => {
+  const rng = mulberry322(seed);
+  const tag = uid();
+  const event_prefix = `diff-${tag}-evt-`;
+  const sub_prefix = `diff-${tag}-sub-`;
+  const event_streams = Array.from(
+    { length: stream_count },
+    (_, i) => `${event_prefix}${i}`
+  );
+  let type_cursor = 0;
+  const next_msg = () => {
+    const kind = type_cursor++ % 3;
+    const amount = 1 + Math.floor(rng() * 9);
+    return kind === 0 ? inc(amount) : kind === 1 ? dec(amount) : reset();
+  };
+  const batch = () => Array.from({ length: 1 + Math.floor(rng() * 3) }, next_msg);
+  const pick_stream = () => event_streams[Math.floor(rng() * event_streams.length)];
+  const ops = [];
+  for (const stream of event_streams)
+    ops.push({ t: "commit", stream, msgs: batch() });
+  const middle = 8 + Math.floor(rng() * 16);
+  for (let i = 0; i < middle; i++) {
+    const stream = pick_stream();
+    const kind = Math.floor(rng() * 3);
+    if (kind === 0) ops.push({ t: "commit", stream, msgs: batch() });
+    else if (kind === 1)
+      ops.push({ t: "snapshot", stream, count: Math.floor(rng() * 1e3) });
+    else ops.push({ t: "truncate", stream, count: Math.floor(rng() * 1e3) });
+  }
+  for (const stream of event_streams)
+    ops.push({ t: "commit", stream, msgs: batch() });
+  const lanes = ["default", "slow", "fast"];
+  const subs = event_streams.map((source, i) => ({
+    stream: `${sub_prefix}${i}`,
+    source,
+    lane: lanes[i % lanes.length],
+    priority: i % 4
+  }));
+  return { event_prefix, event_streams, sub_prefix, ops, subs };
+};
+var apply_plan = async (store, plan) => {
+  for (const op of plan.ops) {
+    if (op.t === "commit") {
+      await store.commit(
+        op.stream,
+        op.msgs,
+        make_meta({ stream: op.stream })
+      );
+    } else if (op.t === "snapshot") {
+      await store.commit(
+        op.stream,
+        [{ name: import_act.SNAP_EVENT, data: { count: op.count } }],
+        make_meta({ stream: op.stream })
+      );
+    } else {
+      await store.truncate([
+        { stream: op.stream, snapshot: { count: op.count } }
+      ]);
+    }
+  }
+  await store.subscribe(
+    plan.subs.map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      lane: s.lane,
+      priority: s.priority
+    }))
+  );
+};
+var runStoreDifferentialTck = (options) => {
+  (0, import_vitest6.describe)(`TCK / Store differential / ${options.name}`, () => {
+    const base_seed = options.seed ?? 2759;
+    const stream_count = options.streams ?? 4;
+    const plans = Array.from(
+      { length: options.runs ?? 8 },
+      (_, r) => build_plan(base_seed + r, stream_count)
+    );
+    const live = [];
+    (0, import_vitest6.beforeAll)(async () => {
+      for (const spec of options.stores) {
+        const store = await spec.factory();
+        await store.drop();
+        await store.seed();
+        for (const plan of plans) await apply_plan(store, plan);
+        live.push({ name: spec.name, store });
+      }
+    });
+    (0, import_vitest6.afterAll)(async () => {
+      for (const { store } of live) await store.dispose();
+    });
+    const assert_identical = async (label, produce) => {
+      const reference = await produce(live[0].store);
+      for (let i = 1; i < live.length; i++) {
+        const actual = await produce(live[i].store);
+        (0, import_vitest6.expect)(
+          actual,
+          `${live[i].name} diverged from ${live[0].name} on "${label}"`
+        ).toEqual(reference);
+      }
+    };
+    plans.forEach((plan, run) => {
+      const seed_hex = `0x${(base_seed + run).toString(16)}`;
+      (0, import_vitest6.describe)(`workload ${run} (seed ${seed_hex})`, () => {
+        (0, import_vitest6.it)("yields identical event order under a global forward query", async () => {
+          await assert_identical("forward query", async (store) => {
+            const out = [];
+            await store.query(
+              (e) => {
+                out.push(normalize_event(e));
+              },
+              { stream: `^${plan.event_prefix}` }
+            );
+            return out;
+          });
+        });
+        (0, import_vitest6.it)("yields identical snapshot floors under with_snaps", async () => {
+          await assert_identical("with_snaps floor", async (store) => {
+            const by_stream = {};
+            for (const stream of plan.event_streams) {
+              const out = [];
+              await store.query(
+                (e) => {
+                  out.push(normalize_event(e));
+                },
+                { stream, stream_exact: true, with_snaps: true }
+              );
+              by_stream[stream] = out;
+            }
+            return by_stream;
+          });
+        });
+        (0, import_vitest6.it)("yields identical order under backward traversal", async () => {
+          await assert_identical("backward query", async (store) => {
+            const by_stream = {};
+            for (const stream of plan.event_streams) {
+              const out = [];
+              await store.query(
+                (e) => {
+                  out.push(normalize_event(e));
+                },
+                { stream, stream_exact: true, backward: true }
+              );
+              by_stream[stream] = out;
+            }
+            return by_stream;
+          });
+        });
+        (0, import_vitest6.it)("yields identical query_stats output (head/tail/count/names)", async () => {
+          await assert_identical("query_stats", async (store) => {
+            const stats = await store.query_stats(
+              { stream: `^${plan.event_prefix}` },
+              { tail: true, count: true, names: true }
+            );
+            const keys = [...stats.keys()];
+            const content = {};
+            for (const [stream, s] of stats) {
+              content[stream] = {
+                head: normalize_event(s.head),
+                tail: normalize_event(
+                  s.tail
+                ),
+                count: s.count,
+                names: s.names
+              };
+            }
+            return { keys, content };
+          });
+        });
+        (0, import_vitest6.it)("yields identical query_streams output", async () => {
+          await assert_identical("query_streams", async (store) => {
+            const rows = [];
+            const { count } = await store.query_streams(
+              (p) => {
+                rows.push({
+                  stream: p.stream,
+                  source: p.source,
+                  at: p.at,
+                  blocked: p.blocked,
+                  priority: p.priority,
+                  lane: p.lane
+                });
+              },
+              { stream: `^${plan.sub_prefix}`, limit: 1e3 }
+            );
+            rows.sort((a, b) => a.stream.localeCompare(b.stream));
+            return { count, rows };
+          });
+        });
+      });
+    });
+  });
+};
+
 // src/store-property-tck.ts
-var import_vitest4 = require("@fast-check/vitest");
-var import_vitest5 = require("vitest");
-var streamArb = import_vitest4.fc.constantFrom("s1", "s2", "s3");
-var commitArb = import_vitest4.fc.record({
+var import_vitest7 = require("@fast-check/vitest");
+var import_vitest8 = require("vitest");
+var streamArb = import_vitest7.fc.constantFrom("s1", "s2", "s3");
+var commitArb = import_vitest7.fc.record({
   stream: streamArb,
-  count: import_vitest4.fc.integer({ min: 1, max: 3 })
+  count: import_vitest7.fc.integer({ min: 1, max: 3 })
 });
-var claimStreamArb = import_vitest4.fc.constantFrom("a", "b", "c");
-var opArb = import_vitest4.fc.oneof(
-  import_vitest4.fc.record({ kind: import_vitest4.fc.constant("commit"), stream: claimStreamArb }),
-  import_vitest4.fc.record({ kind: import_vitest4.fc.constant("claim") }),
-  import_vitest4.fc.record({ kind: import_vitest4.fc.constant("ack-all") }),
-  import_vitest4.fc.record({ kind: import_vitest4.fc.constant("block-all") })
+var claimStreamArb = import_vitest7.fc.constantFrom("a", "b", "c");
+var opArb = import_vitest7.fc.oneof(
+  import_vitest7.fc.record({ kind: import_vitest7.fc.constant("commit"), stream: claimStreamArb }),
+  import_vitest7.fc.record({ kind: import_vitest7.fc.constant("claim") }),
+  import_vitest7.fc.record({ kind: import_vitest7.fc.constant("ack-all") }),
+  import_vitest7.fc.record({ kind: import_vitest7.fc.constant("block-all") })
 );
 var events = (count) => Array.from({ length: count }, () => inc(1));
 var runStorePropertyTck = (options) => {
   const numRuns = options.numRuns ?? 100;
-  (0, import_vitest5.describe)(`TCK / Store properties / ${options.name}`, () => {
+  (0, import_vitest8.describe)(`TCK / Store properties / ${options.name}`, () => {
     let store;
-    (0, import_vitest5.beforeAll)(async () => {
+    (0, import_vitest8.beforeAll)(async () => {
       store = await options.factory();
       await store.seed();
     });
-    (0, import_vitest5.afterAll)(async () => {
+    (0, import_vitest8.afterAll)(async () => {
       await store.dispose();
     });
     const reset2 = async () => {
       await store.drop();
       await store.seed();
     };
-    (0, import_vitest5.describe)("commit version invariants", () => {
-      import_vitest4.test.prop([import_vitest4.fc.array(commitArb, { minLength: 0, maxLength: 30 })], {
+    (0, import_vitest8.describe)("commit version invariants", () => {
+      import_vitest7.test.prop([import_vitest7.fc.array(commitArb, { minLength: 0, maxLength: 30 })], {
         numRuns
       })(
         "per-stream versions are 0..N-1 in commit order, regardless of interleaving",
@@ -326,19 +691,19 @@ var runStorePropertyTck = (options) => {
               make_meta({ stream })
             );
             committed.forEach((e, i) => {
-              (0, import_vitest5.expect)(e.version).toBe(before + 1 + i);
+              (0, import_vitest8.expect)(e.version).toBe(before + 1 + i);
             });
             expected.set(stream, before + count);
           }
           for (const stream of new Set(commits.map((c) => c.stream))) {
             const seen = await collect(store, { stream, stream_exact: true });
             seen.forEach((e, i) => {
-              (0, import_vitest5.expect)(e.version).toBe(i);
+              (0, import_vitest8.expect)(e.version).toBe(i);
             });
           }
         }
       );
-      import_vitest4.test.prop([import_vitest4.fc.array(commitArb, { minLength: 1, maxLength: 20 })], {
+      import_vitest7.test.prop([import_vitest7.fc.array(commitArb, { minLength: 1, maxLength: 20 })], {
         numRuns
       })(
         "bad expectedVersion throws and commits no events",
@@ -353,7 +718,7 @@ var runStorePropertyTck = (options) => {
           }
           const stream = commits[0].stream;
           const before = await collect(store, { stream, stream_exact: true });
-          await (0, import_vitest5.expect)(
+          await (0, import_vitest8.expect)(
             store.commit(
               stream,
               [inc(1)],
@@ -362,12 +727,12 @@ var runStorePropertyTck = (options) => {
             )
           ).rejects.toThrow();
           const after = await collect(store, { stream, stream_exact: true });
-          (0, import_vitest5.expect)(after.length).toBe(before.length);
+          (0, import_vitest8.expect)(after.length).toBe(before.length);
         }
       );
     });
-    (0, import_vitest5.describe)("claim/lease lifecycle invariants", () => {
-      import_vitest4.test.prop([import_vitest4.fc.array(opArb, { minLength: 1, maxLength: 30 })], {
+    (0, import_vitest8.describe)("claim/lease lifecycle invariants", () => {
+      import_vitest7.test.prop([import_vitest7.fc.array(opArb, { minLength: 1, maxLength: 30 })], {
         numRuns
       })(
         "no leaks: claims are always acked or blocked, never lost",
@@ -408,13 +773,13 @@ var runStorePropertyTck = (options) => {
               );
             }
           }
-          (0, import_vitest5.expect)(totalResolved + pending.length).toBe(totalClaims);
+          (0, import_vitest8.expect)(totalResolved + pending.length).toBe(totalClaims);
         }
       );
-      import_vitest4.test.prop(
+      import_vitest7.test.prop(
         [
-          import_vitest4.fc.array(claimStreamArb, { minLength: 1, maxLength: 5 }),
-          import_vitest4.fc.array(claimStreamArb, { minLength: 0, maxLength: 5 })
+          import_vitest7.fc.array(claimStreamArb, { minLength: 1, maxLength: 5 }),
+          import_vitest7.fc.array(claimStreamArb, { minLength: 0, maxLength: 5 })
         ],
         { numRuns }
       )(
@@ -446,13 +811,13 @@ var runStorePropertyTck = (options) => {
             await store.claim(10, 10, "worker", 6e4)
           );
           for (const lease of acked2) {
-            (0, import_vitest5.expect)(lease.at).toBeGreaterThanOrEqual(
+            (0, import_vitest8.expect)(lease.at).toBeGreaterThanOrEqual(
               watermark1.get(lease.stream)
             );
           }
         }
       );
-      import_vitest4.test.prop([import_vitest4.fc.array(claimStreamArb, { minLength: 1, maxLength: 5 })], {
+      import_vitest7.test.prop([import_vitest7.fc.array(claimStreamArb, { minLength: 1, maxLength: 5 })], {
         numRuns
       })("blocked streams cannot be claimed again", async (commits) => {
         await reset2();
@@ -475,46 +840,46 @@ var runStorePropertyTck = (options) => {
           make_meta({ stream: "ctrl" })
         );
         const reclaim = await store.claim(10, 10, "worker2", 6e4);
-        for (const l of reclaim) (0, import_vitest5.expect)(blockedSet.has(l.stream)).toBe(false);
+        for (const l of reclaim) (0, import_vitest8.expect)(blockedSet.has(l.stream)).toBe(false);
       });
     });
   });
 };
 
 // src/store-tck.ts
-var import_act = require("@rotorsoft/act");
-var import_vitest6 = require("vitest");
+var import_act2 = require("@rotorsoft/act");
+var import_vitest9 = require("vitest");
 var runStoreTck = (options) => {
-  (0, import_vitest6.describe)(`TCK / Store / ${options.name}`, () => {
+  (0, import_vitest9.describe)(`TCK / Store / ${options.name}`, () => {
     let store;
     const caps = { ...options.capabilities };
-    (0, import_vitest6.beforeAll)(async () => {
+    (0, import_vitest9.beforeAll)(async () => {
       store = await options.factory();
       await store.drop();
       await store.seed();
     });
-    (0, import_vitest6.afterAll)(async () => {
+    (0, import_vitest9.afterAll)(async () => {
       await store.dispose();
     });
-    (0, import_vitest6.describe)("commit", () => {
-      (0, import_vitest6.it)("returns committed events with sequenced ids and versions", async () => {
+    (0, import_vitest9.describe)("commit", () => {
+      (0, import_vitest9.it)("returns committed events with sequenced ids and versions", async () => {
         const s = `commit-seq-${uid()}`;
         const committed = await store.commit(
           s,
           [inc(1), inc(2), dec(3)],
           make_meta({ stream: s })
         );
-        (0, import_vitest6.expect)(committed).toHaveLength(3);
-        (0, import_vitest6.expect)(committed[0].version).toBe(0);
-        (0, import_vitest6.expect)(committed[1].version).toBe(1);
-        (0, import_vitest6.expect)(committed[2].version).toBe(2);
-        (0, import_vitest6.expect)(committed[0].name).toBe("Incremented");
-        (0, import_vitest6.expect)(committed[2].data).toEqual({ amount: 3 });
+        (0, import_vitest9.expect)(committed).toHaveLength(3);
+        (0, import_vitest9.expect)(committed[0].version).toBe(0);
+        (0, import_vitest9.expect)(committed[1].version).toBe(1);
+        (0, import_vitest9.expect)(committed[2].version).toBe(2);
+        (0, import_vitest9.expect)(committed[0].name).toBe("Incremented");
+        (0, import_vitest9.expect)(committed[2].data).toEqual({ amount: 3 });
         for (let i = 1; i < committed.length; i++) {
-          (0, import_vitest6.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          (0, import_vitest9.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
-      (0, import_vitest6.it)("attaches correlation and stream metadata", async () => {
+      (0, import_vitest9.it)("attaches correlation and stream metadata", async () => {
         const s = `commit-meta-${uid()}`;
         const correlation = `cor-${uid()}`;
         const committed = await store.commit(
@@ -522,10 +887,10 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s, correlation })
         );
-        (0, import_vitest6.expect)(committed[0].stream).toBe(s);
-        (0, import_vitest6.expect)(committed[0].meta.correlation).toBe(correlation);
+        (0, import_vitest9.expect)(committed[0].stream).toBe(s);
+        (0, import_vitest9.expect)(committed[0].meta.correlation).toBe(correlation);
       });
-      (0, import_vitest6.it)("throws ConcurrencyError when expectedVersion is wrong", async () => {
+      (0, import_vitest9.it)("throws ConcurrencyError when expectedVersion is wrong", async () => {
         const s = `commit-cc-${uid()}`;
         await store.commit(
           s,
@@ -538,26 +903,26 @@ var runStoreTck = (options) => {
           make_meta({ stream: s }),
           0
         );
-        await (0, import_vitest6.expect)(
+        await (0, import_vitest9.expect)(
           store.commit(s, [inc(1)], make_meta({ stream: s }), 0)
-        ).rejects.toBeInstanceOf(import_act.ConcurrencyError);
+        ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
       });
-      (0, import_vitest6.it)("preserves prior events when a concurrent commit is rejected", async () => {
+      (0, import_vitest9.it)("preserves prior events when a concurrent commit is rejected", async () => {
         const s = `commit-cc-preserve-${uid()}`;
         await store.commit(
           s,
           [inc(1), inc(2)],
           make_meta({ stream: s })
         );
-        await (0, import_vitest6.expect)(
+        await (0, import_vitest9.expect)(
           store.commit(s, [inc(3)], make_meta({ stream: s }), 0)
-        ).rejects.toBeInstanceOf(import_act.ConcurrencyError);
+        ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
         const found = await collect(store, { stream: s, stream_exact: true });
-        (0, import_vitest6.expect)(found).toHaveLength(2);
+        (0, import_vitest9.expect)(found).toHaveLength(2);
       });
     });
-    (0, import_vitest6.describe)("query", () => {
-      (0, import_vitest6.it)("filters by stream, names, correlation, limit, with_snaps", async () => {
+    (0, import_vitest9.describe)("query", () => {
+      (0, import_vitest9.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()}`;
@@ -575,23 +940,69 @@ var runStoreTck = (options) => {
           stream: s1,
           stream_exact: true
         });
-        (0, import_vitest6.expect)(by_stream).toHaveLength(2);
+        (0, import_vitest9.expect)(by_stream).toHaveLength(2);
         const by_name = await collect(store, {
           stream: s2,
           stream_exact: true,
           names: ["Reset"]
         });
-        (0, import_vitest6.expect)(by_name).toHaveLength(1);
-        (0, import_vitest6.expect)(by_name[0].name).toBe("Reset");
+        (0, import_vitest9.expect)(by_name).toHaveLength(1);
+        (0, import_vitest9.expect)(by_name[0].name).toBe("Reset");
         const by_correlation = await collect(store, { correlation: cor });
-        (0, import_vitest6.expect)(by_correlation).toHaveLength(5);
+        (0, import_vitest9.expect)(by_correlation).toHaveLength(5);
         const limited = await collect(store, {
           correlation: cor,
           limit: 2
         });
-        (0, import_vitest6.expect)(limited).toHaveLength(2);
+        (0, import_vitest9.expect)(limited).toHaveLength(2);
       });
-      (0, import_vitest6.it)("supports backward traversal", async () => {
+      (0, import_vitest9.it)("with_snaps resumes from the latest snapshot per stream", async () => {
+        const s = `q-snap-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1), inc(1)],
+          make_meta({ stream: s })
+        );
+        const [snap] = await store.commit(
+          s,
+          [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }],
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(1), inc(1), inc(1)],
+          make_meta({ stream: s })
+        );
+        const from_snap = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true
+        });
+        (0, import_vitest9.expect)(from_snap).toHaveLength(4);
+        (0, import_vitest9.expect)(from_snap[0].name).toBe(import_act2.SNAP_EVENT);
+        const domain = await collect(store, { stream: s, stream_exact: true });
+        (0, import_vitest9.expect)(domain).toHaveLength(5);
+        const after_snap = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true,
+          after: snap.id
+        });
+        (0, import_vitest9.expect)(after_snap).toHaveLength(3);
+        const s2 = `q-nosnap-${uid()}`;
+        await store.commit(
+          s2,
+          [inc(1), inc(1)],
+          make_meta({ stream: s2 })
+        );
+        const full = await collect(store, {
+          stream: s2,
+          stream_exact: true,
+          with_snaps: true
+        });
+        (0, import_vitest9.expect)(full).toHaveLength(2);
+      });
+      (0, import_vitest9.it)("supports backward traversal", async () => {
         const s = `q-back-${uid()}`;
         const committed = await store.commit(
           s,
@@ -604,8 +1015,8 @@ var runStoreTck = (options) => {
           stream_exact: true,
           backward: true
         });
-        (0, import_vitest6.expect)(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
-        (0, import_vitest6.expect)(backward.map((e) => e.id)).toEqual(
+        (0, import_vitest9.expect)(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        (0, import_vitest9.expect)(backward.map((e) => e.id)).toEqual(
           [...committed].reverse().map((c) => c.id)
         );
         const latest = await collect(store, {
@@ -614,10 +1025,10 @@ var runStoreTck = (options) => {
           backward: true,
           limit: 1
         });
-        (0, import_vitest6.expect)(latest).toHaveLength(1);
-        (0, import_vitest6.expect)(latest[0].id).toBe(committed.at(-1).id);
+        (0, import_vitest9.expect)(latest).toHaveLength(1);
+        (0, import_vitest9.expect)(latest[0].id).toBe(committed.at(-1).id);
       });
-      (0, import_vitest6.it)("after/before bound the id range", async () => {
+      (0, import_vitest9.it)("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
         const committed = await store.commit(
           s,
@@ -629,7 +1040,7 @@ var runStoreTck = (options) => {
           stream_exact: true,
           after: committed[0].id
         });
-        (0, import_vitest6.expect)(after_first.map((e) => e.id)).toEqual(
+        (0, import_vitest9.expect)(after_first.map((e) => e.id)).toEqual(
           committed.slice(1).map((c) => c.id)
         );
         const before_last = await collect(store, {
@@ -637,11 +1048,11 @@ var runStoreTck = (options) => {
           stream_exact: true,
           before: committed[committed.length - 1].id
         });
-        (0, import_vitest6.expect)(before_last.map((e) => e.id)).toEqual(
+        (0, import_vitest9.expect)(before_last.map((e) => e.id)).toEqual(
           committed.slice(0, -1).map((c) => c.id)
         );
       });
-      (0, import_vitest6.it)("created_after/created_before filter by timestamp", async () => {
+      (0, import_vitest9.it)("created_after/created_before filter by timestamp", async () => {
         const s = `q-ts-${uid()}`;
         const committed = await store.commit(
           s,
@@ -657,15 +1068,15 @@ var runStoreTck = (options) => {
           created_after: before,
           created_before: future
         });
-        (0, import_vitest6.expect)(in_window.length).toBe(1);
+        (0, import_vitest9.expect)(in_window.length).toBe(1);
         const out_of_window = await collect(store, {
           stream: s,
           stream_exact: true,
           created_after: future
         });
-        (0, import_vitest6.expect)(out_of_window.length).toBe(0);
+        (0, import_vitest9.expect)(out_of_window.length).toBe(0);
       });
-      (0, import_vitest6.it)("backward traversal short-circuits at `after` id boundary", async () => {
+      (0, import_vitest9.it)("backward traversal short-circuits at `after` id boundary", async () => {
         const s = `q-back-after-${uid()}`;
         const committed = await store.commit(
           s,
@@ -678,12 +1089,12 @@ var runStoreTck = (options) => {
           backward: true,
           after: committed[0].id
         });
-        (0, import_vitest6.expect)(got.map((e) => e.id)).toEqual([
+        (0, import_vitest9.expect)(got.map((e) => e.id)).toEqual([
           committed[2].id,
           committed[1].id
         ]);
       });
-      (0, import_vitest6.it)("backward traversal short-circuits at `created_after` boundary", async () => {
+      (0, import_vitest9.it)("backward traversal short-circuits at `created_after` boundary", async () => {
         const s = `q-back-cafter-${uid()}`;
         await store.commit(
           s,
@@ -697,9 +1108,9 @@ var runStoreTck = (options) => {
           backward: true,
           created_after: future
         });
-        (0, import_vitest6.expect)(got).toHaveLength(0);
+        (0, import_vitest9.expect)(got).toHaveLength(0);
       });
-      (0, import_vitest6.it)("backward traversal honors created_before by skipping newer events", async () => {
+      (0, import_vitest9.it)("backward traversal honors created_before by skipping newer events", async () => {
         const s = `q-back-ts-${uid()}`;
         const committed = await store.commit(
           s,
@@ -713,9 +1124,9 @@ var runStoreTck = (options) => {
           backward: true,
           created_before: past
         });
-        (0, import_vitest6.expect)(got).toHaveLength(0);
+        (0, import_vitest9.expect)(got).toHaveLength(0);
       });
-      (0, import_vitest6.it)("stream_exact disables regex matching", async () => {
+      (0, import_vitest9.it)("stream_exact disables regex matching", async () => {
         const tag = uid();
         const a = `q-exact-${tag}`;
         const b = `q-exact-${tag}-extra`;
@@ -730,10 +1141,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: b })
         );
         const exact = await collect(store, { stream: a, stream_exact: true });
-        (0, import_vitest6.expect)(exact).toHaveLength(1);
-        (0, import_vitest6.expect)(exact[0].data).toEqual({ amount: 1 });
+        (0, import_vitest9.expect)(exact).toHaveLength(1);
+        (0, import_vitest9.expect)(exact[0].data).toEqual({ amount: 1 });
       });
-      (0, import_vitest6.it)("plain regex without anchors is a substring match", async () => {
+      (0, import_vitest9.it)("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qr-${tag}-inner`;
         const longer = `qr-${tag}-inner-extra`;
@@ -748,9 +1159,9 @@ var runStoreTck = (options) => {
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `qr-${tag}-inner` });
-        (0, import_vitest6.expect)(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
+        (0, import_vitest9.expect)(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
       });
-      (0, import_vitest6.it)("caller-anchored `^name$` matches only the whole string", async () => {
+      (0, import_vitest9.it)("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qr-${tag}-anchor`;
         const longer = `qr-${tag}-anchor-extra`;
@@ -765,10 +1176,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `^qr-${tag}-anchor$` });
-        (0, import_vitest6.expect)(got).toHaveLength(1);
-        (0, import_vitest6.expect)(got[0].stream).toBe(inner);
+        (0, import_vitest9.expect)(got).toHaveLength(1);
+        (0, import_vitest9.expect)(got[0].stream).toBe(inner);
       });
-      (0, import_vitest6.it)("caller-anchored `^prefix` matches by prefix", async () => {
+      (0, import_vitest9.it)("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qr-${tag}-pfx-a`;
         const b = `qr-${tag}-pfx-b`;
@@ -789,18 +1200,39 @@ var runStoreTck = (options) => {
           make_meta({ stream: other })
         );
         const got = await collect(store, { stream: `^qr-${tag}-pfx-` });
-        (0, import_vitest6.expect)(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
+        (0, import_vitest9.expect)(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
       });
     });
-    (0, import_vitest6.describe)("subscribe + claim + ack", () => {
-      (0, import_vitest6.it)("subscribes new streams and is idempotent on repeat", async () => {
+    (0, import_vitest9.describe)("subscribe + claim + ack", () => {
+      (0, import_vitest9.it)("subscribes new streams and is idempotent on repeat", async () => {
         const s = `sub-${uid()}`;
         const first = await store.subscribe([{ stream: s }]);
-        (0, import_vitest6.expect)(first.subscribed).toBe(1);
+        (0, import_vitest9.expect)(first.subscribed).toBe(1);
         const second = await store.subscribe([{ stream: s }]);
-        (0, import_vitest6.expect)(second.subscribed).toBe(0);
+        (0, import_vitest9.expect)(second.subscribed).toBe(0);
       });
-      (0, import_vitest6.it)("claims a subscribed stream and ack releases the lease", async () => {
+      (0, import_vitest9.it)("keeps the maximum priority when a stream is re-subscribed", async () => {
+        const s = `sub-pri-${uid()}`;
+        const read = async () => {
+          const got = {};
+          await store.query_streams(
+            (p) => {
+              got.priority = p.priority;
+            },
+            { stream: s, stream_exact: true }
+          );
+          return got.priority;
+        };
+        await store.subscribe([{ stream: s, priority: 3 }]);
+        (0, import_vitest9.expect)(await read()).toBe(3);
+        await store.subscribe([{ stream: s, priority: 10 }]);
+        (0, import_vitest9.expect)(await read()).toBe(10);
+        await store.subscribe([{ stream: s, priority: 1 }]);
+        (0, import_vitest9.expect)(await read()).toBe(10);
+        await store.subscribe([{ stream: s }]);
+        (0, import_vitest9.expect)(await read()).toBe(10);
+      });
+      (0, import_vitest9.it)("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -811,11 +1243,11 @@ var runStoreTck = (options) => {
         const by = `worker-${uid()}`;
         const leased = await store.claim(100, 0, by, 1e4);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest6.expect)(mine).toBeDefined();
-        (0, import_vitest6.expect)(mine.by).toBe(by);
+        (0, import_vitest9.expect)(mine).toBeDefined();
+        (0, import_vitest9.expect)(mine.by).toBe(by);
         await store.ack([{ ...mine, at: mine.at + 1 }]);
       });
-      (0, import_vitest6.it)("does not double-claim a held lease", async () => {
+      (0, import_vitest9.it)("does not double-claim a held lease", async () => {
         const s = `claim-held-${uid()}`;
         const other = `claim-other-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -826,7 +1258,7 @@ var runStoreTck = (options) => {
         );
         const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1e5);
         const targetA = leasedA.find((l) => l.stream === s);
-        (0, import_vitest6.expect)(targetA).toBeDefined();
+        (0, import_vitest9.expect)(targetA).toBeDefined();
         await store.subscribe([{ stream: other }]);
         await store.commit(
           other,
@@ -834,11 +1266,11 @@ var runStoreTck = (options) => {
           make_meta({ stream: other })
         );
         const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
-        (0, import_vitest6.expect)(leasedB.length).toBeGreaterThan(0);
-        (0, import_vitest6.expect)(leasedB.find((l) => l.stream === s)).toBeUndefined();
-        (0, import_vitest6.expect)(leasedB.find((l) => l.stream === other)).toBeDefined();
+        (0, import_vitest9.expect)(leasedB.length).toBeGreaterThan(0);
+        (0, import_vitest9.expect)(leasedB.find((l) => l.stream === s)).toBeUndefined();
+        (0, import_vitest9.expect)(leasedB.find((l) => l.stream === other)).toBeDefined();
       });
-      (0, import_vitest6.it)("supports dual frontiers (lagging + leading)", async () => {
+      (0, import_vitest9.it)("supports dual frontiers (lagging + leading)", async () => {
         const s = `claim-dual-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -848,12 +1280,12 @@ var runStoreTck = (options) => {
         );
         const first = await store.claim(100, 0, `w-${uid()}`, 1);
         const mine = first.find((l) => l.stream === s);
-        (0, import_vitest6.expect)(mine).toBeDefined();
+        (0, import_vitest9.expect)(mine).toBeDefined();
         await store.ack([{ ...mine, at: mine.at + 1 }]);
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
-        (0, import_vitest6.expect)(second.find((l) => l.stream === s)).toBeDefined();
+        (0, import_vitest9.expect)(second.find((l) => l.stream === s)).toBeDefined();
       });
-      (0, import_vitest6.it)("dedupes when both frontiers would return the same stream", async () => {
+      (0, import_vitest9.it)("dedupes when both frontiers would return the same stream", async () => {
         const s = `claim-dedup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -863,9 +1295,9 @@ var runStoreTck = (options) => {
         );
         const claimed = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const matches = claimed.filter((l) => l.stream === s);
-        (0, import_vitest6.expect)(matches).toHaveLength(1);
+        (0, import_vitest9.expect)(matches).toHaveLength(1);
       });
-      (0, import_vitest6.it)("silently ignores ack from the wrong holder", async () => {
+      (0, import_vitest9.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 }]);
@@ -882,40 +1314,40 @@ var runStoreTck = (options) => {
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const sibling_lease = leased.find((l) => l.stream === sibling);
-        (0, import_vitest6.expect)(mine).toBeDefined();
-        (0, import_vitest6.expect)(sibling_lease).toBeDefined();
+        (0, import_vitest9.expect)(mine).toBeDefined();
+        (0, import_vitest9.expect)(sibling_lease).toBeDefined();
         const acked = await store.ack([
           { ...mine, by: "imposter" },
           sibling_lease
         ]);
-        (0, import_vitest6.expect)(acked.length).toBeGreaterThan(0);
-        (0, import_vitest6.expect)(acked.find((l) => l.stream === s)).toBeUndefined();
+        (0, import_vitest9.expect)(acked.length).toBeGreaterThan(0);
+        (0, import_vitest9.expect)(acked.find((l) => l.stream === s)).toBeUndefined();
       });
-      (0, import_vitest6.it)("ack with a stale (lower) watermark does not throw", async () => {
+      (0, import_vitest9.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_vitest6.expect)(mine).toBeDefined();
-        await (0, import_vitest6.expect)(
+        (0, import_vitest9.expect)(mine).toBeDefined();
+        await (0, import_vitest9.expect)(
           store.ack([{ ...mine, at: -5 }])
         ).resolves.toBeDefined();
       });
-      (0, import_vitest6.it)("claim with no subscribed streams returns an empty array", async () => {
+      (0, import_vitest9.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_vitest6.expect)(claimed).toEqual([]);
+          (0, import_vitest9.expect)(claimed).toEqual([]);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    (0, import_vitest6.describe)("lease semantics", () => {
-      (0, import_vitest6.it)("returns retry=0 on first claim and increments on re-claim without ack", async () => {
+    (0, import_vitest9.describe)("lease semantics", () => {
+      (0, import_vitest9.it)("returns retry=0 on first claim and increments on re-claim without ack", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -929,17 +1361,17 @@ var runStoreTck = (options) => {
           );
           const first = await fresh.claim(1, 0, `w-${uid()}`, 0);
           const f = first.find((l) => l.stream === s);
-          (0, import_vitest6.expect)(f).toBeDefined();
-          (0, import_vitest6.expect)(f.retry).toBe(0);
+          (0, import_vitest9.expect)(f).toBeDefined();
+          (0, import_vitest9.expect)(f.retry).toBe(0);
           const second = await fresh.claim(1, 0, `w-${uid()}`, 1e5);
           const sec = second.find((l) => l.stream === s);
-          (0, import_vitest6.expect)(sec).toBeDefined();
-          (0, import_vitest6.expect)(sec.retry).toBe(1);
+          (0, import_vitest9.expect)(sec).toBeDefined();
+          (0, import_vitest9.expect)(sec.retry).toBe(1);
         } finally {
           await fresh.dispose();
         }
       });
-      (0, import_vitest6.it)("reports lagging=true from the lagging frontier and false from the leading frontier", async () => {
+      (0, import_vitest9.it)("reports lagging=true from the lagging frontier and false from the leading frontier", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -952,16 +1384,16 @@ var runStoreTck = (options) => {
             make_meta({ stream: s })
           );
           const lag = await fresh.claim(1, 0, `w-${uid()}`, 0);
-          (0, import_vitest6.expect)(lag.find((l) => l.stream === s)?.lagging).toBe(true);
+          (0, import_vitest9.expect)(lag.find((l) => l.stream === s)?.lagging).toBe(true);
           const lead = await fresh.claim(0, 1, `w-${uid()}`, 1e5);
-          (0, import_vitest6.expect)(lead.find((l) => l.stream === s)?.lagging).toBe(false);
+          (0, import_vitest9.expect)(lead.find((l) => l.stream === s)?.lagging).toBe(false);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    import_vitest6.describe.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
-      (0, import_vitest6.it)("never double-leases a stream across concurrent claimers", async () => {
+    import_vitest9.describe.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
+      (0, import_vitest9.it)("never double-leases a stream across concurrent claimers", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -984,15 +1416,15 @@ var runStoreTck = (options) => {
             fresh.claim(100, 100, `wB-${uid()}`, 6e4)
           ]);
           const claimed = [...a, ...b].map((l) => l.stream).filter((stream) => owned.has(stream));
-          (0, import_vitest6.expect)(new Set(claimed).size).toBe(claimed.length);
-          (0, import_vitest6.expect)(claimed.length).toBe(owned.size);
+          (0, import_vitest9.expect)(new Set(claimed).size).toBe(claimed.length);
+          (0, import_vitest9.expect)(claimed.length).toBe(owned.size);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    (0, import_vitest6.describe)("block", () => {
-      (0, import_vitest6.it)("hides blocked streams from claim", async () => {
+    (0, import_vitest9.describe)("block", () => {
+      (0, import_vitest9.it)("hides blocked streams from claim", async () => {
         const s = `block-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1002,18 +1434,18 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest6.expect)(mine).toBeDefined();
+        (0, import_vitest9.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_vitest6.expect)(blocked).toHaveLength(1);
-        (0, import_vitest6.expect)(blocked[0].error).toBe("boom");
+        (0, import_vitest9.expect)(blocked).toHaveLength(1);
+        (0, import_vitest9.expect)(blocked[0].error).toBe("boom");
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
-        (0, import_vitest6.expect)(again.find((l) => l.stream === s)).toBeUndefined();
+        (0, import_vitest9.expect)(again.find((l) => l.stream === s)).toBeUndefined();
       });
-      (0, import_vitest6.it)("rejects block calls from a different holder", async () => {
+      (0, import_vitest9.it)("rejects block calls from a different holder", async () => {
         const s = `block-wrong-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1023,17 +1455,17 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest6.expect)(mine).toBeDefined();
+        (0, import_vitest9.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_vitest6.expect)(blocked).toHaveLength(0);
+        (0, import_vitest9.expect)(blocked).toHaveLength(0);
       });
     });
-    (0, import_vitest6.describe)("reset", () => {
-      (0, import_vitest6.it)("rewinds a stream watermark to -1", async () => {
+    (0, import_vitest9.describe)("reset", () => {
+      (0, import_vitest9.it)("rewinds a stream watermark to -1", async () => {
         const s = `reset-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1043,15 +1475,15 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        (0, import_vitest6.expect)(mine).toBeDefined();
+        (0, import_vitest9.expect)(mine).toBeDefined();
         await store.ack([{ ...mine, at: 99 }]);
-        (0, import_vitest6.expect)(await store.reset([s])).toBe(1);
+        (0, import_vitest9.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_vitest6.expect)(back).toBeDefined();
-        (0, import_vitest6.expect)(back.at).toBe(-1);
+        (0, import_vitest9.expect)(back).toBeDefined();
+        (0, import_vitest9.expect)(back.at).toBe(-1);
       });
-      (0, import_vitest6.it)("clears blocked status when resetting", async () => {
+      (0, import_vitest9.it)("clears blocked status when resetting", async () => {
         const s = `reset-blk-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1064,17 +1496,17 @@ var runStoreTck = (options) => {
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
-        (0, import_vitest6.expect)(await store.reset([s])).toBe(1);
+        (0, import_vitest9.expect)(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
-        (0, import_vitest6.expect)(after.find((l) => l.stream === s)).toBeDefined();
+        (0, import_vitest9.expect)(after.find((l) => l.stream === s)).toBeDefined();
       });
-      (0, import_vitest6.it)("returns 0 for unknown streams and empty input", async () => {
-        (0, import_vitest6.expect)(await store.reset([`missing-${uid()}`])).toBe(0);
-        (0, import_vitest6.expect)(await store.reset([])).toBe(0);
+      (0, import_vitest9.it)("returns 0 for unknown streams and empty input", async () => {
+        (0, import_vitest9.expect)(await store.reset([`missing-${uid()}`])).toBe(0);
+        (0, import_vitest9.expect)(await store.reset([])).toBe(0);
       });
     });
-    (0, import_vitest6.describe)("unblock", () => {
-      (0, import_vitest6.it)("clears blocked flag and preserves the watermark", async () => {
+    (0, import_vitest9.describe)("unblock", () => {
+      (0, import_vitest9.it)("clears blocked flag and preserves the watermark", async () => {
         const s = `unblock-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1092,7 +1524,7 @@ var runStoreTck = (options) => {
         await store.ack([{ ...m1, at: m1.at }]);
         const before_block = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m2 = before_block.find((l) => l.stream === s);
-        (0, import_vitest6.expect)(m2).toBeDefined();
+        (0, import_vitest9.expect)(m2).toBeDefined();
         const watermark_before = m2.at;
         await store.block([{ ...m2, error: "permanent" }]);
         let blocked_flag;
@@ -1102,15 +1534,15 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, limit: 1 }
         );
-        (0, import_vitest6.expect)(blocked_flag).toBe(true);
-        (0, import_vitest6.expect)(await store.unblock([s])).toBe(1);
+        (0, import_vitest9.expect)(blocked_flag).toBe(true);
+        (0, import_vitest9.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_vitest6.expect)(back).toBeDefined();
-        (0, import_vitest6.expect)(back.at).toBe(watermark_before);
-        (0, import_vitest6.expect)(back.retry).toBe(0);
+        (0, import_vitest9.expect)(back).toBeDefined();
+        (0, import_vitest9.expect)(back.at).toBe(watermark_before);
+        (0, import_vitest9.expect)(back.retry).toBe(0);
       });
-      (0, import_vitest6.it)("returns 0 when the stream is not blocked", async () => {
+      (0, import_vitest9.it)("returns 0 when the stream is not blocked", async () => {
         const s = `unblock-noop-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1118,13 +1550,13 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
-        (0, import_vitest6.expect)(await store.unblock([s])).toBe(0);
+        (0, import_vitest9.expect)(await store.unblock([s])).toBe(0);
       });
-      (0, import_vitest6.it)("returns 0 for unknown streams and empty input", async () => {
-        (0, import_vitest6.expect)(await store.unblock([`missing-${uid()}`])).toBe(0);
-        (0, import_vitest6.expect)(await store.unblock([])).toBe(0);
+      (0, import_vitest9.it)("returns 0 for unknown streams and empty input", async () => {
+        (0, import_vitest9.expect)(await store.unblock([`missing-${uid()}`])).toBe(0);
+        (0, import_vitest9.expect)(await store.unblock([])).toBe(0);
       });
-      (0, import_vitest6.it)("only counts streams that were actually blocked", async () => {
+      (0, import_vitest9.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 }]);
@@ -1143,9 +1575,9 @@ var runStoreTck = (options) => {
         const others = leased.filter((l) => l.stream !== s1);
         await store.ack(others);
         await store.block([{ ...m1, error: "boom" }]);
-        (0, import_vitest6.expect)(await store.unblock([s1, s2])).toBe(1);
+        (0, import_vitest9.expect)(await store.unblock([s1, s2])).toBe(1);
       });
-      (0, import_vitest6.it)("filter form: unblocks by stream pattern", async () => {
+      (0, import_vitest9.it)("filter form: unblocks by stream pattern", async () => {
         const tag = uid();
         const s1 = `unblock-filter-${tag}-a`;
         const s2 = `unblock-filter-${tag}-b`;
@@ -1177,13 +1609,13 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-filter-${tag}-`
         });
-        (0, import_vitest6.expect)(count).toBe(2);
+        (0, import_vitest9.expect)(count).toBe(2);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
-        (0, import_vitest6.expect)(after.find((l) => l.stream === s3)).toBeUndefined();
-        (0, import_vitest6.expect)(after.find((l) => l.stream === s1)).toBeDefined();
-        (0, import_vitest6.expect)(after.find((l) => l.stream === s2)).toBeDefined();
+        (0, import_vitest9.expect)(after.find((l) => l.stream === s3)).toBeUndefined();
+        (0, import_vitest9.expect)(after.find((l) => l.stream === s1)).toBeDefined();
+        (0, import_vitest9.expect)(after.find((l) => l.stream === s2)).toBeDefined();
       });
-      (0, import_vitest6.it)("filter form: empty filter unblocks every blocked stream", async () => {
+      (0, import_vitest9.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`;
@@ -1207,9 +1639,9 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-empty-${tag}-`
         });
-        (0, import_vitest6.expect)(count).toBe(2);
+        (0, import_vitest9.expect)(count).toBe(2);
       });
-      (0, import_vitest6.it)("filter form: explicit blocked:false matches nothing", async () => {
+      (0, import_vitest9.it)("filter form: explicit blocked:false matches nothing", async () => {
         const tag = uid();
         const s = `unblock-blocked-false-${tag}`;
         await store.subscribe([{ stream: s }]);
@@ -1218,7 +1650,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
-        (0, import_vitest6.expect)(
+        (0, import_vitest9.expect)(
           await store.unblock({
             stream: `^unblock-blocked-false-${tag}`,
             blocked: false
@@ -1226,8 +1658,8 @@ var runStoreTck = (options) => {
         ).toBe(0);
       });
     });
-    (0, import_vitest6.describe)("reset filter form", () => {
-      (0, import_vitest6.it)("resets streams matching a stream pattern", async () => {
+    (0, import_vitest9.describe)("reset filter form", () => {
+      (0, import_vitest9.it)("resets streams matching a stream pattern", async () => {
         const tag = uid();
         const s1 = `reset-filter-${tag}-a`;
         const s2 = `reset-filter-${tag}-b`;
@@ -1258,7 +1690,7 @@ var runStoreTck = (options) => {
         );
         await store.ack(mine.map((l) => ({ ...l, at: l.at + 100 })));
         const count = await store.reset({ stream: `^reset-filter-${tag}-` });
-        (0, import_vitest6.expect)(count).toBe(2);
+        (0, import_vitest9.expect)(count).toBe(2);
         const position_for = async (name) => {
           let at = null;
           await store.query_streams(
@@ -1269,11 +1701,11 @@ var runStoreTck = (options) => {
           );
           return at;
         };
-        (0, import_vitest6.expect)(await position_for(s1)).toBe(-1);
-        (0, import_vitest6.expect)(await position_for(s2)).toBe(-1);
-        (0, import_vitest6.expect)(await position_for(other)).toBeGreaterThan(-1);
+        (0, import_vitest9.expect)(await position_for(s1)).toBe(-1);
+        (0, import_vitest9.expect)(await position_for(s2)).toBe(-1);
+        (0, import_vitest9.expect)(await position_for(other)).toBeGreaterThan(-1);
       });
-      (0, import_vitest6.it)("filter form: resets only blocked streams when blocked:true", async () => {
+      (0, import_vitest9.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`;
@@ -1296,11 +1728,11 @@ var runStoreTck = (options) => {
           stream: `^reset-blocked-${tag}-`,
           blocked: true
         });
-        (0, import_vitest6.expect)(count).toBe(1);
+        (0, import_vitest9.expect)(count).toBe(1);
       });
     });
-    (0, import_vitest6.describe)("prioritize", () => {
-      (0, import_vitest6.it)("sets priority directly, overriding subscribe's max() rule", async () => {
+    (0, import_vitest9.describe)("prioritize", () => {
+      (0, import_vitest9.it)("sets priority directly, overriding subscribe's max() rule", async () => {
         const tag = uid();
         const s1 = `pri-${tag}-a`;
         const s2 = `pri-${tag}-b`;
@@ -1312,7 +1744,7 @@ var runStoreTck = (options) => {
           { stream: s1, stream_exact: true },
           3
         );
-        (0, import_vitest6.expect)(updated).toBe(1);
+        (0, import_vitest9.expect)(updated).toBe(1);
         const got1 = {};
         const got2 = {};
         await store.query_streams(
@@ -1322,12 +1754,12 @@ var runStoreTck = (options) => {
           },
           { stream: `pri-${tag}-.*`, limit: 100 }
         );
-        (0, import_vitest6.expect)(got1.priority).toBe(3);
-        (0, import_vitest6.expect)(got2.priority).toBe(5);
+        (0, import_vitest9.expect)(got1.priority).toBe(3);
+        (0, import_vitest9.expect)(got2.priority).toBe(5);
       });
     });
-    (0, import_vitest6.describe)("lanes", () => {
-      (0, import_vitest6.it)("subscribe defaults lane to 'default' when omitted", async () => {
+    (0, import_vitest9.describe)("lanes", () => {
+      (0, import_vitest9.it)("subscribe defaults lane to 'default' when omitted", async () => {
         const s = `lane-default-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const seen = [];
@@ -1335,9 +1767,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest6.expect)(seen).toEqual(["default"]);
+        (0, import_vitest9.expect)(seen).toEqual(["default"]);
       });
-      (0, import_vitest6.it)("subscribe records the lane passed in", async () => {
+      (0, import_vitest9.it)("subscribe records the lane passed in", async () => {
         const s = `lane-set-${uid()}`;
         await store.subscribe([{ stream: s, lane: "slow" }]);
         const seen = [];
@@ -1345,9 +1777,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest6.expect)(seen).toEqual(["slow"]);
+        (0, import_vitest9.expect)(seen).toEqual(["slow"]);
       });
-      (0, import_vitest6.it)("subscribe re-lanes existing streams on subsequent calls", async () => {
+      (0, import_vitest9.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" }]);
@@ -1356,9 +1788,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        (0, import_vitest6.expect)(seen).toEqual(["fast"]);
+        (0, import_vitest9.expect)(seen).toEqual(["fast"]);
       });
-      (0, import_vitest6.it)("claim() filters by lane when supplied and returns lane on the Lease", async () => {
+      (0, import_vitest9.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}`;
@@ -1382,19 +1814,19 @@ var runStoreTck = (options) => {
         const slow_mine = slow.filter(
           (l) => l.stream === sub_default || l.stream === sub_slow
         );
-        (0, import_vitest6.expect)(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
-        (0, import_vitest6.expect)(slow_mine[0]?.lane).toBe("slow");
+        (0, import_vitest9.expect)(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
+        (0, import_vitest9.expect)(slow_mine[0]?.lane).toBe("slow");
         await store.ack(slow_mine.map((l) => ({ ...l, at: l.at + 1 })));
         const all = await store.claim(50, 0, `w-all-${tag}`, 1e3);
         const all_mine = all.filter((l) => l.stream === sub_default || l.stream === sub_slow).map((l) => ({ stream: l.stream, lane: l.lane }));
-        (0, import_vitest6.expect)(all_mine).toEqual(
-          import_vitest6.expect.arrayContaining([
+        (0, import_vitest9.expect)(all_mine).toEqual(
+          import_vitest9.expect.arrayContaining([
             { stream: sub_default, lane: "default" },
             { stream: sub_slow, lane: "slow" }
           ])
         );
       });
-      (0, import_vitest6.it)("query_streams filters by lane", async () => {
+      (0, import_vitest9.it)("query_streams filters by lane", async () => {
         const tag = uid();
         const a = `lane-q-a-${tag}`;
         const b = `lane-q-b-${tag}`;
@@ -1410,9 +1842,9 @@ var runStoreTck = (options) => {
           stream: `lane-q-.*-${tag}`,
           limit: 100
         });
-        (0, import_vitest6.expect)(seen.sort()).toEqual([a, c]);
+        (0, import_vitest9.expect)(seen.sort()).toEqual([a, c]);
       });
-      (0, import_vitest6.it)("prioritize filters by lane", async () => {
+      (0, import_vitest9.it)("prioritize filters by lane", async () => {
         const tag = uid();
         const a = `lane-pri-a-${tag}`;
         const b = `lane-pri-b-${tag}`;
@@ -1421,16 +1853,16 @@ var runStoreTck = (options) => {
           { stream: b, lane: `pfast-${tag}` }
         ]);
         const updated = await store.prioritize({ lane: `pslow-${tag}` }, 7);
-        (0, import_vitest6.expect)(updated).toBe(1);
+        (0, import_vitest9.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_vitest6.expect)(seen.get(a)).toBe(7);
-        (0, import_vitest6.expect)(seen.get(b)).toBe(0);
+        (0, import_vitest9.expect)(seen.get(a)).toBe(7);
+        (0, import_vitest9.expect)(seen.get(b)).toBe(0);
       });
-      (0, import_vitest6.it)("reset filters by lane", async () => {
+      (0, import_vitest9.it)("reset filters by lane", async () => {
         const tag = uid();
         const src = `lane-reset-src-${tag}`;
         const a = `lane-reset-a-${tag}`;
@@ -1448,7 +1880,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_vitest6.expect)(count).toBe(1);
+        (0, import_vitest9.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), {
@@ -1456,10 +1888,10 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        (0, import_vitest6.expect)(ats.get(a)).toBe(-1);
-        (0, import_vitest6.expect)(ats.get(b)).toBeGreaterThanOrEqual(0);
+        (0, import_vitest9.expect)(ats.get(a)).toBe(-1);
+        (0, import_vitest9.expect)(ats.get(b)).toBeGreaterThanOrEqual(0);
       });
-      (0, import_vitest6.it)("unblock filters by lane", async () => {
+      (0, import_vitest9.it)("unblock filters by lane", async () => {
         const tag = uid();
         const src = `lane-ub-src-${tag}`;
         const a = `lane-ub-a-${tag}`;
@@ -1477,7 +1909,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_vitest6.expect)(count).toBe(1);
+        (0, import_vitest9.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), {
@@ -1485,12 +1917,12 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        (0, import_vitest6.expect)(blocked.get(a)).toBe(false);
-        (0, import_vitest6.expect)(blocked.get(b)).toBe(true);
+        (0, import_vitest9.expect)(blocked.get(a)).toBe(false);
+        (0, import_vitest9.expect)(blocked.get(b)).toBe(true);
       });
     });
-    (0, import_vitest6.describe)("truncate", () => {
-      (0, import_vitest6.it)("seeds a tombstone when no snapshot is provided", async () => {
+    (0, import_vitest9.describe)("truncate", () => {
+      (0, import_vitest9.it)("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
         await store.commit(
           s,
@@ -1498,7 +1930,7 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const result = await store.truncate([{ stream: s }]);
-        (0, import_vitest6.expect)(result.get(s)?.deleted).toBe(2);
+        (0, import_vitest9.expect)(result.get(s)?.deleted).toBe(2);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1506,12 +1938,12 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest6.expect)(remaining).toHaveLength(1);
-        (0, import_vitest6.expect)(remaining[0].name).toBe(
+        (0, import_vitest9.expect)(remaining).toHaveLength(1);
+        (0, import_vitest9.expect)(remaining[0].name).toBe(
           "__tombstone__"
         );
       });
-      (0, import_vitest6.it)("seeds a snapshot when one is provided", async () => {
+      (0, import_vitest9.it)("seeds a snapshot when one is provided", async () => {
         const s = `trunc-snap-${uid()}`;
         await store.commit(
           s,
@@ -1521,7 +1953,7 @@ var runStoreTck = (options) => {
         const result = await store.truncate([
           { stream: s, snapshot: { count: 7 } }
         ]);
-        (0, import_vitest6.expect)(result.get(s)?.deleted).toBe(1);
+        (0, import_vitest9.expect)(result.get(s)?.deleted).toBe(1);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1529,24 +1961,24 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, with_snaps: true }
         );
-        (0, import_vitest6.expect)(remaining).toHaveLength(1);
-        (0, import_vitest6.expect)(remaining[0].name).toBe(
+        (0, import_vitest9.expect)(remaining).toHaveLength(1);
+        (0, import_vitest9.expect)(remaining[0].name).toBe(
           "__snapshot__"
         );
-        (0, import_vitest6.expect)(remaining[0].data).toEqual({ count: 7 });
+        (0, import_vitest9.expect)(remaining[0].data).toEqual({ count: 7 });
       });
-      (0, import_vitest6.it)("returns an empty map for empty input", async () => {
+      (0, import_vitest9.it)("returns an empty map for empty input", async () => {
         const result = await store.truncate([]);
-        (0, import_vitest6.expect)(result.size).toBe(0);
+        (0, import_vitest9.expect)(result.size).toBe(0);
       });
-      (0, import_vitest6.it)("returns 0 deleted for streams that don't exist", async () => {
+      (0, import_vitest9.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_vitest6.expect)(result.get(s)?.deleted).toBe(0);
+        (0, import_vitest9.expect)(result.get(s)?.deleted).toBe(0);
       });
     });
-    (0, import_vitest6.describe)("query_streams", () => {
-      (0, import_vitest6.it)("returns positions filtered by stream regex, exact, source, and source_exact", async () => {
+    (0, import_vitest9.describe)("query_streams", () => {
+      (0, import_vitest9.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`;
@@ -1565,37 +1997,37 @@ var runStoreTck = (options) => {
           (p) => all.push({ stream: p.stream, source: p.source }),
           { stream: `qs-${tag}-.*` }
         );
-        (0, import_vitest6.expect)(all_result.count).toBe(4);
-        (0, import_vitest6.expect)(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
-        (0, import_vitest6.expect)(all.map((p) => p.stream).sort()).toEqual(
+        (0, import_vitest9.expect)(all_result.count).toBe(4);
+        (0, import_vitest9.expect)(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
+        (0, import_vitest9.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_vitest6.expect)(projections.sort()).toEqual([proj1, proj2].sort());
+        (0, import_vitest9.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_vitest6.expect)(exact).toEqual([dyn1]);
+        (0, import_vitest9.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_vitest6.expect)(by_source.sort()).toEqual([dyn1, dyn2].sort());
+        (0, import_vitest9.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_vitest6.expect)(exact_source).toEqual([dyn2]);
+        (0, import_vitest9.expect)(exact_source).toEqual([dyn2]);
       });
-      (0, import_vitest6.it)("paginates with limit + after (keyset)", async () => {
+      (0, import_vitest9.it)("paginates with limit + after (keyset)", async () => {
         const tag = uid();
         const streams = [
           `qp-${tag}-a`,
@@ -1609,17 +2041,17 @@ var runStoreTck = (options) => {
           stream: `qp-${tag}-.*`,
           limit: 2
         });
-        (0, import_vitest6.expect)(page1).toHaveLength(2);
+        (0, import_vitest9.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_vitest6.expect)(page2).toHaveLength(2);
-        (0, import_vitest6.expect)([...page1, ...page2].sort()).toEqual([...streams].sort());
+        (0, import_vitest9.expect)(page2).toHaveLength(2);
+        (0, import_vitest9.expect)([...page1, ...page2].sort()).toEqual([...streams].sort());
       });
-      (0, import_vitest6.it)("filters by blocked status", async () => {
+      (0, import_vitest9.it)("filters by blocked status", async () => {
         const tag = uid();
         const s = `qb-${tag}`;
         const sibling = `qb-${tag}-other`;
@@ -1639,18 +2071,18 @@ var runStoreTck = (options) => {
           (p) => blocked.push({ stream: p.stream, error: p.error }),
           { stream: `qb-${tag}.*`, blocked: true }
         );
-        (0, import_vitest6.expect)(blocked).toHaveLength(1);
-        (0, import_vitest6.expect)(blocked[0].error).toBe("boom");
+        (0, import_vitest9.expect)(blocked).toHaveLength(1);
+        (0, import_vitest9.expect)(blocked[0].error).toBe("boom");
         const unblocked = [];
         await store.query_streams((p) => unblocked.push(p.stream), {
           stream: `qb-${tag}.*`,
           blocked: false
         });
-        (0, import_vitest6.expect)(unblocked).toEqual([sibling]);
+        (0, import_vitest9.expect)(unblocked).toEqual([sibling]);
       });
     });
-    (0, import_vitest6.describe)("query_stats", () => {
-      (0, import_vitest6.it)("array input \u2014 returns head per stream, absent when not in input", async () => {
+    (0, import_vitest9.describe)("query_stats", () => {
+      (0, import_vitest9.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`;
@@ -1671,18 +2103,18 @@ var runStoreTck = (options) => {
           make_meta({ stream: sUnasked })
         );
         const stats = await store.query_stats([sA, sB]);
-        (0, import_vitest6.expect)(stats.size).toBe(2);
-        (0, import_vitest6.expect)(stats.get(sA)?.head.name).toBe("Incremented");
-        (0, import_vitest6.expect)((stats.get(sA)?.head.data).amount).toBe(2);
-        (0, import_vitest6.expect)(stats.get(sB)?.head.name).toBe("Decremented");
-        (0, import_vitest6.expect)((stats.get(sB)?.head.data).amount).toBe(5);
-        (0, import_vitest6.expect)(stats.has(sUnasked)).toBe(false);
+        (0, import_vitest9.expect)(stats.size).toBe(2);
+        (0, import_vitest9.expect)(stats.get(sA)?.head.name).toBe("Incremented");
+        (0, import_vitest9.expect)((stats.get(sA)?.head.data).amount).toBe(2);
+        (0, import_vitest9.expect)(stats.get(sB)?.head.name).toBe("Decremented");
+        (0, import_vitest9.expect)((stats.get(sB)?.head.data).amount).toBe(5);
+        (0, import_vitest9.expect)(stats.has(sUnasked)).toBe(false);
         const empty = await store.query_stats([]);
-        (0, import_vitest6.expect)(empty.size).toBe(0);
+        (0, import_vitest9.expect)(empty.size).toBe(0);
         const unknown = await store.query_stats([`qst-${tag}-missing`]);
-        (0, import_vitest6.expect)(unknown.size).toBe(0);
+        (0, import_vitest9.expect)(unknown.size).toBe(0);
       });
-      (0, import_vitest6.it)("tail returns the earliest event per stream", async () => {
+      (0, import_vitest9.it)("tail returns the earliest event per stream", async () => {
         const tag = uid();
         const s = `qst-tail-${tag}`;
         await store.commit(
@@ -1704,12 +2136,12 @@ var runStoreTck = (options) => {
           tail: true
         });
         const r = stats.get(s);
-        (0, import_vitest6.expect)(r?.head.name).toBe("Incremented");
-        (0, import_vitest6.expect)((r?.head.data).amount).toBe(3);
-        (0, import_vitest6.expect)(r?.tail?.name).toBe("Incremented");
-        (0, import_vitest6.expect)((r?.tail?.data).amount).toBe(1);
+        (0, import_vitest9.expect)(r?.head.name).toBe("Incremented");
+        (0, import_vitest9.expect)((r?.head.data).amount).toBe(3);
+        (0, import_vitest9.expect)(r?.tail?.name).toBe("Incremented");
+        (0, import_vitest9.expect)((r?.tail?.data).amount).toBe(1);
       });
-      (0, import_vitest6.it)("count + names \u2014 full aggregates including framework markers", async () => {
+      (0, import_vitest9.it)("count + names \u2014 full aggregates including framework markers", async () => {
         const tag = uid();
         const s = `qst-cn-${tag}`;
         await store.commit(
@@ -1728,13 +2160,13 @@ var runStoreTck = (options) => {
           names: true
         });
         const r = stats.get(s);
-        (0, import_vitest6.expect)(r?.count).toBe(4);
-        (0, import_vitest6.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
-        (0, import_vitest6.expect)(r?.names?.Incremented).toBe(2);
-        (0, import_vitest6.expect)(r?.names?.Decremented).toBe(1);
-        (0, import_vitest6.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
+        (0, import_vitest9.expect)(r?.count).toBe(4);
+        (0, import_vitest9.expect)(r?.names?.[import_act2.SNAP_EVENT]).toBe(1);
+        (0, import_vitest9.expect)(r?.names?.Incremented).toBe(2);
+        (0, import_vitest9.expect)(r?.names?.Decremented).toBe(1);
+        (0, import_vitest9.expect)(r?.names?.[import_act2.SNAP_EVENT]).toBe(1);
       });
-      (0, import_vitest6.it)("exclude shifts head past filtered events; stream absent when all filtered", async () => {
+      (0, import_vitest9.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}`;
@@ -1749,23 +2181,23 @@ var runStoreTck = (options) => {
           make_meta({ stream: sAllOut })
         );
         const all = await store.query_stats([s]);
-        (0, import_vitest6.expect)(all.get(s)?.head.name).toBe("Incremented");
-        (0, import_vitest6.expect)((all.get(s)?.head.data).amount).toBe(3);
+        (0, import_vitest9.expect)(all.get(s)?.head.name).toBe("Incremented");
+        (0, import_vitest9.expect)((all.get(s)?.head.data).amount).toBe(3);
         const excl = await store.query_stats([s], {
           exclude: ["Incremented"]
         });
-        (0, import_vitest6.expect)(excl.get(s)?.head.name).toBe("Decremented");
-        (0, import_vitest6.expect)((excl.get(s)?.head.data).amount).toBe(2);
+        (0, import_vitest9.expect)(excl.get(s)?.head.name).toBe("Decremented");
+        (0, import_vitest9.expect)((excl.get(s)?.head.data).amount).toBe(2);
         const wipe = await store.query_stats([sAllOut], {
           exclude: ["Incremented", "Decremented", "Reset"]
         });
-        (0, import_vitest6.expect)(wipe.has(sAllOut)).toBe(false);
+        (0, import_vitest9.expect)(wipe.has(sAllOut)).toBe(false);
         const no_tomb = await store.query_stats([s], {
-          exclude: [import_act.TOMBSTONE_EVENT]
+          exclude: [import_act2.TOMBSTONE_EVENT]
         });
-        (0, import_vitest6.expect)(no_tomb.get(s)?.head.name).toBe("Incremented");
+        (0, import_vitest9.expect)(no_tomb.get(s)?.head.name).toBe("Incremented");
       });
-      (0, import_vitest6.it)("before \u2014 time travel narrows head/tail/count", async () => {
+      (0, import_vitest9.it)("before \u2014 time travel narrows head/tail/count", async () => {
         const tag = uid();
         const s = `qst-tt-${tag}`;
         const c1 = await store.commit(
@@ -1790,15 +2222,15 @@ var runStoreTck = (options) => {
           before
         });
         const r = stats.get(s);
-        (0, import_vitest6.expect)(r?.count).toBe(1);
-        (0, import_vitest6.expect)(r?.head.id).toBe(c1[0].id);
-        (0, import_vitest6.expect)(r?.tail?.id).toBe(c1[0].id);
+        (0, import_vitest9.expect)(r?.count).toBe(1);
+        (0, import_vitest9.expect)(r?.head.id).toBe(c1[0].id);
+        (0, import_vitest9.expect)(r?.tail?.id).toBe(c1[0].id);
         const empty = await store.query_stats([s], {
           before: 0
         });
-        (0, import_vitest6.expect)(empty.has(s)).toBe(false);
+        (0, import_vitest9.expect)(empty.has(s)).toBe(false);
       });
-      (0, import_vitest6.it)("filter form \u2014 stream regex, stream_exact, empty {} match", async () => {
+      (0, import_vitest9.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`;
@@ -1821,18 +2253,18 @@ var runStoreTck = (options) => {
         const orders = await store.query_stats({
           stream: `^qsf-${tag}-orders-`
         });
-        (0, import_vitest6.expect)([...orders.keys()].sort()).toEqual([sA, sB].sort());
+        (0, import_vitest9.expect)([...orders.keys()].sort()).toEqual([sA, sB].sort());
         const exact = await store.query_stats({
           stream: sA,
           stream_exact: true
         });
-        (0, import_vitest6.expect)([...exact.keys()]).toEqual([sA]);
+        (0, import_vitest9.expect)([...exact.keys()]).toEqual([sA]);
         const all = await store.query_stats({
           stream: `^qsf-${tag}-`
         });
-        (0, import_vitest6.expect)([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
+        (0, import_vitest9.expect)([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
       });
-      (0, import_vitest6.it)("compose with query_streams for subscription-level filters", async () => {
+      (0, import_vitest9.it)("compose with query_streams for subscription-level filters", async () => {
         const tag = uid();
         const a = `qsc-${tag}-a`;
         const b = `qsc-${tag}-b`;
@@ -1849,7 +2281,7 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === a);
-        (0, import_vitest6.expect)(mine).toBeDefined();
+        (0, import_vitest9.expect)(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== a);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
@@ -1858,12 +2290,12 @@ var runStoreTck = (options) => {
           stream: `^qsc-${tag}-`,
           blocked: true
         });
-        (0, import_vitest6.expect)(blocked_names).toEqual([a]);
+        (0, import_vitest9.expect)(blocked_names).toEqual([a]);
         const stats = await store.query_stats(blocked_names);
-        (0, import_vitest6.expect)(stats.get(a)?.head.name).toBe("Incremented");
-        (0, import_vitest6.expect)(stats.has(b)).toBe(false);
+        (0, import_vitest9.expect)(stats.get(a)?.head.name).toBe("Incremented");
+        (0, import_vitest9.expect)(stats.has(b)).toBe(false);
       });
-      (0, import_vitest6.it)("empty filter {} \u2014 matches every event-bearing stream", async () => {
+      (0, import_vitest9.it)("empty filter {} \u2014 matches every event-bearing stream", async () => {
         const tag = uid();
         const a = `qse-${tag}-a`;
         const b = `qse-${tag}-b`;
@@ -1878,10 +2310,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: b })
         );
         const all = await store.query_stats({});
-        (0, import_vitest6.expect)(all.has(a)).toBe(true);
-        (0, import_vitest6.expect)(all.has(b)).toBe(true);
+        (0, import_vitest9.expect)(all.has(a)).toBe(true);
+        (0, import_vitest9.expect)(all.has(b)).toBe(true);
       });
-      (0, import_vitest6.it)("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
+      (0, import_vitest9.it)("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
         const tag = uid();
         const s = `qsfl-${tag}`;
         await store.commit(
@@ -1892,22 +2324,22 @@ var runStoreTck = (options) => {
         const c = await store.query_stats([s], {
           count: true
         });
-        (0, import_vitest6.expect)(c.get(s)?.count).toBe(3);
-        (0, import_vitest6.expect)(c.get(s)?.names).toBeUndefined();
-        (0, import_vitest6.expect)(c.get(s)?.tail).toBeUndefined();
+        (0, import_vitest9.expect)(c.get(s)?.count).toBe(3);
+        (0, import_vitest9.expect)(c.get(s)?.names).toBeUndefined();
+        (0, import_vitest9.expect)(c.get(s)?.tail).toBeUndefined();
         const n = await store.query_stats([s], {
           names: true
         });
-        (0, import_vitest6.expect)(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
-        (0, import_vitest6.expect)(n.get(s)?.count).toBeUndefined();
-        (0, import_vitest6.expect)(n.get(s)?.tail).toBeUndefined();
+        (0, import_vitest9.expect)(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
+        (0, import_vitest9.expect)(n.get(s)?.count).toBeUndefined();
+        (0, import_vitest9.expect)(n.get(s)?.tail).toBeUndefined();
         const t = await store.query_stats([s], { tail: true });
-        (0, import_vitest6.expect)(t.get(s)?.tail?.name).toBe("Incremented");
-        (0, import_vitest6.expect)((t.get(s)?.tail?.data).amount).toBe(1);
-        (0, import_vitest6.expect)(t.get(s)?.count).toBeUndefined();
-        (0, import_vitest6.expect)(t.get(s)?.names).toBeUndefined();
+        (0, import_vitest9.expect)(t.get(s)?.tail?.name).toBe("Incremented");
+        (0, import_vitest9.expect)((t.get(s)?.tail?.data).amount).toBe(1);
+        (0, import_vitest9.expect)(t.get(s)?.count).toBeUndefined();
+        (0, import_vitest9.expect)(t.get(s)?.names).toBeUndefined();
       });
-      (0, import_vitest6.it)("paginates with limit + after (keyset), ordered by stream name", async () => {
+      (0, import_vitest9.it)("paginates with limit + after (keyset), ordered by stream name", async () => {
         const tag = uid();
         const streams = [
           `qsp-${tag}-a`,
@@ -1927,28 +2359,28 @@ var runStoreTck = (options) => {
           { limit: 2 }
         );
         const k1 = [...page1.keys()];
-        (0, import_vitest6.expect)(k1).toEqual([`qsp-${tag}-a`, `qsp-${tag}-b`]);
+        (0, import_vitest9.expect)(k1).toEqual([`qsp-${tag}-a`, `qsp-${tag}-b`]);
         const page2 = await store.query_stats(
           { stream: `qsp-${tag}-.*` },
           { limit: 2, after: k1.at(-1) }
         );
         const k2 = [...page2.keys()];
-        (0, import_vitest6.expect)(k2).toEqual([`qsp-${tag}-c`, `qsp-${tag}-d`]);
+        (0, import_vitest9.expect)(k2).toEqual([`qsp-${tag}-c`, `qsp-${tag}-d`]);
         const page3 = await store.query_stats(
           { stream: `qsp-${tag}-.*` },
           { limit: 2, after: k2.at(-1) }
         );
-        (0, import_vitest6.expect)(page3.size).toBe(0);
+        (0, import_vitest9.expect)(page3.size).toBe(0);
         const all = await store.query_stats({
           stream: `qsp-${tag}-.*`
         });
-        (0, import_vitest6.expect)([...all.keys()].sort()).toEqual([...streams].sort());
+        (0, import_vitest9.expect)([...all.keys()].sort()).toEqual([...streams].sort());
       });
     });
-    import_vitest6.describe.skipIf(!caps.source_matches)(
+    import_vitest9.describe.skipIf(!caps.source_matches)(
       "query_streams source_matches (capability)",
       () => {
-        (0, import_vitest6.it)("returns only subscriptions whose source pattern matches a name", async () => {
+        (0, import_vitest9.it)("returns only subscriptions whose source pattern matches a name", async () => {
           const tag = uid();
           const subConcreteA = `sm-${tag}-sub-a`;
           const subConcreteB = `sm-${tag}-sub-b`;
@@ -1969,7 +2401,7 @@ var runStoreTck = (options) => {
             stream: `sm-${tag}-sub-.*`,
             source_matches: [srcA]
           });
-          (0, import_vitest6.expect)(matched.sort()).toEqual(
+          (0, import_vitest9.expect)(matched.sort()).toEqual(
             [subConcreteA, subRegex, subNoSource].sort()
           );
           const none = [];
@@ -1977,20 +2409,20 @@ var runStoreTck = (options) => {
             stream: `sm-${tag}-sub-.*`,
             source_matches: [`sm-${tag}-unrelated`]
           });
-          (0, import_vitest6.expect)(none).toEqual([subNoSource]);
+          (0, import_vitest9.expect)(none).toEqual([subNoSource]);
           const both = [];
           await store.query_streams((p) => both.push(p.stream), {
             stream: `sm-${tag}-sub-.*`,
             source_matches: [srcA, srcB]
           });
-          (0, import_vitest6.expect)(both.sort()).toEqual(
+          (0, import_vitest9.expect)(both.sort()).toEqual(
             [subConcreteA, subConcreteB, subRegex, subNoSource].sort()
           );
         });
       }
     );
-    (0, import_vitest6.describe)("query_streams anchor contract", () => {
-      (0, import_vitest6.it)("plain regex without anchors is a substring match", async () => {
+    (0, import_vitest9.describe)("query_streams anchor contract", () => {
+      (0, import_vitest9.it)("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-inner`;
         const longer = `qsr-${tag}-inner-extra`;
@@ -2004,9 +2436,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `qsr-${tag}-inner`
         });
-        (0, import_vitest6.expect)(seen.sort()).toEqual([inner, longer].sort());
+        (0, import_vitest9.expect)(seen.sort()).toEqual([inner, longer].sort());
       });
-      (0, import_vitest6.it)("caller-anchored `^name$` matches only the whole string", async () => {
+      (0, import_vitest9.it)("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-anchor`;
         const longer = `qsr-${tag}-anchor-extra`;
@@ -2015,9 +2447,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-anchor$`
         });
-        (0, import_vitest6.expect)(seen).toEqual([inner]);
+        (0, import_vitest9.expect)(seen).toEqual([inner]);
       });
-      (0, import_vitest6.it)("caller-anchored `^prefix` matches by prefix", async () => {
+      (0, import_vitest9.it)("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qsr-${tag}-pfx-a`;
         const b = `qsr-${tag}-pfx-b`;
@@ -2031,11 +2463,11 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-pfx-`
         });
-        (0, import_vitest6.expect)(seen.sort()).toEqual([a, b].sort());
+        (0, import_vitest9.expect)(seen.sort()).toEqual([a, b].sort());
       });
     });
-    (0, import_vitest6.describe)("prioritize anchor contract", () => {
-      (0, import_vitest6.it)("caller-anchored `^name$` filter matches only the whole string", async () => {
+    (0, import_vitest9.describe)("prioritize anchor contract", () => {
+      (0, import_vitest9.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`;
@@ -2047,17 +2479,17 @@ var runStoreTck = (options) => {
           { stream: `^pr-${tag}-anchor$` },
           7
         );
-        (0, import_vitest6.expect)(updated).toBe(1);
+        (0, import_vitest9.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_vitest6.expect)(seen.get(inner)).toBe(7);
-        (0, import_vitest6.expect)(seen.get(longer)).toBe(0);
+        (0, import_vitest9.expect)(seen.get(inner)).toBe(7);
+        (0, import_vitest9.expect)(seen.get(longer)).toBe(0);
       });
     });
-    (0, import_vitest6.describe)("query_streams head", () => {
-      (0, import_vitest6.it)("maxEventId tracks the highest committed id", async () => {
+    (0, import_vitest9.describe)("query_streams head", () => {
+      (0, import_vitest9.it)("maxEventId tracks the highest committed id", async () => {
         const s = `head-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2070,21 +2502,21 @@ var runStoreTck = (options) => {
           (p) => positions.push(p.stream),
           { stream: s, stream_exact: true, limit: 1 }
         );
-        (0, import_vitest6.expect)(maxEventId).toBeGreaterThanOrEqual(0);
-        (0, import_vitest6.expect)(positions).toEqual([s]);
+        (0, import_vitest9.expect)(maxEventId).toBeGreaterThanOrEqual(0);
+        (0, import_vitest9.expect)(positions).toEqual([s]);
       });
     });
-    (0, import_vitest6.describe)("seed_stream helper coverage", () => {
-      (0, import_vitest6.it)("commits N events with monotonically increasing ids", async () => {
+    (0, import_vitest9.describe)("seed_stream helper coverage", () => {
+      (0, import_vitest9.it)("commits N events with monotonically increasing ids", async () => {
         const s = `seed-${uid()}`;
         const committed = await seed_stream(store, s, 3);
-        (0, import_vitest6.expect)(committed).toHaveLength(3);
+        (0, import_vitest9.expect)(committed).toHaveLength(3);
         for (let i = 1; i < committed.length; i++) {
-          (0, import_vitest6.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          (0, import_vitest9.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
     });
-    import_vitest6.describe.skipIf(!caps.restore)("restore (capability)", () => {
+    import_vitest9.describe.skipIf(!caps.restore)("restore (capability)", () => {
       beforeEach(async () => {
         await store.drop();
         await store.seed();
@@ -2112,8 +2544,8 @@ var runStoreTck = (options) => {
         meta: { correlation: "restore-tck", causation: {} }
       });
       const restore = async (source, opts = {}) => {
-        const cache = new import_act.InMemoryCache();
-        const app = (0, import_act.act)().build({ scoped: { store, cache } });
+        const cache = new import_act2.InMemoryCache();
+        const app = (0, import_act2.act)().build({ scoped: { store, cache } });
         try {
           return await app.restore(source, opts);
         } finally {
@@ -2121,18 +2553,18 @@ var runStoreTck = (options) => {
           await cache.dispose();
         }
       };
-      (0, import_vitest6.it)("returns kept=0 on an empty source", async () => {
+      (0, import_vitest9.it)("returns kept=0 on an empty source", async () => {
         const result = await restore(as_source([]));
-        (0, import_vitest6.expect)(result.kept).toBe(0);
-        (0, import_vitest6.expect)(result.duration_ms).toBeGreaterThanOrEqual(0);
-        (0, import_vitest6.expect)(result.dropped).toEqual({
+        (0, import_vitest9.expect)(result.kept).toBe(0);
+        (0, import_vitest9.expect)(result.duration_ms).toBeGreaterThanOrEqual(0);
+        (0, import_vitest9.expect)(result.dropped).toEqual({
           closed_streams: 0,
           snapshots: 0
         });
         const events2 = await collect(store, { limit: 10 });
-        (0, import_vitest6.expect)(events2).toHaveLength(0);
+        (0, import_vitest9.expect)(events2).toHaveLength(0);
       });
-      (0, import_vitest6.it)("rebuilds a single stream and preserves `created` verbatim", async () => {
+      (0, import_vitest9.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");
@@ -2143,7 +2575,7 @@ var runStoreTck = (options) => {
           event(3, s, 2, "Decremented", t2, { amount: 1 })
         ];
         const result = await restore(as_source(events2));
-        (0, import_vitest6.expect)(result.kept).toBe(3);
+        (0, import_vitest9.expect)(result.kept).toBe(3);
         const back = [];
         await store.query(
           (e) => {
@@ -2151,8 +2583,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest6.expect)(back).toHaveLength(3);
-        (0, import_vitest6.expect)(
+        (0, import_vitest9.expect)(back).toHaveLength(3);
+        (0, import_vitest9.expect)(
           back.map((e) => ({
             stream: e.stream,
             version: e.version,
@@ -2184,7 +2616,7 @@ var runStoreTck = (options) => {
           }
         ]);
       });
-      (0, import_vitest6.it)("rebuilds multiple streams interleaved", async () => {
+      (0, import_vitest9.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");
@@ -2195,7 +2627,7 @@ var runStoreTck = (options) => {
           event(4, b, 1, "Incremented", t, { amount: 30 })
         ];
         const result = await restore(as_source(events2));
-        (0, import_vitest6.expect)(result.kept).toBe(4);
+        (0, import_vitest9.expect)(result.kept).toBe(4);
         const aBack = [];
         const bBack = [];
         await store.query(
@@ -2210,10 +2642,10 @@ var runStoreTck = (options) => {
           },
           { stream: b, stream_exact: true }
         );
-        (0, import_vitest6.expect)(aBack.map((e) => e.version)).toEqual([0, 1]);
-        (0, import_vitest6.expect)(bBack.map((e) => e.version)).toEqual([0, 1]);
+        (0, import_vitest9.expect)(aBack.map((e) => e.version)).toEqual([0, 1]);
+        (0, import_vitest9.expect)(bBack.map((e) => e.version)).toEqual([0, 1]);
       });
-      (0, import_vitest6.it)("preserves Date `created` verbatim", async () => {
+      (0, import_vitest9.it)("preserves Date `created` verbatim", async () => {
         const s = `restore-isoc-${uid()}`;
         const iso = "2021-07-15T12:34:56.789Z";
         await restore(
@@ -2236,10 +2668,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest6.expect)(back).toHaveLength(1);
-        (0, import_vitest6.expect)(back[0].created.toISOString()).toBe(iso);
+        (0, import_vitest9.expect)(back).toHaveLength(1);
+        (0, import_vitest9.expect)(back[0].created.toISOString()).toBe(iso);
       });
-      (0, import_vitest6.it)("wipes pre-existing events before inserting", async () => {
+      (0, import_vitest9.it)("wipes pre-existing events before inserting", async () => {
         const old = `restore-old-${uid()}`;
         await store.commit(
           old,
@@ -2255,14 +2687,14 @@ var runStoreTck = (options) => {
           stream: old,
           stream_exact: true
         });
-        (0, import_vitest6.expect)(old_back).toHaveLength(0);
+        (0, import_vitest9.expect)(old_back).toHaveLength(0);
         const fresh_back = await collect(store, {
           stream: fresh,
           stream_exact: true
         });
-        (0, import_vitest6.expect)(fresh_back).toHaveLength(1);
+        (0, import_vitest9.expect)(fresh_back).toHaveLength(1);
       });
-      (0, import_vitest6.it)("clears subscription/stream-position metadata", async () => {
+      (0, import_vitest9.it)("clears subscription/stream-position metadata", async () => {
         const sub = `restore-sub-${uid()}`;
         await store.subscribe([{ stream: sub, source: "anything" }]);
         const collect_streams = async () => {
@@ -2273,12 +2705,12 @@ var runStoreTck = (options) => {
           return out;
         };
         const before = await collect_streams();
-        (0, import_vitest6.expect)(before.includes(sub)).toBe(true);
+        (0, import_vitest9.expect)(before.includes(sub)).toBe(true);
         await restore(as_source([]));
         const after = await collect_streams();
-        (0, import_vitest6.expect)(after.includes(sub)).toBe(false);
+        (0, import_vitest9.expect)(after.includes(sub)).toBe(false);
       });
-      (0, import_vitest6.it)("preserves snapshot events through restore", async () => {
+      (0, import_vitest9.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(
@@ -2287,7 +2719,7 @@ var runStoreTck = (options) => {
               id: 1,
               stream: s,
               version: 0,
-              name: import_act.SNAP_EVENT,
+              name: import_act2.SNAP_EVENT,
               data: { count: 42 },
               created: t,
               meta: { correlation: "snap", causation: {} }
@@ -2299,10 +2731,10 @@ var runStoreTck = (options) => {
           stream_exact: true,
           with_snaps: true
         });
-        (0, import_vitest6.expect)(back).toHaveLength(1);
-        (0, import_vitest6.expect)(back[0].name).toBe(import_act.SNAP_EVENT);
+        (0, import_vitest9.expect)(back).toHaveLength(1);
+        (0, import_vitest9.expect)(back[0].name).toBe(import_act2.SNAP_EVENT);
       });
-      (0, import_vitest6.it)("rewrites causation refs through the old\u2192new id map", async () => {
+      (0, import_vitest9.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 events2 = [
@@ -2352,12 +2784,12 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest6.expect)(back).toHaveLength(3);
-        (0, import_vitest6.expect)(back[0].meta.causation.event).toBeUndefined();
-        (0, import_vitest6.expect)(back[1].meta.causation.event?.id).toBe(back[0].id);
-        (0, import_vitest6.expect)(back[2].meta.causation.event?.id).toBe(back[1].id);
+        (0, import_vitest9.expect)(back).toHaveLength(3);
+        (0, import_vitest9.expect)(back[0].meta.causation.event).toBeUndefined();
+        (0, import_vitest9.expect)(back[1].meta.causation.event?.id).toBe(back[0].id);
+        (0, import_vitest9.expect)(back[2].meta.causation.event?.id).toBe(back[1].id);
       });
-      (0, import_vitest6.it)("leaves causation refs unmapped when the target isn't in the source", async () => {
+      (0, import_vitest9.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(
@@ -2385,9 +2817,9 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest6.expect)(back[0].meta.causation.event?.id).toBe(999);
+        (0, import_vitest9.expect)(back[0].meta.causation.event?.id).toBe(999);
       });
-      (0, import_vitest6.it)("rolls back atomically when the source throws mid-iteration", async () => {
+      (0, import_vitest9.it)("rolls back atomically when the source throws mid-iteration", async () => {
         const original = `restore-pre-${uid()}`;
         const committed = await store.commit(
           original,
@@ -2413,7 +2845,7 @@ var runStoreTck = (options) => {
           async dispose() {
           }
         };
-        await (0, import_vitest6.expect)(restore(explosive)).rejects.toThrow("boom");
+        await (0, import_vitest9.expect)(restore(explosive)).rejects.toThrow("boom");
         const back = [];
         await store.query(
           (e) => {
@@ -2421,10 +2853,10 @@ var runStoreTck = (options) => {
           },
           { stream: original, stream_exact: true }
         );
-        (0, import_vitest6.expect)(back).toHaveLength(3);
-        (0, import_vitest6.expect)(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        (0, import_vitest9.expect)(back).toHaveLength(3);
+        (0, import_vitest9.expect)(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
       });
-      (0, import_vitest6.it)("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
+      (0, import_vitest9.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(
@@ -2434,7 +2866,7 @@ var runStoreTck = (options) => {
               id: 2,
               stream: s,
               version: 1,
-              name: import_act.SNAP_EVENT,
+              name: import_act2.SNAP_EVENT,
               data: { count: 1 },
               created: t,
               meta: { correlation: "snap", causation: {} }
@@ -2443,19 +2875,19 @@ var runStoreTck = (options) => {
           ]),
           { drop_snapshots: true }
         );
-        (0, import_vitest6.expect)(result.kept).toBe(2);
-        (0, import_vitest6.expect)(result.dropped.snapshots).toBe(1);
+        (0, import_vitest9.expect)(result.kept).toBe(2);
+        (0, import_vitest9.expect)(result.dropped.snapshots).toBe(1);
         const back = await collect(store, {
           stream: s,
           stream_exact: true,
           with_snaps: true
         });
-        (0, import_vitest6.expect)(back).toHaveLength(2);
-        (0, import_vitest6.expect)(
-          back.every((e) => e.name !== import_act.SNAP_EVENT)
+        (0, import_vitest9.expect)(back).toHaveLength(2);
+        (0, import_vitest9.expect)(
+          back.every((e) => e.name !== import_act2.SNAP_EVENT)
         ).toBe(true);
       });
-      (0, import_vitest6.it)("on_progress fires once per event (caller throttles)", async () => {
+      (0, import_vitest9.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");
@@ -2466,11 +2898,11 @@ var runStoreTck = (options) => {
           ]),
           { on_progress: (p) => calls.push(p.processed) }
         );
-        (0, import_vitest6.expect)(calls).toEqual([1, 2]);
+        (0, import_vitest9.expect)(calls).toEqual([1, 2]);
       });
     });
-    import_vitest6.describe.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
-      (0, import_vitest6.it)("commits and loads pii alongside data", async () => {
+    import_vitest9.describe.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
+      (0, import_vitest9.it)("commits and loads pii alongside data", async () => {
         const s = `pii-roundtrip-${uid()}`;
         const committed = await store.commit(
           s,
@@ -2483,8 +2915,8 @@ var runStoreTck = (options) => {
           ],
           make_meta({ stream: s })
         );
-        (0, import_vitest6.expect)(committed).toHaveLength(1);
-        (0, import_vitest6.expect)(committed[0].pii).toEqual({
+        (0, import_vitest9.expect)(committed).toHaveLength(1);
+        (0, import_vitest9.expect)(committed[0].pii).toEqual({
           email: "u@example.com",
           name: "Ursula"
         });
@@ -2495,11 +2927,11 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest6.expect)(seen).toHaveLength(1);
-        (0, import_vitest6.expect)(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
-        (0, import_vitest6.expect)(seen[0].data).toEqual({ amount: 1 });
+        (0, import_vitest9.expect)(seen).toHaveLength(1);
+        (0, import_vitest9.expect)(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
+        (0, import_vitest9.expect)(seen[0].data).toEqual({ amount: 1 });
       });
-      (0, import_vitest6.it)("passes through events without pii (pii is null or undefined on load)", async () => {
+      (0, import_vitest9.it)("passes through events without pii (pii is null or undefined on load)", async () => {
         const s = `pii-none-${uid()}`;
         await store.commit(
           s,
@@ -2513,10 +2945,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest6.expect)(seen).toHaveLength(1);
-        (0, import_vitest6.expect)(seen[0].pii == null).toBe(true);
+        (0, import_vitest9.expect)(seen).toHaveLength(1);
+        (0, import_vitest9.expect)(seen[0].pii == null).toBe(true);
       });
-      (0, import_vitest6.it)("wipes pii for every event on the stream via forget_pii", async () => {
+      (0, import_vitest9.it)("wipes pii for every event on the stream via forget_pii", async () => {
         const s = `pii-forget-${uid()}`;
         await store.commit(
           s,
@@ -2535,9 +2967,9 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const forget = store.forget_pii;
-        (0, import_vitest6.expect)(forget).toBeDefined();
+        (0, import_vitest9.expect)(forget).toBeDefined();
         const wiped = await forget.call(store, s);
-        (0, import_vitest6.expect)(wiped).toBe(2);
+        (0, import_vitest9.expect)(wiped).toBe(2);
         const seen = [];
         await store.query(
           (e) => {
@@ -2545,13 +2977,13 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        (0, import_vitest6.expect)(seen).toHaveLength(2);
+        (0, import_vitest9.expect)(seen).toHaveLength(2);
         for (const e of seen) {
-          (0, import_vitest6.expect)(e.pii == null).toBe(true);
-          (0, import_vitest6.expect)(e.data).toBeDefined();
+          (0, import_vitest9.expect)(e.pii == null).toBe(true);
+          (0, import_vitest9.expect)(e.data).toBeDefined();
         }
       });
-      (0, import_vitest6.it)("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
+      (0, import_vitest9.it)("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
         const s = `pii-forget-idem-${uid()}`;
         await store.commit(
           s,
@@ -2566,11 +2998,11 @@ var runStoreTck = (options) => {
         );
         const forget = store.forget_pii;
         const first = await forget.call(store, s);
-        (0, import_vitest6.expect)(first).toBe(1);
+        (0, import_vitest9.expect)(first).toBe(1);
         const second = await forget.call(store, s);
-        (0, import_vitest6.expect)(second).toBe(0);
+        (0, import_vitest9.expect)(second).toBe(0);
       });
-      (0, import_vitest6.it)("only wipes the targeted stream \u2014 siblings untouched", async () => {
+      (0, import_vitest9.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(
@@ -2603,7 +3035,7 @@ var runStoreTck = (options) => {
           },
           { stream: sA, stream_exact: true }
         );
-        (0, import_vitest6.expect)(a[0].pii == null).toBe(true);
+        (0, import_vitest9.expect)(a[0].pii == null).toBe(true);
         const b = [];
         await store.query(
           (e) => {
@@ -2611,9 +3043,9 @@ var runStoreTck = (options) => {
           },
           { stream: sB, stream_exact: true }
         );
-        (0, import_vitest6.expect)(b[0].pii).toEqual({ email: "bob@example.com" });
+        (0, import_vitest9.expect)(b[0].pii).toEqual({ email: "bob@example.com" });
       });
-      (0, import_vitest6.it)("forget_pii on a stream with no pii events returns 0", async () => {
+      (0, import_vitest9.it)("forget_pii on a stream with no pii events returns 0", async () => {
         const s = `pii-forget-empty-${uid()}`;
         await store.commit(
           s,
@@ -2621,14 +3053,14 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const wiped = await store.forget_pii.call(store, s);
-        (0, import_vitest6.expect)(wiped).toBe(0);
+        (0, import_vitest9.expect)(wiped).toBe(0);
       });
     });
     if (caps.notify) {
-      (0, import_vitest6.describe)("notify (capability)", () => {
-        (0, import_vitest6.it)("delivers a notification when a different instance commits", async () => {
+      (0, import_vitest9.describe)("notify (capability)", () => {
+        (0, import_vitest9.it)("delivers a notification when a different instance commits", async () => {
           const notify = store.notify;
-          (0, import_vitest6.expect)(notify).toBeDefined();
+          (0, import_vitest9.expect)(notify).toBeDefined();
           const received = [];
           let resolve_arrived;
           const arrived = new Promise((res) => {
@@ -2647,9 +3079,9 @@ var runStoreTck = (options) => {
               make_meta({ stream })
             );
             await arrived;
-            (0, import_vitest6.expect)(received.length).toBeGreaterThanOrEqual(1);
-            (0, import_vitest6.expect)(received[0].stream).toBe(stream);
-            (0, import_vitest6.expect)(received[0].events.length).toBeGreaterThanOrEqual(1);
+            (0, import_vitest9.expect)(received.length).toBeGreaterThanOrEqual(1);
+            (0, import_vitest9.expect)(received[0].stream).toBe(stream);
+            (0, import_vitest9.expect)(received[0].events.length).toBeGreaterThanOrEqual(1);
           } finally {
             await writer.dispose();
             await Promise.resolve(disposer());
@@ -2671,9 +3103,12 @@ var runStoreTck = (options) => {
   dec,
   inc,
   reset,
+  runCacheDifferentialTck,
   runCacheTck,
+  runLoggerDifferentialTck,
   runLoggerTck,
   runStabilityTck,
+  runStoreDifferentialTck,
   runStorePropertyTck,
   runStoreTck,
   uid