@rotorsoft/act-tck 1.39.1 → 1.40.0

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

@@ -46,8 +46,7 @@ export type CacheDifferentialTckOptions = {
     readonly runs?: number;
 };
 /**
- * Cross-implementation differential contract for the {@link Cache} port
- * (#1057).
+ * Cross-implementation differential contract for the {@link Cache} port.
  *
  * Where {@link runCacheTck} pins each method's contract against a single
  * implementation, this harness drives a **family of randomized, seeded

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

@@ -1 +1 @@
-{"version":3,"file":"cache-differential-tck.d.ts","sourceRoot":"","sources":["../../src/cache-differential-tck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,sBAAsB,CAAC;AAI9D;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;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;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA8FF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,uBAAuB,YACzB,2BAA2B,KACnC,IAsCF,CAAC"}
+{"version":3,"file":"cache-differential-tck.d.ts","sourceRoot":"","sources":["../../src/cache-differential-tck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,sBAAsB,CAAC;AAI9D;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;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;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA8FF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,uBAAuB,YACzB,2BAA2B,KACnC,IAsCF,CAAC"}

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

@@ -29,8 +29,7 @@ export type LoggerDifferentialTckOptions = {
     readonly loggers: ReadonlyArray<DifferentialLogger>;
 };
 /**
- * Cross-implementation differential contract for the {@link Logger} port
- * (#1057).
+ * Cross-implementation differential contract for the {@link Logger} port.
  *
  * A logger has no portable return value to byte-compare — its output
  * format is adapter-specific by design, which is exactly why

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

@@ -1 +1 @@
-{"version":3,"file":"logger-differential-tck.d.ts","sourceRoot":"","sources":["../../src/logger-differential-tck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;CACrD,CAAC;AAwDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,wBAAwB,YAC1B,4BAA4B,KACpC,IA+BF,CAAC"}
+{"version":3,"file":"logger-differential-tck.d.ts","sourceRoot":"","sources":["../../src/logger-differential-tck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;CACrD,CAAC;AAwDF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,wBAAwB,YAC1B,4BAA4B,KACpC,IA+BF,CAAC"}

package/dist/@types/stability-tck.d.ts

@@ -4,7 +4,8 @@
  * @property name - Display name for the snapshot suite (e.g., the package
  *   name). Used as the `describe` block label so failing snapshots are
  *   attributable at a glance.
- * @property entryPoints - Map of subpath → entry source file. The TCK
+ * @property entryPoints - Map of subpath → entry file, either source
+ *   (`.ts`) or a published declaration (`.d.ts`). The TCK
  *   reads each entry, follows its relative re-exports recursively, and
  *   snapshots the resulting surface text. Empty-string subpaths label
  *   the root entry; everything else is rendered with its key (e.g.
@@ -15,8 +16,8 @@ export type StabilityTckOptions = {
     readonly entryPoints: Readonly<Record<string, string>>;
 };
 /**
- * Snapshot-based public-API stability check. Walks each entry's source
- * file plus everything it re-exports through relative imports, and
+ * Snapshot-based public-API stability check. Walks each entry file plus
+ * everything it re-exports through relative imports, and
  * compares the concatenated text against a committed Vitest snapshot.
  *
  * Catches accidental rename / removal / signature drift on the public
@@ -24,9 +25,13 @@ export type StabilityTckOptions = {
  * shows up as a snapshot diff in the PR; reviewers either accept the
  * change (update the snapshot deliberately) or push back.
  *
- * The TCK reads source (`.ts`) rather than built declarations so it
- * doesn't need a prior `pnpm build`. It follows `from "./relative.js"`
- * re-exports transitively; non-relative paths (other packages, `node:`)
+ * Point it at the built declarations (`.d.ts`) to record the surface
+ * alone: a change to implementation then leaves the snapshot alone, and
+ * doc comments still show. That needs a build first. Point it at source
+ * (`.ts`) to skip the build, at the cost of a snapshot that also moves
+ * with every implementation change. It follows `from "./relative.js"`
+ * re-exports transitively, to `.d.ts` from a declaration and to `.ts`
+ * from source; non-relative paths (other packages, `node:`)
  * stop the walk — drift in another package's surface is that package's
  * stability TCK to catch.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"stability-tck.d.ts","sourceRoot":"","sources":["../../src/stability-tck.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAUlE"}
+{"version":3,"file":"stability-tck.d.ts","sourceRoot":"","sources":["../../src/stability-tck.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAUlE"}

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

@@ -24,19 +24,19 @@ export type DifferentialStore = {
  */
 export type DifferentialSkips = {
     /**
-     * #1197 — SQLite `LIKE` is ASCII-case-insensitive, so a **mixed-case
+     * 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.
+     * that path is case-exact on every adapter. No in-tree adapter sets it.
      */
     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.
+     * Skips the edge-input query assertions: `names: []` and the falsy-zero
+     * `before: 0` / `after: 0` bounds. The in-tree adapters agree on the
+     * guards, but `after: 0` is an absolute id bound and stores number events
+     * from different origins (InMemory from 0, Postgres from 1), so the
+     * Postgres differential still sets it.
      */
     readonly queryEdgeInputs?: boolean;
 };
@@ -90,8 +90,8 @@ export type StoreDifferentialTckOptions = {
     readonly skip?: DifferentialSkips;
 };
 /**
- * Cross-adapter differential contract (#1030, fuzz workloads #1057,
- * lease/truncate/pii/query fuzz #1200).
+ * Cross-adapter differential contract: seeded fuzz workloads over commits,
+ * leases, truncates, pii and queries.
  *
  * Adapters can drift in ways per-adapter cases don't catch — event
  * ordering, the `with_snaps` snapshot floor, the exact shape of
@@ -116,7 +116,7 @@ export type StoreDifferentialTckOptions = {
  * 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
+ * carry mixed case so a case-insensitive pattern filter surfaces as
  * a diff.
  *
  * Wire it with the in-memory store as the reference and one or more

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

@@ -3,7 +3,7 @@ import type { Store } from "@rotorsoft/act/types";
  * Property-based contract for the store-level invariants the drain pipeline
  * depends on — commit version monotonicity, claim/lease no-leak, watermark
  * monotonicity, and block exclusion. These ran only against `InMemoryStore`
- * before ACT-982; running them against the durable adapters too is the only
+ * at first; running them against the durable adapters too is the only
  * way to catch a divergence the example-based TCK cases miss.
  *
  * Each predicate resets the store (`drop` + `seed`) so randomized runs are

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

@@ -28,17 +28,17 @@ export type StoreCapabilities = {
     readonly restore?: boolean;
     /**
      * Adapter honours `subscribe`'s optional `correlator` argument and answers
-     * `correlating` (#1532). When `true`, the TCK runs the correlation-lease
+     * `correlating`. When `true`, the TCK runs the correlation-lease
      * suite — exclusive acquisition, renewal by the same holder, re-acquisition
      * after expiry, per-key independence, and the keyed checkpoint.
      *
      * Optional because a store that ignores the argument simply lets every
-     * worker scan, which is the pre-#1532 behaviour and remains correct: the
+     * worker scan, which is how every worker scanned before keyed checkpoints, and remains correct: the
      * marks are idempotent, so the duplication is waste rather than error.
      */
     readonly lease_correlation?: boolean;
     /**
-     * Adapter supports sensitive-data isolation (#566): accepts the
+     * Adapter supports sensitive-data isolation: accepts the
      * optional `pii` field on commit messages, returns it on load
      * outputs, and implements {@link Store.forget_pii}. When `true`,
      * the TCK runs the PII isolation suite — commit-with-pii
@@ -87,8 +87,8 @@ export type StoreCapabilities = {
      */
     readonly rejects_nonportable_claim_source?: boolean;
     /**
-     * Adapter honors the {@link SubscribeInput.correlated_at} **work mark**
-     * (#1485): `subscribe` applies it as `GREATEST(correlated_at, N)` and
+     * Adapter honors the {@link SubscribeInput.correlated_at} **work mark**:
+     * `subscribe` applies it as `GREATEST(correlated_at, N)` and
      * `claim` serves a marked stream from the subscription row alone
      * (`at < correlated_at`) instead of probing the event log. When `true`,
      * the TCK runs the work-set suite — mark-then-claim, monotonicity
@@ -97,7 +97,7 @@ export type StoreCapabilities = {
      * surfaces (`reset`, `unblock`, `defer`, `prioritize`) leaving the mark
      * intact.
      *
-     * @deprecated Ignored since #1488 — the mark is the only eligibility
+     * @deprecated Ignored: the mark is the only eligibility
      * rule, so this suite always runs. The field is kept so an adapter that
      * still passes `work_set: true` keeps compiling.
      */
@@ -133,7 +133,7 @@ export type StoreTckOptions = {
      *    second commit that advances the version.
      * 3. ~~Construction succeeds, `commit` reports success, and the data
      *    is not there.~~ This is the shape the suite exists to catch
-     *    (#1443: a zero-config SQLite store defaulted to a per-connection
+     *    (a zero-config SQLite store once defaulted to a per-connection
      *    private in-memory database, so `seed`'s DDL landed where later
      *    statements could not see it — every write was accepted and lost).
      *

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":"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;;;;;;;OAOG;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,IA8/KtD,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;;;;;;;OAOG;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,IAmiLtD,CAAC"}

package/dist/index.cjs

@@ -418,8 +418,9 @@ async function load_surface(entry2) {
     const content = await import_node_fs.promises.readFile(abs, "utf8");
     visited.set(abs, content);
     const re_export = /^\s*export\b[^"';]*\bfrom\s+["'](\.[^"']+)["']/gm;
+    const ext = abs.endsWith(".d.ts") ? ".d.ts" : ".ts";
     for (const m of content.matchAll(re_export)) {
-      const rel = m[1].replace(/\.js$/, ".ts");
+      const rel = m[1].replace(/\.js$/, ext);
       const target = import_node_path.default.resolve(import_node_path.default.dirname(abs), rel);
       await walk(target);
     }
@@ -601,7 +602,7 @@ var build_plan = (seed, stream_count, pii_isolation) => {
     // 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.
+    // Edge inputs, gated behind `queryEdgeInputs`.
     {
       label: "empty names filter",
       query: { stream: `^${event_prefix}`, names: [] },
@@ -1342,6 +1343,19 @@ var runStoreTck = (options) => {
         });
         (0, import_vitest9.expect)(limited).toHaveLength(2);
       });
+      (0, import_vitest9.it)("excludes snapshots when called with no query object", async () => {
+        const s = `q-nofilter-${uid()}`;
+        await store.commit(
+          s,
+          [{ name: import_act2.SNAP_EVENT, data: { count: 0 } }],
+          make_meta({ stream: s })
+        );
+        const names = [];
+        await store.query((e) => {
+          names.push(e.name);
+        });
+        (0, import_vitest9.expect)(names).not.toContain(import_act2.SNAP_EVENT);
+      });
       (0, import_vitest9.it)("with_snaps resumes from the latest snapshot per stream", async () => {
         const s = `q-snap-${uid()}`;
         await store.commit(
@@ -3794,6 +3808,25 @@ var runStoreTck = (options) => {
           ]);
           (0, import_vitest9.expect)(remaining[0].id).toBe(snap_b.id);
         });
+        (0, import_vitest9.it)("prunes two windowed targets for one stream in call order", async () => {
+          const later = `trunc-win-twice-${uid()}`;
+          const a1 = await seed_windowed(later);
+          const before = new Date(Date.now() + 6e4);
+          const first = await store.truncate([
+            { stream: later, before, max_id: a1.snap_b.id },
+            { stream: later, before, max_id: a1.snap_a.id }
+          ]);
+          (0, import_vitest9.expect)(first.get(later)?.deleted).toBe(4);
+          (0, import_vitest9.expect)(first.get(later)?.committed.id).toBe(a1.snap_b.id);
+          const earlier = `trunc-win-twice-${uid()}`;
+          const a2 = await seed_windowed(earlier);
+          const second = await store.truncate([
+            { stream: earlier, before, max_id: a2.snap_a.id },
+            { stream: earlier, before, max_id: a2.snap_b.id }
+          ]);
+          (0, import_vitest9.expect)(second.get(earlier)?.deleted).toBe(2);
+          (0, import_vitest9.expect)(second.get(earlier)?.committed.id).toBe(a2.snap_b.id);
+        });
         (0, import_vitest9.it)("honors the max_id cap \u2014 boundary never rises past a lagging consumer", async () => {
           const s = `trunc-win-cap-${uid()}`;
           const { snap_a, snap_b } = await seed_windowed(s);