@rotorsoft/act 1.33.1 → 1.33.3

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-NYH6FNTM.js";
+} from "./chunk-NNTF627K.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -70,7 +70,7 @@ import {
   pii_fields,
   pii_schemas,
   sensitive
-} from "./chunk-TJ4JRRUR.js";
+} from "./chunk-KHFMCJDR.js";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -2785,10 +2785,9 @@ function build_handle_batch(logger) {
 // src/internal/settle.ts
 var SettleLoop = class {
   _timer = void 0;
-  _running = false;
   /**
-   * Resolves when the cycle in flight finishes, so shutdown can wait for
-   * it (`stop()` cancels scheduling only). Never rejects.
+   * The cycle in flight, set while one runs. Shutdown waits for it
+   * (`stop()` cancels scheduling only). Never rejects.
    */
   _inflight;
   /** A wake-up arrived while a cycle ran: run one more pass after it. */
@@ -2820,7 +2819,7 @@ var SettleLoop = class {
   schedule(options) {
     if (this._stopped) return;
     if (options) this._next = options;
-    if (this._running) {
+    if (this._inflight) {
       this._pending = true;
       return;
     }
@@ -2840,15 +2839,10 @@ var SettleLoop = class {
         ...drain_options
       } = this._next ?? {};
       this._next = void 0;
-      this._running = true;
-      let settle_done;
-      this._inflight = new Promise((done) => {
-        settle_done = done;
-      });
-      (async () => {
+      this._inflight = (async () => {
         await this._deps.init();
         let settled_drain;
-        for (let i = 0; i < maxPasses; i++) {
+        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,
@@ -2869,9 +2863,7 @@ var SettleLoop = class {
       })().catch((err) => {
         this._deps.breaker.failed(Date.now(), err);
       }).finally(() => {
-        this._running = false;
         this._inflight = void 0;
-        settle_done();
         if (this._pending) {
           this._pending = false;
           this.schedule(this._next);
@@ -3178,7 +3170,9 @@ var Act = class {
           { ...q, limit: q.limit ?? this._poll_limit ?? 100 },
           true
         ),
-        drain: (o) => this.drain(o),
+        // `settle()` validated the options, and `_schedule` skips writer-only
+        // instances, so the loop drains through the internal path.
+        drain: (o) => this._scoped(() => this._drain_all(o)),
         on_settled: (drain) => this.emit("settled", drain),
         breaker: this._breaker
       },
@@ -3256,12 +3250,7 @@ var Act = class {
       return await s.notify((notification) => {
         try {
           this.emit("notified", notification);
-          if (this._drain) {
-            const armed = this._arm_for_event_names(
-              notification.events.map((e) => e.name)
-            );
-            this._settle_armed(armed);
-          }
+          this._wake(notification.events.map((e) => e.name));
         } catch (err) {
           this._logger.error(err, "notified handler threw");
         }
@@ -3319,10 +3308,7 @@ var Act = class {
         payload,
         do_options
       );
-      const armed = this._arm_for_event_names(
-        snapshots.map((s) => s.event.name)
-      );
-      this._settle_armed(armed);
+      this._wake(snapshots.map((s) => s.event.name));
       this.emit("committed", snapshots);
       return snapshots;
     });
@@ -3469,17 +3455,21 @@ var Act = class {
       return { fetched: [], leased: [], acked: [], blocked: [] };
     return this._scoped(() => this._drain_all(options));
   }
+  /** Arms correlate and every lane; false on an app with no reactions. */
   _arm_all() {
-    if (!this._reactive) return;
+    if (!this._reactive) return false;
     this._correlate.arm();
     for (const c of this._drain_controllers.values()) c.arm();
+    return true;
   }
   /**
-   * Settles what a change armed (a commit, a reset, an unblock, a restore,
-   * a notification from another process), unless the app walks the
-   * pipeline itself (`autoSettle: false`).
+   * Wakes what a change freed (a commit, a reset, an unblock, a restore,
+   * a notification from another process): arms the lanes these events
+   * react on, or every lane without names, and settles them unless the app
+   * walks the pipeline itself (`autoSettle: false`).
    */
-  _settle_armed(armed) {
+  _wake(names) {
+    const armed = names ? this._arm_for_event_names(names) : this._arm_all();
     if (armed && this._auto_settle) this._schedule();
   }
   /** Schedules a settle pass; writer-only instances (`drain: false`) skip it. */
@@ -3559,7 +3549,7 @@ var Act = class {
   /**
    * Starts a background poll that settles on a timer: each tick looks for
    * new events, subscribes the streams their reactions target, and drains
-   * them.
+   * them, along with any stream whose lease a dead worker let expire.
    *
    * Use it when this process can miss commits — another process writes to a
    * store without `notify`, or a notification is lost. It is the safety net
@@ -3588,7 +3578,7 @@ var Act = class {
     if (this._poll) return false;
     this._poll_limit = query.limit || void 0;
     this._poll = setInterval(() => {
-      this._correlate.arm();
+      this._arm_all();
       this._schedule();
     }, frequency);
     return true;
@@ -3647,8 +3637,7 @@ var Act = class {
       for (const handler of this._batch_handlers.values())
         handler[FOLD_RESET]?.();
       if (count > 0) {
-        this._arm_all();
-        this._settle_armed(this._reactive);
+        this._wake();
       }
       return count;
     });
@@ -3682,8 +3671,7 @@ var Act = class {
     return this._scoped(async () => {
       const count = await store().unblock(input);
       if (count > 0) {
-        this._arm_all();
-        this._settle_armed(this._reactive);
+        this._wake();
       }
       return count;
     });
@@ -3745,8 +3733,7 @@ var Act = class {
       });
       if (!sink) {
         this._correlate.restart();
-        this._arm_all();
-        this._settle_armed(this._reactive);
+        this._wake();
       }
       return { kept, migrated, dropped, duration_ms: Date.now() - started };
     });
@@ -3892,7 +3879,8 @@ var Act = class {
    *   `debounceMs` (default 10), `correlate.limit` (default 100, or the
    *   poll's limit while `start_correlations` runs; `after` is always the
    *   checkpoint),
-   *   `maxPasses` (default `Infinity` — kill-switch for runaway loops),
+   *   `maxPasses` (default `Infinity`; caps this settle's passes, not the
+   *   passes a reaction chain's own commits schedule),
    *   `streamLimit` (default 10), `eventLimit` (default 10),
    *   `leaseMillis` (default 10000).
    *