@rotorsoft/act-tck 1.34.0 → 1.34.2

package/dist/index.js

@@ -384,6 +384,24 @@ ${content}`;
 // src/store-differential-tck.ts
 import { SNAP_EVENT } from "@rotorsoft/act";
 import { afterAll as afterAll2, beforeAll as beforeAll2, describe as describe6, expect as expect6, it as it6 } from "vitest";
+var mark_all = async (store) => {
+  const rows = [];
+  const { maxEventId } = await store.query_streams(
+    (p) => rows.push({
+      stream: p.stream,
+      at: p.at,
+      priority: p.priority,
+      lane: p.lane
+    })
+  );
+  const marks = rows.filter((r) => r.at < maxEventId).map((r) => ({
+    stream: r.stream,
+    priority: r.priority,
+    lane: r.lane,
+    correlated_at: maxEventId
+  }));
+  await store.subscribe(marks);
+};
 var mulberry322 = (seed) => {
   let a = seed >>> 0;
   return () => {
@@ -600,6 +618,7 @@ var apply_plan = async (store, plan, pii_isolation) => {
       ]);
     } else if (op.t === "claim") {
       const by = uid();
+      await mark_all(store);
       const leased = await store.claim(1e5, 1e5, by, op.millis);
       for (const l of leased) if (owned.has(l.stream)) held.set(l.stream, by);
     } else if (op.t === "ack") {
@@ -856,6 +875,24 @@ var runStoreDifferentialTck = (options) => {
 // src/store-property-tck.ts
 import { fc, test } from "@fast-check/vitest";
 import { afterAll as afterAll3, beforeAll as beforeAll3, describe as describe7, expect as expect7 } from "vitest";
+var mark_all2 = async (store) => {
+  const rows = [];
+  const { maxEventId } = await store.query_streams(
+    (p) => rows.push({
+      stream: p.stream,
+      at: p.at,
+      priority: p.priority,
+      lane: p.lane
+    })
+  );
+  const marks = rows.filter((r) => r.at < maxEventId).map((r) => ({
+    stream: r.stream,
+    priority: r.priority,
+    lane: r.lane,
+    correlated_at: maxEventId
+  }));
+  await store.subscribe(marks);
+};
 var streamArb = fc.constantFrom("s1", "s2", "s3");
 var commitArb = fc.record({
   stream: streamArb,
@@ -963,6 +1000,7 @@ var runStorePropertyTck = (options) => {
                 make_meta({ stream: op.stream })
               );
             } else if (op.kind === "claim") {
+              await mark_all2(store);
               const claimed = await store.claim(5, 5, "worker", 6e4);
               totalClaims += claimed.length;
               pending = [...pending, ...claimed];
@@ -1004,6 +1042,7 @@ var runStorePropertyTck = (options) => {
               make_meta({ stream })
             );
           }
+          await mark_all2(store);
           const acked1 = await store.ack(
             await store.claim(10, 10, "worker", 6e4)
           );
@@ -1016,6 +1055,7 @@ var runStorePropertyTck = (options) => {
               make_meta({ stream })
             );
           }
+          await mark_all2(store);
           const acked2 = await store.ack(
             await store.claim(10, 10, "worker", 6e4)
           );
@@ -1039,6 +1079,7 @@ var runStorePropertyTck = (options) => {
             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));
@@ -1048,6 +1089,7 @@ var runStorePropertyTck = (options) => {
           [inc(1)],
           make_meta({ stream: "ctrl" })
         );
+        await mark_all2(store);
         const reclaim = await store.claim(10, 10, "worker2", 6e4);
         for (const l of reclaim) expect7(blockedSet.has(l.stream)).toBe(false);
       });
@@ -1069,6 +1111,38 @@ var runStoreTck = (options) => {
   describe8(`TCK / Store / ${options.name}`, () => {
     let store;
     const caps = { ...options.capabilities };
+    const is_literal = (source) => !/[\]^$.*+?()[{}|\\]/.test(source);
+    const correlate = async (target = store) => {
+      const rows = [];
+      await target.query_streams(
+        (p) => rows.push({
+          stream: p.stream,
+          source: p.source,
+          at: p.at,
+          priority: p.priority,
+          lane: p.lane
+        }),
+        { limit: 1e3 }
+      );
+      const marks = [];
+      for (const row of rows) {
+        let mark = -1;
+        await target.query(
+          (e) => {
+            mark = Math.max(mark, e.id);
+          },
+          row.source !== void 0 ? { stream: row.source, stream_exact: is_literal(row.source) } : {}
+        );
+        if (mark > row.at)
+          marks.push({
+            stream: row.stream,
+            priority: row.priority,
+            lane: row.lane,
+            correlated_at: mark
+          });
+      }
+      if (marks.length) await target.subscribe(marks);
+    };
     beforeAll4(async () => {
       store = await options.factory();
       await store.drop();
@@ -1695,18 +1769,21 @@ var runStoreTck = (options) => {
         const s = `fresh-empty-${uid()}`;
         const src = `fresh-src-${uid()}`;
         await store.subscribe([{ stream: s, source: src }]);
+        await correlate();
         const leases = await store.claim(5, 5, `w-${uid()}`, 5e3);
         expect8(leases.filter((l) => l.stream === s)).toHaveLength(0);
       });
-      it7("claims a fresh subscription as soon as its first event lands", async () => {
+      it7("claims a fresh subscription as soon as its first event is marked", async () => {
         const s = `fresh-first-${uid()}`;
         const src = `fresh-first-src-${uid()}`;
         await store.subscribe([{ stream: s, source: src }]);
-        await store.commit(
+        const [first] = await store.commit(
           src,
           [inc(1)],
           make_meta({ stream: src })
         );
+        await store.subscribe([{ stream: s, correlated_at: first.id }]);
+        await correlate();
         const leases = await store.claim(5, 5, `w-${uid()}`, 5e3);
         const mine = leases.filter((l) => l.stream === s);
         expect8(mine).toHaveLength(1);
@@ -1799,7 +1876,7 @@ var runStoreTck = (options) => {
           expect8(seen).not.toContain("correlated");
         });
       });
-      describe8.skipIf(!caps.work_set)("subscription work set", () => {
+      describe8("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);
@@ -1886,16 +1963,17 @@ var runStoreTck = (options) => {
           await store.prioritize({ stream: s, stream_exact: true }, 5);
           expect8(await claimable(s)).toBe(true);
         });
-        it7("falls back to the legacy probe for an unmarked stream", async () => {
-          const s = `ws-legacy-${uid()}`;
-          const src = `ws-legacy-src-${uid()}`;
+        it7("never claims an unmarked stream, however much work the log holds", async () => {
+          const s = `ws-unmarked-${uid()}`;
+          const src = `ws-unmarked-src-${uid()}`;
           await store.subscribe([{ stream: s, source: src }]);
-          expect8(await claimable(s)).toBe(false);
-          await store.commit(
+          const [event] = await store.commit(
             src,
             [inc(1)],
             make_meta({ stream: src })
           );
+          expect8(await claimable(s)).toBe(false);
+          await store.subscribe([{ stream: s, correlated_at: event.id }]);
           expect8(await claimable(s)).toBe(true);
         });
         it7("surfaces the mark on query_streams positions", async () => {
@@ -1928,6 +2006,7 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         const by = `worker-${uid()}`;
+        await correlate();
         const leased = await store.claim(100, 0, by, 1e4);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
@@ -1950,6 +2029,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1e5);
         const targetA = leasedA.find((l) => l.stream === s);
         expect8(targetA).toBeDefined();
@@ -1959,6 +2039,7 @@ var runStoreTck = (options) => {
           [inc(2)],
           make_meta({ stream: other })
         );
+        await correlate();
         const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
         expect8(leasedB.length).toBeGreaterThan(0);
         expect8(leasedB.find((l) => l.stream === s)).toBeUndefined();
@@ -1972,11 +2053,13 @@ var runStoreTck = (options) => {
           [inc(1), inc(2)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leasedA = await store.claim(100, 0, `wA-${uid()}`, 1);
         const a = leasedA.find((l) => l.stream === s);
         expect8(a).toBeDefined();
         expect8(a.retry).toBe(0);
         await new Promise((r) => setTimeout(r, 50));
+        await correlate();
         const leasedB = await store.claim(100, 0, `wB-${uid()}`, 1e5);
         const b = leasedB.find((l) => l.stream === s);
         expect8(b).toBeDefined();
@@ -1997,10 +2080,12 @@ var runStoreTck = (options) => {
           [inc(1), inc(2)],
           make_meta({ stream: s })
         );
+        await correlate();
         const first = await store.claim(100, 0, `w-${uid()}`, 1);
         const mine = first.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
         await store.ack([{ ...mine, at: mine.at + 1 }]);
+        await correlate();
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
         expect8(second.find((l) => l.stream === s)).toBeDefined();
       });
@@ -2034,6 +2119,7 @@ var runStoreTck = (options) => {
           let low_claimed = false;
           const MAX_CYCLES = 20;
           for (let cycle = 0; cycle < MAX_CYCLES && !low_claimed; cycle++) {
+            await correlate(fresh);
             const leases = await fresh.claim(4, 0, by, 1e3);
             if (leases.some((l) => l.stream === low)) {
               low_claimed = true;
@@ -2061,6 +2147,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const claimed = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const matches = claimed.filter((l) => l.stream === s);
         expect8(matches).toHaveLength(1);
@@ -2079,6 +2166,7 @@ var runStoreTck = (options) => {
           [inc(2)],
           make_meta({ stream: sibling })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const sibling_lease = leased.find((l) => l.stream === sibling);
@@ -2095,6 +2183,7 @@ var runStoreTck = (options) => {
         const s = `ack-stale-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const by = `w-${uid()}`;
+        await correlate();
         const leased = await store.claim(100, 0, by, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
@@ -2107,6 +2196,7 @@ var runStoreTck = (options) => {
         try {
           await fresh.drop();
           await fresh.seed();
+          await correlate(fresh);
           const claimed = await fresh.claim(1, 1, `w-${uid()}`, 1e3);
           expect8(claimed).toEqual([]);
         } finally {
@@ -2127,10 +2217,12 @@ var runStoreTck = (options) => {
             [inc(1)],
             make_meta({ stream: s })
           );
+          await correlate(fresh);
           const first = await fresh.claim(1, 0, `w-${uid()}`, 0);
           const f = first.find((l) => l.stream === s);
           expect8(f).toBeDefined();
           expect8(f.retry).toBe(0);
+          await correlate(fresh);
           const second = await fresh.claim(1, 0, `w-${uid()}`, 1e5);
           const sec = second.find((l) => l.stream === s);
           expect8(sec).toBeDefined();
@@ -2151,8 +2243,10 @@ var runStoreTck = (options) => {
             [inc(1)],
             make_meta({ stream: s })
           );
+          await correlate(fresh);
           const lag = await fresh.claim(1, 0, `w-${uid()}`, 0);
           expect8(lag.find((l) => l.stream === s)?.lagging).toBe(true);
+          await correlate(fresh);
           const lead = await fresh.claim(0, 1, `w-${uid()}`, 1e5);
           expect8(lead.find((l) => l.stream === s)?.lagging).toBe(false);
         } finally {
@@ -2167,14 +2261,17 @@ var runStoreTck = (options) => {
           const s = `lease-timeout-${uid()}`;
           await fresh.subscribe([{ stream: s }]);
           const [e1] = await seed_stream(fresh, s, 1);
+          await correlate(fresh);
           const a = await fresh.claim(1, 0, `wA-${uid()}`, 0);
           expect8(a.find((l) => l.stream === s)?.retry).toBe(0);
+          await correlate(fresh);
           const b = await fresh.claim(1, 0, `wB-${uid()}`, 3e4);
           const b_lease = b.find((l) => l.stream === s);
           expect8(b_lease).toBeDefined();
           expect8(b_lease.retry).toBe(1);
           await fresh.ack([{ ...b_lease, at: e1.id }]);
           await seed_stream(fresh, s, 1);
+          await correlate(fresh);
           const c = await fresh.claim(1, 0, `wC-${uid()}`, 3e4);
           expect8(c.find((l) => l.stream === s)?.retry).toBe(0);
         } finally {
@@ -2182,42 +2279,7 @@ var runStoreTck = (options) => {
         }
       });
     });
-    describe8("claim source matching", () => {
-      it7("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);
-          expect8(mine).toBeDefined();
-          expect8(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);
-          expect8(second.find((l) => l.stream === control)).toBeDefined();
-          expect8(second.find((l) => l.stream === target)).toBeUndefined();
-        } finally {
-          await fresh.dispose();
-        }
-      });
+    describe8("source windows and lease exclusivity", () => {
       it7("receives exactly its source stream's events", async () => {
         const fresh = await options.factory();
         try {
@@ -2227,12 +2289,14 @@ var runStoreTck = (options) => {
           const target = `agg-${uid()}`;
           await fresh.subscribe([{ stream: target, source: base }]);
           const [e1] = await seed_stream(fresh, base, 1);
+          await correlate(fresh);
           const first = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
           const f = first.find((l) => l.stream === target);
           expect8(f).toBeDefined();
           expect8(f.source).toBe(base);
           await fresh.ack([{ ...f, at: e1.id }]);
           const [e2] = await seed_stream(fresh, base, 1);
+          await correlate(fresh);
           const second = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
           const sec = second.find((l) => l.stream === target);
           expect8(sec).toBeDefined();
@@ -2257,6 +2321,7 @@ var runStoreTck = (options) => {
           await fresh.subscribe([{ stream: target, source: base }]);
           const [b1] = await seed_stream(fresh, base, 1);
           await seed_stream(fresh, sibling, 1);
+          await correlate(fresh);
           const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
           const lease = claimed.find((l) => l.stream === target);
           expect8(lease).toBeDefined();
@@ -2272,64 +2337,6 @@ var runStoreTck = (options) => {
         }
       });
     });
-    describe8.skipIf(!caps.pattern_claim_source)(
-      "claim pattern source matching (capability)",
-      () => {
-        it7("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);
-            expect8(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);
-            expect8(second.find((s) => s.stream === target)).toBeDefined();
-            expect8(eb.stream).toBe(b);
-          } finally {
-            await fresh.dispose();
-          }
-        });
-        it7("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);
-            expect8(l1).toBeDefined();
-            expect8(first.map((s) => s.stream)).not.toContain(control);
-            await fresh.ack([{ ...l1, at: ea.id }]);
-            await seed_stream(fresh, other, 1);
-            const claimed = await fresh.claim(100, 0, `w-${uid()}`, 3e4);
-            const streams = claimed.map((s) => s.stream);
-            expect8(streams).toContain(control);
-            expect8(streams).not.toContain(target);
-          } finally {
-            await fresh.dispose();
-          }
-        });
-      }
-    );
     describe8.skipIf(!caps.rejects_nonportable_claim_source)(
       "claim source registration (capability)",
       () => {
@@ -2347,23 +2354,6 @@ var runStoreTck = (options) => {
             await fresh.dispose();
           }
         });
-        it7("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);
-            expect8(claimed.find((s) => s.stream === target)).toBeDefined();
-            expect8(e.stream).toBe(matched);
-          } finally {
-            await fresh.dispose();
-          }
-        });
       }
     );
     describe8.skipIf(!caps.concurrent_claim)("concurrency (capability)", () => {
@@ -2385,6 +2375,7 @@ var runStoreTck = (options) => {
             );
           }
           const owned = new Set(streams);
+          await correlate(fresh);
           const [a, b] = await Promise.all([
             fresh.claim(100, 100, `wA-${uid()}`, 6e4),
             fresh.claim(100, 100, `wB-${uid()}`, 6e4)
@@ -2405,10 +2396,12 @@ var runStoreTck = (options) => {
           const other = `unexpired-other-${uid()}`;
           await fresh.subscribe([{ stream: s }]);
           await seed_stream(fresh, s, 1);
+          await correlate(fresh);
           const a = await fresh.claim(100, 100, `wA-${uid()}`, 6e4);
           expect8(a.find((l) => l.stream === s)).toBeDefined();
           await fresh.subscribe([{ stream: other }]);
           await seed_stream(fresh, other, 1);
+          await correlate(fresh);
           const b = await fresh.claim(100, 100, `wB-${uid()}`, 6e4);
           expect8(b.find((l) => l.stream === other)).toBeDefined();
           expect8(b.find((l) => l.stream === s)).toBeUndefined();
@@ -2424,6 +2417,7 @@ var runStoreTck = (options) => {
           const s = `expired-${uid()}`;
           await fresh.subscribe([{ stream: s }]);
           const [e1] = await seed_stream(fresh, s, 1);
+          await correlate(fresh);
           const dead = await fresh.claim(100, 0, `wDead-${uid()}`, 0);
           expect8(dead.find((l) => l.stream === s)?.retry).toBe(0);
           const [b, c] = await Promise.all([
@@ -2435,6 +2429,7 @@ var runStoreTck = (options) => {
           expect8(winners[0].retry).toBe(1);
           await fresh.ack([{ ...winners[0], at: e1.id }]);
           await seed_stream(fresh, s, 1);
+          await correlate(fresh);
           const again = await fresh.claim(100, 0, `wNext-${uid()}`, 6e4);
           expect8(again.find((l) => l.stream === s)?.retry).toBe(0);
         } finally {
@@ -2451,6 +2446,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
@@ -2461,6 +2457,7 @@ var runStoreTck = (options) => {
         ]);
         expect8(blocked).toHaveLength(1);
         expect8(blocked[0].error).toBe("boom");
+        await correlate();
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
         expect8(again.find((l) => l.stream === s)).toBeUndefined();
       });
@@ -2472,6 +2469,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
@@ -2497,6 +2495,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `right-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
@@ -2515,6 +2514,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
@@ -2541,6 +2541,7 @@ var runStoreTck = (options) => {
             make_meta({ stream: st })
           );
         expect8(await store.defer([s], Date.now() + 36e5)).toBe(1);
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         expect8(leased.find((l) => l.stream === ctl)).toBeDefined();
         expect8(leased.find((l) => l.stream === s)).toBeUndefined();
@@ -2554,6 +2555,7 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         expect8(await store.defer([s], Date.now() - 1e3)).toBe(1);
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
@@ -2570,9 +2572,12 @@ var runStoreTck = (options) => {
           make_meta({ stream: s })
         );
         await store.defer([s], Date.now() + 36e5);
+        await correlate();
         await store.claim(100, 100, `w1-${uid()}`, 1e5);
+        await correlate();
         await store.claim(100, 100, `w2-${uid()}`, 1e5);
         await store.defer([s], Date.now() - 1e3);
+        await correlate();
         const leased = await store.claim(100, 100, `w3-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
@@ -2591,6 +2596,7 @@ var runStoreTck = (options) => {
         );
         await store.defer([s], Date.now() + 36e5);
         expect8(await store.reset([s])).toBe(1);
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         expect8(leased.find((l) => l.stream === s)).toBeDefined();
       });
@@ -2639,6 +2645,7 @@ var runStoreTck = (options) => {
           Date.now() + 36e5
         );
         expect8(n).toBe(2);
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         expect8(leased.find((l) => l.stream === ctl)).toBeDefined();
         expect8(leased.find((l) => l.stream === a)).toBeUndefined();
@@ -2674,6 +2681,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: ctl })
         );
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const s_lease = leased.find((l) => l.stream === s);
         const ctl_lease = leased.find((l) => l.stream === ctl);
@@ -2688,6 +2696,7 @@ var runStoreTck = (options) => {
           [inc(2)],
           make_meta({ stream: ctl })
         );
+        await correlate();
         const again = await store.claim(100, 100, `w-${uid()}`, 1e5);
         expect8(again.find((l) => l.stream === ctl)).toBeDefined();
         expect8(again.find((l) => l.stream === s)).toBeUndefined();
@@ -2700,9 +2709,11 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         await store.ack([{ ...mine, due: Date.now() - 1e3, retry: -1 }]);
+        await correlate();
         const again = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const re = again.find((l) => l.stream === s);
         expect8(re).toBeDefined();
@@ -2718,9 +2729,11 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         await store.ack([{ ...mine, due: Date.now() - 1e3, retry: 3 }]);
+        await correlate();
         const again = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const re = again.find((l) => l.stream === s);
         expect8(re).toBeDefined();
@@ -2741,12 +2754,14 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine.at).toBeLessThan(e1.id);
         await store.ack([
           { ...mine, at: e1.id, due: Date.now() - 1e3, retry: 2 }
         ]);
+        await correlate();
         const again = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const re = again.find((l) => l.stream === s);
         expect8(re).toBeDefined();
@@ -2762,6 +2777,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         await store.ack([
@@ -2780,11 +2796,13 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         expect8(mine).toBeDefined();
         await store.ack([{ ...mine, at: 99 }]);
         expect8(await store.reset([s])).toBe(1);
+        await correlate();
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
         expect8(back).toBeDefined();
@@ -2798,12 +2816,14 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const others = leased.filter((l) => l.stream !== s);
         await store.ack(others);
         await store.block([{ ...mine, error: "boom" }]);
         expect8(await store.reset([s])).toBe(1);
+        await correlate();
         const after = await store.claim(100, 0, `w2-${uid()}`, 1e5);
         expect8(after.find((l) => l.stream === s)).toBeDefined();
       });
@@ -2836,9 +2856,11 @@ var runStoreTck = (options) => {
           [inc(2)],
           make_meta({ stream: s })
         );
+        await correlate();
         const first = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = first.find((l) => l.stream === s);
         await store.ack([{ ...m1, at: m1.at }]);
+        await correlate();
         const before_block = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m2 = before_block.find((l) => l.stream === s);
         expect8(m2).toBeDefined();
@@ -2853,6 +2875,7 @@ var runStoreTck = (options) => {
         );
         expect8(blocked_flag).toBe(true);
         expect8(await store.unblock([s])).toBe(1);
+        await correlate();
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const back = after.find((l) => l.stream === s);
         expect8(back).toBeDefined();
@@ -2887,6 +2910,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s2 })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = leased.find((l) => l.stream === s1);
         const others = leased.filter((l) => l.stream !== s1);
@@ -2915,6 +2939,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s3 })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const blockable = leased.filter((l) => l.stream === s1 || l.stream === s2 || l.stream === s3).map((l) => ({ ...l, error: "boom" }));
         await store.ack(
@@ -2927,6 +2952,7 @@ var runStoreTck = (options) => {
           stream: `^unblock-filter-${tag}-`
         });
         expect8(count).toBe(2);
+        await correlate();
         const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
         expect8(after.find((l) => l.stream === s3)).toBeUndefined();
         expect8(after.find((l) => l.stream === s1)).toBeDefined();
@@ -2947,6 +2973,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s2 })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.filter((l) => l.stream === s1 || l.stream === s2);
         await store.ack(leased.filter((l) => !mine.includes(l)));
@@ -3001,6 +3028,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: other })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.filter(
           (l) => l.stream === s1 || l.stream === s2 || l.stream === other
@@ -3037,6 +3065,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s2 })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const m1 = leased.find((l) => l.stream === s1);
         await store.ack(leased.filter((l) => l.stream !== s1));
@@ -3127,6 +3156,7 @@ var runStoreTck = (options) => {
           { stream: sub_default, source: src1 },
           { stream: sub_slow, source: src2, lane: "slow" }
         ]);
+        await correlate();
         const slow = await store.claim(50, 0, `w-slow-${tag}`, 1e3, "slow");
         const slow_mine = slow.filter(
           (l) => l.stream === sub_default || l.stream === sub_slow
@@ -3134,6 +3164,7 @@ var runStoreTck = (options) => {
         expect8(slow_mine.map((l) => l.stream)).toEqual([sub_slow]);
         expect8(slow_mine[0]?.lane).toBe("slow");
         await store.ack(slow_mine.map((l) => ({ ...l, at: l.at + 1 })));
+        await correlate();
         const all = await store.claim(50, 0, `w-all-${tag}`, 1e3);
         const all_mine = all.filter((l) => l.stream === sub_default || l.stream === sub_slow).map((l) => ({ stream: l.stream, lane: l.lane }));
         expect8(all_mine).toEqual(
@@ -3193,6 +3224,7 @@ var runStoreTck = (options) => {
           { stream: a, source: src, lane: `rslow-${tag}` },
           { stream: b, source: src, lane: `rfast-${tag}` }
         ]);
+        await correlate();
         const leases = await store.claim(50, 0, `w-${tag}`, 5e3);
         const mine = leases.filter((l) => l.stream === a || l.stream === b);
         await store.ack(mine.map((l) => ({ ...l, at: l.at + 1 })));
@@ -3222,6 +3254,7 @@ var runStoreTck = (options) => {
           { stream: a, source: src, lane: `uslow-${tag}` },
           { stream: b, source: src, lane: `ufast-${tag}` }
         ]);
+        await correlate();
         const leases = await store.claim(50, 0, `w-${tag}`, 5e3);
         const mine = leases.filter((l) => l.stream === a || l.stream === b);
         await store.block(mine.map((l) => ({ ...l, error: "boom" })));
@@ -3612,6 +3645,7 @@ var runStoreTck = (options) => {
           [inc(1)],
           make_meta({ stream: s })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === s);
         const others = leased.filter((l) => l.stream !== s);
@@ -3860,6 +3894,7 @@ var runStoreTck = (options) => {
           [inc(2)],
           make_meta({ stream: b })
         );
+        await correlate();
         const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
         const mine = leased.find((l) => l.stream === a);
         expect8(mine).toBeDefined();