abxbus 2.4.32 → 2.5.1

package/dist/esm/EventBus.js

@@ -141,6 +141,7 @@ class EventBus {
   find_waiters;
   // set of EphemeralFindEventHandler objects that are waiting for a matching future event
   middlewares;
+  destroyed;
   static normalizeMiddlewares(middlewares) {
     const normalized = [];
     for (const middleware of middlewares ?? []) {
@@ -162,9 +163,9 @@ class EventBus {
     this.event_handler_concurrency = options.event_handler_concurrency ?? "serial";
     this.event_handler_completion = options.event_handler_completion ?? "all";
     this.event_handler_detect_file_paths = options.event_handler_detect_file_paths ?? true;
-    this.event_timeout = options.event_timeout === void 0 ? 60 : options.event_timeout;
-    this.event_handler_slow_timeout = options.event_handler_slow_timeout === void 0 ? 30 : options.event_handler_slow_timeout;
-    this.event_slow_timeout = options.event_slow_timeout === void 0 ? 300 : options.event_slow_timeout;
+    this.event_timeout = options.event_timeout ?? 60;
+    this.event_handler_slow_timeout = options.event_handler_slow_timeout ?? 30;
+    this.event_slow_timeout = options.event_slow_timeout ?? 300;
     this.runloop_running = false;
     this.handlers = /* @__PURE__ */ new Map();
     this.handlers_by_key = /* @__PURE__ */ new Map();
@@ -177,6 +178,7 @@ class EventBus {
     this.in_flight_event_ids = /* @__PURE__ */ new Set();
     this.locks = new LockManager(this);
     this.middlewares = EventBus.normalizeMiddlewares(options.middlewares);
+    this.destroyed = false;
     this.all_instances.add(this);
     this.dispatch = this.dispatch.bind(this);
     this.emit = this.emit.bind(this);
@@ -263,7 +265,7 @@ class EventBus {
   }
   async _runHandlersWithTimeout(event, pending_entries, event_timeout, fn) {
     try {
-      if (event_timeout === null || pending_entries.length === 0) {
+      if (event_timeout === null || event_timeout <= 0 || pending_entries.length === 0) {
         await fn();
       } else {
         await _runWithTimeout(event_timeout, () => this._createEventTimeoutError(event, pending_entries, event_timeout), fn);
@@ -400,10 +402,11 @@ class EventBus {
       options.event_handler_detect_file_paths = record.event_handler_detect_file_paths;
     }
     const bus = new EventBus(name, options);
-    if (!record.handlers || typeof record.handlers !== "object" || Array.isArray(record.handlers)) {
+    const raw_handlers = record.handlers ?? {};
+    if (!raw_handlers || typeof raw_handlers !== "object" || Array.isArray(raw_handlers)) {
       throw new Error("EventBus.fromJSON(data) requires handlers as an id-keyed object");
     }
-    for (const [handler_id, payload] of Object.entries(record.handlers)) {
+    for (const [handler_id, payload] of Object.entries(raw_handlers)) {
       if (!payload || typeof payload !== "object") {
         continue;
       }
@@ -416,11 +419,12 @@ class EventBus {
       );
       bus.handlers.set(parsed.id, parsed);
     }
-    if (!record.handlers_by_key || typeof record.handlers_by_key !== "object" || Array.isArray(record.handlers_by_key)) {
+    const raw_handlers_by_key = record.handlers_by_key ?? {};
+    if (!raw_handlers_by_key || typeof raw_handlers_by_key !== "object" || Array.isArray(raw_handlers_by_key)) {
       throw new Error("EventBus.fromJSON(data) requires handlers_by_key as an object");
     }
     bus.handlers_by_key.clear();
-    for (const [raw_key, raw_ids] of Object.entries(record.handlers_by_key)) {
+    for (const [raw_key, raw_ids] of Object.entries(raw_handlers_by_key)) {
       if (!Array.isArray(raw_ids)) {
         continue;
       }
@@ -493,21 +497,49 @@ class EventBus {
   removeEventFromHistory(event_id) {
     return this.event_history.delete(event_id);
   }
-  // destroy the event bus and all its state to allow for garbage collection
-  destroy() {
-    this.all_instances.discard(this);
-    this.handlers.clear();
-    this.handlers_by_key.clear();
-    for (const event of this.event_history.values()) {
-      event._gc();
+  _raiseIfDestroyed() {
+    if (this.destroyed) {
+      throw new Error(`${this.toString()} has been destroyed and cannot be used again`);
     }
-    this.event_history.clear();
-    this.pending_event_queue.length = 0;
-    this.in_flight_event_ids.clear();
-    this.find_waiters.clear();
-    this.locks.clear();
+  }
+  destroy(clear_or_options = true) {
+    const clear = typeof clear_or_options === "object" && clear_or_options !== null ? clear_or_options.clear ?? true : clear_or_options;
+    if (this.destroyed) {
+      if (clear) {
+        this.handlers.clear();
+        this.handlers_by_key.clear();
+        this.event_history.clear();
+        this.middlewares.length = 0;
+      }
+      return Promise.resolve();
+    }
+    const finish = () => {
+      this.destroyed = true;
+      this.all_instances.discard(this);
+      this.runloop_running = false;
+      for (const waiter of Array.from(this.find_waiters)) {
+        if (waiter.timeout_id) {
+          clearTimeout(waiter.timeout_id);
+        }
+        this.find_waiters.delete(waiter);
+        waiter.resolve(null);
+      }
+      this.pending_event_queue.length = 0;
+      this.in_flight_event_ids.clear();
+      this.locks.clear();
+      if (!clear) {
+        return;
+      }
+      this.handlers.clear();
+      this.handlers_by_key.clear();
+      this.event_history.clear();
+      this.middlewares.length = 0;
+    };
+    finish();
+    return Promise.resolve();
   }
   on(event_pattern, handler, options = {}) {
+    this._raiseIfDestroyed();
     const normalized_key = normalizeEventPattern(event_pattern);
     const handler_name = EventHandler.handlerNameFromCallable(handler);
     const handler_entry = new EventHandler({
@@ -532,6 +564,7 @@ class EventBus {
     return handler_entry;
   }
   off(event_pattern, handler) {
+    this._raiseIfDestroyed();
     const normalized_key = normalizeEventPattern(event_pattern);
     if (typeof handler === "object" && handler instanceof EventHandler && handler.id !== void 0) {
       handler = handler.id;
@@ -552,7 +585,12 @@ class EventBus {
     }
   }
   emit(event) {
+    this._raiseIfDestroyed();
     const original_event = event._event_original ?? event;
+    const current_result = this.locks._getRawActiveHandlerResultForCurrentAsyncContext();
+    if (current_result && current_result.status !== "pending" && current_result.status !== "started" && (current_result.error instanceof EventHandlerTimeoutError || current_result.error instanceof EventHandlerCancelledError || current_result.error instanceof EventHandlerAbortedError)) {
+      return original_event;
+    }
     if (!original_event.event_bus) {
       original_event.event_bus = this;
     }
@@ -590,7 +628,11 @@ class EventBus {
     this._resolveFindWaiters(original_event);
     original_event.event_pending_bus_count += 1;
     this.pending_event_queue.push(original_event);
-    this._startRunloop();
+    if (this.locks.getLockForEvent(original_event) === null) {
+      this._startParallelEventTaskFromQueue(original_event);
+    } else {
+      this._startRunloop();
+    }
     return this._getEventProxyScopedToThisBus(original_event);
   }
   // alias for emit
@@ -612,6 +654,7 @@ class EventBus {
     return results.length > 0 ? results[0] : null;
   }
   async filter(event_pattern, where_or_options = {}, maybe_options = {}) {
+    this._raiseIfDestroyed();
     const where = typeof where_or_options === "function" ? where_or_options : () => true;
     const options = typeof where_or_options === "function" ? maybe_options : where_or_options;
     const matches = await this.event_history.filter(event_pattern, where, {
@@ -642,6 +685,7 @@ class EventBus {
     });
   }
   async waitUntilIdle(timeout = null) {
+    this._raiseIfDestroyed();
     return await this.locks.waitForIdle(timeout);
   }
   // Weak idle check: only checks if handlers are idle, doesnt check that the queue is empty
@@ -692,6 +736,7 @@ class EventBus {
     return this.event_history.get(event_id) ?? this.all_instances.findEventById(event_id);
   }
   _startRunloop() {
+    this._raiseIfDestroyed();
     if (this.runloop_running) {
       return;
     }
@@ -700,6 +745,21 @@ class EventBus {
       void this._runloop();
     });
   }
+  _startParallelEventTaskFromQueue(event) {
+    if (this.in_flight_event_ids.has(event.event_id)) {
+      return;
+    }
+    const queue_index = this.pending_event_queue.indexOf(event);
+    if (queue_index >= 0) {
+      this.pending_event_queue.splice(queue_index, 1);
+    } else if (event.event_status === "completed") {
+      return;
+    }
+    this.in_flight_event_ids.add(event.event_id);
+    this.scheduleMicrotask(() => {
+      void this._processEvent(event);
+    });
+  }
   // schedule the processing of an event on the event bus by its normal _runloop
   // optionally using a pre-acquired lock if we're inside handling of a parent event
   async _processEvent(event, options = {}) {
@@ -713,6 +773,7 @@ class EventBus {
       event._markStarted();
       pending_entries = event._createPendingHandlerResults(this);
       const resolved_event_timeout = event.event_timeout ?? this.event_timeout;
+      const resolved_event_slow_timeout = event.event_slow_timeout ?? this.event_slow_timeout;
       if (this.middlewares.length > 0) {
         for (const entry of pending_entries) {
           await this._onEventResultChange(scoped_event, entry.result, "pending");
@@ -724,7 +785,10 @@ class EventBus {
           event,
           pending_entries,
           resolved_event_timeout,
-          () => _runWithSlowMonitor(event._createSlowEventWarningTimer(), () => scoped_event._runHandlers(pending_entries))
+          () => _runWithSlowMonitor(
+            event._createSlowEventWarningTimer(resolved_event_slow_timeout, this.name),
+            () => scoped_event._runHandlers(pending_entries)
+          )
         ),
         options
       );
@@ -737,7 +801,7 @@ class EventBus {
       this.locks._notifyIdleListeners();
     }
   }
-  // Called when a handler does `await child.done()` — processes the child event
+  // Called when a handler does `await child.now()` — processes the child event
   // immediately ("queue-jump") instead of waiting for the _runloop to pick it up.
   //
   // Yield-and-reacquire: if the calling handler holds a handler concurrency lock,
@@ -750,9 +814,9 @@ class EventBus {
     const currently_active_event_result = proxy_result ?? this.locks._getActiveHandlerResultForCurrentAsyncContext();
     if (!currently_active_event_result) {
       const queue_index = this.pending_event_queue.indexOf(original_event);
-      const can_process_now = queue_index === 0 && !this.locks._isPaused() && !this.in_flight_event_ids.has(original_event.event_id) && !this._hasProcessedEvent(original_event);
-      if (can_process_now) {
-        const event_lock = this.locks.getLockForEvent(original_event);
+      const event_lock = this.locks.getLockForEvent(original_event);
+      const can_process_queue_head_normally = queue_index === 0 && !this.locks._isPaused() && !this.in_flight_event_ids.has(original_event.event_id) && !this._hasProcessedEvent(original_event) && (event_lock === null || event_lock.in_use === 0);
+      if (can_process_queue_head_normally) {
         let pre_acquired_lock = null;
         if (event_lock) {
           await event_lock.acquire();
@@ -760,8 +824,7 @@ class EventBus {
         }
         const queue_head = this.pending_event_queue[0];
         const queue_head_original = queue_head?._event_original ?? queue_head;
-        const still_can_process_now = queue_head_original === original_event && !this.locks._isPaused() && !this.in_flight_event_ids.has(original_event.event_id) && !this._hasProcessedEvent(original_event);
-        if (still_can_process_now) {
+        if (queue_head_original === original_event && !this.locks._isPaused() && !this.in_flight_event_ids.has(original_event.event_id) && !this._hasProcessedEvent(original_event)) {
           this.pending_event_queue.shift();
           this.in_flight_event_ids.add(original_event.event_id);
           await this._processEvent(original_event, {
@@ -769,15 +832,13 @@ class EventBus {
             pre_acquired_lock
           });
           if (original_event.event_status !== "completed") {
-            await original_event.eventCompleted();
+            await this._processEventImmediatelyAcrossBuses(original_event);
           }
           return event;
         }
-        if (pre_acquired_lock) {
-          pre_acquired_lock.release();
-        }
+        pre_acquired_lock?.release();
       }
-      await original_event.eventCompleted();
+      await this._processEventImmediatelyAcrossBuses(original_event);
       return event;
     }
     const active_parent = currently_active_event_result.event._event_original ?? currently_active_event_result.event;
@@ -801,65 +862,68 @@ class EventBus {
   // Processes a queue-jumped event across all buses that have it emitted.
   // Called from _processEventImmediately after the parent handler's lock has been yielded.
   async _processEventImmediatelyAcrossBuses(event) {
-    const ordered = [];
-    const seen = /* @__PURE__ */ new Set();
-    const event_path = Array.isArray(event.event_path) ? event.event_path : [];
-    for (const label of event_path) {
-      for (const bus of this.all_instances) {
-        if (bus.label !== label) {
-          continue;
-        }
-        if (!bus.event_history.has(event.event_id)) {
-          continue;
-        }
-        if (bus._hasProcessedEvent(event)) {
-          continue;
-        }
-        if (!seen.has(bus)) {
-          ordered.push(bus);
-          seen.add(bus);
-        }
-      }
-    }
-    if (!seen.has(this) && this.event_history.has(event.event_id)) {
-      ordered.push(this);
-    }
-    if (ordered.length === 0) {
-      await event.eventCompleted();
-      return;
-    }
     const initiating_event_lock = this.locks.getLockForEvent(event);
-    const pause_releases = [];
-    try {
-      for (const bus of ordered) {
-        if (bus !== this) {
-          pause_releases.push(bus.locks._requestRunloopPause());
+    for (; ; ) {
+      const ordered = [];
+      const seen = /* @__PURE__ */ new Set();
+      const event_path = Array.isArray(event.event_path) ? event.event_path : [];
+      for (const label of event_path) {
+        for (const bus of this.all_instances) {
+          if (bus.label !== label) {
+            continue;
+          }
+          if (!bus.event_history.has(event.event_id)) {
+            continue;
+          }
+          if (bus._hasProcessedEvent(event)) {
+            continue;
+          }
+          if (!seen.has(bus)) {
+            ordered.push(bus);
+            seen.add(bus);
+          }
         }
       }
-      for (const bus of ordered) {
-        const index = bus.pending_event_queue.indexOf(event);
-        if (index >= 0) {
-          bus.pending_event_queue.splice(index, 1);
+      if (!seen.has(this) && this.event_history.has(event.event_id) && !this._hasProcessedEvent(event)) {
+        ordered.push(this);
+      }
+      const pause_releases = [];
+      let processed_bus = false;
+      try {
+        for (const bus of ordered) {
+          if (bus !== this) {
+            pause_releases.push(bus.locks._requestRunloopPause());
+          }
         }
-        if (bus._hasProcessedEvent(event)) {
-          continue;
+        for (const bus of ordered) {
+          const index = bus.pending_event_queue.indexOf(event);
+          if (index >= 0) {
+            bus.pending_event_queue.splice(index, 1);
+          }
+          if (bus._hasProcessedEvent(event)) {
+            continue;
+          }
+          if (bus.in_flight_event_ids.has(event.event_id)) {
+            continue;
+          }
+          bus.in_flight_event_ids.add(event.event_id);
+          processed_bus = true;
+          const bus_event_lock = bus.locks.getLockForEvent(event);
+          const should_bypass_event_lock = bus === this || initiating_event_lock !== null && bus_event_lock === initiating_event_lock;
+          await bus._processEvent(event, {
+            bypass_event_locks: should_bypass_event_lock
+          });
         }
-        if (bus.in_flight_event_ids.has(event.event_id)) {
-          continue;
+      } finally {
+        for (const release of pause_releases) {
+          release();
         }
-        bus.in_flight_event_ids.add(event.event_id);
-        const bus_event_lock = bus.locks.getLockForEvent(event);
-        const should_bypass_event_lock = bus === this || initiating_event_lock !== null && bus_event_lock === initiating_event_lock;
-        await bus._processEvent(event, {
-          bypass_event_locks: should_bypass_event_lock
-        });
       }
-      if (event.event_status !== "completed") {
-        await event.eventCompleted();
+      if (event.event_status === "completed") {
+        return;
       }
-    } finally {
-      for (const release of pause_releases) {
-        release();
+      if (!processed_bus) {
+        await new Promise((resolve) => setTimeout(resolve, 1));
       }
     }
   }
@@ -944,7 +1008,11 @@ class EventBus {
         if (prop === "dispatch" || prop === "emit") {
           const emit_child_event = (child_event) => {
             const original_child = child_event._event_original ?? child_event;
-            if (handler_result) {
+            const handler_result_is_terminal = handler_result && handler_result.status !== "pending" && handler_result.status !== "started";
+            if (handler_result_is_terminal && (handler_result.error instanceof EventHandlerTimeoutError || handler_result.error instanceof EventHandlerCancelledError || handler_result.error instanceof EventHandlerAbortedError)) {
+              return original_child;
+            }
+            if (handler_result && !handler_result_is_terminal) {
               handler_result._linkEmittedChildEvent(original_child);
             } else if (!original_child.event_parent_id && original_child.event_id !== parent_event_id) {
               original_child.event_parent_id = parent_event_id;