@rotorsoft/act 1.33.11 → 1.33.13

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-F4F7CYBN.js";
+} from "./chunk-MSD67APM.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -70,7 +70,7 @@ import {
   pii_fields,
   pii_schemas,
   sensitive
-} from "./chunk-2FOO4S2J.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,12 +1255,13 @@ 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,
+      read: false,
       marked: 0,
       scanned: false
     });
@@ -1360,6 +1355,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 +1389,11 @@ var CorrelateCycle = class {
             lane
           });
       }
-      return { subscribed, last_id, marked, scanned: true };
+      return { subscribed, last_id, read, marked, scanned: true };
     }
     this._checkpoint = last_id;
     if (!stopped && found !== query.limit) this._lowered = raised;
-    return { subscribed: 0, last_id, marked: 0, scanned: true };
+    return { subscribed: 0, last_id, read, marked: 0, scanned: true };
   }
   /**
    * Read the row of each target this scan had no record of (new or evicted),
@@ -2354,6 +2350,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 +2384,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 +2441,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 +2492,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 +2859,23 @@ 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 { subscribed, read, scanned } = await this._deps.correlate(correlate_query);
           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 = subscribed > 0 || drain.leased.length > 0 || 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,8 +3180,6 @@ var Act = class {
   _build_settle(options) {
     return new SettleLoop(
       {
-        init: () => this._scoped(() => this._correlate.init()),
-        checkpoint: () => this._correlate.checkpoint,
         correlate: (q) => this._correlate_scanned(
           { ...q, limit: q.limit ?? this._poll_limit ?? 100 },
           true
@@ -3199,9 +3195,10 @@ var Act = class {
   }
   _shutdown_promise;
   /**
-   * Per-instance teardown: stops scheduling, gives the cycles in flight up
-   * to `graceMs` to reach their `ack` (an abandoned handler holds its lease
-   * until it expires), then removes listeners and the notify subscription.
+   * Per-instance teardown: stops scheduling, removes the notify
+   * subscription, gives the cycles in flight up to `graceMs` to reach their
+   * `ack` (an abandoned handler holds its lease until it expires), then
+   * hands back the correlation lease and removes listeners.
    * The budget is a ceiling, not a delay.
    *
    * Idempotent: repeated calls return the same promise, with the first
@@ -3513,27 +3510,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
@@ -3557,11 +3547,12 @@ var Act = class {
   }
   /** `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 };
+    if (!this._drain)
+      return { subscribed: 0, last_id: -1, read: false, scanned: false };
     return this._scoped(async () => {
-      const { subscribed, last_id, marked, scanned } = await this._correlate.correlate(query, lease);
+      const { subscribed, last_id, read, marked, scanned } = await this._correlate.correlate(query, lease);
       if (subscribed > 0 || marked > 0) this._arm_all();
-      return { subscribed, last_id, scanned };
+      return { subscribed, last_id, read, scanned };
     });
   }
   /**
@@ -3885,10 +3876,8 @@ var Act = class {
    * A local change that frees reaction work (a commit, `reset()`,
    * `unblock()`, `restore()`) schedules this on its own unless the app
    * sets `autoSettle: false`. Call it at startup, to run what was pending
-   * before a restart, or with options for the next pass. A pass already
-   * scheduled is never put off: calls before it runs join it (a shorter
-   * `debounceMs` brings it forward), and a call during a running cycle
-   * queues one more pass after it. Runs correlate→drain in a loop until a pass makes no
+   * before a restart, or with options for the next pass; the scheduling
+   * rule is in the event-sourcing docs (§ settle). Runs correlate→drain in a loop until a pass makes no
    * progress — no new subscriptions, no events read, no streams leased —
    * then emits the `"settled"` lifecycle event, so one call fully catches
    * up paginated streams without forcing callers to loop.