@rotorsoft/act-tck 1.26.2 → 1.26.4

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

@@ -7,9 +7,15 @@ import type { Store } from "@rotorsoft/act/types";
 export type StoreCapabilities = {
     /**
      * Adapter implements {@link Store.notify}. When `true`, the TCK runs
-     * a basic subscribe/dispose smoke test. Cross-process LISTEN/NOTIFY
-     * semantics are not exercised — that needs two processes and stays
-     * in the adapter's own suite.
+     * the cross-instance conformance cases: a listener receives commits
+     * from a *sibling* instance produced by the same `factory`, never its
+     * own commits (the port's self-filtering MUST), and exactly one
+     * notification per commit transaction carrying the full event batch.
+     * Requires the `factory` to produce instances sharing one backing
+     * store — e.g. two PostgresStores on the same schema/table, or two
+     * `withBroker` decorators on one broker. True cross-*process*
+     * LISTEN/NOTIFY plumbing needs two processes and stays in the
+     * adapter's own suite.
      */
     readonly notify?: boolean;
     /**
@@ -90,7 +96,8 @@ export type StoreTckOptions = {
  *   `ValidationError` — never a silent approximation
  * - `subscribe` — idempotent re-subscribe, watermark return value
  * - `claim` / `ack` — lease lifecycle, dual frontiers, leased streams
- *   not double-claimed
+ *   not double-claimed, exact-source has-work matching, timed-out-lease
+ *   retry accounting
  * - `block` — blocked streams hidden from claim, only same-drainer can block
  * - `reset` — restart watermarks (including blocked), no-op for missing
  * - `prioritize` — bulk priority updates by filter
@@ -99,7 +106,9 @@ export type StoreTckOptions = {
  *   behind the closest safe snapshot, tail + subscriptions kept,
  *   no-snapshot no-op, mixed full + windowed targets
  * - `query_streams` — filters, exact-match, pagination, blocked
- * - `notify` (capability-gated) — subscribe + dispose smoke test
+ * - `notify` (capability-gated) — cross-instance delivery, self-filtering
+ *   (an instance never receives its own commits), one notification per
+ *   commit transaction with the full event batch
  *
  * Tests namespace their streams with a per-test {@link uid} so the
  * suite is parallel-safe against a shared backing store (e.g., a real

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;;;;;OAKG;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;CACnC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,eAAe,KAAG,IAonGtD,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;CACnC,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,IAy4GtD,CAAC"}

package/dist/index.cjs

@@ -1481,6 +1481,93 @@ var runStoreTck = (options) => {
           await fresh.dispose();
         }
       });
+      (0, import_vitest9.it)("counts a timed-out lease reclaimed by another worker against the retry budget; ack resets it", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const s = `lease-timeout-${uid()}`;
+          await fresh.subscribe([{ stream: s }]);
+          const [e1] = await seed_stream(fresh, s, 1);
+          const a = await fresh.claim(1, 0, `wA-${uid()}`, 0);
+          (0, import_vitest9.expect)(a.find((l) => l.stream === s)?.retry).toBe(0);
+          const b = await fresh.claim(1, 0, `wB-${uid()}`, 3e4);
+          const b_lease = b.find((l) => l.stream === s);
+          (0, import_vitest9.expect)(b_lease).toBeDefined();
+          (0, import_vitest9.expect)(b_lease.retry).toBe(1);
+          await fresh.ack([{ ...b_lease, at: e1.id }]);
+          await seed_stream(fresh, s, 1);
+          const c = await fresh.claim(1, 0, `wC-${uid()}`, 3e4);
+          (0, import_vitest9.expect)(c.find((l) => l.stream === s)?.retry).toBe(0);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+    });
+    (0, import_vitest9.describe)("claim source matching", () => {
+      (0, import_vitest9.it)("treats source as an exact stream name \u2014 no substring or pattern overmatch", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const base = `src-${uid()}`;
+          const sibling = `${base}2`;
+          const target = `agg-${uid()}`;
+          const control = `ctl-${uid()}`;
+          await fresh.subscribe([
+            { stream: target, source: base },
+            // Control subscription sourced from the sibling — it DOES see
+            // the sibling commit below, so the negative assertion runs
+            // through a populated claim result.
+            { stream: control, source: sibling }
+          ]);
+          const [seeded] = await seed_stream(fresh, base, 1);
+          const [ctl_seeded] = await seed_stream(fresh, sibling, 1);
+          const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          const mine = first.find((l) => l.stream === target);
+          const ctl = first.find((l) => l.stream === control);
+          (0, import_vitest9.expect)(mine).toBeDefined();
+          (0, import_vitest9.expect)(ctl).toBeDefined();
+          await fresh.ack([
+            { ...mine, at: seeded.id },
+            { ...ctl, at: ctl_seeded.id }
+          ]);
+          await seed_stream(fresh, sibling, 1);
+          const second = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          (0, import_vitest9.expect)(second.find((l) => l.stream === control)).toBeDefined();
+          (0, import_vitest9.expect)(second.find((l) => l.stream === target)).toBeUndefined();
+        } finally {
+          await fresh.dispose();
+        }
+      });
+      (0, import_vitest9.it)("receives exactly its source stream's events", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const base = `src-${uid()}`;
+          const target = `agg-${uid()}`;
+          await fresh.subscribe([{ stream: target, source: base }]);
+          const [e1] = await seed_stream(fresh, base, 1);
+          const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          const f = first.find((l) => l.stream === target);
+          (0, import_vitest9.expect)(f).toBeDefined();
+          (0, import_vitest9.expect)(f.source).toBe(base);
+          await fresh.ack([{ ...f, at: e1.id }]);
+          const [e2] = await seed_stream(fresh, base, 1);
+          const second = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          const sec = second.find((l) => l.stream === target);
+          (0, import_vitest9.expect)(sec).toBeDefined();
+          (0, import_vitest9.expect)(sec.at).toBe(e1.id);
+          const events2 = await collect(fresh, {
+            stream: sec.source,
+            after: sec.at
+          });
+          (0, import_vitest9.expect)(events2.map((e) => e.id)).toEqual([e2.id]);
+        } finally {
+          await fresh.dispose();
+        }
+      });
     });
     import_vitest9.describe.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
       (0, import_vitest9.it)("never double-leases a stream across concurrent claimers", async () => {
@@ -1512,6 +1599,51 @@ var runStoreTck = (options) => {
           await fresh.dispose();
         }
       });
+      (0, import_vitest9.it)("does not hand an unexpired lease to a competing claimer", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const s = `unexpired-${uid()}`;
+          const other = `unexpired-other-${uid()}`;
+          await fresh.subscribe([{ stream: s }]);
+          await seed_stream(fresh, s, 1);
+          const a = await fresh.claim(100, 100, `wA-${uid()}`, 6e4);
+          (0, import_vitest9.expect)(a.find((l) => l.stream === s)).toBeDefined();
+          await fresh.subscribe([{ stream: other }]);
+          await seed_stream(fresh, other, 1);
+          const b = await fresh.claim(100, 100, `wB-${uid()}`, 6e4);
+          (0, import_vitest9.expect)(b.find((l) => l.stream === other)).toBeDefined();
+          (0, import_vitest9.expect)(b.find((l) => l.stream === s)).toBeUndefined();
+        } finally {
+          await fresh.dispose();
+        }
+      });
+      (0, import_vitest9.it)("hands an expired lease to exactly one competing claimer, with retry accounting shared across workers", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const s = `expired-${uid()}`;
+          await fresh.subscribe([{ stream: s }]);
+          const [e1] = await seed_stream(fresh, s, 1);
+          const dead = await fresh.claim(100, 0, `wDead-${uid()}`, 0);
+          (0, import_vitest9.expect)(dead.find((l) => l.stream === s)?.retry).toBe(0);
+          const [b, c] = await Promise.all([
+            fresh.claim(100, 100, `wB-${uid()}`, 6e4),
+            fresh.claim(100, 100, `wC-${uid()}`, 6e4)
+          ]);
+          const winners = [...b, ...c].filter((l) => l.stream === s);
+          (0, import_vitest9.expect)(winners).toHaveLength(1);
+          (0, import_vitest9.expect)(winners[0].retry).toBe(1);
+          await fresh.ack([{ ...winners[0], at: e1.id }]);
+          await seed_stream(fresh, s, 1);
+          const again = await fresh.claim(100, 0, `wNext-${uid()}`, 6e4);
+          (0, import_vitest9.expect)(again.find((l) => l.stream === s)?.retry).toBe(0);
+        } finally {
+          await fresh.dispose();
+        }
+      });
     });
     (0, import_vitest9.describe)("block", () => {
       (0, import_vitest9.it)("hides blocked streams from claim", async () => {
@@ -3502,6 +3634,89 @@ var runStoreTck = (options) => {
             await Promise.resolve(disposer());
           }
         });
+        (0, import_vitest9.it)("does not deliver an instance's own commits (self-filtering)", async () => {
+          const received = [];
+          let resolve_sentinel;
+          const sentinel_arrived = new Promise((res) => {
+            resolve_sentinel = res;
+          });
+          const own = `notify-self-${uid()}`;
+          const remote = `notify-remote-${uid()}`;
+          const sentinel = `notify-sentinel-${uid()}`;
+          const disposer = await store.notify.call(store, (n) => {
+            received.push(n);
+            if (n.stream === sentinel) resolve_sentinel();
+          });
+          const writer = await options.factory();
+          try {
+            await store.commit(
+              own,
+              [inc(1)],
+              make_meta({ stream: own })
+            );
+            await writer.commit(
+              remote,
+              [inc(1)],
+              make_meta({ stream: remote })
+            );
+            await writer.commit(
+              sentinel,
+              [inc(1)],
+              make_meta({ stream: sentinel })
+            );
+            await sentinel_arrived;
+            (0, import_vitest9.expect)(received.find((n) => n.stream === own)).toBeUndefined();
+            (0, import_vitest9.expect)(received.find((n) => n.stream === remote)).toBeDefined();
+            (0, import_vitest9.expect)(received.find((n) => n.stream === sentinel)).toBeDefined();
+          } finally {
+            await writer.dispose();
+            await Promise.resolve(disposer());
+          }
+        });
+        (0, import_vitest9.it)("delivers one notification per commit transaction carrying the full event batch", async () => {
+          const received = [];
+          let resolve_sentinel;
+          const sentinel_arrived = new Promise((res) => {
+            resolve_sentinel = res;
+          });
+          const batch = `notify-batch-${uid()}`;
+          const sentinel = `notify-batch-sentinel-${uid()}`;
+          const disposer = await store.notify.call(store, (n) => {
+            received.push(n);
+            if (n.stream === sentinel) resolve_sentinel();
+          });
+          const writer = await options.factory();
+          try {
+            await writer.commit(
+              batch,
+              [inc(1), inc(2), inc(3)],
+              make_meta({ stream: batch })
+            );
+            await writer.commit(
+              sentinel,
+              [inc(1)],
+              make_meta({ stream: sentinel })
+            );
+            await sentinel_arrived;
+            const batch_notifications = received.filter(
+              (n) => n.stream === batch
+            );
+            (0, import_vitest9.expect)(batch_notifications).toHaveLength(1);
+            const events2 = batch_notifications[0].events;
+            (0, import_vitest9.expect)(events2).toHaveLength(3);
+            (0, import_vitest9.expect)(events2.map((e) => e.name)).toEqual([
+              "Incremented",
+              "Incremented",
+              "Incremented"
+            ]);
+            (0, import_vitest9.expect)([...events2.map((e) => e.id)].sort((a, b) => a - b)).toEqual(
+              events2.map((e) => e.id)
+            );
+          } finally {
+            await writer.dispose();
+            await Promise.resolve(disposer());
+          }
+        });
       });
     }
   });