@rotorsoft/act 1.23.38 → 1.23.39

package/dist/index.js

@@ -2616,13 +2616,6 @@ var EMPTY_DRAIN = {
   acked: [],
   blocked: []
 };
-var contain = (logger, sink, fn) => {
-  try {
-    fn();
-  } catch (error) {
-    logger.error(error, `${sink} listener threw`);
-  }
-};
 var DrainController = class {
   _armed = false;
   _locked = false;
@@ -2731,7 +2724,7 @@ var DrainController = class {
         leading,
         eventLimit,
         leaseMillis,
-        (b) => contain(this._deps.logger, "blocked", () => this._deps.on_blocked(b)),
+        (b) => this._deps.on_blocked(b),
         this._deps.lane
       );
       if (!cycle) {
@@ -2749,8 +2742,7 @@ var DrainController = class {
         if (next !== void 0) this._defer.set(h.lease.stream, next);
       }
       if (this._defer.size > 0) this._defer.schedule();
-      if (acked.length)
-        contain(this._deps.logger, "acked", () => this._deps.on_acked(acked));
+      if (acked.length) this._deps.on_acked(acked);
       if (closeable.length) await this._deps.on_close(closeable);
       this._deps.breaker.passed();
       const has_errors = handled.some(({ error }) => error);
@@ -3029,8 +3021,7 @@ var SettleLoop = class {
           const made_progress = subscribed > 0 || drain.acked.length > 0 || drain.blocked.length > 0 || last_id > after_before;
           if (!made_progress) break;
         }
-        if (settled_drain)
-          contain(log(), "settled", () => this._deps.on_settled(settled_drain));
+        if (settled_drain) this._deps.on_settled(settled_drain);
       })().catch((err) => {
         this._deps.breaker.failed(Date.now(), err);
       }).finally(() => {
@@ -3102,9 +3093,41 @@ var Act = class {
   /**
    * Emit a lifecycle event. The payload type is inferred from the event name
    * via {@link ActLifecycleEvents}.
+   *
+   * **Every listener is contained individually.** Lifecycle listeners are
+   * observers — `observability.md` promises that a throwing one is "contained,
+   * not fatal" — and containment belongs here rather than at each call site,
+   * for two reasons the previous arrangement got wrong (#1437):
+   *
+   * - Wrapping the *emit* rather than each *listener* still let the first
+   *   thrower abort the rest: `EventEmitter.emit` stops dispatching on the
+   *   first exception, so a second `app.on("acked", …)` never ran. The
+   *   documented "the remaining sinks still fire" was false whenever an event
+   *   had more than one listener. Same lesson as #1423, where guarding the
+   *   loop instead of each callback left every later SSE subscriber unserved.
+   * - Only *some* call sites wrapped at all. The drain contained `acked` and
+   *   `blocked`; `committed`, `forgotten` and `close()`'s `closed` did not, so
+   *   a throwing listener rejected `do()`, `forget()` and `close()` **after**
+   *   their durable work had already landed. A caller retrying a "failed"
+   *   `do()` writes the event twice, since the framework has no dedup by
+   *   design.
+   *
+   * Containing here makes it a property of emitting, so a new lifecycle event
+   * cannot reintroduce the gap by omission.
+   *
+   * Uses `rawListeners` so `once` wrappers still de-register themselves, and
+   * returns "had listeners" to preserve the `EventEmitter.emit` contract.
    */
   emit(event, args) {
-    return this._emitter.emit(event, args);
+    const listeners = this._emitter.rawListeners(event);
+    for (const listener of listeners) {
+      try {
+        listener(args);
+      } catch (error) {
+        this._logger.error(error, `${String(event)} listener threw`);
+      }
+    }
+    return listeners.length > 0;
   }
   /**
    * The single store-failure handler: log it, then emit the `error`
@@ -3346,11 +3369,7 @@ var Act = class {
             with_stream_lock: (stream, work) => this._with_close_lock(stream, work)
           });
           this._forget_closed_subscriptions(result);
-          try {
-            this.emit("closed", result);
-          } catch (err) {
-            this._logger.error(err, "closed listener threw");
-          }
+          this.emit("closed", result);
         },
         breaker: this._breaker,
         // Re-scope the per-lane worker's auto-start ticks so their drain