@rotorsoft/act-tck 0.1.0

package/dist/index.js

@@ -0,0 +1,956 @@
+// src/cache-tck.ts
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+var entry = (event_id, state = {}) => ({
+  state,
+  version: event_id,
+  event_id,
+  patches: 1,
+  snaps: 0
+});
+var runCacheTck = (options) => {
+  describe(`TCK / Cache / ${options.name}`, () => {
+    let cache;
+    beforeEach(() => {
+      cache = options.factory();
+    });
+    afterEach(async () => {
+      await cache.dispose();
+    });
+    it("returns undefined for an unset stream", async () => {
+      expect(await cache.get("missing")).toBeUndefined();
+    });
+    it("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);
+    });
+    it("set overwrites a prior entry on the same stream", async () => {
+      await cache.set("s1", entry(1, { count: 1 }));
+      await cache.set("s1", entry(2, { count: 2 }));
+      const got = await cache.get("s1");
+      expect(got?.event_id).toBe(2);
+      expect(got?.state).toEqual({ count: 2 });
+    });
+    it("invalidate removes one stream and leaves others", async () => {
+      await cache.set("a", entry(1));
+      await cache.set("b", entry(2));
+      await cache.invalidate("a");
+      expect(await cache.get("a")).toBeUndefined();
+      expect(await cache.get("b")).toBeDefined();
+    });
+    it("invalidate on an unknown stream is a no-op", async () => {
+      await expect(cache.invalidate("never-set")).resolves.toBeUndefined();
+    });
+    it("clear empties every stream", async () => {
+      await cache.set("a", entry(1));
+      await cache.set("b", entry(2));
+      await cache.set("c", entry(3));
+      await cache.clear();
+      expect(await cache.get("a")).toBeUndefined();
+      expect(await cache.get("b")).toBeUndefined();
+      expect(await cache.get("c")).toBeUndefined();
+    });
+    it("clear on an empty cache is a no-op", async () => {
+      await expect(cache.clear()).resolves.toBeUndefined();
+    });
+    it("entries are isolated per stream", async () => {
+      const ea = entry(1, { id: "a" });
+      const eb = entry(2, { id: "b" });
+      await cache.set("a", ea);
+      await cache.set("b", eb);
+      expect(await cache.get("a")).toEqual(ea);
+      expect(await cache.get("b")).toEqual(eb);
+    });
+    it("dispose is idempotent", async () => {
+      await cache.set("a", entry(1));
+      await cache.dispose();
+      await expect(cache.dispose()).resolves.toBeUndefined();
+    });
+  });
+};
+
+// src/fixtures/events.ts
+import { z } from "zod";
+var Incremented = z.object({ amount: z.number().int() });
+var Decremented = z.object({ amount: z.number().int() });
+var Reset = z.object({});
+var CounterSchemas = {
+  Incremented,
+  Decremented,
+  Reset
+};
+var COUNTER_EVENT_NAMES = [
+  "Incremented",
+  "Decremented",
+  "Reset"
+];
+
+// src/fixtures/helpers.ts
+import { randomUUID } from "crypto";
+var uid = () => randomUUID().slice(0, 8);
+var actor = (name = "tester") => ({ id: randomUUID(), name });
+var makeMeta = (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 seedStream = async (store, stream, count, correlation) => {
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const committed = await store.commit(
+      stream,
+      [inc(1)],
+      makeMeta({ correlation, stream })
+    );
+    out.push(...committed);
+  }
+  return out;
+};
+var collect = async (store, query) => {
+  const out = [];
+  await store.query((e) => {
+    out.push(e);
+  }, query);
+  return out;
+};
+
+// src/logger-tck.ts
+import { afterEach as afterEach2, beforeEach as beforeEach2, describe as describe2, expect as expect2, it as it2 } from "vitest";
+var LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
+var runLoggerTck = (options) => {
+  describe2(`TCK / Logger / ${options.name}`, () => {
+    let logger;
+    let originalStdout;
+    beforeEach2(() => {
+      logger = options.factory();
+      originalStdout = process.stdout.write.bind(process.stdout);
+      process.stdout.write = (() => true);
+    });
+    afterEach2(async () => {
+      process.stdout.write = originalStdout;
+      await logger.dispose();
+    });
+    it2("exposes a non-empty `level` string", () => {
+      expect2(typeof logger.level).toBe("string");
+      expect2(logger.level.length).toBeGreaterThan(0);
+    });
+    for (const level of LEVELS) {
+      it2(`${level}(msg) does not throw`, () => {
+        expect2(() => logger[level]("hello")).not.toThrow();
+      });
+      it2(`${level}(obj) does not throw`, () => {
+        expect2(() => logger[level]({ k: "v" })).not.toThrow();
+      });
+      it2(`${level}(obj, msg) does not throw`, () => {
+        expect2(() => logger[level]({ k: "v" }, "context")).not.toThrow();
+      });
+    }
+    it2("accepts a null payload", () => {
+      expect2(() => logger.info(null, "null payload")).not.toThrow();
+    });
+    it2("accepts a cyclic payload without throwing", () => {
+      const cyclic = { name: "loop" };
+      cyclic.self = cyclic;
+      expect2(() => logger.info(cyclic, "cycle")).not.toThrow();
+    });
+    it2("child(bindings) returns a Logger satisfying the same contract", () => {
+      const child = logger.child({ requestId: "abc" });
+      expect2(typeof child.level).toBe("string");
+      for (const level of LEVELS) {
+        expect2(typeof child[level]).toBe("function");
+      }
+      expect2(typeof child.child).toBe("function");
+      expect2(typeof child.dispose).toBe("function");
+    });
+    it2("child loggers can themselves spawn children", () => {
+      const c1 = logger.child({ a: 1 });
+      const c2 = c1.child({ b: 2 });
+      expect2(() => c2.info("nested")).not.toThrow();
+    });
+    it2("dispose is idempotent and awaitable", async () => {
+      await expect2(logger.dispose()).resolves.toBeUndefined();
+      await expect2(logger.dispose()).resolves.toBeUndefined();
+    });
+  });
+};
+
+// src/store-tck.ts
+import { ConcurrencyError } from "@rotorsoft/act";
+import { afterAll, beforeAll, describe as describe3, expect as expect3, it as it3 } from "vitest";
+var runStoreTck = (options) => {
+  describe3(`TCK / Store / ${options.name}`, () => {
+    let store;
+    const caps = options.capabilities ?? {};
+    beforeAll(async () => {
+      store = await options.factory();
+      await store.drop();
+      await store.seed();
+    });
+    afterAll(async () => {
+      await store.dispose();
+    });
+    describe3("commit", () => {
+      it3("returns committed events with sequenced ids and versions", async () => {
+        const s = `commit-seq-${uid()}`;
+        const committed = await store.commit(
+          s,
+          [inc(1), inc(2), dec(3)],
+          makeMeta({ stream: s })
+        );
+        expect3(committed).toHaveLength(3);
+        expect3(committed[0].version).toBe(0);
+        expect3(committed[1].version).toBe(1);
+        expect3(committed[2].version).toBe(2);
+        expect3(committed[0].name).toBe("Incremented");
+        expect3(committed[2].data).toEqual({ amount: 3 });
+        for (let i = 1; i < committed.length; i++) {
+          expect3(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+        }
+      });
+      it3("attaches correlation and stream metadata", async () => {
+        const s = `commit-meta-${uid()}`;
+        const correlation = `cor-${uid()}`;
+        const committed = await store.commit(
+          s,
+          [inc(1)],
+          makeMeta({ stream: s, correlation })
+        );
+        expect3(committed[0].stream).toBe(s);
+        expect3(committed[0].meta.correlation).toBe(correlation);
+      });
+      it3("throws ConcurrencyError when expectedVersion is wrong", async () => {
+        const s = `commit-cc-${uid()}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          s,
+          [inc(1)],
+          makeMeta({ stream: s }),
+          0
+        );
+        await expect3(
+          store.commit(s, [inc(1)], makeMeta({ stream: s }), 0)
+        ).rejects.toBeInstanceOf(ConcurrencyError);
+      });
+      it3("preserves prior events when a concurrent commit is rejected", async () => {
+        const s = `commit-cc-preserve-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1), inc(2)],
+          makeMeta({ stream: s })
+        );
+        await expect3(
+          store.commit(s, [inc(3)], makeMeta({ stream: s }), 0)
+        ).rejects.toBeInstanceOf(ConcurrencyError);
+        const found = await collect(store, { stream: s, stream_exact: true });
+        expect3(found).toHaveLength(2);
+      });
+    });
+    describe3("query", () => {
+      it3("filters by stream, names, correlation, limit, with_snaps", async () => {
+        const s1 = `q-s1-${uid()}`;
+        const s2 = `q-s2-${uid()}`;
+        const cor = `q-cor-${uid()}`;
+        await store.commit(
+          s1,
+          [inc(1), dec(1)],
+          makeMeta({ stream: s1, correlation: cor })
+        );
+        await store.commit(
+          s2,
+          [inc(2), dec(2), reset()],
+          makeMeta({ stream: s2, correlation: cor })
+        );
+        const byStream = await collect(store, {
+          stream: s1,
+          stream_exact: true
+        });
+        expect3(byStream).toHaveLength(2);
+        const byName = await collect(store, {
+          stream: s2,
+          stream_exact: true,
+          names: ["Reset"]
+        });
+        expect3(byName).toHaveLength(1);
+        expect3(byName[0].name).toBe("Reset");
+        const byCorrelation = await collect(store, { correlation: cor });
+        expect3(byCorrelation).toHaveLength(5);
+        const limited = await collect(store, {
+          correlation: cor,
+          limit: 2
+        });
+        expect3(limited).toHaveLength(2);
+      });
+      it3("supports backward traversal", async () => {
+        const s = `q-back-${uid()}`;
+        const committed = await store.commit(
+          s,
+          [inc(1), inc(2), inc(3)],
+          makeMeta({ stream: s })
+        );
+        const forward = await collect(store, { stream: s, stream_exact: true });
+        const backward = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          backward: true
+        });
+        expect3(forward.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+        expect3(backward.map((e) => e.id)).toEqual(
+          [...committed].reverse().map((c) => c.id)
+        );
+      });
+      it3("after/before bound the id range", async () => {
+        const s = `q-bounds-${uid()}`;
+        const committed = await store.commit(
+          s,
+          [inc(1), inc(2), inc(3), inc(4)],
+          makeMeta({ stream: s })
+        );
+        const afterFirst = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          after: committed[0].id
+        });
+        expect3(afterFirst.map((e) => e.id)).toEqual(
+          committed.slice(1).map((c) => c.id)
+        );
+        const beforeLast = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          before: committed[committed.length - 1].id
+        });
+        expect3(beforeLast.map((e) => e.id)).toEqual(
+          committed.slice(0, -1).map((c) => c.id)
+        );
+      });
+      it3("created_after/created_before filter by timestamp", async () => {
+        const s = `q-ts-${uid()}`;
+        const before = new Date(Date.now() - 6e4);
+        const future = new Date(Date.now() + 6e4);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const inWindow = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          created_after: before,
+          created_before: future
+        });
+        expect3(inWindow.length).toBe(1);
+        const outOfWindow = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          created_after: future
+        });
+        expect3(outOfWindow.length).toBe(0);
+      });
+      it3("backward traversal short-circuits at `after` id boundary", async () => {
+        const s = `q-back-after-${uid()}`;
+        const committed = await store.commit(
+          s,
+          [inc(1), inc(2), inc(3)],
+          makeMeta({ stream: s })
+        );
+        const got = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          backward: true,
+          after: committed[0].id
+        });
+        expect3(got.map((e) => e.id)).toEqual([
+          committed[2].id,
+          committed[1].id
+        ]);
+      });
+      it3("backward traversal short-circuits at `created_after` boundary", async () => {
+        const s = `q-back-cafter-${uid()}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const future = new Date(Date.now() + 6e4);
+        const got = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          backward: true,
+          created_after: future
+        });
+        expect3(got).toHaveLength(0);
+      });
+      it3("backward traversal honors created_before by skipping newer events", async () => {
+        const s = `q-back-ts-${uid()}`;
+        await store.commit(s, [inc(1)], makeMeta());
+        const past = new Date(Date.now() - 6e4);
+        const got = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          backward: true,
+          created_before: past
+        });
+        expect3(got).toHaveLength(0);
+      });
+      it3("stream_exact disables regex matching", async () => {
+        const tag = uid();
+        const a = `q-exact-${tag}`;
+        const b = `q-exact-${tag}-extra`;
+        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
+        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        const exact = await collect(store, { stream: a, stream_exact: true });
+        expect3(exact).toHaveLength(1);
+        expect3(exact[0].data).toEqual({ amount: 1 });
+      });
+      it3("plain regex without anchors is a substring match", async () => {
+        const tag = uid();
+        const inner = `qr-${tag}-inner`;
+        const longer = `qr-${tag}-inner-extra`;
+        await store.commit(
+          inner,
+          [inc(1)],
+          makeMeta({ stream: inner })
+        );
+        await store.commit(
+          longer,
+          [inc(2)],
+          makeMeta({ stream: longer })
+        );
+        const got = await collect(store, { stream: `qr-${tag}-inner` });
+        expect3(got.map((e) => e.stream).sort()).toEqual([inner, longer].sort());
+      });
+      it3("caller-anchored `^name$` matches only the whole string", async () => {
+        const tag = uid();
+        const inner = `qr-${tag}-anchor`;
+        const longer = `qr-${tag}-anchor-extra`;
+        await store.commit(
+          inner,
+          [inc(1)],
+          makeMeta({ stream: inner })
+        );
+        await store.commit(
+          longer,
+          [inc(2)],
+          makeMeta({ stream: longer })
+        );
+        const got = await collect(store, { stream: `^qr-${tag}-anchor$` });
+        expect3(got).toHaveLength(1);
+        expect3(got[0].stream).toBe(inner);
+      });
+      it3("caller-anchored `^prefix` matches by prefix", async () => {
+        const tag = uid();
+        const a = `qr-${tag}-pfx-a`;
+        const b = `qr-${tag}-pfx-b`;
+        const other = `zz-${tag}-other`;
+        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
+        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        await store.commit(
+          other,
+          [inc(3)],
+          makeMeta({ stream: other })
+        );
+        const got = await collect(store, { stream: `^qr-${tag}-pfx-` });
+        expect3(got.map((e) => e.stream).sort()).toEqual([a, b].sort());
+      });
+    });
+    describe3("subscribe + claim + ack", () => {
+      it3("subscribes new streams and is idempotent on repeat", async () => {
+        const s = `sub-${uid()}`;
+        const first = await store.subscribe([{ stream: s }]);
+        expect3(first.subscribed).toBe(1);
+        const second = await store.subscribe([{ stream: s }]);
+        expect3(second.subscribed).toBe(0);
+      });
+      it3("claims a subscribed stream and ack releases the lease", async () => {
+        const s = `claim-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const by = `worker-${uid()}`;
+        const leased = await store.claim(100, 0, by, 1e4);
+        const mine = leased.find((l) => l.stream === s);
+        expect3(mine).toBeDefined();
+        expect3(mine.by).toBe(by);
+        await store.ack([{ ...mine, at: mine.at + 1 }]);
+      });
+      it3("does not double-claim a held lease", async () => {
+        const s = `claim-held-${uid()}`;
+        const other = `claim-other-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1e5);
+        const targetA = leasedA.find((l) => l.stream === s);
+        expect3(targetA).toBeDefined();
+        await store.subscribe([{ stream: other }]);
+        await store.commit(
+          other,
+          [inc(2)],
+          makeMeta({ stream: other })
+        );
+        const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
+        expect3(leasedB.length).toBeGreaterThan(0);
+        expect3(leasedB.find((l) => l.stream === s)).toBeUndefined();
+        expect3(leasedB.find((l) => l.stream === other)).toBeDefined();
+      });
+      it3("supports dual frontiers (lagging + leading)", async () => {
+        const s = `claim-dual-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(
+          s,
+          [inc(1), inc(2)],
+          makeMeta({ stream: s })
+        );
+        const first = await store.claim(100, 0, `w-${uid()}`, 1);
+        const mine = first.find((l) => l.stream === s);
+        expect3(mine).toBeDefined();
+        await store.ack([{ ...mine, at: mine.at + 1 }]);
+        const second = await store.claim(0, 100, `w-${uid()}`, 1);
+        expect3(second.find((l) => l.stream === s)).toBeDefined();
+      });
+      it3("dedupes when both frontiers would return the same stream", async () => {
+        const s = `claim-dedup-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const claimed = await store.claim(100, 100, `w-${uid()}`, 1e5);
+        const matches = claimed.filter((l) => l.stream === s);
+        expect3(matches).toHaveLength(1);
+      });
+      it3("silently ignores ack from the wrong holder", async () => {
+        const s = `ack-wrong-${uid()}`;
+        const sibling = `ack-sibling-${uid()}`;
+        await store.subscribe([{ stream: s }, { stream: sibling }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(
+          sibling,
+          [inc(2)],
+          makeMeta({ stream: sibling })
+        );
+        const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === s);
+        const siblingLease = leased.find((l) => l.stream === sibling);
+        expect3(mine).toBeDefined();
+        expect3(siblingLease).toBeDefined();
+        const acked = await store.ack([
+          { ...mine, by: "imposter" },
+          siblingLease
+        ]);
+        expect3(acked.length).toBeGreaterThan(0);
+        expect3(acked.find((l) => l.stream === s)).toBeUndefined();
+      });
+      it3("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);
+        expect3(mine).toBeDefined();
+        await expect3(
+          store.ack([{ ...mine, at: -5 }])
+        ).resolves.toBeDefined();
+      });
+      it3("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);
+          expect3(claimed).toEqual([]);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+    });
+    describe3("block", () => {
+      it3("hides blocked streams from claim", async () => {
+        const s = `block-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === s);
+        expect3(mine).toBeDefined();
+        const others = leased.filter((l) => l.stream !== s);
+        await store.ack(others);
+        const blocked = await store.block([
+          { ...mine, error: "boom" }
+        ]);
+        expect3(blocked).toHaveLength(1);
+        expect3(blocked[0].error).toBe("boom");
+        const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
+        expect3(again.find((l) => l.stream === s)).toBeUndefined();
+      });
+      it3("rejects block calls from a different holder", async () => {
+        const s = `block-wrong-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === s);
+        expect3(mine).toBeDefined();
+        const others = leased.filter((l) => l.stream !== s);
+        await store.ack(others);
+        const blocked = await store.block([
+          { ...mine, by: "imposter", error: "no" }
+        ]);
+        expect3(blocked).toHaveLength(0);
+      });
+    });
+    describe3("reset", () => {
+      it3("rewinds a stream watermark to -1", async () => {
+        const s = `reset-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === s);
+        expect3(mine).toBeDefined();
+        await store.ack([{ ...mine, at: 99 }]);
+        expect3(await store.reset([s])).toBe(1);
+        const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
+        const back = after.find((l) => l.stream === s);
+        expect3(back).toBeDefined();
+        expect3(back.at).toBe(-1);
+      });
+      it3("clears blocked status when resetting", async () => {
+        const s = `reset-blk-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === s);
+        const others = leased.filter((l) => l.stream !== s);
+        await store.ack(others);
+        await store.block([{ ...mine, error: "boom" }]);
+        expect3(await store.reset([s])).toBe(1);
+        const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
+        expect3(after.find((l) => l.stream === s)).toBeDefined();
+      });
+      it3("returns 0 for unknown streams and empty input", async () => {
+        expect3(await store.reset([`missing-${uid()}`])).toBe(0);
+        expect3(await store.reset([])).toBe(0);
+      });
+    });
+    describe3("prioritize", () => {
+      it3("sets priority directly, overriding subscribe's max() rule", async () => {
+        const tag = uid();
+        const s1 = `pri-${tag}-a`;
+        const s2 = `pri-${tag}-b`;
+        await store.subscribe([
+          { stream: s1, priority: 5 },
+          { stream: s2, priority: 5 }
+        ]);
+        const updated = await store.prioritize(
+          { stream: s1, stream_exact: true },
+          3
+        );
+        expect3(updated).toBe(1);
+        const got1 = {};
+        const got2 = {};
+        await store.query_streams(
+          (p) => {
+            if (p.stream === s1) got1.priority = p.priority;
+            if (p.stream === s2) got2.priority = p.priority;
+          },
+          { stream: `pri-${tag}-.*`, limit: 100 }
+        );
+        expect3(got1.priority).toBe(3);
+        expect3(got2.priority).toBe(5);
+      });
+    });
+    describe3("truncate", () => {
+      it3("seeds a tombstone when no snapshot is provided", async () => {
+        const s = `trunc-tomb-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1), inc(2)],
+          makeMeta({ stream: s })
+        );
+        const result = await store.truncate([{ stream: s }]);
+        expect3(result.get(s)?.deleted).toBe(2);
+        const remaining = [];
+        await store.query(
+          (e) => {
+            remaining.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        expect3(remaining).toHaveLength(1);
+        expect3(remaining[0].name).toBe(
+          "__tombstone__"
+        );
+      });
+      it3("seeds a snapshot when one is provided", async () => {
+        const s = `trunc-snap-${uid()}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const result = await store.truncate([
+          { stream: s, snapshot: { count: 7 } }
+        ]);
+        expect3(result.get(s)?.deleted).toBe(1);
+        const remaining = [];
+        await store.query(
+          (e) => {
+            remaining.push(e);
+          },
+          { stream: s, stream_exact: true, with_snaps: true }
+        );
+        expect3(remaining).toHaveLength(1);
+        expect3(remaining[0].name).toBe(
+          "__snapshot__"
+        );
+        expect3(remaining[0].data).toEqual({ count: 7 });
+      });
+      it3("returns an empty map for empty input", async () => {
+        const result = await store.truncate([]);
+        expect3(result.size).toBe(0);
+      });
+      it3("returns 0 deleted for streams that don't exist", async () => {
+        const s = `trunc-missing-${uid()}`;
+        const result = await store.truncate([{ stream: s }]);
+        expect3(result.get(s)?.deleted).toBe(0);
+      });
+    });
+    describe3("query_streams", () => {
+      it3("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`;
+        const dyn1 = `qs-${tag}-stats-1`;
+        const dyn2 = `qs-${tag}-stats-2`;
+        const src1 = `qs-${tag}-src-1`;
+        const src2 = `qs-${tag}-src-2`;
+        await store.subscribe([
+          { stream: proj1 },
+          { stream: proj2 },
+          { stream: dyn1, source: src1 },
+          { stream: dyn2, source: src2 }
+        ]);
+        const all = [];
+        const allResult = await store.query_streams(
+          (p) => all.push({ stream: p.stream, source: p.source }),
+          { stream: `qs-${tag}-.*` }
+        );
+        expect3(allResult.count).toBe(4);
+        expect3(allResult.maxEventId).toBeGreaterThanOrEqual(-1);
+        expect3(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-.*`
+        });
+        expect3(projections.sort()).toEqual([proj1, proj2].sort());
+        const exact = [];
+        await store.query_streams((p) => exact.push(p.stream), {
+          stream: dyn1,
+          stream_exact: true
+        });
+        expect3(exact).toEqual([dyn1]);
+        const bySource = [];
+        await store.query_streams((p) => bySource.push(p.stream), {
+          stream: `qs-${tag}-.*`,
+          source: `qs-${tag}-src-.*`
+        });
+        expect3(bySource.sort()).toEqual([dyn1, dyn2].sort());
+        const exactSource = [];
+        await store.query_streams((p) => exactSource.push(p.stream), {
+          stream: `qs-${tag}-.*`,
+          source: src2,
+          source_exact: true
+        });
+        expect3(exactSource).toEqual([dyn2]);
+      });
+      it3("paginates with limit + after (keyset)", async () => {
+        const tag = uid();
+        const streams = [
+          `qp-${tag}-a`,
+          `qp-${tag}-b`,
+          `qp-${tag}-c`,
+          `qp-${tag}-d`
+        ];
+        await store.subscribe(streams.map((stream) => ({ stream })));
+        const page1 = [];
+        await store.query_streams((p) => page1.push(p.stream), {
+          stream: `qp-${tag}-.*`,
+          limit: 2
+        });
+        expect3(page1).toHaveLength(2);
+        const page2 = [];
+        await store.query_streams((p) => page2.push(p.stream), {
+          stream: `qp-${tag}-.*`,
+          limit: 2,
+          after: page1.at(-1)
+        });
+        expect3(page2).toHaveLength(2);
+        expect3([...page1, ...page2].sort()).toEqual([...streams].sort());
+      });
+      it3("filters by blocked status", async () => {
+        const tag = uid();
+        const s = `qb-${tag}`;
+        const sibling = `qb-${tag}-other`;
+        await store.subscribe([{ stream: s }, { stream: sibling }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === s);
+        const others = leased.filter((l) => l.stream !== s);
+        await store.ack(others);
+        await store.block([{ ...mine, error: "boom" }]);
+        const blocked = [];
+        await store.query_streams(
+          (p) => blocked.push({ stream: p.stream, error: p.error }),
+          { stream: `qb-${tag}.*`, blocked: true }
+        );
+        expect3(blocked).toHaveLength(1);
+        expect3(blocked[0].error).toBe("boom");
+        const unblocked = [];
+        await store.query_streams((p) => unblocked.push(p.stream), {
+          stream: `qb-${tag}.*`,
+          blocked: false
+        });
+        expect3(unblocked).toEqual([sibling]);
+      });
+    });
+    describe3("query_streams anchor contract", () => {
+      it3("plain regex without anchors is a substring match", async () => {
+        const tag = uid();
+        const inner = `qsr-${tag}-inner`;
+        const longer = `qsr-${tag}-inner-extra`;
+        const other = `zz-${tag}-other`;
+        await store.subscribe([
+          { stream: inner },
+          { stream: longer },
+          { stream: other }
+        ]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.stream), {
+          stream: `qsr-${tag}-inner`
+        });
+        expect3(seen.sort()).toEqual([inner, longer].sort());
+      });
+      it3("caller-anchored `^name$` matches only the whole string", async () => {
+        const tag = uid();
+        const inner = `qsr-${tag}-anchor`;
+        const longer = `qsr-${tag}-anchor-extra`;
+        await store.subscribe([{ stream: inner }, { stream: longer }]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.stream), {
+          stream: `^qsr-${tag}-anchor$`
+        });
+        expect3(seen).toEqual([inner]);
+      });
+      it3("caller-anchored `^prefix` matches by prefix", async () => {
+        const tag = uid();
+        const a = `qsr-${tag}-pfx-a`;
+        const b = `qsr-${tag}-pfx-b`;
+        const other = `zz-${tag}-pfx-c`;
+        await store.subscribe([
+          { stream: a },
+          { stream: b },
+          { stream: other }
+        ]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.stream), {
+          stream: `^qsr-${tag}-pfx-`
+        });
+        expect3(seen.sort()).toEqual([a, b].sort());
+      });
+    });
+    describe3("prioritize anchor contract", () => {
+      it3("caller-anchored `^name$` filter matches only the whole string", async () => {
+        const tag = uid();
+        const inner = `pr-${tag}-anchor`;
+        const longer = `pr-${tag}-anchor-extra`;
+        await store.subscribe([
+          { stream: inner, priority: 0 },
+          { stream: longer, priority: 0 }
+        ]);
+        const updated = await store.prioritize(
+          { stream: `^pr-${tag}-anchor$` },
+          7
+        );
+        expect3(updated).toBe(1);
+        const seen = /* @__PURE__ */ new Map();
+        await store.query_streams((p) => seen.set(p.stream, p.priority), {
+          stream: `pr-${tag}-anchor`
+        });
+        expect3(seen.get(inner)).toBe(7);
+        expect3(seen.get(longer)).toBe(0);
+      });
+    });
+    describe3("query_streams head", () => {
+      it3("maxEventId tracks the highest committed id", async () => {
+        const s = `head-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const positions = [];
+        const { maxEventId } = await store.query_streams(
+          (p) => positions.push(p.stream),
+          { stream: s, stream_exact: true, limit: 1 }
+        );
+        expect3(maxEventId).toBeGreaterThanOrEqual(0);
+        expect3(positions).toEqual([s]);
+      });
+    });
+    describe3("seedStream helper coverage", () => {
+      it3("commits N events with monotonically increasing ids", async () => {
+        const s = `seed-${uid()}`;
+        const committed = await seedStream(store, s, 3);
+        expect3(committed).toHaveLength(3);
+        for (let i = 1; i < committed.length; i++) {
+          expect3(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+        }
+      });
+    });
+    if (caps.notify) {
+      describe3("notify (capability)", () => {
+        it3("delivers a notification when a different instance commits", async () => {
+          const notify = store.notify;
+          expect3(notify).toBeDefined();
+          const received = [];
+          let resolveArrived;
+          const arrived = new Promise((res) => {
+            resolveArrived = res;
+          });
+          const disposer = await notify.call(store, (n) => {
+            received.push(n);
+            resolveArrived();
+          });
+          const writer = await options.factory();
+          try {
+            const stream = `notify-${uid()}`;
+            await writer.commit(
+              stream,
+              [inc(1)],
+              makeMeta({ stream })
+            );
+            await arrived;
+            expect3(received.length).toBeGreaterThanOrEqual(1);
+            expect3(received[0].stream).toBe(stream);
+            expect3(received[0].events.length).toBeGreaterThanOrEqual(1);
+          } finally {
+            await writer.dispose();
+            await Promise.resolve(disposer());
+          }
+        });
+      });
+    }
+  });
+};
+export {
+  COUNTER_EVENT_NAMES,
+  CounterSchemas,
+  Decremented,
+  Incremented,
+  Reset,
+  actor,
+  collect,
+  dec,
+  inc,
+  makeMeta,
+  reset,
+  runCacheTck,
+  runLoggerTck,
+  runStoreTck,
+  seedStream,
+  uid
+};
+//# sourceMappingURL=index.js.map