@rotorsoft/act-tck 1.17.0 → 1.17.1

package/dist/index.js

@@ -1,5 +1,139 @@
+// src/cache-differential-tck.ts
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+// src/fixtures/helpers.ts
+import { randomUUID } from "crypto";
+var uid = () => randomUUID().slice(0, 8);
+var actor = (name = "tester") => ({ id: randomUUID(), name });
+var make_meta = (opts = {}) => ({
+  correlation: opts.correlation ?? 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) => {
+  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 = [];
+    beforeAll(async () => {
+      for (const spec of options.caches) {
+        live.push({ name: spec.name, cache: await spec.factory() });
+      }
+    });
+    afterAll(async () => {
+      for (const { cache } of live) await cache.dispose();
+    });
+    plans.forEach((plan, run) => {
+      const seed_hex = `0x${(base_seed + run).toString(16)}`;
+      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);
+            expect(
+              actual,
+              `${live[i].name} diverged from ${live[0].name} after ${op.t}`
+            ).toEqual(reference);
+          }
+        }
+      });
+    });
+  });
+};
+
 // src/cache-tck.ts
-import { afterEach, beforeEach as beforeEach2, describe, expect, it } from "vitest";
+import { afterEach, beforeEach as beforeEach2, describe as describe2, expect as expect2, it as it2 } from "vitest";
 var entry = (event_id, state = {}) => ({
   state,
   version: event_id,
@@ -8,7 +142,7 @@ var entry = (event_id, state = {}) => ({
   snaps: 0
 });
 var runCacheTck = (options) => {
-  describe(`TCK / Cache / ${options.name}`, () => {
+  describe2(`TCK / Cache / ${options.name}`, () => {
     let cache;
     beforeEach2(() => {
       cache = options.factory();
@@ -16,55 +150,55 @@ var runCacheTck = (options) => {
     afterEach(async () => {
       await cache.dispose();
     });
-    it("returns undefined for an unset stream", async () => {
-      expect(await cache.get("missing")).toBeUndefined();
+    it2("returns undefined for an unset stream", async () => {
+      expect2(await cache.get("missing")).toBeUndefined();
     });
-    it("set then get round-trips an entry", async () => {
+    it2("set then get round-trips an entry", async () => {
       const e = entry(1, { count: 7 });
       await cache.set("s1", e);
-      expect(await cache.get("s1")).toEqual(e);
+      expect2(await cache.get("s1")).toEqual(e);
     });
-    it("set overwrites a prior entry on the same stream", async () => {
+    it2("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");
-      expect(got?.event_id).toBe(2);
-      expect(got?.state).toEqual({ count: 2 });
+      expect2(got?.event_id).toBe(2);
+      expect2(got?.state).toEqual({ count: 2 });
     });
-    it("invalidate removes one stream and leaves others", async () => {
+    it2("invalidate removes one stream and leaves others", async () => {
       await cache.set("a", entry(1));
       await cache.set("b", entry(2));
       await cache.invalidate("a");
-      expect(await cache.get("a")).toBeUndefined();
-      expect(await cache.get("b")).toBeDefined();
+      expect2(await cache.get("a")).toBeUndefined();
+      expect2(await cache.get("b")).toBeDefined();
     });
-    it("invalidate on an unknown stream is a no-op", async () => {
-      await expect(cache.invalidate("never-set")).resolves.toBeUndefined();
+    it2("invalidate on an unknown stream is a no-op", async () => {
+      await expect2(cache.invalidate("never-set")).resolves.toBeUndefined();
     });
-    it("clear empties every stream", async () => {
+    it2("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();
-      expect(await cache.get("a")).toBeUndefined();
-      expect(await cache.get("b")).toBeUndefined();
-      expect(await cache.get("c")).toBeUndefined();
+      expect2(await cache.get("a")).toBeUndefined();
+      expect2(await cache.get("b")).toBeUndefined();
+      expect2(await cache.get("c")).toBeUndefined();
     });
-    it("clear on an empty cache is a no-op", async () => {
-      await expect(cache.clear()).resolves.toBeUndefined();
+    it2("clear on an empty cache is a no-op", async () => {
+      await expect2(cache.clear()).resolves.toBeUndefined();
     });
-    it("entries are isolated per stream", async () => {
+    it2("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);
-      expect(await cache.get("a")).toEqual(ea);
-      expect(await cache.get("b")).toEqual(eb);
+      expect2(await cache.get("a")).toEqual(ea);
+      expect2(await cache.get("b")).toEqual(eb);
     });
-    it("dispose is idempotent", async () => {
+    it2("dispose is idempotent", async () => {
       await cache.set("a", entry(1));
       await cache.dispose();
-      await expect(cache.dispose()).resolves.toBeUndefined();
+      await expect2(cache.dispose()).resolves.toBeUndefined();
     });
   });
 };
@@ -85,105 +219,122 @@ var COUNTER_EVENT_NAMES = [
   "Reset"
 ];
 
-// src/fixtures/helpers.ts
-import { randomUUID } from "crypto";
-var uid = () => randomUUID().slice(0, 8);
-var actor = (name = "tester") => ({ id: randomUUID(), name });
-var make_meta = (opts = {}) => ({
-  correlation: opts.correlation ?? 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
+import { afterEach as afterEach2, beforeEach as beforeEach3, describe as describe3, expect as expect3, it as it3 } from "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) => {
+  describe3(`TCK / Logger differential / ${options.name}`, () => {
+    let live = [];
+    let original_stdout;
+    beforeEach3(() => {
+      live = options.loggers.map((spec) => ({
+        name: spec.name,
+        logger: spec.factory()
+      }));
+      original_stdout = process.stdout.write.bind(process.stdout);
+      process.stdout.write = (() => true);
+    });
+    afterEach2(async () => {
+      process.stdout.write = original_stdout;
+      for (const { logger } of live) await logger.dispose();
+    });
+    it3("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);
+        expect3(actual, `${live[i].name} diverged from ${live[0].name}`).toEqual(
+          reference
+        );
+      }
+    });
+  });
 };
 
 // src/logger-tck.ts
-import { afterEach as afterEach2, beforeEach as beforeEach3, describe as describe2, expect as expect2, it as it2 } from "vitest";
-var LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
+import { afterEach as afterEach3, beforeEach as beforeEach4, describe as describe4, expect as expect4, it as it4 } from "vitest";
+var LEVELS2 = ["fatal", "error", "warn", "info", "debug", "trace"];
 var runLoggerTck = (options) => {
-  describe2(`TCK / Logger / ${options.name}`, () => {
+  describe4(`TCK / Logger / ${options.name}`, () => {
     let logger;
     let original_stdout;
-    beforeEach3(() => {
+    beforeEach4(() => {
       logger = options.factory();
       original_stdout = process.stdout.write.bind(process.stdout);
       process.stdout.write = (() => true);
     });
-    afterEach2(async () => {
+    afterEach3(async () => {
       process.stdout.write = original_stdout;
       await logger.dispose();
     });
-    it2("exposes a non-empty `level` string", () => {
-      expect2(typeof logger.level).toBe("string");
-      expect2(logger.level.length).toBeGreaterThan(0);
+    it4("exposes a non-empty `level` string", () => {
+      expect4(typeof logger.level).toBe("string");
+      expect4(logger.level.length).toBeGreaterThan(0);
     });
-    for (const level of LEVELS) {
-      it2(`${level}(msg) does not throw`, () => {
-        expect2(() => logger[level]("hello")).not.toThrow();
+    for (const level of LEVELS2) {
+      it4(`${level}(msg) does not throw`, () => {
+        expect4(() => logger[level]("hello")).not.toThrow();
       });
-      it2(`${level}(obj) does not throw`, () => {
-        expect2(() => logger[level]({ k: "v" })).not.toThrow();
+      it4(`${level}(obj) does not throw`, () => {
+        expect4(() => logger[level]({ k: "v" })).not.toThrow();
       });
-      it2(`${level}(obj, msg) does not throw`, () => {
-        expect2(() => logger[level]({ k: "v" }, "context")).not.toThrow();
+      it4(`${level}(obj, msg) does not throw`, () => {
+        expect4(() => logger[level]({ k: "v" }, "context")).not.toThrow();
       });
     }
-    it2("accepts a null payload", () => {
-      expect2(() => logger.info(null, "null payload")).not.toThrow();
+    it4("accepts a null payload", () => {
+      expect4(() => logger.info(null, "null payload")).not.toThrow();
     });
-    it2("accepts a cyclic payload without throwing", () => {
+    it4("accepts a cyclic payload without throwing", () => {
       const cyclic = { name: "loop" };
       cyclic.self = cyclic;
-      expect2(() => logger.info(cyclic, "cycle")).not.toThrow();
+      expect4(() => logger.info(cyclic, "cycle")).not.toThrow();
     });
-    it2("child(bindings) returns a Logger satisfying the same contract", () => {
+    it4("child(bindings) returns a Logger satisfying the same contract", () => {
       const child = logger.child({ request_id: "abc" });
-      expect2(typeof child.level).toBe("string");
-      for (const level of LEVELS) {
-        expect2(typeof child[level]).toBe("function");
+      expect4(typeof child.level).toBe("string");
+      for (const level of LEVELS2) {
+        expect4(typeof child[level]).toBe("function");
       }
-      expect2(typeof child.child).toBe("function");
-      expect2(typeof child.dispose).toBe("function");
+      expect4(typeof child.child).toBe("function");
+      expect4(typeof child.dispose).toBe("function");
     });
-    it2("child loggers can themselves spawn children", () => {
+    it4("child loggers can themselves spawn children", () => {
       const c1 = logger.child({ a: 1 });
       const c2 = c1.child({ b: 2 });
-      expect2(() => c2.info("nested")).not.toThrow();
+      expect4(() => c2.info("nested")).not.toThrow();
     });
-    it2("dispose is idempotent and awaitable", async () => {
-      await expect2(logger.dispose()).resolves.toBeUndefined();
-      await expect2(logger.dispose()).resolves.toBeUndefined();
+    it4("dispose is idempotent and awaitable", async () => {
+      await expect4(logger.dispose()).resolves.toBeUndefined();
+      await expect4(logger.dispose()).resolves.toBeUndefined();
     });
   });
 };
@@ -191,14 +342,14 @@ var runLoggerTck = (options) => {
 // src/stability-tck.ts
 import { promises as fs } from "fs";
 import path from "path";
-import { describe as describe3, expect as expect3, it as it3 } from "vitest";
+import { describe as describe5, expect as expect5, it as it5 } from "vitest";
 function runStabilityTck(options) {
-  describe3(`${options.name} \u2014 public API stability`, () => {
+  describe5(`${options.name} \u2014 public API stability`, () => {
     for (const [subpath, entry2] of Object.entries(options.entryPoints)) {
       const label = subpath || "(root)";
-      it3(`stable public surface for ${label}`, async () => {
+      it5(`stable public surface for ${label}`, async () => {
         const surface = await load_surface(entry2);
-        expect3(surface).toMatchSnapshot();
+        expect5(surface).toMatchSnapshot();
       });
     }
   });
@@ -228,9 +379,220 @@ ${content}`;
   }).join("\n");
 }
 
+// src/store-differential-tck.ts
+import { SNAP_EVENT } from "@rotorsoft/act";
+import { afterAll as afterAll2, beforeAll as beforeAll2, describe as describe6, expect as expect6, it as it6 } from "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: 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) => {
+  describe6(`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 = [];
+    beforeAll2(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 });
+      }
+    });
+    afterAll2(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);
+        expect6(
+          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)}`;
+      describe6(`workload ${run} (seed ${seed_hex})`, () => {
+        it6("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;
+          });
+        });
+        it6("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;
+          });
+        });
+        it6("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;
+          });
+        });
+        it6("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 };
+          });
+        });
+        it6("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
 import { fc, test } from "@fast-check/vitest";
-import { afterAll, beforeAll, describe as describe4, expect as expect4 } from "vitest";
+import { afterAll as afterAll3, beforeAll as beforeAll3, describe as describe7, expect as expect7 } from "vitest";
 var streamArb = fc.constantFrom("s1", "s2", "s3");
 var commitArb = fc.record({
   stream: streamArb,
@@ -246,20 +608,20 @@ var opArb = fc.oneof(
 var events = (count) => Array.from({ length: count }, () => inc(1));
 var runStorePropertyTck = (options) => {
   const numRuns = options.numRuns ?? 100;
-  describe4(`TCK / Store properties / ${options.name}`, () => {
+  describe7(`TCK / Store properties / ${options.name}`, () => {
     let store;
-    beforeAll(async () => {
+    beforeAll3(async () => {
       store = await options.factory();
       await store.seed();
     });
-    afterAll(async () => {
+    afterAll3(async () => {
       await store.dispose();
     });
     const reset2 = async () => {
       await store.drop();
       await store.seed();
     };
-    describe4("commit version invariants", () => {
+    describe7("commit version invariants", () => {
       test.prop([fc.array(commitArb, { minLength: 0, maxLength: 30 })], {
         numRuns
       })(
@@ -275,14 +637,14 @@ var runStorePropertyTck = (options) => {
               make_meta({ stream })
             );
             committed.forEach((e, i) => {
-              expect4(e.version).toBe(before + 1 + i);
+              expect7(e.version).toBe(before + 1 + i);
             });
             expected.set(stream, before + count);
           }
           for (const stream of new Set(commits.map((c) => c.stream))) {
             const seen = await collect(store, { stream, stream_exact: true });
             seen.forEach((e, i) => {
-              expect4(e.version).toBe(i);
+              expect7(e.version).toBe(i);
             });
           }
         }
@@ -302,7 +664,7 @@ var runStorePropertyTck = (options) => {
           }
           const stream = commits[0].stream;
           const before = await collect(store, { stream, stream_exact: true });
-          await expect4(
+          await expect7(
             store.commit(
               stream,
               [inc(1)],
@@ -311,11 +673,11 @@ var runStorePropertyTck = (options) => {
             )
           ).rejects.toThrow();
           const after = await collect(store, { stream, stream_exact: true });
-          expect4(after.length).toBe(before.length);
+          expect7(after.length).toBe(before.length);
         }
       );
     });
-    describe4("claim/lease lifecycle invariants", () => {
+    describe7("claim/lease lifecycle invariants", () => {
       test.prop([fc.array(opArb, { minLength: 1, maxLength: 30 })], {
         numRuns
       })(
@@ -357,7 +719,7 @@ var runStorePropertyTck = (options) => {
               );
             }
           }
-          expect4(totalResolved + pending.length).toBe(totalClaims);
+          expect7(totalResolved + pending.length).toBe(totalClaims);
         }
       );
       test.prop(
@@ -395,7 +757,7 @@ var runStorePropertyTck = (options) => {
             await store.claim(10, 10, "worker", 6e4)
           );
           for (const lease of acked2) {
-            expect4(lease.at).toBeGreaterThanOrEqual(
+            expect7(lease.at).toBeGreaterThanOrEqual(
               watermark1.get(lease.stream)
             );
           }
@@ -424,7 +786,7 @@ var runStorePropertyTck = (options) => {
           make_meta({ stream: "ctrl" })
         );
         const reclaim = await store.claim(10, 10, "worker2", 6e4);
-        for (const l of reclaim) expect4(blockedSet.has(l.stream)).toBe(false);
+        for (const l of reclaim) expect7(blockedSet.has(l.stream)).toBe(false);
       });
     });
   });
@@ -435,41 +797,41 @@ import {
   act,
   ConcurrencyError,
   InMemoryCache,
-  SNAP_EVENT,
+  SNAP_EVENT as SNAP_EVENT2,
   TOMBSTONE_EVENT
 } from "@rotorsoft/act";
-import { afterAll as afterAll2, beforeAll as beforeAll2, describe as describe5, expect as expect5, it as it4 } from "vitest";
+import { afterAll as afterAll4, beforeAll as beforeAll4, describe as describe8, expect as expect8, it as it7 } from "vitest";
 var runStoreTck = (options) => {
-  describe5(`TCK / Store / ${options.name}`, () => {
+  describe8(`TCK / Store / ${options.name}`, () => {
     let store;
     const caps = { ...options.capabilities };
-    beforeAll2(async () => {
+    beforeAll4(async () => {
       store = await options.factory();
       await store.drop();
       await store.seed();
     });
-    afterAll2(async () => {
+    afterAll4(async () => {
       await store.dispose();
     });
-    describe5("commit", () => {
-      it4("returns committed events with sequenced ids and versions", async () => {
+    describe8("commit", () => {
+      it7("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 })
         );
-        expect5(committed).toHaveLength(3);
-        expect5(committed[0].version).toBe(0);
-        expect5(committed[1].version).toBe(1);
-        expect5(committed[2].version).toBe(2);
-        expect5(committed[0].name).toBe("Incremented");
-        expect5(committed[2].data).toEqual({ amount: 3 });
+        expect8(committed).toHaveLength(3);
+        expect8(committed[0].version).toBe(0);
+        expect8(committed[1].version).toBe(1);
+        expect8(committed[2].version).toBe(2);
+        expect8(committed[0].name).toBe("Incremented");
+        expect8(committed[2].data).toEqual({ amount: 3 });
         for (let i = 1; i < committed.length; i++) {
-          expect5(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          expect8(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
-      it4("attaches correlation and stream metadata", async () => {
+      it7("attaches correlation and stream metadata", async () => {
         const s = `commit-meta-${uid()}`;
         const correlation = `cor-${uid()}`;
         const committed = await store.commit(
@@ -477,10 +839,10 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s, correlation })
         );
-        expect5(committed[0].stream).toBe(s);
-        expect5(committed[0].meta.correlation).toBe(correlation);
+        expect8(committed[0].stream).toBe(s);
+        expect8(committed[0].meta.correlation).toBe(correlation);
       });
-      it4("throws ConcurrencyError when expectedVersion is wrong", async () => {
+      it7("throws ConcurrencyError when expectedVersion is wrong", async () => {
         const s = `commit-cc-${uid()}`;
         await store.commit(
           s,
@@ -493,26 +855,26 @@ var runStoreTck = (options) => {
           make_meta({ stream: s }),
           0
         );
-        await expect5(
+        await expect8(
           store.commit(s, [inc(1)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(ConcurrencyError);
       });
-      it4("preserves prior events when a concurrent commit is rejected", async () => {
+      it7("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 expect5(
+        await expect8(
           store.commit(s, [inc(3)], make_meta({ stream: s }), 0)
         ).rejects.toBeInstanceOf(ConcurrencyError);
         const found = await collect(store, { stream: s, stream_exact: true });
-        expect5(found).toHaveLength(2);
+        expect8(found).toHaveLength(2);
       });
     });
-    describe5("query", () => {
-      it4("filters by stream, names, correlation, limit, with_snaps", async () => {
+    describe8("query", () => {
+      it7("filters by stream, names, correlation, limit, with_snaps", async () => {
         const s1 = `q-s1-${uid()}`;
         const s2 = `q-s2-${uid()}`;
         const cor = `q-cor-${uid()}`;
@@ -530,23 +892,23 @@ var runStoreTck = (options) => {
           stream: s1,
           stream_exact: true
         });
-        expect5(by_stream).toHaveLength(2);
+        expect8(by_stream).toHaveLength(2);
         const by_name = await collect(store, {
           stream: s2,
           stream_exact: true,
           names: ["Reset"]
         });
-        expect5(by_name).toHaveLength(1);
-        expect5(by_name[0].name).toBe("Reset");
+        expect8(by_name).toHaveLength(1);
+        expect8(by_name[0].name).toBe("Reset");
         const by_correlation = await collect(store, { correlation: cor });
-        expect5(by_correlation).toHaveLength(5);
+        expect8(by_correlation).toHaveLength(5);
         const limited = await collect(store, {
           correlation: cor,
           limit: 2
         });
-        expect5(limited).toHaveLength(2);
+        expect8(limited).toHaveLength(2);
       });
-      it4("with_snaps resumes from the latest snapshot per stream", async () => {
+      it7("with_snaps resumes from the latest snapshot per stream", async () => {
         const s = `q-snap-${uid()}`;
         await store.commit(
           s,
@@ -555,7 +917,7 @@ var runStoreTck = (options) => {
         );
         const [snap] = await store.commit(
           s,
-          [{ name: SNAP_EVENT, data: { count: 2 } }],
+          [{ name: SNAP_EVENT2, data: { count: 2 } }],
           make_meta({ stream: s })
         );
         await store.commit(
@@ -568,17 +930,17 @@ var runStoreTck = (options) => {
           stream_exact: true,
           with_snaps: true
         });
-        expect5(from_snap).toHaveLength(4);
-        expect5(from_snap[0].name).toBe(SNAP_EVENT);
+        expect8(from_snap).toHaveLength(4);
+        expect8(from_snap[0].name).toBe(SNAP_EVENT2);
         const domain = await collect(store, { stream: s, stream_exact: true });
-        expect5(domain).toHaveLength(5);
+        expect8(domain).toHaveLength(5);
         const after_snap = await collect(store, {
           stream: s,
           stream_exact: true,
           with_snaps: true,
           after: snap.id
         });
-        expect5(after_snap).toHaveLength(3);
+        expect8(after_snap).toHaveLength(3);
         const s2 = `q-nosnap-${uid()}`;
         await store.commit(
           s2,
@@ -590,9 +952,9 @@ var runStoreTck = (options) => {
           stream_exact: true,
           with_snaps: true
         });
-        expect5(full).toHaveLength(2);
+        expect8(full).toHaveLength(2);
       });
-      it4("supports backward traversal", async () => {
+      it7("supports backward traversal", async () => {
         const s = `q-back-${uid()}`;
         const committed = await store.commit(
           s,
@@ -605,8 +967,8 @@ var runStoreTck = (options) => {
           stream_exact: true,
           backward: true
         });
-        expect5(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
-        expect5(backward.map((e) => e.id)).toEqual(
+        expect8(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        expect8(backward.map((e) => e.id)).toEqual(
           [...committed].reverse().map((c) => c.id)
         );
         const latest = await collect(store, {
@@ -615,10 +977,10 @@ var runStoreTck = (options) => {
           backward: true,
           limit: 1
         });
-        expect5(latest).toHaveLength(1);
-        expect5(latest[0].id).toBe(committed.at(-1).id);
+        expect8(latest).toHaveLength(1);
+        expect8(latest[0].id).toBe(committed.at(-1).id);
       });
-      it4("after/before bound the id range", async () => {
+      it7("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
         const committed = await store.commit(
           s,
@@ -630,7 +992,7 @@ var runStoreTck = (options) => {
           stream_exact: true,
           after: committed[0].id
         });
-        expect5(after_first.map((e) => e.id)).toEqual(
+        expect8(after_first.map((e) => e.id)).toEqual(
           committed.slice(1).map((c) => c.id)
         );
         const before_last = await collect(store, {
@@ -638,11 +1000,11 @@ var runStoreTck = (options) => {
           stream_exact: true,
           before: committed[committed.length - 1].id
         });
-        expect5(before_last.map((e) => e.id)).toEqual(
+        expect8(before_last.map((e) => e.id)).toEqual(
           committed.slice(0, -1).map((c) => c.id)
         );
       });
-      it4("created_after/created_before filter by timestamp", async () => {
+      it7("created_after/created_before filter by timestamp", async () => {
         const s = `q-ts-${uid()}`;
         const committed = await store.commit(
           s,
@@ -658,15 +1020,15 @@ var runStoreTck = (options) => {
           created_after: before,
           created_before: future
         });
-        expect5(in_window.length).toBe(1);
+        expect8(in_window.length).toBe(1);
         const out_of_window = await collect(store, {
           stream: s,
           stream_exact: true,
           created_after: future
         });
-        expect5(out_of_window.length).toBe(0);
+        expect8(out_of_window.length).toBe(0);
       });
-      it4("backward traversal short-circuits at `after` id boundary", async () => {
+      it7("backward traversal short-circuits at `after` id boundary", async () => {
         const s = `q-back-after-${uid()}`;
         const committed = await store.commit(
           s,
@@ -679,12 +1041,12 @@ var runStoreTck = (options) => {
           backward: true,
           after: committed[0].id
         });
-        expect5(got.map((e) => e.id)).toEqual([
+        expect8(got.map((e) => e.id)).toEqual([
           committed[2].id,
           committed[1].id
         ]);
       });
-      it4("backward traversal short-circuits at `created_after` boundary", async () => {
+      it7("backward traversal short-circuits at `created_after` boundary", async () => {
         const s = `q-back-cafter-${uid()}`;
         await store.commit(
           s,
@@ -698,9 +1060,9 @@ var runStoreTck = (options) => {
           backward: true,
           created_after: future
         });
-        expect5(got).toHaveLength(0);
+        expect8(got).toHaveLength(0);
       });
-      it4("backward traversal honors created_before by skipping newer events", async () => {
+      it7("backward traversal honors created_before by skipping newer events", async () => {
         const s = `q-back-ts-${uid()}`;
         const committed = await store.commit(
           s,
@@ -714,9 +1076,9 @@ var runStoreTck = (options) => {
           backward: true,
           created_before: past
         });
-        expect5(got).toHaveLength(0);
+        expect8(got).toHaveLength(0);
       });
-      it4("stream_exact disables regex matching", async () => {
+      it7("stream_exact disables regex matching", async () => {
         const tag = uid();
         const a = `q-exact-${tag}`;
         const b = `q-exact-${tag}-extra`;
@@ -731,10 +1093,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: b })
         );
         const exact = await collect(store, { stream: a, stream_exact: true });
-        expect5(exact).toHaveLength(1);
-        expect5(exact[0].data).toEqual({ amount: 1 });
+        expect8(exact).toHaveLength(1);
+        expect8(exact[0].data).toEqual({ amount: 1 });
       });
-      it4("plain regex without anchors is a substring match", async () => {
+      it7("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qr-${tag}-inner`;
         const longer = `qr-${tag}-inner-extra`;
@@ -749,9 +1111,9 @@ var runStoreTck = (options) => {
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `qr-${tag}-inner` });
-        expect5(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
+        expect8(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
       });
-      it4("caller-anchored `^name$` matches only the whole string", async () => {
+      it7("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qr-${tag}-anchor`;
         const longer = `qr-${tag}-anchor-extra`;
@@ -766,10 +1128,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `^qr-${tag}-anchor$` });
-        expect5(got).toHaveLength(1);
-        expect5(got[0].stream).toBe(inner);
+        expect8(got).toHaveLength(1);
+        expect8(got[0].stream).toBe(inner);
       });
-      it4("caller-anchored `^prefix` matches by prefix", async () => {
+      it7("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qr-${tag}-pfx-a`;
         const b = `qr-${tag}-pfx-b`;
@@ -790,18 +1152,39 @@ var runStoreTck = (options) => {
           make_meta({ stream: other })
         );
         const got = await collect(store, { stream: `^qr-${tag}-pfx-` });
-        expect5(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
+        expect8(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
       });
     });
-    describe5("subscribe + claim + ack", () => {
-      it4("subscribes new streams and is idempotent on repeat", async () => {
+    describe8("subscribe + claim + ack", () => {
+      it7("subscribes new streams and is idempotent on repeat", async () => {
         const s = `sub-${uid()}`;
         const first = await store.subscribe([{ stream: s }]);
-        expect5(first.subscribed).toBe(1);
+        expect8(first.subscribed).toBe(1);
         const second = await store.subscribe([{ stream: s }]);
-        expect5(second.subscribed).toBe(0);
+        expect8(second.subscribed).toBe(0);
+      });
+      it7("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 }]);
+        expect8(await read()).toBe(3);
+        await store.subscribe([{ stream: s, priority: 10 }]);
+        expect8(await read()).toBe(10);
+        await store.subscribe([{ stream: s, priority: 1 }]);
+        expect8(await read()).toBe(10);
+        await store.subscribe([{ stream: s }]);
+        expect8(await read()).toBe(10);
       });
-      it4("claims a subscribed stream and ack releases the lease", async () => {
+      it7("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -812,11 +1195,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);
-        expect5(mine).toBeDefined();
-        expect5(mine.by).toBe(by);
+        expect8(mine).toBeDefined();
+        expect8(mine.by).toBe(by);
         await store.ack([{ ...mine, at: mine.at + 1 }]);
       });
-      it4("does not double-claim a held lease", async () => {
+      it7("does not double-claim a held lease", async () => {
         const s = `claim-held-${uid()}`;
         const other = `claim-other-${uid()}`;
         await store.subscribe([{ stream: s }]);
@@ -827,7 +1210,7 @@ var runStoreTck = (options) => {
         );
         const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1e5);
         const targetA = leasedA.find((l) => l.stream === s);
-        expect5(targetA).toBeDefined();
+        expect8(targetA).toBeDefined();
         await store.subscribe([{ stream: other }]);
         await store.commit(
           other,
@@ -835,11 +1218,11 @@ var runStoreTck = (options) => {
           make_meta({ stream: other })
         );
         const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
-        expect5(leasedB.length).toBeGreaterThan(0);
-        expect5(leasedB.find((l) => l.stream === s)).toBeUndefined();
-        expect5(leasedB.find((l) => l.stream === other)).toBeDefined();
+        expect8(leasedB.length).toBeGreaterThan(0);
+        expect8(leasedB.find((l) => l.stream === s)).toBeUndefined();
+        expect8(leasedB.find((l) => l.stream === other)).toBeDefined();
       });
-      it4("supports dual frontiers (lagging + leading)", async () => {
+      it7("supports dual frontiers (lagging + leading)", async () => {
         const s = `claim-dual-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -849,12 +1232,12 @@ var runStoreTck = (options) => {
         );
         const first = await store.claim(100, 0, `w-${uid()}`, 1);
         const mine = first.find((l) => l.stream === s);
-        expect5(mine).toBeDefined();
+        expect8(mine).toBeDefined();
         await store.ack([{ ...mine, at: mine.at + 1 }]);
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
-        expect5(second.find((l) => l.stream === s)).toBeDefined();
+        expect8(second.find((l) => l.stream === s)).toBeDefined();
       });
-      it4("dedupes when both frontiers would return the same stream", async () => {
+      it7("dedupes when both frontiers would return the same stream", async () => {
         const s = `claim-dedup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -864,9 +1247,9 @@ var runStoreTck = (options) => {
         );
         const claimed = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const matches = claimed.filter((l) => l.stream === s);
-        expect5(matches).toHaveLength(1);
+        expect8(matches).toHaveLength(1);
       });
-      it4("silently ignores ack from the wrong holder", async () => {
+      it7("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 }]);
@@ -883,40 +1266,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);
-        expect5(mine).toBeDefined();
-        expect5(sibling_lease).toBeDefined();
+        expect8(mine).toBeDefined();
+        expect8(sibling_lease).toBeDefined();
         const acked = await store.ack([
           { ...mine, by: "imposter" },
           sibling_lease
         ]);
-        expect5(acked.length).toBeGreaterThan(0);
-        expect5(acked.find((l) => l.stream === s)).toBeUndefined();
+        expect8(acked.length).toBeGreaterThan(0);
+        expect8(acked.find((l) => l.stream === s)).toBeUndefined();
       });
-      it4("ack with a stale (lower) watermark does not throw", async () => {
+      it7("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);
-        expect5(mine).toBeDefined();
-        await expect5(
+        expect8(mine).toBeDefined();
+        await expect8(
           store.ack([{ ...mine, at: -5 }])
         ).resolves.toBeDefined();
       });
-      it4("claim with no subscribed streams returns an empty array", async () => {
+      it7("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);
-          expect5(claimed).toEqual([]);
+          expect8(claimed).toEqual([]);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    describe5("lease semantics", () => {
-      it4("returns retry=0 on first claim and increments on re-claim without ack", async () => {
+    describe8("lease semantics", () => {
+      it7("returns retry=0 on first claim and increments on re-claim without ack", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -930,17 +1313,17 @@ var runStoreTck = (options) => {
           );
           const first = await fresh.claim(1, 0, `w-${uid()}`, 0);
           const f = first.find((l) => l.stream === s);
-          expect5(f).toBeDefined();
-          expect5(f.retry).toBe(0);
+          expect8(f).toBeDefined();
+          expect8(f.retry).toBe(0);
           const second = await fresh.claim(1, 0, `w-${uid()}`, 1e5);
           const sec = second.find((l) => l.stream === s);
-          expect5(sec).toBeDefined();
-          expect5(sec.retry).toBe(1);
+          expect8(sec).toBeDefined();
+          expect8(sec.retry).toBe(1);
         } finally {
           await fresh.dispose();
         }
       });
-      it4("reports lagging=true from the lagging frontier and false from the leading frontier", async () => {
+      it7("reports lagging=true from the lagging frontier and false from the leading frontier", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -953,16 +1336,16 @@ var runStoreTck = (options) => {
             make_meta({ stream: s })
           );
           const lag = await fresh.claim(1, 0, `w-${uid()}`, 0);
-          expect5(lag.find((l) => l.stream === s)?.lagging).toBe(true);
+          expect8(lag.find((l) => l.stream === s)?.lagging).toBe(true);
           const lead = await fresh.claim(0, 1, `w-${uid()}`, 1e5);
-          expect5(lead.find((l) => l.stream === s)?.lagging).toBe(false);
+          expect8(lead.find((l) => l.stream === s)?.lagging).toBe(false);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    describe5.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
-      it4("never double-leases a stream across concurrent claimers", async () => {
+    describe8.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
+      it7("never double-leases a stream across concurrent claimers", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -985,15 +1368,15 @@ var runStoreTck = (options) => {
             fresh.claim(100, 100, `wB-${uid()}`, 6e4)
           ]);
           const claimed = [...a, ...b].map((l) => l.stream).filter((stream) => owned.has(stream));
-          expect5(new Set(claimed).size).toBe(claimed.length);
-          expect5(claimed.length).toBe(owned.size);
+          expect8(new Set(claimed).size).toBe(claimed.length);
+          expect8(claimed.length).toBe(owned.size);
         } finally {
           await fresh.dispose();
         }
       });
     });
-    describe5("block", () => {
-      it4("hides blocked streams from claim", async () => {
+    describe8("block", () => {
+      it7("hides blocked streams from claim", async () => {
         const s = `block-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1003,18 +1386,18 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect5(mine).toBeDefined();
+        expect8(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         const blocked = await store.block([
           { ...mine, error: "boom" }
         ]);
-        expect5(blocked).toHaveLength(1);
-        expect5(blocked[0].error).toBe("boom");
+        expect8(blocked).toHaveLength(1);
+        expect8(blocked[0].error).toBe("boom");
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
-        expect5(again.find((l) => l.stream === s)).toBeUndefined();
+        expect8(again.find((l) => l.stream === s)).toBeUndefined();
       });
-      it4("rejects block calls from a different holder", async () => {
+      it7("rejects block calls from a different holder", async () => {
         const s = `block-wrong-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1024,17 +1407,17 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect5(mine).toBeDefined();
+        expect8(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         const blocked = await store.block([
           { ...mine, by: "imposter", error: "no" }
         ]);
-        expect5(blocked).toHaveLength(0);
+        expect8(blocked).toHaveLength(0);
       });
     });
-    describe5("reset", () => {
-      it4("rewinds a stream watermark to -1", async () => {
+    describe8("reset", () => {
+      it7("rewinds a stream watermark to -1", async () => {
         const s = `reset-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1044,15 +1427,15 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
-        expect5(mine).toBeDefined();
+        expect8(mine).toBeDefined();
         await store.ack([{ ...mine, at: 99 }]);
-        expect5(await store.reset([s])).toBe(1);
+        expect8(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
-        expect5(back).toBeDefined();
-        expect5(back.at).toBe(-1);
+        expect8(back).toBeDefined();
+        expect8(back.at).toBe(-1);
       });
-      it4("clears blocked status when resetting", async () => {
+      it7("clears blocked status when resetting", async () => {
         const s = `reset-blk-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1065,17 +1448,17 @@ var runStoreTck = (options) => {
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
-        expect5(await store.reset([s])).toBe(1);
+        expect8(await store.reset([s])).toBe(1);
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
-        expect5(after.find((l) => l.stream === s)).toBeDefined();
+        expect8(after.find((l) => l.stream === s)).toBeDefined();
       });
-      it4("returns 0 for unknown streams and empty input", async () => {
-        expect5(await store.reset([`missing-${uid()}`])).toBe(0);
-        expect5(await store.reset([])).toBe(0);
+      it7("returns 0 for unknown streams and empty input", async () => {
+        expect8(await store.reset([`missing-${uid()}`])).toBe(0);
+        expect8(await store.reset([])).toBe(0);
       });
     });
-    describe5("unblock", () => {
-      it4("clears blocked flag and preserves the watermark", async () => {
+    describe8("unblock", () => {
+      it7("clears blocked flag and preserves the watermark", async () => {
         const s = `unblock-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1093,7 +1476,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);
-        expect5(m2).toBeDefined();
+        expect8(m2).toBeDefined();
         const watermark_before = m2.at;
         await store.block([{ ...m2, error: "permanent" }]);
         let blocked_flag;
@@ -1103,15 +1486,15 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, limit: 1 }
         );
-        expect5(blocked_flag).toBe(true);
-        expect5(await store.unblock([s])).toBe(1);
+        expect8(blocked_flag).toBe(true);
+        expect8(await store.unblock([s])).toBe(1);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
-        expect5(back).toBeDefined();
-        expect5(back.at).toBe(watermark_before);
-        expect5(back.retry).toBe(0);
+        expect8(back).toBeDefined();
+        expect8(back.at).toBe(watermark_before);
+        expect8(back.retry).toBe(0);
       });
-      it4("returns 0 when the stream is not blocked", async () => {
+      it7("returns 0 when the stream is not blocked", async () => {
         const s = `unblock-noop-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -1119,13 +1502,13 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
-        expect5(await store.unblock([s])).toBe(0);
+        expect8(await store.unblock([s])).toBe(0);
       });
-      it4("returns 0 for unknown streams and empty input", async () => {
-        expect5(await store.unblock([`missing-${uid()}`])).toBe(0);
-        expect5(await store.unblock([])).toBe(0);
+      it7("returns 0 for unknown streams and empty input", async () => {
+        expect8(await store.unblock([`missing-${uid()}`])).toBe(0);
+        expect8(await store.unblock([])).toBe(0);
       });
-      it4("only counts streams that were actually blocked", async () => {
+      it7("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 }]);
@@ -1144,9 +1527,9 @@ var runStoreTck = (options) => {
         const others = leased.filter((l) => l.stream !== s1);
         await store.ack(others);
         await store.block([{ ...m1, error: "boom" }]);
-        expect5(await store.unblock([s1, s2])).toBe(1);
+        expect8(await store.unblock([s1, s2])).toBe(1);
       });
-      it4("filter form: unblocks by stream pattern", async () => {
+      it7("filter form: unblocks by stream pattern", async () => {
         const tag = uid();
         const s1 = `unblock-filter-${tag}-a`;
         const s2 = `unblock-filter-${tag}-b`;
@@ -1178,13 +1561,13 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-filter-${tag}-`
         });
-        expect5(count).toBe(2);
+        expect8(count).toBe(2);
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
-        expect5(after.find((l) => l.stream === s3)).toBeUndefined();
-        expect5(after.find((l) => l.stream === s1)).toBeDefined();
-        expect5(after.find((l) => l.stream === s2)).toBeDefined();
+        expect8(after.find((l) => l.stream === s3)).toBeUndefined();
+        expect8(after.find((l) => l.stream === s1)).toBeDefined();
+        expect8(after.find((l) => l.stream === s2)).toBeDefined();
       });
-      it4("filter form: empty filter unblocks every blocked stream", async () => {
+      it7("filter form: empty filter unblocks every blocked stream", async () => {
         const tag = uid();
         const s1 = `unblock-empty-${tag}-a`;
         const s2 = `unblock-empty-${tag}-b`;
@@ -1208,9 +1591,9 @@ var runStoreTck = (options) => {
         const count = await store.unblock({
           stream: `^unblock-empty-${tag}-`
         });
-        expect5(count).toBe(2);
+        expect8(count).toBe(2);
       });
-      it4("filter form: explicit blocked:false matches nothing", async () => {
+      it7("filter form: explicit blocked:false matches nothing", async () => {
         const tag = uid();
         const s = `unblock-blocked-false-${tag}`;
         await store.subscribe([{ stream: s }]);
@@ -1219,7 +1602,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
-        expect5(
+        expect8(
           await store.unblock({
             stream: `^unblock-blocked-false-${tag}`,
             blocked: false
@@ -1227,8 +1610,8 @@ var runStoreTck = (options) => {
         ).toBe(0);
       });
     });
-    describe5("reset filter form", () => {
-      it4("resets streams matching a stream pattern", async () => {
+    describe8("reset filter form", () => {
+      it7("resets streams matching a stream pattern", async () => {
         const tag = uid();
         const s1 = `reset-filter-${tag}-a`;
         const s2 = `reset-filter-${tag}-b`;
@@ -1259,7 +1642,7 @@ var runStoreTck = (options) => {
         );
         await store.ack(mine.map((l) => ({ ...l, at: l.at + 100 })));
         const count = await store.reset({ stream: `^reset-filter-${tag}-` });
-        expect5(count).toBe(2);
+        expect8(count).toBe(2);
         const position_for = async (name) => {
           let at = null;
           await store.query_streams(
@@ -1270,11 +1653,11 @@ var runStoreTck = (options) => {
           );
           return at;
         };
-        expect5(await position_for(s1)).toBe(-1);
-        expect5(await position_for(s2)).toBe(-1);
-        expect5(await position_for(other)).toBeGreaterThan(-1);
+        expect8(await position_for(s1)).toBe(-1);
+        expect8(await position_for(s2)).toBe(-1);
+        expect8(await position_for(other)).toBeGreaterThan(-1);
       });
-      it4("filter form: resets only blocked streams when blocked:true", async () => {
+      it7("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`;
@@ -1297,11 +1680,11 @@ var runStoreTck = (options) => {
           stream: `^reset-blocked-${tag}-`,
           blocked: true
         });
-        expect5(count).toBe(1);
+        expect8(count).toBe(1);
       });
     });
-    describe5("prioritize", () => {
-      it4("sets priority directly, overriding subscribe's max() rule", async () => {
+    describe8("prioritize", () => {
+      it7("sets priority directly, overriding subscribe's max() rule", async () => {
         const tag = uid();
         const s1 = `pri-${tag}-a`;
         const s2 = `pri-${tag}-b`;
@@ -1313,7 +1696,7 @@ var runStoreTck = (options) => {
           { stream: s1, stream_exact: true },
           3
         );
-        expect5(updated).toBe(1);
+        expect8(updated).toBe(1);
         const got1 = {};
         const got2 = {};
         await store.query_streams(
@@ -1323,12 +1706,12 @@ var runStoreTck = (options) => {
           },
           { stream: `pri-${tag}-.*`, limit: 100 }
         );
-        expect5(got1.priority).toBe(3);
-        expect5(got2.priority).toBe(5);
+        expect8(got1.priority).toBe(3);
+        expect8(got2.priority).toBe(5);
       });
     });
-    describe5("lanes", () => {
-      it4("subscribe defaults lane to 'default' when omitted", async () => {
+    describe8("lanes", () => {
+      it7("subscribe defaults lane to 'default' when omitted", async () => {
         const s = `lane-default-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const seen = [];
@@ -1336,9 +1719,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect5(seen).toEqual(["default"]);
+        expect8(seen).toEqual(["default"]);
       });
-      it4("subscribe records the lane passed in", async () => {
+      it7("subscribe records the lane passed in", async () => {
         const s = `lane-set-${uid()}`;
         await store.subscribe([{ stream: s, lane: "slow" }]);
         const seen = [];
@@ -1346,9 +1729,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect5(seen).toEqual(["slow"]);
+        expect8(seen).toEqual(["slow"]);
       });
-      it4("subscribe re-lanes existing streams on subsequent calls", async () => {
+      it7("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" }]);
@@ -1357,9 +1740,9 @@ var runStoreTck = (options) => {
           stream: s,
           stream_exact: true
         });
-        expect5(seen).toEqual(["fast"]);
+        expect8(seen).toEqual(["fast"]);
       });
-      it4("claim() filters by lane when supplied and returns lane on the Lease", async () => {
+      it7("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}`;
@@ -1383,19 +1766,19 @@ var runStoreTck = (options) => {
         const slow_mine = slow.filter(
           (l) => l.stream === sub_default || l.stream === sub_slow
         );
-        expect5(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
-        expect5(slow_mine[0]?.lane).toBe("slow");
+        expect8(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
+        expect8(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 }));
-        expect5(all_mine).toEqual(
-          expect5.arrayContaining([
+        expect8(all_mine).toEqual(
+          expect8.arrayContaining([
             { stream: sub_default, lane: "default" },
             { stream: sub_slow, lane: "slow" }
           ])
         );
       });
-      it4("query_streams filters by lane", async () => {
+      it7("query_streams filters by lane", async () => {
         const tag = uid();
         const a = `lane-q-a-${tag}`;
         const b = `lane-q-b-${tag}`;
@@ -1411,9 +1794,9 @@ var runStoreTck = (options) => {
           stream: `lane-q-.*-${tag}`,
           limit: 100
         });
-        expect5(seen.sort()).toEqual([a, c]);
+        expect8(seen.sort()).toEqual([a, c]);
       });
-      it4("prioritize filters by lane", async () => {
+      it7("prioritize filters by lane", async () => {
         const tag = uid();
         const a = `lane-pri-a-${tag}`;
         const b = `lane-pri-b-${tag}`;
@@ -1422,16 +1805,16 @@ var runStoreTck = (options) => {
           { stream: b, lane: `pfast-${tag}` }
         ]);
         const updated = await store.prioritize({ lane: `pslow-${tag}` }, 7);
-        expect5(updated).toBe(1);
+        expect8(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
         });
-        expect5(seen.get(a)).toBe(7);
-        expect5(seen.get(b)).toBe(0);
+        expect8(seen.get(a)).toBe(7);
+        expect8(seen.get(b)).toBe(0);
       });
-      it4("reset filters by lane", async () => {
+      it7("reset filters by lane", async () => {
         const tag = uid();
         const src = `lane-reset-src-${tag}`;
         const a = `lane-reset-a-${tag}`;
@@ -1449,7 +1832,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}` });
-        expect5(count).toBe(1);
+        expect8(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), {
@@ -1457,10 +1840,10 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        expect5(ats.get(a)).toBe(-1);
-        expect5(ats.get(b)).toBeGreaterThanOrEqual(0);
+        expect8(ats.get(a)).toBe(-1);
+        expect8(ats.get(b)).toBeGreaterThanOrEqual(0);
       });
-      it4("unblock filters by lane", async () => {
+      it7("unblock filters by lane", async () => {
         const tag = uid();
         const src = `lane-ub-src-${tag}`;
         const a = `lane-ub-a-${tag}`;
@@ -1478,7 +1861,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}` });
-        expect5(count).toBe(1);
+        expect8(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), {
@@ -1486,12 +1869,12 @@ var runStoreTck = (options) => {
             stream_exact: true
           });
         }
-        expect5(blocked.get(a)).toBe(false);
-        expect5(blocked.get(b)).toBe(true);
+        expect8(blocked.get(a)).toBe(false);
+        expect8(blocked.get(b)).toBe(true);
       });
     });
-    describe5("truncate", () => {
-      it4("seeds a tombstone when no snapshot is provided", async () => {
+    describe8("truncate", () => {
+      it7("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
         await store.commit(
           s,
@@ -1499,7 +1882,7 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const result = await store.truncate([{ stream: s }]);
-        expect5(result.get(s)?.deleted).toBe(2);
+        expect8(result.get(s)?.deleted).toBe(2);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1507,12 +1890,12 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect5(remaining).toHaveLength(1);
-        expect5(remaining[0].name).toBe(
+        expect8(remaining).toHaveLength(1);
+        expect8(remaining[0].name).toBe(
           "__tombstone__"
         );
       });
-      it4("seeds a snapshot when one is provided", async () => {
+      it7("seeds a snapshot when one is provided", async () => {
         const s = `trunc-snap-${uid()}`;
         await store.commit(
           s,
@@ -1522,7 +1905,7 @@ var runStoreTck = (options) => {
         const result = await store.truncate([
           { stream: s, snapshot: { count: 7 } }
         ]);
-        expect5(result.get(s)?.deleted).toBe(1);
+        expect8(result.get(s)?.deleted).toBe(1);
         const remaining = [];
         await store.query(
           (e) => {
@@ -1530,24 +1913,24 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true, with_snaps: true }
         );
-        expect5(remaining).toHaveLength(1);
-        expect5(remaining[0].name).toBe(
+        expect8(remaining).toHaveLength(1);
+        expect8(remaining[0].name).toBe(
           "__snapshot__"
         );
-        expect5(remaining[0].data).toEqual({ count: 7 });
+        expect8(remaining[0].data).toEqual({ count: 7 });
       });
-      it4("returns an empty map for empty input", async () => {
+      it7("returns an empty map for empty input", async () => {
         const result = await store.truncate([]);
-        expect5(result.size).toBe(0);
+        expect8(result.size).toBe(0);
       });
-      it4("returns 0 deleted for streams that don't exist", async () => {
+      it7("returns 0 deleted for streams that don't exist", async () => {
         const s = `trunc-missing-${uid()}`;
         const result = await store.truncate([{ stream: s }]);
-        expect5(result.get(s)?.deleted).toBe(0);
+        expect8(result.get(s)?.deleted).toBe(0);
       });
     });
-    describe5("query_streams", () => {
-      it4("returns positions filtered by stream regex, exact, source, and source_exact", async () => {
+    describe8("query_streams", () => {
+      it7("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`;
@@ -1566,37 +1949,37 @@ var runStoreTck = (options) => {
           (p) => all.push({ stream: p.stream, source: p.source }),
           { stream: `qs-${tag}-.*` }
         );
-        expect5(all_result.count).toBe(4);
-        expect5(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
-        expect5(all.map((p) => p.stream).sort()).toEqual(
+        expect8(all_result.count).toBe(4);
+        expect8(all_result.maxEventId).toBeGreaterThanOrEqual(-1);
+        expect8(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-.*`
         });
-        expect5(projections.sort()).toEqual([proj1, proj2].sort());
+        expect8(projections.sort()).toEqual([proj1, proj2].sort());
         const exact = [];
         await store.query_streams((p) => exact.push(p.stream), {
           stream: dyn1,
           stream_exact: true
         });
-        expect5(exact).toEqual([dyn1]);
+        expect8(exact).toEqual([dyn1]);
         const by_source = [];
         await store.query_streams((p) => by_source.push(p.stream), {
           stream: `qs-${tag}-.*`,
           source: `qs-${tag}-src-.*`
         });
-        expect5(by_source.sort()).toEqual([dyn1, dyn2].sort());
+        expect8(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
         });
-        expect5(exact_source).toEqual([dyn2]);
+        expect8(exact_source).toEqual([dyn2]);
       });
-      it4("paginates with limit + after (keyset)", async () => {
+      it7("paginates with limit + after (keyset)", async () => {
         const tag = uid();
         const streams = [
           `qp-${tag}-a`,
@@ -1610,17 +1993,17 @@ var runStoreTck = (options) => {
           stream: `qp-${tag}-.*`,
           limit: 2
         });
-        expect5(page1).toHaveLength(2);
+        expect8(page1).toHaveLength(2);
         const page2 = [];
         await store.query_streams((p) => page2.push(p.stream), {
           stream: `qp-${tag}-.*`,
           limit: 2,
           after: page1.at(-1)
         });
-        expect5(page2).toHaveLength(2);
-        expect5([...page1, ...page2].sort()).toEqual([...streams].sort());
+        expect8(page2).toHaveLength(2);
+        expect8([...page1, ...page2].sort()).toEqual([...streams].sort());
       });
-      it4("filters by blocked status", async () => {
+      it7("filters by blocked status", async () => {
         const tag = uid();
         const s = `qb-${tag}`;
         const sibling = `qb-${tag}-other`;
@@ -1640,18 +2023,18 @@ var runStoreTck = (options) => {
           (p) => blocked.push({ stream: p.stream, error: p.error }),
           { stream: `qb-${tag}.*`, blocked: true }
         );
-        expect5(blocked).toHaveLength(1);
-        expect5(blocked[0].error).toBe("boom");
+        expect8(blocked).toHaveLength(1);
+        expect8(blocked[0].error).toBe("boom");
         const unblocked = [];
         await store.query_streams((p) => unblocked.push(p.stream), {
           stream: `qb-${tag}.*`,
           blocked: false
         });
-        expect5(unblocked).toEqual([sibling]);
+        expect8(unblocked).toEqual([sibling]);
       });
     });
-    describe5("query_stats", () => {
-      it4("array input \u2014 returns head per stream, absent when not in input", async () => {
+    describe8("query_stats", () => {
+      it7("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`;
@@ -1672,18 +2055,18 @@ var runStoreTck = (options) => {
           make_meta({ stream: sUnasked })
         );
         const stats = await store.query_stats([sA, sB]);
-        expect5(stats.size).toBe(2);
-        expect5(stats.get(sA)?.head.name).toBe("Incremented");
-        expect5((stats.get(sA)?.head.data).amount).toBe(2);
-        expect5(stats.get(sB)?.head.name).toBe("Decremented");
-        expect5((stats.get(sB)?.head.data).amount).toBe(5);
-        expect5(stats.has(sUnasked)).toBe(false);
+        expect8(stats.size).toBe(2);
+        expect8(stats.get(sA)?.head.name).toBe("Incremented");
+        expect8((stats.get(sA)?.head.data).amount).toBe(2);
+        expect8(stats.get(sB)?.head.name).toBe("Decremented");
+        expect8((stats.get(sB)?.head.data).amount).toBe(5);
+        expect8(stats.has(sUnasked)).toBe(false);
         const empty = await store.query_stats([]);
-        expect5(empty.size).toBe(0);
+        expect8(empty.size).toBe(0);
         const unknown = await store.query_stats([`qst-${tag}-missing`]);
-        expect5(unknown.size).toBe(0);
+        expect8(unknown.size).toBe(0);
       });
-      it4("tail returns the earliest event per stream", async () => {
+      it7("tail returns the earliest event per stream", async () => {
         const tag = uid();
         const s = `qst-tail-${tag}`;
         await store.commit(
@@ -1705,12 +2088,12 @@ var runStoreTck = (options) => {
           tail: true
         });
         const r = stats.get(s);
-        expect5(r?.head.name).toBe("Incremented");
-        expect5((r?.head.data).amount).toBe(3);
-        expect5(r?.tail?.name).toBe("Incremented");
-        expect5((r?.tail?.data).amount).toBe(1);
+        expect8(r?.head.name).toBe("Incremented");
+        expect8((r?.head.data).amount).toBe(3);
+        expect8(r?.tail?.name).toBe("Incremented");
+        expect8((r?.tail?.data).amount).toBe(1);
       });
-      it4("count + names \u2014 full aggregates including framework markers", async () => {
+      it7("count + names \u2014 full aggregates including framework markers", async () => {
         const tag = uid();
         const s = `qst-cn-${tag}`;
         await store.commit(
@@ -1729,13 +2112,13 @@ var runStoreTck = (options) => {
           names: true
         });
         const r = stats.get(s);
-        expect5(r?.count).toBe(4);
-        expect5(r?.names?.[SNAP_EVENT]).toBe(1);
-        expect5(r?.names?.Incremented).toBe(2);
-        expect5(r?.names?.Decremented).toBe(1);
-        expect5(r?.names?.[SNAP_EVENT]).toBe(1);
+        expect8(r?.count).toBe(4);
+        expect8(r?.names?.[SNAP_EVENT2]).toBe(1);
+        expect8(r?.names?.Incremented).toBe(2);
+        expect8(r?.names?.Decremented).toBe(1);
+        expect8(r?.names?.[SNAP_EVENT2]).toBe(1);
       });
-      it4("exclude shifts head past filtered events; stream absent when all filtered", async () => {
+      it7("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}`;
@@ -1750,23 +2133,23 @@ var runStoreTck = (options) => {
           make_meta({ stream: sAllOut })
         );
         const all = await store.query_stats([s]);
-        expect5(all.get(s)?.head.name).toBe("Incremented");
-        expect5((all.get(s)?.head.data).amount).toBe(3);
+        expect8(all.get(s)?.head.name).toBe("Incremented");
+        expect8((all.get(s)?.head.data).amount).toBe(3);
         const excl = await store.query_stats([s], {
           exclude: ["Incremented"]
         });
-        expect5(excl.get(s)?.head.name).toBe("Decremented");
-        expect5((excl.get(s)?.head.data).amount).toBe(2);
+        expect8(excl.get(s)?.head.name).toBe("Decremented");
+        expect8((excl.get(s)?.head.data).amount).toBe(2);
         const wipe = await store.query_stats([sAllOut], {
           exclude: ["Incremented", "Decremented", "Reset"]
         });
-        expect5(wipe.has(sAllOut)).toBe(false);
+        expect8(wipe.has(sAllOut)).toBe(false);
         const no_tomb = await store.query_stats([s], {
           exclude: [TOMBSTONE_EVENT]
         });
-        expect5(no_tomb.get(s)?.head.name).toBe("Incremented");
+        expect8(no_tomb.get(s)?.head.name).toBe("Incremented");
       });
-      it4("before \u2014 time travel narrows head/tail/count", async () => {
+      it7("before \u2014 time travel narrows head/tail/count", async () => {
         const tag = uid();
         const s = `qst-tt-${tag}`;
         const c1 = await store.commit(
@@ -1791,15 +2174,15 @@ var runStoreTck = (options) => {
           before
         });
         const r = stats.get(s);
-        expect5(r?.count).toBe(1);
-        expect5(r?.head.id).toBe(c1[0].id);
-        expect5(r?.tail?.id).toBe(c1[0].id);
+        expect8(r?.count).toBe(1);
+        expect8(r?.head.id).toBe(c1[0].id);
+        expect8(r?.tail?.id).toBe(c1[0].id);
         const empty = await store.query_stats([s], {
           before: 0
         });
-        expect5(empty.has(s)).toBe(false);
+        expect8(empty.has(s)).toBe(false);
       });
-      it4("filter form \u2014 stream regex, stream_exact, empty {} match", async () => {
+      it7("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`;
@@ -1822,18 +2205,18 @@ var runStoreTck = (options) => {
         const orders = await store.query_stats({
           stream: `^qsf-${tag}-orders-`
         });
-        expect5([...orders.keys()].sort()).toEqual([sA, sB].sort());
+        expect8([...orders.keys()].sort()).toEqual([sA, sB].sort());
         const exact = await store.query_stats({
           stream: sA,
           stream_exact: true
         });
-        expect5([...exact.keys()]).toEqual([sA]);
+        expect8([...exact.keys()]).toEqual([sA]);
         const all = await store.query_stats({
           stream: `^qsf-${tag}-`
         });
-        expect5([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
+        expect8([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
       });
-      it4("compose with query_streams for subscription-level filters", async () => {
+      it7("compose with query_streams for subscription-level filters", async () => {
         const tag = uid();
         const a = `qsc-${tag}-a`;
         const b = `qsc-${tag}-b`;
@@ -1850,7 +2233,7 @@ var runStoreTck = (options) => {
         );
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === a);
-        expect5(mine).toBeDefined();
+        expect8(mine).toBeDefined();
         const others = leased.filter((l) => l.stream !== a);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
@@ -1859,12 +2242,12 @@ var runStoreTck = (options) => {
           stream: `^qsc-${tag}-`,
           blocked: true
         });
-        expect5(blocked_names).toEqual([a]);
+        expect8(blocked_names).toEqual([a]);
         const stats = await store.query_stats(blocked_names);
-        expect5(stats.get(a)?.head.name).toBe("Incremented");
-        expect5(stats.has(b)).toBe(false);
+        expect8(stats.get(a)?.head.name).toBe("Incremented");
+        expect8(stats.has(b)).toBe(false);
       });
-      it4("empty filter {} \u2014 matches every event-bearing stream", async () => {
+      it7("empty filter {} \u2014 matches every event-bearing stream", async () => {
         const tag = uid();
         const a = `qse-${tag}-a`;
         const b = `qse-${tag}-b`;
@@ -1879,10 +2262,10 @@ var runStoreTck = (options) => {
           make_meta({ stream: b })
         );
         const all = await store.query_stats({});
-        expect5(all.has(a)).toBe(true);
-        expect5(all.has(b)).toBe(true);
+        expect8(all.has(a)).toBe(true);
+        expect8(all.has(b)).toBe(true);
       });
-      it4("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
+      it7("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
         const tag = uid();
         const s = `qsfl-${tag}`;
         await store.commit(
@@ -1893,22 +2276,22 @@ var runStoreTck = (options) => {
         const c = await store.query_stats([s], {
           count: true
         });
-        expect5(c.get(s)?.count).toBe(3);
-        expect5(c.get(s)?.names).toBeUndefined();
-        expect5(c.get(s)?.tail).toBeUndefined();
+        expect8(c.get(s)?.count).toBe(3);
+        expect8(c.get(s)?.names).toBeUndefined();
+        expect8(c.get(s)?.tail).toBeUndefined();
         const n = await store.query_stats([s], {
           names: true
         });
-        expect5(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
-        expect5(n.get(s)?.count).toBeUndefined();
-        expect5(n.get(s)?.tail).toBeUndefined();
+        expect8(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
+        expect8(n.get(s)?.count).toBeUndefined();
+        expect8(n.get(s)?.tail).toBeUndefined();
         const t = await store.query_stats([s], { tail: true });
-        expect5(t.get(s)?.tail?.name).toBe("Incremented");
-        expect5((t.get(s)?.tail?.data).amount).toBe(1);
-        expect5(t.get(s)?.count).toBeUndefined();
-        expect5(t.get(s)?.names).toBeUndefined();
+        expect8(t.get(s)?.tail?.name).toBe("Incremented");
+        expect8((t.get(s)?.tail?.data).amount).toBe(1);
+        expect8(t.get(s)?.count).toBeUndefined();
+        expect8(t.get(s)?.names).toBeUndefined();
       });
-      it4("paginates with limit + after (keyset), ordered by stream name", async () => {
+      it7("paginates with limit + after (keyset), ordered by stream name", async () => {
         const tag = uid();
         const streams = [
           `qsp-${tag}-a`,
@@ -1928,28 +2311,28 @@ var runStoreTck = (options) => {
           { limit: 2 }
         );
         const k1 = [...page1.keys()];
-        expect5(k1).toEqual([`qsp-${tag}-a`, `qsp-${tag}-b`]);
+        expect8(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()];
-        expect5(k2).toEqual([`qsp-${tag}-c`, `qsp-${tag}-d`]);
+        expect8(k2).toEqual([`qsp-${tag}-c`, `qsp-${tag}-d`]);
         const page3 = await store.query_stats(
           { stream: `qsp-${tag}-.*` },
           { limit: 2, after: k2.at(-1) }
         );
-        expect5(page3.size).toBe(0);
+        expect8(page3.size).toBe(0);
         const all = await store.query_stats({
           stream: `qsp-${tag}-.*`
         });
-        expect5([...all.keys()].sort()).toEqual([...streams].sort());
+        expect8([...all.keys()].sort()).toEqual([...streams].sort());
       });
     });
-    describe5.skipIf(!caps.source_matches)(
+    describe8.skipIf(!caps.source_matches)(
       "query_streams source_matches (capability)",
       () => {
-        it4("returns only subscriptions whose source pattern matches a name", async () => {
+        it7("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`;
@@ -1970,7 +2353,7 @@ var runStoreTck = (options) => {
             stream: `sm-${tag}-sub-.*`,
             source_matches: [srcA]
           });
-          expect5(matched.sort()).toEqual(
+          expect8(matched.sort()).toEqual(
             [subConcreteA, subRegex, subNoSource].sort()
           );
           const none = [];
@@ -1978,20 +2361,20 @@ var runStoreTck = (options) => {
             stream: `sm-${tag}-sub-.*`,
             source_matches: [`sm-${tag}-unrelated`]
           });
-          expect5(none).toEqual([subNoSource]);
+          expect8(none).toEqual([subNoSource]);
           const both = [];
           await store.query_streams((p) => both.push(p.stream), {
             stream: `sm-${tag}-sub-.*`,
             source_matches: [srcA, srcB]
           });
-          expect5(both.sort()).toEqual(
+          expect8(both.sort()).toEqual(
             [subConcreteA, subConcreteB, subRegex, subNoSource].sort()
           );
         });
       }
     );
-    describe5("query_streams anchor contract", () => {
-      it4("plain regex without anchors is a substring match", async () => {
+    describe8("query_streams anchor contract", () => {
+      it7("plain regex without anchors is a substring match", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-inner`;
         const longer = `qsr-${tag}-inner-extra`;
@@ -2005,9 +2388,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `qsr-${tag}-inner`
         });
-        expect5(seen.sort()).toEqual([inner, longer].sort());
+        expect8(seen.sort()).toEqual([inner, longer].sort());
       });
-      it4("caller-anchored `^name$` matches only the whole string", async () => {
+      it7("caller-anchored `^name$` matches only the whole string", async () => {
         const tag = uid();
         const inner = `qsr-${tag}-anchor`;
         const longer = `qsr-${tag}-anchor-extra`;
@@ -2016,9 +2399,9 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-anchor$`
         });
-        expect5(seen).toEqual([inner]);
+        expect8(seen).toEqual([inner]);
       });
-      it4("caller-anchored `^prefix` matches by prefix", async () => {
+      it7("caller-anchored `^prefix` matches by prefix", async () => {
         const tag = uid();
         const a = `qsr-${tag}-pfx-a`;
         const b = `qsr-${tag}-pfx-b`;
@@ -2032,11 +2415,11 @@ var runStoreTck = (options) => {
         await store.query_streams((p) => seen.push(p.stream), {
           stream: `^qsr-${tag}-pfx-`
         });
-        expect5(seen.sort()).toEqual([a, b].sort());
+        expect8(seen.sort()).toEqual([a, b].sort());
       });
     });
-    describe5("prioritize anchor contract", () => {
-      it4("caller-anchored `^name$` filter matches only the whole string", async () => {
+    describe8("prioritize anchor contract", () => {
+      it7("caller-anchored `^name$` filter matches only the whole string", async () => {
         const tag = uid();
         const inner = `pr-${tag}-anchor`;
         const longer = `pr-${tag}-anchor-extra`;
@@ -2048,17 +2431,17 @@ var runStoreTck = (options) => {
           { stream: `^pr-${tag}-anchor$` },
           7
         );
-        expect5(updated).toBe(1);
+        expect8(updated).toBe(1);
         const seen = /* @__PURE__ */ new Map();
         await store.query_streams((p) => seen.set(p.stream, p.priority), {
           stream: `pr-${tag}-anchor`
         });
-        expect5(seen.get(inner)).toBe(7);
-        expect5(seen.get(longer)).toBe(0);
+        expect8(seen.get(inner)).toBe(7);
+        expect8(seen.get(longer)).toBe(0);
       });
     });
-    describe5("query_streams head", () => {
-      it4("maxEventId tracks the highest committed id", async () => {
+    describe8("query_streams head", () => {
+      it7("maxEventId tracks the highest committed id", async () => {
         const s = `head-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2071,21 +2454,21 @@ var runStoreTck = (options) => {
           (p) => positions.push(p.stream),
           { stream: s, stream_exact: true, limit: 1 }
         );
-        expect5(maxEventId).toBeGreaterThanOrEqual(0);
-        expect5(positions).toEqual([s]);
+        expect8(maxEventId).toBeGreaterThanOrEqual(0);
+        expect8(positions).toEqual([s]);
       });
     });
-    describe5("seed_stream helper coverage", () => {
-      it4("commits N events with monotonically increasing ids", async () => {
+    describe8("seed_stream helper coverage", () => {
+      it7("commits N events with monotonically increasing ids", async () => {
         const s = `seed-${uid()}`;
         const committed = await seed_stream(store, s, 3);
-        expect5(committed).toHaveLength(3);
+        expect8(committed).toHaveLength(3);
         for (let i = 1; i < committed.length; i++) {
-          expect5(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+          expect8(committed[i].id).toBeGreaterThan(committed[i - 1].id);
         }
       });
     });
-    describe5.skipIf(!caps.restore)("restore (capability)", () => {
+    describe8.skipIf(!caps.restore)("restore (capability)", () => {
       beforeEach(async () => {
         await store.drop();
         await store.seed();
@@ -2122,18 +2505,18 @@ var runStoreTck = (options) => {
           await cache.dispose();
         }
       };
-      it4("returns kept=0 on an empty source", async () => {
+      it7("returns kept=0 on an empty source", async () => {
         const result = await restore(as_source([]));
-        expect5(result.kept).toBe(0);
-        expect5(result.duration_ms).toBeGreaterThanOrEqual(0);
-        expect5(result.dropped).toEqual({
+        expect8(result.kept).toBe(0);
+        expect8(result.duration_ms).toBeGreaterThanOrEqual(0);
+        expect8(result.dropped).toEqual({
           closed_streams: 0,
           snapshots: 0
         });
         const events2 = await collect(store, { limit: 10 });
-        expect5(events2).toHaveLength(0);
+        expect8(events2).toHaveLength(0);
       });
-      it4("rebuilds a single stream and preserves `created` verbatim", async () => {
+      it7("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");
@@ -2144,7 +2527,7 @@ var runStoreTck = (options) => {
           event(3, s, 2, "Decremented", t2, { amount: 1 })
         ];
         const result = await restore(as_source(events2));
-        expect5(result.kept).toBe(3);
+        expect8(result.kept).toBe(3);
         const back = [];
         await store.query(
           (e) => {
@@ -2152,8 +2535,8 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect5(back).toHaveLength(3);
-        expect5(
+        expect8(back).toHaveLength(3);
+        expect8(
           back.map((e) => ({
             stream: e.stream,
             version: e.version,
@@ -2185,7 +2568,7 @@ var runStoreTck = (options) => {
           }
         ]);
       });
-      it4("rebuilds multiple streams interleaved", async () => {
+      it7("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");
@@ -2196,7 +2579,7 @@ var runStoreTck = (options) => {
           event(4, b, 1, "Incremented", t, { amount: 30 })
         ];
         const result = await restore(as_source(events2));
-        expect5(result.kept).toBe(4);
+        expect8(result.kept).toBe(4);
         const aBack = [];
         const bBack = [];
         await store.query(
@@ -2211,10 +2594,10 @@ var runStoreTck = (options) => {
           },
           { stream: b, stream_exact: true }
         );
-        expect5(aBack.map((e) => e.version)).toEqual([0, 1]);
-        expect5(bBack.map((e) => e.version)).toEqual([0, 1]);
+        expect8(aBack.map((e) => e.version)).toEqual([0, 1]);
+        expect8(bBack.map((e) => e.version)).toEqual([0, 1]);
       });
-      it4("preserves Date `created` verbatim", async () => {
+      it7("preserves Date `created` verbatim", async () => {
         const s = `restore-isoc-${uid()}`;
         const iso = "2021-07-15T12:34:56.789Z";
         await restore(
@@ -2237,10 +2620,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect5(back).toHaveLength(1);
-        expect5(back[0].created.toISOString()).toBe(iso);
+        expect8(back).toHaveLength(1);
+        expect8(back[0].created.toISOString()).toBe(iso);
       });
-      it4("wipes pre-existing events before inserting", async () => {
+      it7("wipes pre-existing events before inserting", async () => {
         const old = `restore-old-${uid()}`;
         await store.commit(
           old,
@@ -2256,14 +2639,14 @@ var runStoreTck = (options) => {
           stream: old,
           stream_exact: true
         });
-        expect5(old_back).toHaveLength(0);
+        expect8(old_back).toHaveLength(0);
         const fresh_back = await collect(store, {
           stream: fresh,
           stream_exact: true
         });
-        expect5(fresh_back).toHaveLength(1);
+        expect8(fresh_back).toHaveLength(1);
       });
-      it4("clears subscription/stream-position metadata", async () => {
+      it7("clears subscription/stream-position metadata", async () => {
         const sub = `restore-sub-${uid()}`;
         await store.subscribe([{ stream: sub, source: "anything" }]);
         const collect_streams = async () => {
@@ -2274,12 +2657,12 @@ var runStoreTck = (options) => {
           return out;
         };
         const before = await collect_streams();
-        expect5(before.includes(sub)).toBe(true);
+        expect8(before.includes(sub)).toBe(true);
         await restore(as_source([]));
         const after = await collect_streams();
-        expect5(after.includes(sub)).toBe(false);
+        expect8(after.includes(sub)).toBe(false);
       });
-      it4("preserves snapshot events through restore", async () => {
+      it7("preserves snapshot events through restore", async () => {
         const s = `restore-snap-${uid()}`;
         const t = /* @__PURE__ */ new Date("2020-04-01T00:00:00.000Z");
         await restore(
@@ -2288,7 +2671,7 @@ var runStoreTck = (options) => {
               id: 1,
               stream: s,
               version: 0,
-              name: SNAP_EVENT,
+              name: SNAP_EVENT2,
               data: { count: 42 },
               created: t,
               meta: { correlation: "snap", causation: {} }
@@ -2300,10 +2683,10 @@ var runStoreTck = (options) => {
           stream_exact: true,
           with_snaps: true
         });
-        expect5(back).toHaveLength(1);
-        expect5(back[0].name).toBe(SNAP_EVENT);
+        expect8(back).toHaveLength(1);
+        expect8(back[0].name).toBe(SNAP_EVENT2);
       });
-      it4("rewrites causation refs through the old\u2192new id map", async () => {
+      it7("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 = [
@@ -2353,12 +2736,12 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect5(back).toHaveLength(3);
-        expect5(back[0].meta.causation.event).toBeUndefined();
-        expect5(back[1].meta.causation.event?.id).toBe(back[0].id);
-        expect5(back[2].meta.causation.event?.id).toBe(back[1].id);
+        expect8(back).toHaveLength(3);
+        expect8(back[0].meta.causation.event).toBeUndefined();
+        expect8(back[1].meta.causation.event?.id).toBe(back[0].id);
+        expect8(back[2].meta.causation.event?.id).toBe(back[1].id);
       });
-      it4("leaves causation refs unmapped when the target isn't in the source", async () => {
+      it7("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(
@@ -2386,9 +2769,9 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect5(back[0].meta.causation.event?.id).toBe(999);
+        expect8(back[0].meta.causation.event?.id).toBe(999);
       });
-      it4("rolls back atomically when the source throws mid-iteration", async () => {
+      it7("rolls back atomically when the source throws mid-iteration", async () => {
         const original = `restore-pre-${uid()}`;
         const committed = await store.commit(
           original,
@@ -2414,7 +2797,7 @@ var runStoreTck = (options) => {
           async dispose() {
           }
         };
-        await expect5(restore(explosive)).rejects.toThrow("boom");
+        await expect8(restore(explosive)).rejects.toThrow("boom");
         const back = [];
         await store.query(
           (e) => {
@@ -2422,10 +2805,10 @@ var runStoreTck = (options) => {
           },
           { stream: original, stream_exact: true }
         );
-        expect5(back).toHaveLength(3);
-        expect5(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        expect8(back).toHaveLength(3);
+        expect8(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
       });
-      it4("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
+      it7("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(
@@ -2435,7 +2818,7 @@ var runStoreTck = (options) => {
               id: 2,
               stream: s,
               version: 1,
-              name: SNAP_EVENT,
+              name: SNAP_EVENT2,
               data: { count: 1 },
               created: t,
               meta: { correlation: "snap", causation: {} }
@@ -2444,19 +2827,19 @@ var runStoreTck = (options) => {
           ]),
           { drop_snapshots: true }
         );
-        expect5(result.kept).toBe(2);
-        expect5(result.dropped.snapshots).toBe(1);
+        expect8(result.kept).toBe(2);
+        expect8(result.dropped.snapshots).toBe(1);
         const back = await collect(store, {
           stream: s,
           stream_exact: true,
           with_snaps: true
         });
-        expect5(back).toHaveLength(2);
-        expect5(
-          back.every((e) => e.name !== SNAP_EVENT)
+        expect8(back).toHaveLength(2);
+        expect8(
+          back.every((e) => e.name !== SNAP_EVENT2)
         ).toBe(true);
       });
-      it4("on_progress fires once per event (caller throttles)", async () => {
+      it7("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");
@@ -2467,11 +2850,11 @@ var runStoreTck = (options) => {
           ]),
           { on_progress: (p) => calls.push(p.processed) }
         );
-        expect5(calls).toEqual([1, 2]);
+        expect8(calls).toEqual([1, 2]);
       });
     });
-    describe5.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
-      it4("commits and loads pii alongside data", async () => {
+    describe8.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
+      it7("commits and loads pii alongside data", async () => {
         const s = `pii-roundtrip-${uid()}`;
         const committed = await store.commit(
           s,
@@ -2484,8 +2867,8 @@ var runStoreTck = (options) => {
           ],
           make_meta({ stream: s })
         );
-        expect5(committed).toHaveLength(1);
-        expect5(committed[0].pii).toEqual({
+        expect8(committed).toHaveLength(1);
+        expect8(committed[0].pii).toEqual({
           email: "u@example.com",
           name: "Ursula"
         });
@@ -2496,11 +2879,11 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect5(seen).toHaveLength(1);
-        expect5(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
-        expect5(seen[0].data).toEqual({ amount: 1 });
+        expect8(seen).toHaveLength(1);
+        expect8(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
+        expect8(seen[0].data).toEqual({ amount: 1 });
       });
-      it4("passes through events without pii (pii is null or undefined on load)", async () => {
+      it7("passes through events without pii (pii is null or undefined on load)", async () => {
         const s = `pii-none-${uid()}`;
         await store.commit(
           s,
@@ -2514,10 +2897,10 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect5(seen).toHaveLength(1);
-        expect5(seen[0].pii == null).toBe(true);
+        expect8(seen).toHaveLength(1);
+        expect8(seen[0].pii == null).toBe(true);
       });
-      it4("wipes pii for every event on the stream via forget_pii", async () => {
+      it7("wipes pii for every event on the stream via forget_pii", async () => {
         const s = `pii-forget-${uid()}`;
         await store.commit(
           s,
@@ -2536,9 +2919,9 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const forget = store.forget_pii;
-        expect5(forget).toBeDefined();
+        expect8(forget).toBeDefined();
         const wiped = await forget.call(store, s);
-        expect5(wiped).toBe(2);
+        expect8(wiped).toBe(2);
         const seen = [];
         await store.query(
           (e) => {
@@ -2546,13 +2929,13 @@ var runStoreTck = (options) => {
           },
           { stream: s, stream_exact: true }
         );
-        expect5(seen).toHaveLength(2);
+        expect8(seen).toHaveLength(2);
         for (const e of seen) {
-          expect5(e.pii == null).toBe(true);
-          expect5(e.data).toBeDefined();
+          expect8(e.pii == null).toBe(true);
+          expect8(e.data).toBeDefined();
         }
       });
-      it4("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
+      it7("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
         const s = `pii-forget-idem-${uid()}`;
         await store.commit(
           s,
@@ -2567,11 +2950,11 @@ var runStoreTck = (options) => {
         );
         const forget = store.forget_pii;
         const first = await forget.call(store, s);
-        expect5(first).toBe(1);
+        expect8(first).toBe(1);
         const second = await forget.call(store, s);
-        expect5(second).toBe(0);
+        expect8(second).toBe(0);
       });
-      it4("only wipes the targeted stream \u2014 siblings untouched", async () => {
+      it7("only wipes the targeted stream \u2014 siblings untouched", async () => {
         const sA = `pii-iso-a-${uid()}`;
         const sB = `pii-iso-b-${uid()}`;
         await store.commit(
@@ -2604,7 +2987,7 @@ var runStoreTck = (options) => {
           },
           { stream: sA, stream_exact: true }
         );
-        expect5(a[0].pii == null).toBe(true);
+        expect8(a[0].pii == null).toBe(true);
         const b = [];
         await store.query(
           (e) => {
@@ -2612,9 +2995,9 @@ var runStoreTck = (options) => {
           },
           { stream: sB, stream_exact: true }
         );
-        expect5(b[0].pii).toEqual({ email: "bob@example.com" });
+        expect8(b[0].pii).toEqual({ email: "bob@example.com" });
       });
-      it4("forget_pii on a stream with no pii events returns 0", async () => {
+      it7("forget_pii on a stream with no pii events returns 0", async () => {
         const s = `pii-forget-empty-${uid()}`;
         await store.commit(
           s,
@@ -2622,14 +3005,14 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const wiped = await store.forget_pii.call(store, s);
-        expect5(wiped).toBe(0);
+        expect8(wiped).toBe(0);
       });
     });
     if (caps.notify) {
-      describe5("notify (capability)", () => {
-        it4("delivers a notification when a different instance commits", async () => {
+      describe8("notify (capability)", () => {
+        it7("delivers a notification when a different instance commits", async () => {
           const notify = store.notify;
-          expect5(notify).toBeDefined();
+          expect8(notify).toBeDefined();
           const received = [];
           let resolve_arrived;
           const arrived = new Promise((res) => {
@@ -2648,9 +3031,9 @@ var runStoreTck = (options) => {
               make_meta({ stream })
             );
             await arrived;
-            expect5(received.length).toBeGreaterThanOrEqual(1);
-            expect5(received[0].stream).toBe(stream);
-            expect5(received[0].events.length).toBeGreaterThanOrEqual(1);
+            expect8(received.length).toBeGreaterThanOrEqual(1);
+            expect8(received[0].stream).toBe(stream);
+            expect8(received[0].events.length).toBeGreaterThanOrEqual(1);
           } finally {
             await writer.dispose();
             await Promise.resolve(disposer());
@@ -2671,9 +3054,12 @@ export {
   dec,
   inc,
   reset,
+  runCacheDifferentialTck,
   runCacheTck,
+  runLoggerDifferentialTck,
   runLoggerTck,
   runStabilityTck,
+  runStoreDifferentialTck,
   runStorePropertyTck,
   runStoreTck,
   uid