@rotorsoft/act-tck 1.34.4 → 1.36.0

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

@@ -17,6 +17,18 @@ export type StorePropertyTckOptions = {
     factory: () => Store | Promise<Store>;
     /** fast-check runs per property. Default 100; lower for durable adapters. */
     numRuns?: number;
+    /**
+     * Per-property timeout in milliseconds. Default 5000, matching vitest.
+     *
+     * Every run of a property is a full reset plus a dozen or more round
+     * trips, so against a real database the wall time is dominated by I/O and
+     * by whatever else the machine is doing. Vitest's default is comfortable
+     * in isolation and not under a parallel suite sharing one server, which
+     * showed up as this file intermittently timing out rather than failing an
+     * assertion. Durable adapters should raise it; the in-memory store has no
+     * reason to.
+     */
+    timeoutMs?: number;
 };
 export declare const runStorePropertyTck: (options: StorePropertyTckOptions) => void;
 //# sourceMappingURL=store-property-tck.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"store-property-tck.d.ts","sourceRoot":"","sources":["../../src/store-property-tck.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAwClD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACtC,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAkBF,eAAO,MAAM,mBAAmB,YAAa,uBAAuB,KAAG,IAgNtE,CAAC"}
+{"version":3,"file":"store-property-tck.d.ts","sourceRoot":"","sources":["../../src/store-property-tck.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAwClD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACtC,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAkBF,eAAO,MAAM,mBAAmB,YAAa,uBAAuB,KAAG,IAyNtE,CAAC"}

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

@@ -26,6 +26,17 @@ export type StoreCapabilities = {
      * rollback on mid-iteration throw.
      */
     readonly restore?: boolean;
+    /**
+     * Adapter honours `subscribe`'s optional `correlator` argument and answers
+     * `correlating` (#1532). 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
+     * marks are idempotent, so the duplication is waste rather than error.
+     */
+    readonly lease_correlation?: boolean;
     /**
      * Adapter supports sensitive-data isolation (#566): accepts the
      * optional `pii` field on commit messages, returns it on load

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,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;;;;;;;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,IA0qJtD,CAAC"}
+{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAQA,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,IAg2JtD,CAAC"}

package/dist/index.cjs

@@ -962,6 +962,7 @@ var opArb = import_vitest7.fc.oneof(
 var events = (count) => Array.from({ length: count }, () => inc(1));
 var runStorePropertyTck = (options) => {
   const numRuns = options.numRuns ?? 100;
+  const timeout = options.timeoutMs ?? 5e3;
   (0, import_vitest8.describe)(`TCK / Store properties / ${options.name}`, () => {
     let store;
     (0, import_vitest8.beforeAll)(async () => {
@@ -1001,7 +1002,8 @@ var runStorePropertyTck = (options) => {
               (0, import_vitest8.expect)(e.version).toBe(i);
             });
           }
-        }
+        },
+        timeout
       );
       import_vitest7.test.prop([import_vitest7.fc.array(commitArb, { minLength: 1, maxLength: 20 })], {
         numRuns
@@ -1028,7 +1030,8 @@ var runStorePropertyTck = (options) => {
           ).rejects.toThrow();
           const after = await collect(store, { stream, stream_exact: true });
           (0, import_vitest8.expect)(after.length).toBe(before.length);
-        }
+        },
+        timeout
       );
     });
     (0, import_vitest8.describe)("claim/lease lifecycle invariants", () => {
@@ -1075,7 +1078,8 @@ var runStorePropertyTck = (options) => {
             }
           }
           (0, import_vitest8.expect)(totalResolved + pending.length).toBe(totalClaims);
-        }
+        },
+        timeout
       );
       import_vitest7.test.prop(
         [
@@ -1118,35 +1122,40 @@ var runStorePropertyTck = (options) => {
               watermark1.get(lease.stream)
             );
           }
-        }
+        },
+        timeout
       );
       import_vitest7.test.prop([import_vitest7.fc.array(claimStreamArb, { minLength: 1, maxLength: 5 })], {
         numRuns
-      })("blocked streams cannot be claimed again", async (commits) => {
-        await reset2();
-        const streams = [...new Set(commits)];
-        await store.subscribe(streams.map((stream) => ({ stream })));
-        for (const stream of commits) {
+      })(
+        "blocked streams cannot be claimed again",
+        async (commits) => {
+          await reset2();
+          const streams = [...new Set(commits)];
+          await store.subscribe(streams.map((stream) => ({ stream })));
+          for (const stream of commits) {
+            await store.commit(
+              stream,
+              [inc(1)],
+              make_meta({ stream })
+            );
+          }
+          await mark_all2(store);
+          const claimed = await store.claim(10, 10, "worker", 6e4);
+          await store.block(claimed.map((l) => ({ ...l, error: "test" })));
+          const blockedSet = new Set(claimed.map((l) => l.stream));
+          await store.subscribe([{ stream: "ctrl" }]);
           await store.commit(
-            stream,
+            "ctrl",
             [inc(1)],
-            make_meta({ stream })
+            make_meta({ stream: "ctrl" })
           );
-        }
-        await mark_all2(store);
-        const claimed = await store.claim(10, 10, "worker", 6e4);
-        await store.block(claimed.map((l) => ({ ...l, error: "test" })));
-        const blockedSet = new Set(claimed.map((l) => l.stream));
-        await store.subscribe([{ stream: "ctrl" }]);
-        await store.commit(
-          "ctrl",
-          [inc(1)],
-          make_meta({ stream: "ctrl" })
-        );
-        await mark_all2(store);
-        const reclaim = await store.claim(10, 10, "worker2", 6e4);
-        for (const l of reclaim) (0, import_vitest8.expect)(blockedSet.has(l.stream)).toBe(false);
-      });
+          await mark_all2(store);
+          const reclaim = await store.claim(10, 10, "worker2", 6e4);
+          for (const l of reclaim) (0, import_vitest8.expect)(blockedSet.has(l.stream)).toBe(false);
+        },
+        timeout
+      );
     });
   });
 };
@@ -3342,7 +3351,7 @@ var runStoreTck = (options) => {
       });
     });
     (0, import_vitest9.describe)("truncate", () => {
-      (0, import_vitest9.it)("keeps the subscription row for a restart target, drops it for a retire (#1398)", async () => {
+      (0, import_vitest9.it)("leaves subscriptions untouched for restart and retire alike (#1527)", async () => {
         const tag = uid();
         const restarted = `trunc-restart-${tag}`;
         const retired = `trunc-retire-${tag}`;
@@ -3368,7 +3377,24 @@ var runStoreTck = (options) => {
           limit: 100
         });
         (0, import_vitest9.expect)(rows).toContain(restarted);
-        (0, import_vitest9.expect)(rows).not.toContain(retired);
+        (0, import_vitest9.expect)(rows).toContain(retired);
+      });
+      (0, import_vitest9.it)("leaves a retired stream's surviving subscription unclaimable (#1527)", async () => {
+        const lane = `inert-lane-${uid()}`;
+        const s = `trunc-inert-${uid()}`;
+        const [e] = await store.commit(
+          s,
+          [inc(1)],
+          make_meta({ stream: s })
+        );
+        await store.subscribe([{ stream: s, correlated_at: e.id, lane }]);
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e4, lane);
+        (0, import_vitest9.expect)(leased).toHaveLength(1);
+        await store.ack([{ ...leased[0], at: e.id }]);
+        await store.truncate([{ stream: s, meta: make_meta({ stream: s }) }]);
+        (0, import_vitest9.expect)(
+          await store.claim(100, 0, `w-${uid()}`, 1e4, lane)
+        ).toHaveLength(0);
       });
       (0, import_vitest9.it)("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
@@ -4179,6 +4205,103 @@ var runStoreTck = (options) => {
         }
       });
     });
+    import_vitest9.describe.skipIf(!caps.lease_correlation)(
+      "correlation lease via subscribe (capability)",
+      () => {
+        const by = () => `corr-${uid()}`;
+        const key = () => `key-${uid()}`;
+        const take = (k, who, millis = 1e4) => store.subscribe([], void 0, { key: k, by: who, millis });
+        const release = async (k, who) => {
+          await take(k, who, 1);
+          await new Promise((r) => setTimeout(r, 20));
+        };
+        (0, import_vitest9.it)("grants the lease to the first caller", async () => {
+          const k = key();
+          const who = by();
+          (0, import_vitest9.expect)((await take(k, who)).correlating).toBe(true);
+          await release(k, who);
+        });
+        (0, import_vitest9.it)("answers undefined when no correlator is supplied", async () => {
+          (0, import_vitest9.expect)(await store.subscribe([])).not.toHaveProperty("correlating");
+        });
+        (0, import_vitest9.it)("refuses a second holder while the lease is live", async () => {
+          const k = key();
+          const who = by();
+          (0, import_vitest9.expect)((await take(k, who)).correlating).toBe(true);
+          (0, import_vitest9.expect)((await take(k, by())).correlating).toBe(false);
+          await release(k, who);
+        });
+        (0, import_vitest9.it)("lets the same holder renew rather than failing", async () => {
+          const k = key();
+          const who = by();
+          (0, import_vitest9.expect)((await take(k, who)).correlating).toBe(true);
+          (0, import_vitest9.expect)((await take(k, who)).correlating).toBe(true);
+          await release(k, who);
+        });
+        (0, import_vitest9.it)("becomes available again once the lease expires", async () => {
+          const k = key();
+          (0, import_vitest9.expect)((await take(k, by(), 1)).correlating).toBe(true);
+          await new Promise((r) => setTimeout(r, 30));
+          const next = by();
+          (0, import_vitest9.expect)((await take(k, next)).correlating).toBe(true);
+          await release(k, next);
+        });
+        (0, import_vitest9.it)("keys leases independently, so one correlator cannot starve another", async () => {
+          const a = key();
+          const b = key();
+          const holder_a = by();
+          const holder_b = by();
+          (0, import_vitest9.expect)((await take(a, holder_a)).correlating).toBe(true);
+          (0, import_vitest9.expect)((await take(b, holder_b)).correlating).toBe(true);
+          await release(a, holder_a);
+          await release(b, holder_b);
+        });
+        (0, import_vitest9.it)("still advances the checkpoint for a caller that loses the lease", async () => {
+          const k = key();
+          const holder = by();
+          (0, import_vitest9.expect)((await take(k, holder)).correlating).toBe(true);
+          const loser = await store.subscribe([], 7777, {
+            key: k,
+            by: by(),
+            millis: 1e4
+          });
+          (0, import_vitest9.expect)(loser.correlating).toBe(false);
+          (0, import_vitest9.expect)(loser.correlated_at).toBeGreaterThanOrEqual(7777);
+          await release(k, holder);
+        });
+        (0, import_vitest9.it)("seeds a new key from the shared floor, then lets it diverge", async () => {
+          const a = key();
+          const holder_a = by();
+          const first = await store.subscribe([], 4100, {
+            key: a,
+            by: holder_a,
+            millis: 1e4
+          });
+          (0, import_vitest9.expect)(first.correlated_at).toBeGreaterThanOrEqual(4100);
+          const b = key();
+          const holder_b = by();
+          const second = await store.subscribe([], void 0, {
+            key: b,
+            by: holder_b,
+            millis: 1e4
+          });
+          (0, import_vitest9.expect)(second.correlated_at).toBeGreaterThanOrEqual(4100);
+          await store.subscribe([], 9e3, {
+            key: a,
+            by: holder_a,
+            millis: 1e4
+          });
+          const b_again = await store.subscribe([], void 0, {
+            key: b,
+            by: holder_b,
+            millis: 1e4
+          });
+          (0, import_vitest9.expect)(b_again.correlated_at).toBe(second.correlated_at);
+          await release(a, holder_a);
+          await release(b, holder_b);
+        });
+      }
+    );
     import_vitest9.describe.skipIf(!caps.restore)("restore (capability)", () => {
       beforeEach(async () => {
         await store.drop();