@rotorsoft/act 1.33.12 → 1.33.14

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-YZ2NKMVS.js";
+} from "./chunk-MSD67APM.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -70,7 +70,7 @@ import {
   pii_fields,
   pii_schemas,
   sensitive
-} from "./chunk-URF33KO3.js";
+} from "./chunk-CAL4XEVN.js";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -1156,7 +1156,6 @@ function report_lane_conflict(seen, handler, target, kept, dropped) {
 }
 var CorrelateCycle = class {
   _checkpoint = -1;
-  _initialized = false;
   /** Lease holder id; per instance, so a restart never inherits a stale claim. */
   _by = randomUUID();
   _key;
@@ -1210,16 +1209,12 @@ var CorrelateCycle = class {
   arm() {
     this._raised++;
   }
-  async init() {
-    if (this._initialized) return;
-    if (!this._init_promise) {
-      this._init_promise = this._run_init().catch((error) => {
-        this._init_promise = void 0;
-        throw error;
-      });
-    }
+  async _init() {
+    this._init_promise ??= this._run_init().catch((error) => {
+      this._init_promise = void 0;
+      throw error;
+    });
     await this._init_promise;
-    this._initialized = true;
   }
   async _run_init() {
     const { watermark, correlated_at } = await this._cd.subscribe([
@@ -1237,7 +1232,6 @@ var CorrelateCycle = class {
   }
   /** After `restore` replaced the log: forget everything and cold-start again. */
   restart() {
-    this._initialized = false;
     this._init_promise = void 0;
     this._checkpoint = -1;
     this._dynamic_subscriptions.clear();
@@ -1261,14 +1255,12 @@ var CorrelateCycle = class {
     return pattern.test(stream);
   }
   /** Scan past the checkpoint, subscribe new targets and raise their work marks. */
-  async correlate(query = { after: -1, limit: 10 }, lease = false) {
-    await this.init();
+  async correlate(query, lease = false) {
+    await this._init();
     const epoch = this._epoch;
     const idle = () => ({
-      subscribed: 0,
-      last_id: this._checkpoint,
-      marked: 0,
-      scanned: false
+      kind: "idle",
+      last_id: this._checkpoint
     });
     if (this._raised === this._lowered) return idle();
     const raised = this._raised;
@@ -1360,6 +1352,7 @@ var CorrelateCycle = class {
       { ...query, after, with_pii: false }
     );
     if (this._declared_lanes.size > 1) await this._recall(correlated);
+    const read = last_id > after;
     if (this._epoch !== epoch) return idle();
     const streams = [];
     for (const [stream, entry] of correlated) {
@@ -1393,11 +1386,11 @@ var CorrelateCycle = class {
             lane
           });
       }
-      return { subscribed, last_id, marked, scanned: true };
+      return { kind: "scanned", last_id, subscribed, marked, read };
     }
     this._checkpoint = last_id;
     if (!stopped && found !== query.limit) this._lowered = raised;
-    return { subscribed: 0, last_id, marked: 0, scanned: true };
+    return { kind: "scanned", last_id, subscribed: 0, marked: 0, read };
   }
   /**
    * Read the row of each target this scan had no record of (new or evicted),
@@ -2354,6 +2347,14 @@ var EMPTY_DRAIN = {
   acked: [],
   blocked: []
 };
+function merge_drains(drains) {
+  return {
+    fetched: drains.flatMap((d) => d.fetched),
+    leased: drains.flatMap((d) => d.leased),
+    acked: drains.flatMap((d) => d.acked),
+    blocked: drains.flatMap((d) => d.blocked)
+  };
+}
 var RETRY = "";
 var DrainController = class {
   /**
@@ -2380,9 +2381,8 @@ var DrainController = class {
   _worker;
   _misrouted = /* @__PURE__ */ new Set();
   _stopped = false;
-  /** Never rejects; graceful shutdown waits on it. */
+  /** The pass in flight. Never rejects; graceful shutdown waits on it. */
   _inflight;
-  _inflight_done;
   _deps;
   constructor(deps) {
     this._deps = deps;
@@ -2438,10 +2438,17 @@ var DrainController = class {
     const leaseMillis = d.leaseMillis ?? options.leaseMillis ?? DEFAULT_LEASE_MILLIS;
     if (this._deps.breaker.state(Date.now()) === "open")
       return EMPTY_DRAIN;
+    const pass = this._pass(streamLimit, eventLimit, leaseMillis).finally(
+      () => {
+        this._inflight = void 0;
+      }
+    );
+    this._inflight = pass;
+    return pass;
+  }
+  /** One claim → fetch → handle → ack pass. Never throws. */
+  async _pass(streamLimit, eventLimit, leaseMillis) {
     try {
-      this._inflight = new Promise((done) => {
-        this._inflight_done = done;
-      });
       const lagging = Math.ceil(streamLimit * this._ratio);
       const leading = streamLimit - lagging;
       const started = Date.now();
@@ -2482,9 +2489,6 @@ var DrainController = class {
       return EMPTY_DRAIN;
     } finally {
       if (!this._stopped) this._defer.schedule();
-      this._inflight = void 0;
-      this._inflight_done?.();
-      this._inflight_done = void 0;
     }
   }
 };
@@ -2852,32 +2856,24 @@ var SettleLoop = class {
       this._timer = void 0;
       const {
         debounceMs: _,
-        correlate: correlate_query = {},
+        // Every pass scans from correlation's own checkpoint.
+        correlate: { after: _after, ...correlate_query } = {},
         maxPasses = Infinity,
         ...drain_options
       } = this._next ?? {};
       this._next = void 0;
       this._inflight = (async () => {
-        await this._deps.init();
-        let settled_drain;
+        const passes = [];
         for (let i = 0; i < maxPasses && !this._stopped; i++) {
-          const after_before = this._deps.checkpoint();
-          const { subscribed, last_id, scanned } = await this._deps.correlate({
-            ...correlate_query,
-            after: after_before
-          });
+          const pass = await this._deps.correlate(correlate_query);
+          const scanned = pass.kind === "scanned";
           if (scanned) this._deps.breaker.passed();
           const drain = await this._deps.drain(drain_options);
-          settled_drain = settled_drain ? {
-            fetched: [...settled_drain.fetched, ...drain.fetched],
-            leased: [...settled_drain.leased, ...drain.leased],
-            acked: [...settled_drain.acked, ...drain.acked],
-            blocked: [...settled_drain.blocked, ...drain.blocked]
-          } : drain;
-          const made_progress = subscribed > 0 || drain.leased.length > 0 || last_id > after_before;
+          passes.push(drain);
+          const made_progress = drain.leased.length > 0 || scanned && (pass.subscribed > 0 || pass.read);
           if (!made_progress) break;
         }
-        if (settled_drain) this._deps.on_settled(settled_drain);
+        if (passes.length) this._deps.on_settled(merge_drains(passes));
       })().catch((err) => {
         this._deps.breaker.failed(Date.now(), err);
       }).finally(() => {
@@ -3182,9 +3178,7 @@ var Act = class {
   _build_settle(options) {
     return new SettleLoop(
       {
-        init: () => this._scoped(() => this._correlate.init()),
-        checkpoint: () => this._correlate.checkpoint,
-        correlate: (q) => this._correlate_scanned(
+        correlate: (q) => this._correlate_pass(
           { ...q, limit: q.limit ?? this._poll_limit ?? 100 },
           true
         ),
@@ -3247,15 +3241,16 @@ var Act = class {
     if (running.length === 0 && !settling) return;
     const grace = grace_ms ?? this._derive_grace_ms(running, !!settling);
     if (grace <= 0) return;
-    const inflight = running.map((c) => c.inflight);
-    if (settling) inflight.push(settling);
     let timer;
     const budget = new Promise((resolve) => {
       timer = setTimeout(resolve, grace);
       timer.unref();
     });
     try {
-      await Promise.race([Promise.all(inflight), budget]);
+      await Promise.race([
+        Promise.all([...running.map((c) => c.inflight), settling]),
+        budget
+      ]);
     } finally {
       clearTimeout(timer);
     }
@@ -3514,27 +3509,20 @@ var Act = class {
   }
   /** In parallel, so a slow lane never holds up a fast one. */
   async _drain_all(options) {
-    const results = await Promise.all(
-      [...this._drain_controllers.values()].map((c) => c.drain(options))
+    const merged = merge_drains(
+      await Promise.all(
+        [...this._drain_controllers.values()].map((c) => c.drain(options))
+      )
     );
-    const fetched = [];
-    const leased = [];
-    const acked = [];
-    const blocked = [];
-    for (const r of results) {
-      fetched.push(
-        ...r.fetched.map((f) => ({
-          ...f,
-          events: f.events.map(
-            (e) => this.registry.query_gate(e.name)(e)
-          )
-        }))
-      );
-      leased.push(...r.leased);
-      acked.push(...r.acked);
-      blocked.push(...r.blocked);
-    }
-    return { fetched, leased, acked, blocked };
+    return {
+      ...merged,
+      fetched: merged.fetched.map((f) => ({
+        ...f,
+        events: f.events.map(
+          (e) => this.registry.query_gate(e.name)(e)
+        )
+      }))
+    };
   }
   /**
    * Scans committed events from the correlation checkpoint, subscribes the
@@ -3553,16 +3541,20 @@ var Act = class {
    * @see {@link start_correlations} for automatic periodic correlation
    */
   async correlate(query = { after: -1, limit: 10 }) {
-    const { subscribed, last_id } = await this._correlate_scanned(query);
-    return { subscribed, last_id };
+    const pass = await this._correlate_pass(query);
+    return {
+      subscribed: pass.kind === "scanned" ? pass.subscribed : 0,
+      last_id: pass.last_id
+    };
   }
-  /** `correlate` plus `scanned`, which settle needs for the breaker. */
-  async _correlate_scanned(query, lease = false) {
-    if (!this._drain) return { subscribed: 0, last_id: -1, scanned: false };
+  /** One correlate pass; arms every lane when it found work. */
+  async _correlate_pass(query, lease = false) {
+    if (!this._drain) return { kind: "idle", last_id: -1 };
     return this._scoped(async () => {
-      const { subscribed, last_id, marked, scanned } = await this._correlate.correlate(query, lease);
-      if (subscribed > 0 || marked > 0) this._arm_all();
-      return { subscribed, last_id, scanned };
+      const pass = await this._correlate.correlate(query, lease);
+      if (pass.kind === "scanned" && (pass.subscribed > 0 || pass.marked > 0))
+        this._arm_all();
+      return pass;
     });
   }
   /**