@rotorsoft/act-tck 1.38.19 → 1.38.21

package/dist/@types/store-tck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAQV,KAAK,EAIN,MAAM,sBAAsB,CAAC;AAc9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,gCAAgC,CAAC,EAAE,OAAO,CAAC;IACpD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACxD;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,YAAa,eAAe,KAAG,IAgzKtD,CAAC"}
+{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAQV,KAAK,EAIN,MAAM,sBAAsB,CAAC;AAe9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,gCAAgC,CAAC,EAAE,OAAO,CAAC;IACpD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACxD;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,YAAa,eAAe,KAAG,IAmgLtD,CAAC"}

package/dist/index.cjs

@@ -189,9 +189,9 @@ var runCacheDifferentialTck = (options) => {
 
 // src/cache-tck.ts
 var import_vitest2 = require("vitest");
-var entry = (event_id, state = {}, stream = `s-${event_id}`) => ({
+var entry = (event_id, state2 = {}, stream = `s-${event_id}`) => ({
   stream,
-  state,
+  state: state2,
   version: event_id,
   event_id,
   patches: 1,
@@ -417,7 +417,7 @@ async function load_surface(entry2) {
     if (visited.has(abs)) return;
     const content = await import_node_fs.promises.readFile(abs, "utf8");
     visited.set(abs, content);
-    const re_export = /^\s*(?:import|export)\b[^"';]*\bfrom\s+["'](\.[^"']+)["']/gm;
+    const re_export = /^\s*export\b[^"';]*\bfrom\s+["'](\.[^"']+)["']/gm;
     for (const m of content.matchAll(re_export)) {
       const rel = m[1].replace(/\.js$/, ".ts");
       const target = import_node_path.default.resolve(import_node_path.default.dirname(abs), rel);
@@ -1163,6 +1163,7 @@ var runStorePropertyTck = (options) => {
 // src/store-tck.ts
 var import_act2 = require("@rotorsoft/act");
 var import_vitest9 = require("vitest");
+var import_zod2 = require("zod");
 var runStoreTck = (options) => {
   (0, import_vitest9.describe)(`TCK / Store / ${options.name}`, () => {
     let store;
@@ -2196,7 +2197,7 @@ var runStoreTck = (options) => {
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
         (0, import_vitest9.expect)(second.find((l) => l.stream === s)).toBeDefined();
       });
-      (0, import_vitest9.it)("does not starve a default-priority lagging stream under sustained high-priority load (ACT-1223)", async () => {
+      (0, import_vitest9.it)("does not starve a default-priority lagging stream under sustained high-priority load", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -2598,7 +2599,7 @@ var runStoreTck = (options) => {
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
         (0, import_vitest9.expect)(again.find((l) => l.stream === s)).toBeUndefined();
       });
-      (0, import_vitest9.it)("returns the post-block row, not the caller's lease (#1382)", async () => {
+      (0, import_vitest9.it)("returns the post-block row, not the caller's lease", async () => {
         const s = `block-returns-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2643,7 +2644,7 @@ var runStoreTck = (options) => {
         ]);
         (0, import_vitest9.expect)(blocked).toHaveLength(0);
       });
-      (0, import_vitest9.it)("re-blocking an already-blocked stream is a no-op (#1263)", async () => {
+      (0, import_vitest9.it)("re-blocking an already-blocked stream is a no-op", async () => {
         const s = `block-twice-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2761,7 +2762,7 @@ var runStoreTck = (options) => {
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         (0, import_vitest9.expect)(leased.find((l) => l.stream === s)).toBeDefined();
       });
-      (0, import_vitest9.it)("exposes a future deferred_at via query_streams (#1221)", async () => {
+      (0, import_vitest9.it)("exposes a future deferred_at via query_streams", async () => {
         const deferred = `defer-qs-${uid()}`;
         const plain = `defer-qs-plain-${uid()}`;
         await store.subscribe([{ stream: deferred }, { stream: plain }]);
@@ -2816,7 +2817,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(await store.defer([`missing-${uid()}`], Date.now())).toBe(0);
         (0, import_vitest9.expect)(await store.defer([], Date.now())).toBe(0);
       });
-      (0, import_vitest9.it)("counts a duplicated stream name once (#1360)", async () => {
+      (0, import_vitest9.it)("counts a duplicated stream name once", async () => {
         const s = `defer-dup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2882,7 +2883,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(re.retry).toBe(0);
         await store.ack([{ ...re, at: 1e6 }]);
       });
-      (0, import_vitest9.it)("persists the lease's retry on a backoff-style due lease (#1262)", async () => {
+      (0, import_vitest9.it)("persists the lease's retry on a backoff-style due lease", async () => {
         const s = `ackdefer-retry-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2902,7 +2903,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(re.retry).toBe(4);
         await store.ack([{ ...re, at: 1e6 }]);
       });
-      (0, import_vitest9.it)("advances the watermark to `at` while persisting the schedule on a partial-progress due lease (#1278)", async () => {
+      (0, import_vitest9.it)("advances the watermark to `at` while persisting the schedule on a partial-progress due lease", async () => {
         const s = `ackadvance-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const [e1] = await store.commit(
@@ -2992,7 +2993,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(await store.reset([`missing-${uid()}`])).toBe(0);
         (0, import_vitest9.expect)(await store.reset([])).toBe(0);
       });
-      (0, import_vitest9.it)("counts a duplicated stream name once (#1360)", async () => {
+      (0, import_vitest9.it)("counts a duplicated stream name once", async () => {
         const s = `reset-dup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -3264,6 +3265,106 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(got1.priority).toBe(3);
         (0, import_vitest9.expect)(got2.priority).toBe(5);
       });
+      (0, import_vitest9.it)("matches a stream pattern", async () => {
+        const tag = uid();
+        await store.subscribe([
+          { stream: `pri-${tag}-proj-a` },
+          { stream: `pri-${tag}-proj-b` },
+          { stream: `pri-${tag}-audit-x` }
+        ]);
+        (0, import_vitest9.expect)(
+          await store.prioritize({ stream: `^pri-${tag}-proj-.*$` }, 3)
+        ).toBe(2);
+      });
+      (0, import_vitest9.it)("matches by source, skipping rows that have none", async () => {
+        const tag = uid();
+        await store.subscribe([
+          { stream: `pri-${tag}-t1`, source: `pri-src-${tag}-users` },
+          { stream: `pri-${tag}-t2`, source: `pri-src-${tag}-audit` },
+          { stream: `pri-${tag}-t3` }
+        ]);
+        (0, import_vitest9.expect)(
+          await store.prioritize(
+            { source: `pri-src-${tag}-users`, source_exact: true },
+            4
+          )
+        ).toBe(1);
+        (0, import_vitest9.expect)(
+          await store.prioritize({ source: `^pri-src-${tag}-.*$` }, 6)
+        ).toBe(2);
+      });
+      (0, import_vitest9.it)("matches by blocked state, both ways", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const tag = uid();
+          const src = `pri-src-${tag}`;
+          const ok = `pri-${tag}-ok`;
+          const bad = `pri-${tag}-bad`;
+          await fresh.commit(
+            src,
+            [inc(1)],
+            make_meta({ stream: src })
+          );
+          await fresh.subscribe([
+            { stream: ok, source: src },
+            { stream: bad, source: src }
+          ]);
+          await correlate(fresh);
+          const leases = await fresh.claim(2, 0, `w-${uid()}`, 5e3);
+          const lease = leases.find((l) => l.stream === bad);
+          await fresh.block([{ ...lease, error: "boom" }]);
+          const scope = `^pri-${tag}-.*$`;
+          (0, import_vitest9.expect)(
+            await fresh.prioritize({ stream: scope, blocked: true }, 9)
+          ).toBe(1);
+          (0, import_vitest9.expect)(
+            await fresh.prioritize({ stream: scope, blocked: false }, 9)
+          ).toBe(1);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+      (0, import_vitest9.it)("an empty filter updates every row, and skips rows already at the value", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const tag = uid();
+          await fresh.subscribe([
+            { stream: `pri-${tag}-a` },
+            { stream: `pri-${tag}-b`, priority: 5 }
+          ]);
+          (0, import_vitest9.expect)(await fresh.prioritize({}, 5)).toBe(1);
+          (0, import_vitest9.expect)(await fresh.prioritize({}, 5)).toBe(0);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+      (0, import_vitest9.it)("claim returns higher-priority streams first under tied watermarks", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const tag = uid();
+          const src = `pri-src-${tag}`;
+          await fresh.commit(
+            src,
+            [inc(1), inc(2)],
+            make_meta({ stream: src })
+          );
+          await fresh.subscribe([
+            { stream: `pri-${tag}-low`, source: src, priority: 0 },
+            { stream: `pri-${tag}-high`, source: src, priority: 5 }
+          ]);
+          await correlate(fresh);
+          const leases = await fresh.claim(1, 0, `w-${uid()}`, 5e3);
+          (0, import_vitest9.expect)(leases.map((l) => l.stream)).toEqual([`pri-${tag}-high`]);
+        } finally {
+          await fresh.dispose();
+        }
+      });
     });
     (0, import_vitest9.describe)("lanes", () => {
       (0, import_vitest9.it)("subscribe defaults lane to 'default' when omitted", async () => {
@@ -3477,7 +3578,7 @@ var runStoreTck = (options) => {
       });
     });
     (0, import_vitest9.describe)("long identifiers", () => {
-      (0, import_vitest9.it)("accepts a stream name well past 100 characters (#1420)", async () => {
+      (0, import_vitest9.it)("accepts a stream name well past 100 characters", async () => {
         const tag = uid();
         const long = `${tag}-${"x".repeat(140)}`;
         await store.commit(
@@ -3500,7 +3601,7 @@ var runStoreTck = (options) => {
       });
     });
     (0, import_vitest9.describe)("truncate", () => {
-      (0, import_vitest9.it)("leaves subscriptions untouched for restart and retire alike (#1527)", async () => {
+      (0, import_vitest9.it)("leaves subscriptions untouched for restart and retire alike", async () => {
         const tag = uid();
         const restarted = `trunc-restart-${tag}`;
         const retired = `trunc-retire-${tag}`;
@@ -3528,7 +3629,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(rows).toContain(restarted);
         (0, import_vitest9.expect)(rows).toContain(retired);
       });
-      (0, import_vitest9.it)("leaves a retired stream's surviving subscription unclaimable (#1527)", async () => {
+      (0, import_vitest9.it)("leaves a retired stream's surviving subscription unclaimable", async () => {
         const lane = `inert-lane-${uid()}`;
         const s = `trunc-inert-${uid()}`;
         const [e] = await store.commit(
@@ -3590,7 +3691,7 @@ var runStoreTck = (options) => {
         );
         (0, import_vitest9.expect)(remaining[0].data).toEqual({ count: 7 });
       });
-      (0, import_vitest9.it)("leaves exactly one seed when a stream is listed twice (#1677)", async () => {
+      (0, import_vitest9.it)("leaves exactly one seed when a stream is listed twice", async () => {
         const s = `trunc-dup-${uid()}`;
         await store.commit(
           s,
@@ -3612,7 +3713,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(remaining[0].data).toEqual({ count: 2 });
         (0, import_vitest9.expect)(result.get(s)?.deleted).toBe(1);
       });
-      (0, import_vitest9.it)("applies windowed targets before full ones (#1677)", async () => {
+      (0, import_vitest9.it)("applies windowed targets before full ones", async () => {
         const s = `trunc-mix-${uid()}`;
         await store.commit(
           s,
@@ -3816,7 +3917,7 @@ var runStoreTck = (options) => {
       });
     });
     (0, import_vitest9.describe)("query_streams", () => {
-      (0, import_vitest9.it)("keyset pagination visits every stream regardless of name case (#1375)", async () => {
+      (0, import_vitest9.it)("keyset pagination visits every stream regardless of name case", async () => {
         const tag = uid();
         const names = [
           `${tag}-Bravo`,
@@ -4011,7 +4112,7 @@ var runStoreTck = (options) => {
         });
         (0, import_vitest9.expect)(stats.size).toBe(0);
       });
-      (0, import_vitest9.it)("keyset pagination visits every stream regardless of name case (#1357)", async () => {
+      (0, import_vitest9.it)("keyset pagination visits every stream regardless of name case", async () => {
         const tag = uid();
         const names = [
           `${tag}-Bravo`,
@@ -4304,6 +4405,43 @@ var runStoreTck = (options) => {
         });
         (0, import_vitest9.expect)([...all.keys()].sort()).toEqual([...streams].sort());
       });
+      (0, import_vitest9.it)("pages the count and tail paths by limit + after too", async () => {
+        const tag = uid();
+        for (const s of [`qsc-${tag}-c`, `qsc-${tag}-a`, `qsc-${tag}-b`])
+          await store.commit(
+            s,
+            [inc(1), inc(2)],
+            make_meta({ stream: s })
+          );
+        const pattern = { stream: `qsc-${tag}-.*` };
+        const counted = await store.query_stats(pattern, {
+          count: true,
+          names: true,
+          limit: 2
+        });
+        (0, import_vitest9.expect)([...counted.keys()]).toEqual([`qsc-${tag}-a`, `qsc-${tag}-b`]);
+        (0, import_vitest9.expect)(counted.get(`qsc-${tag}-a`)?.count).toBe(2);
+        (0, import_vitest9.expect)(counted.get(`qsc-${tag}-a`)?.names).toEqual({ Incremented: 2 });
+        const counted2 = await store.query_stats(pattern, {
+          count: true,
+          limit: 2,
+          after: `qsc-${tag}-b`
+        });
+        (0, import_vitest9.expect)([...counted2.keys()]).toEqual([`qsc-${tag}-c`]);
+        const tailed = await store.query_stats(pattern, {
+          tail: true,
+          limit: 2
+        });
+        (0, import_vitest9.expect)([...tailed.keys()]).toEqual([`qsc-${tag}-a`, `qsc-${tag}-b`]);
+        (0, import_vitest9.expect)(tailed.get(`qsc-${tag}-a`)?.head.version).toBe(1);
+        (0, import_vitest9.expect)(tailed.get(`qsc-${tag}-a`)?.tail?.version).toBe(0);
+        const tailed2 = await store.query_stats(pattern, {
+          tail: true,
+          limit: 2,
+          after: `qsc-${tag}-b`
+        });
+        (0, import_vitest9.expect)([...tailed2.keys()]).toEqual([`qsc-${tag}-c`]);
+      });
     });
     import_vitest9.describe.skipIf(!caps.source_matches)(
       "query_streams source_matches (capability)",
@@ -4434,6 +4572,52 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(positions).toEqual([s]);
       });
     });
+    (0, import_vitest9.describe)("autoclose end-to-end", () => {
+      const Ticket = (0, import_act2.state)({ TckTicket: import_zod2.z.object({ open: import_zod2.z.boolean() }) }).init(() => ({ open: false })).emits({
+        TckTicketOpened: import_zod2.z.object({ title: import_zod2.z.string() }),
+        TckTicketResolved: import_zod2.z.object({})
+      }).patch({
+        TckTicketOpened: () => ({ open: true }),
+        TckTicketResolved: () => ({ open: false })
+      }).on({ OpenTckTicket: import_zod2.z.object({ title: import_zod2.z.string() }) }).emit((a) => ["TckTicketOpened", { title: a.title }]).on({ ResolveTckTicket: import_zod2.z.object({}) }).emit(() => ["TckTicketResolved", {}]).autocloses({ is: "TckTicketResolved" }).build();
+      const actor2 = { id: "tck", name: "tck" };
+      const run = async (resolve) => {
+        const fresh = await options.factory();
+        await fresh.drop();
+        await fresh.seed();
+        const cache = new import_act2.InMemoryCache();
+        const app = (0, import_act2.act)().withState(Ticket).build({ scoped: { store: fresh, cache } });
+        const truncated = [];
+        app.on("closed", (r) => truncated.push(...r.truncated.keys()));
+        const stream = `ac-${uid()}`;
+        try {
+          await app.do("OpenTckTicket", { stream, actor: actor2 }, { title: "a" });
+          if (resolve) await app.do("ResolveTckTicket", { stream, actor: actor2 }, {});
+          await app.correlate();
+          await app.drain();
+          const surviving = [];
+          await fresh.query((e) => surviving.push(String(e.name)), {
+            stream,
+            stream_exact: true
+          });
+          return { stream, truncated, surviving };
+        } finally {
+          await app.shutdown();
+          await cache.dispose();
+          await fresh.dispose();
+        }
+      };
+      (0, import_vitest9.it)("closes a stream whose head is the terminal event, leaving a tombstone", async () => {
+        const { stream, truncated, surviving } = await run(true);
+        (0, import_vitest9.expect)(truncated).toContain(stream);
+        (0, import_vitest9.expect)(surviving).toEqual([import_act2.TOMBSTONE_EVENT]);
+      });
+      (0, import_vitest9.it)("leaves a stream whose head is not the terminal event", async () => {
+        const { stream, truncated, surviving } = await run(false);
+        (0, import_vitest9.expect)(truncated).not.toContain(stream);
+        (0, import_vitest9.expect)(surviving).toEqual(["TckTicketOpened"]);
+      });
+    });
     (0, import_vitest9.describe)("seed_stream helper coverage", () => {
       (0, import_vitest9.it)("commits N events with monotonically increasing ids", async () => {
         const s = `seed-${uid()}`;
@@ -5072,7 +5256,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
         (0, import_vitest9.expect)(seen[0].data).toEqual({ amount: 1 });
       });
-      (0, import_vitest9.describe)("with_pii (#1675)", () => {
+      (0, import_vitest9.describe)("with_pii", () => {
         const seed_pii = async (s) => await store.commit(
           s,
           [
@@ -5136,7 +5320,7 @@ var runStoreTck = (options) => {
           for (const e of seen) (0, import_vitest9.expect)(e.pii ?? null).toBeNull();
         });
       });
-      (0, import_vitest9.it)("round-trips a Date losslessly in pii, like data/meta (#1365/#1370/#1556)", async () => {
+      (0, import_vitest9.it)("round-trips a Date losslessly in pii, like data/meta", async () => {
         const s = `pii-date-${uid()}`;
         const when = /* @__PURE__ */ new Date("2024-03-01T10:20:30.000Z");
         await store.commit(
@@ -5165,7 +5349,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(recovered(born)).toBe(when.getTime());
         (0, import_vitest9.expect)(typeof at).toBe(typeof born);
       });
-      (0, import_vitest9.it)("query_stats head/tail never carry pii \u2014 introspection surface is pii-safe (#1294)", async () => {
+      (0, import_vitest9.it)("query_stats head/tail never carry pii \u2014 introspection surface is pii-safe", async () => {
         const s = `pii-stats-${uid()}`;
         await store.commit(
           s,