@rotorsoft/act-tck 1.30.5 → 1.32.0

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

@@ -82,6 +82,22 @@ export type StoreCapabilities = {
      * to InMemory/PG for full regex claim sources.
      */
     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
+     * `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
+     * across positive/zero/negative values, `ack` retiring a stream from
+     * the claimable set and a later mark re-adding it, and the operator
+     * surfaces (`reset`, `unblock`, `defer`, `prioritize`) leaving the mark
+     * intact.
+     *
+     * An adapter that ignores the field keeps working through the legacy
+     * has-work probe and leaves this `false`. The flag disappears once the
+     * legacy arm is deleted and the mark becomes the only eligibility rule.
+     */
+    readonly work_set?: boolean;
 };
 /**
  * Options for {@link runStoreTck}.

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

package/dist/index.cjs

@@ -1806,6 +1806,146 @@ var runStoreTck = (options) => {
         await store.subscribe([{ stream: s }]);
         (0, import_vitest9.expect)(await read()).toBe(0);
       });
+      (0, import_vitest9.describe)("correlate checkpoint", () => {
+        const peek = async () => (await store.subscribe([])).correlated_at;
+        (0, import_vitest9.it)("round-trips an advance through subscribe", async () => {
+          const base = await peek();
+          (0, import_vitest9.expect)((await store.subscribe([], base + 10)).correlated_at).toBe(
+            base + 10
+          );
+          (0, import_vitest9.expect)(await peek()).toBe(base + 10);
+        });
+        (0, import_vitest9.it)("persists only when greater than the stored value", async () => {
+          const base = await peek();
+          await store.subscribe([], base - 5);
+          (0, import_vitest9.expect)(await peek()).toBe(base);
+          await store.subscribe([], base);
+          (0, import_vitest9.expect)(await peek()).toBe(base);
+          await store.subscribe([], base + 3);
+          (0, import_vitest9.expect)(await peek()).toBe(base + 3);
+        });
+        (0, import_vitest9.it)("is left untouched when subscribe omits it", async () => {
+          const base = await peek();
+          await store.subscribe([]);
+          (0, import_vitest9.expect)(await peek()).toBe(base);
+        });
+        (0, import_vitest9.it)("advances in the same call that registers discovered targets", async () => {
+          const base = await peek();
+          const s = `cp-sub-${uid()}`;
+          const { subscribed, correlated_at } = await store.subscribe(
+            [{ stream: s }],
+            base + 7
+          );
+          (0, import_vitest9.expect)(subscribed).toBe(1);
+          (0, import_vitest9.expect)(correlated_at).toBe(base + 7);
+        });
+        (0, import_vitest9.it)("is invisible to every stream-scoped surface", async () => {
+          const seen = [];
+          await store.query_streams((p) => seen.push(p.stream), {});
+          (0, import_vitest9.expect)(seen.some((n) => n.startsWith("__correlate"))).toBe(false);
+          (0, import_vitest9.expect)(seen).not.toContain("correlated");
+        });
+      });
+      import_vitest9.describe.skipIf(!caps.work_set)("subscription work set", () => {
+        const claimable = async (stream) => {
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1);
+          const mine = leased.find((l) => l.stream === stream);
+          if (mine) await store.ack([{ ...mine, at: mine.at }]);
+          return mine !== void 0;
+        };
+        (0, import_vitest9.it)("claims a marked stream without probing the event log", async () => {
+          const s = `ws-mark-${uid()}`;
+          await store.subscribe([{ stream: s, source: `ws-src-${uid()}` }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(false);
+          await store.subscribe([{ stream: s, correlated_at: 7 }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+          const s2 = `ws-mark-nosrc-${uid()}`;
+          await store.subscribe([{ stream: s2, correlated_at: 7 }]);
+          (0, import_vitest9.expect)(await claimable(s2)).toBe(true);
+        });
+        (0, import_vitest9.it)("never regresses the mark, for every value on the number line", async () => {
+          const s = `ws-mono-${uid()}`;
+          await store.subscribe([
+            { stream: s, source: `ws-none-${uid()}`, correlated_at: 10 }
+          ]);
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          await store.ack([
+            { ...leased.find((l) => l.stream === s), at: 5 }
+          ]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+          await store.subscribe([{ stream: s, correlated_at: 4 }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+          await store.subscribe([{ stream: s, correlated_at: 5 }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+          await store.subscribe([{ stream: s, correlated_at: -3 }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+          await store.subscribe([{ stream: s, correlated_at: 0 }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+          const leased2 = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          await store.ack([
+            { ...leased2.find((l) => l.stream === s), at: 10 }
+          ]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(false);
+          await store.subscribe([{ stream: s, correlated_at: 11 }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+        });
+        (0, import_vitest9.it)("retires a stream when ack catches the watermark up to the mark", async () => {
+          const s = `ws-retire-${uid()}`;
+          await store.subscribe([
+            { stream: s, source: `ws-none-${uid()}`, correlated_at: 5 }
+          ]);
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          const mine = leased.find((l) => l.stream === s);
+          (0, import_vitest9.expect)(mine).toBeDefined();
+          await store.ack([{ ...mine, at: 5 }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(false);
+          await store.subscribe([{ stream: s, correlated_at: 6 }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+        });
+        (0, import_vitest9.it)("keeps the mark across reset, so a rebuild is claimable", async () => {
+          const s = `ws-reset-${uid()}`;
+          await store.subscribe([
+            { stream: s, source: `ws-none-${uid()}`, correlated_at: 3 }
+          ]);
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          await store.ack([
+            { ...leased.find((l) => l.stream === s), at: 3 }
+          ]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(false);
+          await store.reset([s]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+        });
+        (0, import_vitest9.it)("keeps the mark across unblock, defer, and prioritize", async () => {
+          const s = `ws-ops-${uid()}`;
+          await store.subscribe([
+            { stream: s, source: `ws-none-${uid()}`, correlated_at: 9 }
+          ]);
+          const leased = await store.claim(100, 0, `w-${uid()}`, 1e4);
+          const mine = leased.find((l) => l.stream === s);
+          await store.block([{ ...mine, error: "poison" }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(false);
+          (0, import_vitest9.expect)(await store.unblock([s])).toBe(1);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+          await store.defer([s], Date.now() + 6e4);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(false);
+          await store.defer([s], Date.now() - 1);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+          await store.prioritize({ stream: s, stream_exact: true }, 5);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+        });
+        (0, import_vitest9.it)("falls back to the legacy probe for an unmarked stream", async () => {
+          const s = `ws-legacy-${uid()}`;
+          const src = `ws-legacy-src-${uid()}`;
+          await store.subscribe([{ stream: s, source: src }]);
+          (0, import_vitest9.expect)(await claimable(s)).toBe(false);
+          await store.commit(
+            src,
+            [inc(1)],
+            make_meta({ stream: src })
+          );
+          (0, import_vitest9.expect)(await claimable(s)).toBe(true);
+        });
+      });
       (0, import_vitest9.it)("claims a subscribed stream and ack releases the lease", async () => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);