@rotorsoft/act-tck 1.26.4 → 1.26.6

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

@@ -56,6 +56,32 @@ export type StoreCapabilities = {
      * so correctness never depends on this flag — only probe cost.
      */
     readonly source_matches?: boolean;
+    /**
+     * Adapter matches a **pattern** reaction `source` (one carrying regex
+     * metacharacters, e.g. the calculator's `^(A|B)$`) as a full RegExp in
+     * claim()'s has-work probe, so a stream whose max event id exceeds the
+     * subscription watermark is claimed when its name matches the pattern.
+     * When `true`, the TCK runs the pattern-source claim suite. Literal
+     * sources stay exact everywhere regardless of this flag — the fast,
+     * index-friendly path.
+     *
+     * Stores that cannot run an arbitrary regex against candidate streams
+     * (e.g. SQLite, whose libsql build has no `REGEXP` and whose portable
+     * `LIKE` grammar cannot express alternation/grouping) leave this
+     * `false` and instead reject a non-portable claim source at
+     * {@link subscribe} time — see {@link rejects_nonportable_claim_source}.
+     */
+    readonly pattern_claim_source?: boolean;
+    /**
+     * Adapter cannot faithfully match every regex claim `source`, so it
+     * fails loud at registration: {@link subscribe} throws
+     * {@link ValidationError} for a source outside its portable subset
+     * (alternation/grouping like `^(A|B)$`), rather than silently never
+     * claiming the stream. When `true`, the TCK runs the reject-at-subscribe
+     * case. Currently only SQLite sets this — its message points operators
+     * to InMemory/PG for full regex claim sources.
+     */
+    readonly rejects_nonportable_claim_source?: 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,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"}
+{"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,IA0iHtD,CAAC"}

package/dist/index.cjs

@@ -1568,7 +1568,130 @@ var runStoreTck = (options) => {
           await fresh.dispose();
         }
       });
+      (0, import_vitest9.it)("fetches only the exact source stream's events, never a sibling prefix", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const base = `fx-${uid()}`;
+          const sibling = `${base}2`;
+          const target = `agg-${uid()}`;
+          await fresh.subscribe([{ stream: target, source: base }]);
+          const [b1] = await seed_stream(fresh, base, 1);
+          await seed_stream(fresh, sibling, 1);
+          const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+          const lease = claimed.find((l) => l.stream === target);
+          (0, import_vitest9.expect)(lease).toBeDefined();
+          const events2 = await collect(fresh, {
+            stream: lease.source,
+            stream_exact: true,
+            after: -1
+          });
+          (0, import_vitest9.expect)(events2.map((e) => e.stream)).toEqual([base]);
+          (0, import_vitest9.expect)(events2.map((e) => e.id)).toEqual([b1.id]);
+        } finally {
+          await fresh.dispose();
+        }
+      });
     });
+    import_vitest9.describe.skipIf(!caps.pattern_claim_source)(
+      "claim pattern source matching (capability)",
+      () => {
+        (0, import_vitest9.it)("claims a pattern-source target when any matched stream has work (^(A|B)$)", async () => {
+          const fresh = await options.factory();
+          try {
+            await fresh.drop();
+            await fresh.seed();
+            const a = `A-${uid()}`;
+            const b = `B-${uid()}`;
+            const target = `board-${uid()}`;
+            const pattern = `^(${a}|${b})$`;
+            await fresh.subscribe([{ stream: target, source: pattern }]);
+            const [ea] = await seed_stream(fresh, a, 1);
+            const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            const l1 = first.find((s) => s.stream === target);
+            (0, import_vitest9.expect)(l1).toBeDefined();
+            await fresh.ack([{ ...l1, at: ea.id }]);
+            const [eb] = await seed_stream(fresh, b, 1);
+            const second = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            (0, import_vitest9.expect)(second.find((s) => s.stream === target)).toBeDefined();
+            (0, import_vitest9.expect)(eb.stream).toBe(b);
+          } finally {
+            await fresh.dispose();
+          }
+        });
+        (0, import_vitest9.it)("does not claim a pattern-source target when no matched stream has work", async () => {
+          const fresh = await options.factory();
+          try {
+            await fresh.drop();
+            await fresh.seed();
+            const a = `A-${uid()}`;
+            const b = `B-${uid()}`;
+            const other = `Z-${uid()}`;
+            const target = `board-${uid()}`;
+            const control = `ctl-${uid()}`;
+            const pattern = `^(${a}|${b})$`;
+            await fresh.subscribe([
+              { stream: target, source: pattern },
+              { stream: control, source: other }
+            ]);
+            const [ea] = await seed_stream(fresh, a, 1);
+            const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            const l1 = first.find((s) => s.stream === target);
+            (0, import_vitest9.expect)(l1).toBeDefined();
+            const c1 = first.find((s) => s.stream === control);
+            (0, import_vitest9.expect)(c1).toBeDefined();
+            await fresh.ack([
+              { ...l1, at: ea.id },
+              { ...c1, at: -1 }
+            ]);
+            await seed_stream(fresh, other, 1);
+            const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            const streams = claimed.map((s) => s.stream);
+            (0, import_vitest9.expect)(streams).toContain(control);
+            (0, import_vitest9.expect)(streams).not.toContain(target);
+          } finally {
+            await fresh.dispose();
+          }
+        });
+      }
+    );
+    import_vitest9.describe.skipIf(!caps.rejects_nonportable_claim_source)(
+      "claim source registration (capability)",
+      () => {
+        (0, import_vitest9.it)("throws at subscribe for a non-portable (alternation) claim source", async () => {
+          const fresh = await options.factory();
+          try {
+            await fresh.drop();
+            await fresh.seed();
+            await (0, import_vitest9.expect)(
+              fresh.subscribe([
+                { stream: `board-${uid()}`, source: `^(${uid()}|${uid()})$` }
+              ])
+            ).rejects.toThrow(import_act2.ValidationError);
+          } finally {
+            await fresh.dispose();
+          }
+        });
+        (0, import_vitest9.it)("accepts a portable-subset pattern claim source (^prefix.*) and claims on match", async () => {
+          const fresh = await options.factory();
+          try {
+            await fresh.drop();
+            await fresh.seed();
+            const prefix = `pfx${uid()}`.replace(/-/g, "");
+            const matched = `${prefix}child`;
+            const target = `board-${uid()}`;
+            await fresh.subscribe([{ stream: target, source: `^${prefix}.*` }]);
+            const [e] = await seed_stream(fresh, matched, 1);
+            const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
+            (0, import_vitest9.expect)(claimed.find((s) => s.stream === target)).toBeDefined();
+            (0, import_vitest9.expect)(e.stream).toBe(matched);
+          } 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 () => {
         const fresh = await options.factory();