@rotorsoft/act 1.32.15 → 1.32.16

package/dist/index.js

@@ -1684,7 +1684,7 @@ var CorrelateCycle = class {
     this._initialized = true;
   }
   async _run_init() {
-    const { watermark, correlated_at } = await store().subscribe([
+    const { watermark, correlated_at } = await this._cd.subscribe([
       ...this._static_targets
     ]);
     this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - this._cold_start_back_scan);
@@ -2756,7 +2756,16 @@ function warn_misrouted(seen, stream, handler, event) {
     `Reaction "${handler}" on "${event}" resolved to target "${stream}", which a projection already serves. A target is served by one batch handler or one state projection, so this reaction can never run \u2014 and delivering to it would hand the projection an aggregate from another stream. Skipping it. The equivalent static \`.to({ target })\` is rejected at build; a dynamic resolver's target is only knowable here.`
   );
 }
-async function run_drain_cycle(ops, registry, batch_handlers, misrouted, store_failing, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
+async function run_drain_cycle(deps, cycle) {
+  const { ops, registry, batch_handlers, handle, handle_batch, lane } = deps;
+  const {
+    lagging,
+    leading,
+    eventLimit,
+    leaseMillis,
+    misrouted,
+    store_failing
+  } = cycle;
   const leased = await ops.claim(
     lagging,
     leading,
@@ -2828,7 +2837,7 @@ async function run_drain_cycle(ops, registry, batch_handlers, misrouted, store_f
   const blocked = await ops.block(
     handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }))
   );
-  if (blocked.length) on_blocked(blocked);
+  if (blocked.length) deps.on_blocked(blocked);
   const submitted = handled.flatMap((h, i) => {
     const advance = h.handled > 0 ? h.acked_at : leased[i].at;
     return h.defer !== void 0 ? { ...h.lease, at: advance, due: h.defer, retry: -1 } : h.next_attempt_at !== void 0 ? { ...h.lease, at: advance, due: h.next_attempt_at } : h.handled > 0 || !h.error ? { ...h.lease, at: h.acked_at } : [];
@@ -2959,21 +2968,14 @@ var DrainController = class {
       });
       const lagging = Math.ceil(streamLimit * this._ratio);
       const leading = streamLimit - lagging;
-      const cycle = await run_drain_cycle(
-        this._deps.ops,
-        this._deps.registry,
-        this._deps.batch_handlers,
-        this._misrouted,
-        this._deps.breaker.failing,
-        this._deps.handle,
-        this._deps.handle_batch,
+      const cycle = await run_drain_cycle(this._deps, {
         lagging,
         leading,
         eventLimit,
         leaseMillis,
-        (b) => this._deps.on_blocked(b),
-        this._deps.lane
-      );
+        misrouted: this._misrouted,
+        store_failing: this._deps.breaker.failing
+      });
       if (!cycle) {
         this._deps.breaker.passed();
         this._armed = false;