@rotorsoft/act-tck 1.26.9 → 1.26.10

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

@@ -14,6 +14,32 @@ export type DifferentialStore = {
      */
     readonly factory: () => Store | Promise<Store>;
 };
+/**
+ * Known cross-adapter divergences the caller wants the differential to
+ * skip until the backing fix lands. Each flag suppresses exactly the
+ * assertions that a currently-filed bug makes red, so the differential
+ * stays green on master and the gate un-gates itself (delete the flag)
+ * when the fix merges. Every flag names its issue so the reason is
+ * auditable at the call site.
+ */
+export type DifferentialSkips = {
+    /**
+     * #1197 — SQLite `LIKE` is ASCII-case-insensitive, so a **mixed-case
+     * regex pattern** filter overmatches vs PG (`~`) / InMemory (`RegExp`),
+     * which are case-sensitive. Skips only the pattern-driven mixed-case
+     * assertions; exact-match (`stream_exact`) mixed-case still runs, since
+     * that path is case-exact on every adapter. Un-gate when #1197 lands.
+     */
+    readonly caseInsensitivePatterns?: boolean;
+    /**
+     * #1199 — `names: []` and falsy-zero `before`/`after: 0` guards differ
+     * across adapters (`names: []` → PG returns all, InMemory/SQLite return
+     * none; `before: 0` / `after: 0` are dropped by some adapters' truthy
+     * guards). Skips only those specific edge-input query assertions.
+     * Un-gate when #1199 lands.
+     */
+    readonly queryEdgeInputs?: boolean;
+};
 /**
  * Options for {@link runStoreDifferentialTck}.
  */
@@ -46,15 +72,36 @@ export type StoreDifferentialTckOptions = {
      * explores; fewer keep durable-adapter suites fast. Default `8`.
      */
     readonly runs?: number;
+    /**
+     * Whether the comparand adapters support the optional {@link Store.forget_pii}
+     * surface (and the `pii` field on commit). When `true`, the workload
+     * commits PII-bearing events and the differential asserts that
+     * `forget_pii` wipes them identically across adapters. All in-tree
+     * adapters implement it, so it defaults to `true`; a third-party store
+     * that opts out sets it `false`. Default `true`.
+     */
+    readonly piiIsolation?: boolean;
+    /**
+     * Known-divergence gates — see {@link DifferentialSkips}. Each flag
+     * suppresses the assertions a currently-filed bug makes red so the
+     * differential stays green until the fix merges. Default: nothing
+     * skipped.
+     */
+    readonly skip?: DifferentialSkips;
 };
 /**
- * Cross-adapter differential contract (#1030, fuzz workloads #1057).
+ * Cross-adapter differential contract (#1030, fuzz workloads #1057,
+ * lease/truncate/pii/query fuzz #1200).
  *
  * Adapters can drift in ways per-adapter cases don't catch — event
  * ordering, the `with_snaps` snapshot floor, the exact shape of
- * `query_stats` / `query_streams` output. This harness drives a **family
- * of randomized, seeded workloads** (commits, inline snapshots, truncates,
- * subscriptions) against every store in `options.stores`, then asserts
+ * `query_stats` / `query_streams` output, the lease lifecycle's effect on
+ * a stream's `retry`/`blocked`/`error`, windowed-truncate boundaries,
+ * `forget_pii` erasure, and query-option edge cases. This harness drives a
+ * **family of randomized, seeded workloads** — commits (some PII-bearing),
+ * inline + windowed truncates, subscriptions, and the full lease lifecycle
+ * (`claim` / `ack` / `defer` / `block` / `unblock` / `reset` /
+ * `prioritize`) — against every store in `options.stores`, then asserts
  * their **normalized** outputs are byte-for-byte identical for every
  * workload.
  *
@@ -65,10 +112,12 @@ export type StoreDifferentialTckOptions = {
  *
  * Normalization drops only the fields that legitimately differ between
  * stores (absolute event ids, `created` timestamps, correlation/causation
- * uuids) and keeps everything that defines correctness (stream, version,
- * name, data, and emission order). A one-adapter `with_snaps` regression —
- * the canonical failure mode — surfaces as a diff against the in-memory
- * reference, with the offending seed in the describe block.
+ * uuids, lease holder UUIDs, and wall-clock lease expiries) and keeps
+ * everything that defines correctness (stream, version, name, data,
+ * emission order, and the durable subscription state a lease op leaves
+ * behind: watermark, retry, blocked, error, priority, lane). Stream names
+ * carry mixed case so a case-insensitive pattern filter (#1197) surfaces as
+ * a diff.
  *
  * Wire it with the in-memory store as the reference and one or more
  * durable adapters as comparands:

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

@@ -1 +1 @@
-{"version":3,"file":"store-differential-tck.d.ts","sourceRoot":"","sources":["../../src/store-differential-tck.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAsB,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAYtE;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CAChD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAmLF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,2BAA2B,KACnC,IAwKF,CAAC"}
+{"version":3,"file":"store-differential-tck.d.ts","sourceRoot":"","sources":["../../src/store-differential-tck.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAKV,KAAK,EACN,MAAM,sBAAsB,CAAC;AAY9B;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CAChD,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACpC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC;CACnC,CAAC;AAgfF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,2BAA2B,KACnC,IA0RF,CAAC"}

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":"AAQA,OAAO,KAAK,EAQV,KAAK,EAEN,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;;;;;;;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;CACrD,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;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,eAAe,KAAG,IAykHtD,CAAC"}
+{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAQV,KAAK,EAEN,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;;;;;;;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;CACrD,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;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,eAAe,KAAG,IAurHtD,CAAC"}

package/dist/index.cjs

@@ -448,20 +448,28 @@ var mulberry322 = (seed) => {
   };
 };
 var normalize_event = (e) => ({
+  stream: e.stream,
+  version: e.version,
+  name: e.name,
+  data: e.data,
+  pii: e.pii != null
+});
+var normalize_identity = (e) => ({
   stream: e.stream,
   version: e.version,
   name: e.name,
   data: e.data
 });
-var build_plan = (seed, stream_count) => {
+var build_plan = (seed, stream_count, pii_isolation) => {
   const rng = mulberry322(seed);
   const tag = uid();
-  const event_prefix = `diff-${tag}-evt-`;
-  const sub_prefix = `diff-${tag}-sub-`;
+  const event_prefix = `Diff-${tag}-Evt-`;
+  const sub_prefix = `Diff-${tag}-Sub-`;
   const event_streams = Array.from(
     { length: stream_count },
-    (_, i) => `${event_prefix}${i}`
+    (_, i) => `${event_prefix}S${i}`
   );
+  const correlation = `corr-${tag}`;
   let type_cursor = 0;
   const next_msg = () => {
     const kind = type_cursor++ % 3;
@@ -470,65 +478,246 @@ var build_plan = (seed, stream_count) => {
   };
   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}`,
+  const lease_prefix = `Diff-${tag}-Src-`;
+  const lease_sources = event_streams.map((_, i) => `${lease_prefix}S${i}`);
+  const subs = lease_sources.map((source, i) => ({
+    stream: `${sub_prefix}S${i}`,
     source,
     lane: lanes[i % lanes.length],
     priority: i % 4
   }));
-  return { event_prefix, event_streams, sub_prefix, ops, subs };
+  const pick_sub = () => Math.floor(rng() * subs.length);
+  const ops = [];
+  const pii_stream = event_streams[0];
+  event_streams.forEach((stream, i) => {
+    ops.push({
+      t: "commit",
+      stream,
+      msgs: batch(),
+      pii: pii_isolation && i === 0 ? { email: `u-${tag}@example.com`, name: "Ursula" } : void 0
+    });
+  });
+  for (const src of lease_sources)
+    ops.push({ t: "commit", stream: src, msgs: [inc(1)] });
+  const middle = 12 + Math.floor(rng() * 20);
+  for (let i = 0; i < middle; i++) {
+    const kind = Math.floor(rng() * 10);
+    if (kind === 0) {
+      ops.push({ t: "commit", stream: pick_stream(), msgs: batch() });
+    } else if (kind === 1) {
+      ops.push({
+        t: "snapshot",
+        stream: pick_stream(),
+        count: Math.floor(rng() * 1e3)
+      });
+    } else if (kind === 2) {
+      ops.push({
+        t: "truncate",
+        stream: pick_stream(),
+        count: Math.floor(rng() * 1e3)
+      });
+    } else if (kind === 3) {
+      ops.push({
+        t: "truncate_windowed",
+        stream: pick_stream(),
+        max_id: rng() < 0.5
+      });
+    } else if (kind === 4) {
+      ops.push({ t: "claim", millis: 1e5 });
+    } else if (kind === 5) {
+      ops.push({ t: "ack", sub: pick_sub() });
+    } else if (kind === 6) {
+      ops.push({
+        t: "defer",
+        sub: pick_sub(),
+        due: 41024448e5 + Math.floor(rng() * 1e3)
+      });
+    } else if (kind === 7) {
+      ops.push({
+        t: "block",
+        sub: pick_sub(),
+        error: `boom-${Math.floor(rng() * 100)}`
+      });
+    } else if (kind === 8) {
+      ops.push({ t: "unblock", sub: pick_sub() });
+    } else {
+      if (rng() < 0.5) ops.push({ t: "reset_sub", sub: pick_sub() });
+      else
+        ops.push({
+          t: "prioritize",
+          sub: pick_sub(),
+          priority: Math.floor(rng() * 10)
+        });
+    }
+  }
+  const filter_name = "Incremented";
+  for (const stream of event_streams)
+    ops.push({ t: "commit", stream, msgs: [inc(1)] });
+  const query_cases = [
+    {
+      label: "names filter (single event name)",
+      query: { stream: `^${event_prefix}`, names: [filter_name] }
+    },
+    {
+      label: "correlation filter",
+      query: { stream: `^${event_prefix}`, correlation }
+    },
+    {
+      label: "limit bound",
+      query: { stream: `^${event_prefix}`, limit: 3 }
+    },
+    {
+      label: "backward + limit",
+      query: { stream: `^${event_prefix}`, backward: true, limit: 4 }
+    },
+    // Absolute `id` bounds (`after`/`before` with positive ids) are
+    // deliberately absent: event ids are the canonical "legitimately
+    // differs between adapters" field (see `normalize_event`), and full
+    // truncates renumber them differently per store, so a positive id
+    // bound selects a different absolute window on each adapter. The
+    // gated falsy-zero cases below compare only the *guard* behavior
+    // (filter applied → subset, vs filter dropped → all), which stays a
+    // well-defined divergence regardless of the concrete id values.
+    // #1199 edge inputs — opposite semantics across adapters today.
+    {
+      label: "empty names filter",
+      query: { stream: `^${event_prefix}`, names: [] },
+      gated: "queryEdgeInputs"
+    },
+    {
+      label: "before: 0 (falsy-zero guard)",
+      query: { stream: `^${event_prefix}`, before: 0 },
+      gated: "queryEdgeInputs"
+    },
+    {
+      label: "backward + after: 0 (falsy-zero guard)",
+      query: { stream: `^${event_prefix}`, backward: true, after: 0 },
+      gated: "queryEdgeInputs"
+    }
+  ];
+  return {
+    event_prefix,
+    event_streams,
+    sub_prefix,
+    ops,
+    subs,
+    correlation,
+    pii_stream,
+    query_cases,
+    filter_name
+  };
 };
-var apply_plan = async (store, plan) => {
+var apply_plan = async (store, plan, pii_isolation) => {
+  await store.subscribe(
+    plan.subs.map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      lane: s.lane,
+      priority: s.priority
+    }))
+  );
+  const held = /* @__PURE__ */ new Map();
+  const owned = new Set(plan.subs.map((s) => s.stream));
   for (const op of plan.ops) {
     if (op.t === "commit") {
+      const msgs = op.pii && pii_isolation ? op.msgs.map((m, i) => i === 0 ? { ...m, pii: op.pii } : m) : op.msgs;
       await store.commit(
         op.stream,
-        op.msgs,
-        make_meta({ stream: op.stream })
+        msgs,
+        make_meta({ stream: op.stream, correlation: plan.correlation })
       );
     } else if (op.t === "snapshot") {
       await store.commit(
         op.stream,
         [{ name: import_act.SNAP_EVENT, data: { count: op.count } }],
-        make_meta({ stream: op.stream })
+        make_meta({ stream: op.stream, correlation: plan.correlation })
       );
-    } else {
+    } else if (op.t === "truncate") {
       await store.truncate([
         { stream: op.stream, snapshot: { count: op.count } }
       ]);
+    } else if (op.t === "truncate_windowed") {
+      await store.commit(
+        op.stream,
+        [{ name: import_act.SNAP_EVENT, data: { count: 1 } }],
+        make_meta({ stream: op.stream, correlation: plan.correlation })
+      );
+      await store.truncate([
+        {
+          stream: op.stream,
+          before: new Date(Date.now() + 6e4),
+          // A wide cap that still fits a 32-bit event-id column, so it
+          // never excludes the boundary snapshot on any adapter.
+          ...op.max_id ? { max_id: 2147483647 } : {}
+        }
+      ]);
+    } else if (op.t === "claim") {
+      const by = uid();
+      const leased = await store.claim(1e5, 1e5, by, op.millis);
+      for (const l of leased) if (owned.has(l.stream)) held.set(l.stream, by);
+    } else if (op.t === "ack") {
+      const stream = plan.subs[op.sub].stream;
+      const by = held.get(stream);
+      if (by) {
+        await store.ack([{ stream, at: 0, by, retry: 0, lagging: true }]);
+        held.delete(stream);
+      }
+    } else if (op.t === "defer") {
+      const stream = plan.subs[op.sub].stream;
+      const by = held.get(stream);
+      if (by) {
+        const lease = {
+          stream,
+          at: 0,
+          by,
+          retry: 0,
+          lagging: true,
+          due: op.due
+        };
+        await store.ack([lease]);
+        held.delete(stream);
+      }
+    } else if (op.t === "block") {
+      const stream = plan.subs[op.sub].stream;
+      const by = held.get(stream);
+      if (by) {
+        const lease = {
+          stream,
+          at: 0,
+          by,
+          retry: 0,
+          lagging: true,
+          error: op.error
+        };
+        await store.block([lease]);
+        held.delete(stream);
+      }
+    } else if (op.t === "unblock") {
+      const stream = plan.subs[op.sub].stream;
+      await store.unblock([stream]);
+      held.delete(stream);
+    } else if (op.t === "reset_sub") {
+      const stream = plan.subs[op.sub].stream;
+      await store.reset([stream]);
+      held.delete(stream);
+    } else {
+      await store.prioritize(
+        { stream: plan.subs[op.sub].stream, stream_exact: true },
+        op.priority
+      );
     }
   }
-  await store.subscribe(
-    plan.subs.map((s) => ({
-      stream: s.stream,
-      source: s.source,
-      lane: s.lane,
-      priority: s.priority
-    }))
-  );
 };
 var runStoreDifferentialTck = (options) => {
   (0, import_vitest6.describe)(`TCK / Store differential / ${options.name}`, () => {
     const base_seed = options.seed ?? 2759;
     const stream_count = options.streams ?? 4;
+    const pii_isolation = options.piiIsolation ?? true;
+    const skip = { ...options.skip };
     const plans = Array.from(
       { length: options.runs ?? 8 },
-      (_, r) => build_plan(base_seed + r, stream_count)
+      (_, r) => build_plan(base_seed + r, stream_count, pii_isolation)
     );
     const live = [];
     (0, import_vitest6.beforeAll)(async () => {
@@ -536,7 +725,7 @@ var runStoreDifferentialTck = (options) => {
         const store = await spec.factory();
         await store.drop();
         await store.seed();
-        for (const plan of plans) await apply_plan(store, plan);
+        for (const plan of plans) await apply_plan(store, plan, pii_isolation);
         live.push({ name: spec.name, store });
       }
     });
@@ -600,6 +789,21 @@ var runStoreDifferentialTck = (options) => {
             return by_stream;
           });
         });
+        plan.query_cases.forEach((qc) => {
+          const gated = qc.gated && skip[qc.gated];
+          import_vitest6.it.skipIf(gated)(
+            `yields identical events under ${qc.label}`,
+            async () => {
+              await assert_identical(`query / ${qc.label}`, async (store) => {
+                const out = [];
+                await store.query((e) => {
+                  out.push(normalize_event(e));
+                }, qc.query);
+                return out;
+              });
+            }
+          );
+        });
         (0, import_vitest6.it)("yields identical query_stats output (head/tail/count/names)", async () => {
           await assert_identical("query_stats", async (store) => {
             const stats = await store.query_stats(
@@ -610,8 +814,8 @@ var runStoreDifferentialTck = (options) => {
             const content = {};
             for (const [stream, s] of stats) {
               content[stream] = {
-                head: normalize_event(s.head),
-                tail: normalize_event(
+                head: normalize_identity(s.head),
+                tail: normalize_identity(
                   s.tail
                 ),
                 count: s.count,
@@ -621,7 +825,7 @@ var runStoreDifferentialTck = (options) => {
             return { keys, content };
           });
         });
-        (0, import_vitest6.it)("yields identical query_streams output", async () => {
+        (0, import_vitest6.it)("yields identical query_streams output (incl. lease-lifecycle state)", async () => {
           await assert_identical("query_streams", async (store) => {
             const rows = [];
             const { count } = await store.query_streams(
@@ -632,7 +836,10 @@ var runStoreDifferentialTck = (options) => {
                   at: p.at,
                   blocked: p.blocked,
                   priority: p.priority,
-                  lane: p.lane
+                  lane: p.lane,
+                  retry: p.retry,
+                  error: p.error,
+                  leased: p.leased_by != null
                 });
               },
               { stream: `^${plan.sub_prefix}`, limit: 1e3 }
@@ -641,6 +848,60 @@ var runStoreDifferentialTck = (options) => {
             return { count, rows };
           });
         });
+        import_vitest6.it.skipIf(skip.caseInsensitivePatterns)(
+          "matches case-sensitively under a lower-cased pattern filter",
+          async () => {
+            await assert_identical(
+              "query_streams lower-cased pattern",
+              async (store) => {
+                const collect_streams = async (pattern) => {
+                  const streams = [];
+                  await store.query_streams(
+                    (p) => {
+                      streams.push(p.stream);
+                    },
+                    { stream: pattern, limit: 1e3 }
+                  );
+                  streams.sort((a, b) => a.localeCompare(b));
+                  return streams;
+                };
+                const matched = await collect_streams(`^${plan.sub_prefix}S`);
+                const lowered = await collect_streams(
+                  `^${plan.sub_prefix.toLowerCase()}s`
+                );
+                return { matched, lowered };
+              }
+            );
+          }
+        );
+        (0, import_vitest6.it)("yields identical events under an exact mixed-case stream lookup", async () => {
+          await assert_identical("query exact mixed-case", async (store) => {
+            const out = [];
+            await store.query(
+              (e) => {
+                out.push(normalize_event(e));
+              },
+              { stream: plan.event_streams[0], stream_exact: true }
+            );
+            return out;
+          });
+        });
+        import_vitest6.it.skipIf(!pii_isolation)(
+          "erases pii identically via forget_pii",
+          async () => {
+            await assert_identical("forget_pii erase", async (store) => {
+              const erased = await store.forget_pii(plan.pii_stream);
+              const after = [];
+              await store.query(
+                (e) => {
+                  after.push(normalize_event(e));
+                },
+                { stream: plan.pii_stream, stream_exact: true }
+              );
+              return { erased, after };
+            });
+          }
+        );
       });
     });
   });
@@ -1054,6 +1315,54 @@ var runStoreTck = (options) => {
           committed.slice(0, -1).map((c) => c.id)
         );
       });
+      (0, import_vitest9.it)("names:[] matches no events", async () => {
+        const s = `q-names-empty-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1), dec(1)],
+          make_meta({ stream: s })
+        );
+        const none = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          names: []
+        });
+        (0, import_vitest9.expect)(none).toHaveLength(0);
+        const all = await collect(store, { stream: s, stream_exact: true });
+        (0, import_vitest9.expect)(all).toHaveLength(2);
+      });
+      (0, import_vitest9.it)("after:0 and before:0 are honored as id bounds", async () => {
+        const s = `q-zero-bound-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1), inc(2), inc(3)],
+          make_meta({ stream: s })
+        );
+        (0, import_vitest9.expect)(
+          await collect(store, { stream: s, stream_exact: true, before: 0 })
+        ).toHaveLength(0);
+        (0, import_vitest9.expect)(
+          await collect(store, {
+            stream: s,
+            stream_exact: true,
+            before: 0,
+            backward: true
+          })
+        ).toHaveLength(0);
+        const forward = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          after: 0
+        });
+        (0, import_vitest9.expect)(forward.every((e) => e.id > 0)).toBe(true);
+        const backward = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          after: 0,
+          backward: true
+        });
+        (0, import_vitest9.expect)(backward.every((e) => e.id > 0)).toBe(true);
+      });
       (0, import_vitest9.it)("created_after/created_before filter by timestamp", async () => {
         const s = `q-ts-${uid()}`;
         const committed = await store.commit(
@@ -1292,6 +1601,34 @@ var runStoreTck = (options) => {
         if (error !== void 0) (0, import_vitest9.expect)(error).toBeInstanceOf(import_act2.ValidationError);
         else (0, import_vitest9.expect)(count).toBe(1);
       });
+      (0, import_vitest9.it)("stream filters match case-sensitively (query)", async () => {
+        const tag = uid();
+        const lower = `order-${tag}`;
+        const upper = `Order-${tag}`;
+        await seed_streams([lower, upper]);
+        (0, import_vitest9.expect)(await streams_matching(`^order-${tag}`)).toEqual([lower]);
+        (0, import_vitest9.expect)(await streams_matching(`^Order-${tag}$`)).toEqual([upper]);
+        (0, import_vitest9.expect)(await streams_matching(`order-${tag}`)).toEqual([lower]);
+      });
+      (0, import_vitest9.it)("stream filters match case-sensitively (position filters)", async () => {
+        const tag = uid();
+        const lower = `csp-order-${tag}`;
+        const upper = `csp-Order-${tag}`;
+        await store.subscribe([{ stream: lower }, { stream: upper }]);
+        const got = [];
+        await store.query_streams((p) => got.push(p.stream), {
+          stream: `^csp-order-${tag}`
+        });
+        (0, import_vitest9.expect)(got).toEqual([lower]);
+      });
+      (0, import_vitest9.it)("bulk stream ops match case-sensitively", async () => {
+        const tag = uid();
+        const lower = `bcs-order-${tag}`;
+        const upper = `bcs-Order-${tag}`;
+        await store.subscribe([{ stream: lower }, { stream: upper }]);
+        const count = await store.reset({ stream: `^bcs-order-${tag}` });
+        (0, import_vitest9.expect)(count).toBe(1);
+      });
     });
     (0, import_vitest9.describe)("subscribe + claim + ack", () => {
       (0, import_vitest9.it)("subscribes new streams and is idempotent on repeat", async () => {