abxbus 2.4.32 → 2.5.0

package/src/EventBus.ts

@@ -44,6 +44,10 @@ export type EventBusOptions = {
   middlewares?: EventBusMiddlewareInput[]
 }
 
+export type EventBusDestroyOptions = {
+  clear?: boolean
+}
+
 export type EventBusJSON = {
   id: string
   name: string
@@ -199,6 +203,7 @@ export class EventBus {
   locks: LockManager
   find_waiters: Set<EphemeralFindEventHandler> // set of EphemeralFindEventHandler objects that are waiting for a matching future event
   middlewares: EventBusMiddleware[]
+  private destroyed: boolean
 
   private static normalizeMiddlewares(middlewares?: EventBusMiddlewareInput[]): EventBusMiddleware[] {
     const normalized: EventBusMiddleware[] = []
@@ -224,9 +229,9 @@ export 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 === undefined ? 60 : options.event_timeout
-    this.event_handler_slow_timeout = options.event_handler_slow_timeout === undefined ? 30 : options.event_handler_slow_timeout
-    this.event_slow_timeout = options.event_slow_timeout === undefined ? 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
 
     // initialize runtime state
     this.runloop_running = false
@@ -241,6 +246,7 @@ export class EventBus {
     this.in_flight_event_ids = new Set()
     this.locks = new LockManager(this)
     this.middlewares = EventBus.normalizeMiddlewares(options.middlewares)
+    this.destroyed = false
 
     this.all_instances.add(this)
 
@@ -367,7 +373,7 @@ export class EventBus {
     fn: () => Promise<void>
   ): Promise<void> {
     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)
@@ -525,10 +531,11 @@ export class EventBus {
     }
     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 as Record<string, unknown>)) {
+    for (const [handler_id, payload] of Object.entries(raw_handlers as Record<string, unknown>)) {
       if (!payload || typeof payload !== 'object') {
         continue
       }
@@ -542,11 +549,12 @@ export 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 as Record<string, unknown>)) {
+    for (const [raw_key, raw_ids] of Object.entries(raw_handlers_by_key as Record<string, unknown>)) {
       if (!Array.isArray(raw_ids)) {
         continue
       }
@@ -633,21 +641,51 @@ export class EventBus {
     return this.event_history.delete(event_id)
   }
 
-  // destroy the event bus and all its state to allow for garbage collection
-  destroy(): void {
-    this.all_instances.discard(this)
-    this.handlers.clear()
-    this.handlers_by_key.clear()
-    for (const event of this.event_history.values()) {
-      event._gc()
+  private _raiseIfDestroyed(): void {
+    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 the event bus and all its state to allow for garbage collection
+  destroy(clear?: boolean): Promise<void>
+  destroy(options?: EventBusDestroyOptions): Promise<void>
+  destroy(clear_or_options: boolean | EventBusDestroyOptions = true): Promise<void> {
+    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 = (): void => {
+      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<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>, options?: Partial<EventHandler>): EventHandler
   on<T extends BaseEvent>(
     event_pattern: string | '*',
@@ -659,6 +697,7 @@ export class EventBus {
     handler: EventHandlerCallable | UntypedEventHandlerFunction,
     options: Partial<EventHandler> = {}
   ): EventHandler {
+    this._raiseIfDestroyed()
     const normalized_key = normalizeEventPattern(event_pattern) // get string event_type or '*'
     const handler_name = EventHandler.handlerNameFromCallable(handler as EventHandlerCallable)
     const handler_entry = new EventHandler({
@@ -687,6 +726,7 @@ export class EventBus {
   }
 
   off<T extends BaseEvent>(event_pattern: EventPattern<T> | '*', handler?: EventHandlerCallable<T> | string | EventHandler): void {
+    this._raiseIfDestroyed()
     const normalized_key = normalizeEventPattern(event_pattern)
     if (typeof handler === 'object' && handler instanceof EventHandler && handler.id !== undefined) {
       handler = handler.id
@@ -708,7 +748,19 @@ export class EventBus {
   }
 
   emit<T extends BaseEvent>(event: T): T {
+    this._raiseIfDestroyed()
     const original_event = event._event_original ?? event // if event is a bus-scoped proxy already, get the original underlying event object
+    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 as T
+    }
     if (!original_event.event_bus) {
       // if we are the first bus to emit this event, set the event_bus property on the original event object
       original_event.event_bus = this
@@ -760,7 +812,11 @@ export class EventBus {
 
     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) as T
   }
@@ -806,6 +862,7 @@ export class EventBus {
     where_or_options: ((event: T) => boolean) | FilterOptions<T> = {},
     maybe_options: FilterOptions<T> = {}
   ): Promise<T[]> {
+    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 as EventPattern<T> | '*', where, {
@@ -843,6 +900,7 @@ export class EventBus {
   }
 
   async waitUntilIdle(timeout: number | null = null): Promise<boolean> {
+    this._raiseIfDestroyed()
     return await this.locks.waitForIdle(timeout)
   }
 
@@ -901,6 +959,7 @@ export class EventBus {
   }
 
   private _startRunloop(): void {
+    this._raiseIfDestroyed()
     if (this.runloop_running) {
       return
     }
@@ -910,6 +969,22 @@ export class EventBus {
     })
   }
 
+  private _startParallelEventTaskFromQueue(event: BaseEvent): void {
+    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
   private async _processEvent(
@@ -932,6 +1007,7 @@ export 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')
@@ -941,7 +1017,9 @@ export class EventBus {
         event,
         () =>
           this._runHandlersWithTimeout(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
       )
@@ -955,7 +1033,7 @@ export class EventBus {
     }
   }
 
-  // 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,
@@ -970,18 +1048,15 @@ export class EventBus {
     const proxy_result = handler_result?.status === 'started' ? handler_result : undefined
     const currently_active_event_result = proxy_result ?? this.locks._getActiveHandlerResultForCurrentAsyncContext()
     if (!currently_active_event_result) {
-      // Not inside any handler scope — avoid queue-jump, but if this event is
-      // next in line we can process it immediately without waiting on the _runloop.
-      // We must acquire/revalidate the event lock first to avoid racing the runloop
-      // and accidentally reordering/removing the wrong queue head.
       const queue_index = this.pending_event_queue.indexOf(original_event)
-      const can_process_now =
+      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)
-      if (can_process_now) {
-        const event_lock = this.locks.getLockForEvent(original_event)
+        !this._hasProcessedEvent(original_event) &&
+        (event_lock === null || event_lock.in_use === 0)
+      if (can_process_queue_head_normally) {
         let pre_acquired_lock: AsyncLock | null = null
         if (event_lock) {
           await event_lock.acquire()
@@ -989,12 +1064,12 @@ export 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 =
+        if (
           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) {
+        ) {
           this.pending_event_queue.shift()
           this.in_flight_event_ids.add(original_event.event_id)
           await this._processEvent(original_event, {
@@ -1002,15 +1077,13 @@ export 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
     }
 
@@ -1047,78 +1120,83 @@ export 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.
   private async _processEventImmediatelyAcrossBuses(event: BaseEvent): Promise<void> {
-    // Use event_path ordering to pick candidate buses and filter out buses that
-    // haven't seen the event or already processed it.
-    const ordered: EventBus[] = []
-    const seen = new Set<EventBus>()
-    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
-    }
-
     // Determine which event lock the initiating bus resolves to, so we can
     // detect when other buses share the same instance (global-serial).
     const initiating_event_lock = this.locks.getLockForEvent(event)
-    const pause_releases: Array<() => void> = []
 
-    try {
-      for (const bus of ordered) {
-        if (bus !== this) {
-          pause_releases.push(bus.locks._requestRunloopPause())
+    for (;;) {
+      // Use event_path ordering to pick candidate buses and filter out buses
+      // that haven't seen the event or already processed it. Forwarding
+      // handlers can append new buses while this method is already running, so
+      // this list must be rebuilt until the event is fully complete.
+      const ordered: EventBus[] = []
+      const seen = new Set<EventBus>()
+      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) && !this._hasProcessedEvent(event)) {
+        ordered.push(this)
+      }
 
-      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
+      const pause_releases: Array<() => void> = []
+      let processed_bus = false
+      try {
+        for (const bus of ordered) {
+          if (bus !== this) {
+            pause_releases.push(bus.locks._requestRunloopPause())
+          }
         }
-        bus.in_flight_event_ids.add(event.event_id)
 
-        // Bypass event lock on the initiating bus (we're already inside a handler
-        // that acquired it). For other buses, only bypass if they resolve to the same
-        // lock instance (global-serial shares one lock across all buses).
-        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)
+        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
+
+          // Bypass event lock on the initiating bus (we're already inside a handler
+          // that acquired it). For other buses, only bypass if they resolve to the same
+          // lock instance (global-serial shares one lock across all buses).
+          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,
-        })
+          await bus._processEvent(event, {
+            bypass_event_locks: should_bypass_event_lock,
+          })
+        }
+      } finally {
+        for (const release of pause_releases) {
+          release()
+        }
       }
 
-      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))
       }
     }
   }
@@ -1147,7 +1225,7 @@ export class EventBus {
           pre_acquired_lock = event_lock
         }
         // Queue head may have changed while waiting for the lock
-        // (e.g. done() processing the head immediately). Revalidate
+        // (e.g. now() processing the head immediately). Revalidate
         // before mutating the queue to avoid removing the wrong event.
         const current_head = this.pending_event_queue[0]
         const current_head_original = current_head?._event_original ?? current_head
@@ -1209,7 +1287,16 @@ export class EventBus {
         if (prop === 'dispatch' || prop === 'emit') {
           const emit_child_event = <TChild extends BaseEvent>(child_event: TChild): TChild => {
             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 as TChild
+            }
+            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) {
               // fallback for non-handler scoped emit/dispatch

package/src/EventHandler.ts

@@ -24,7 +24,7 @@ export type EphemeralFindEventHandler = {
   // Resolved on dispatch, ephemeral, and never shows up in the processing tree.
   event_pattern: string | '*'
   matches: (event: BaseEvent) => boolean
-  resolve: (event: BaseEvent) => void
+  resolve: (event: BaseEvent | null) => void
   timeout_id?: ReturnType<typeof setTimeout>
 }
 
@@ -49,7 +49,7 @@ export class FindWaiter {
     data: unknown,
     overrides: {
       matches?: (event: BaseEvent) => boolean
-      resolve?: (event: BaseEvent) => void
+      resolve?: (event: BaseEvent | null) => void
     } = {}
   ): EphemeralFindEventHandler {
     const record = FindWaiterJSONSchema.parse(data)
@@ -70,7 +70,7 @@ export class FindWaiter {
     data: unknown,
     overrides: {
       matches?: (event: BaseEvent) => boolean
-      resolve?: (event: BaseEvent) => void
+      resolve?: (event: BaseEvent | null) => void
     } = {}
   ): EphemeralFindEventHandler[] {
     if (!Array.isArray(data)) {

package/src/EventResult.ts

@@ -25,8 +25,8 @@ export const EventResultJSONSchema = z
     handler_id: z.string(),
     handler_name: z.string(),
     handler_file_path: z.string().nullable().optional(),
-    handler_timeout: z.number().nullable().optional(),
-    handler_slow_timeout: z.number().nullable().optional(),
+    handler_timeout: z.number().nonnegative().nullable().optional(),
+    handler_slow_timeout: z.number().nonnegative().nullable().optional(),
     handler_registered_at: z.string().datetime().optional(),
     handler_event_pattern: z.union([z.string(), z.literal('*')]).optional(),
     eventbus_name: z.string(),
@@ -171,18 +171,24 @@ export class EventResult<TEvent extends BaseEvent = BaseEvent> {
     return this.result
   }
 
-  // Resolve handler timeout in seconds using precedence: handler -> event -> bus defaults.
+  // Resolve handler timeout in seconds using event-local values plus the executing bus defaults.
   get handler_timeout(): number | null {
     const original = this.event._event_original ?? this.event
-    const resolved_event_timeout = original.event_timeout ?? this.bus.event_timeout
+    const raw_event_timeout = original.event_timeout ?? this.bus.event_timeout
+    const resolved_event_timeout =
+      raw_event_timeout !== null && raw_event_timeout !== undefined && raw_event_timeout > 0 ? raw_event_timeout : null
 
     let resolved_handler_timeout: number | null
-    if (this.handler.handler_timeout !== undefined) {
+    if (this.handler.handler_timeout !== undefined && this.handler.handler_timeout !== null) {
       resolved_handler_timeout = this.handler.handler_timeout
-    } else if (original.event_handler_timeout !== undefined) {
+    } else if (original.event_handler_timeout !== undefined && original.event_handler_timeout !== null) {
       resolved_handler_timeout = original.event_handler_timeout
     } else {
-      resolved_handler_timeout = this.bus.event_timeout
+      resolved_handler_timeout = resolved_event_timeout
+    }
+
+    if (resolved_handler_timeout !== null && resolved_handler_timeout <= 0) {
+      resolved_handler_timeout = null
     }
 
     if (resolved_handler_timeout === null && resolved_event_timeout === null) {
@@ -197,31 +203,21 @@ export class EventResult<TEvent extends BaseEvent = BaseEvent> {
     return Math.min(resolved_handler_timeout, resolved_event_timeout)
   }
 
-  // Resolve slow handler warning threshold in seconds using precedence: handler -> event -> bus defaults.
+  // Resolve slow handler warning threshold in seconds using event-local values plus the executing bus defaults.
   get handler_slow_timeout(): number | null {
     const original = this.event._event_original ?? this.event
 
-    if (this.handler.handler_slow_timeout !== undefined) {
+    if (this.handler.handler_slow_timeout !== undefined && this.handler.handler_slow_timeout !== null) {
       return this.handler.handler_slow_timeout
     }
-    if (original.event_handler_slow_timeout !== undefined) {
-      return original.event_handler_slow_timeout
-    }
-    const event_slow_timeout = (original as { event_slow_timeout?: number | null }).event_slow_timeout
-    if (event_slow_timeout !== undefined) {
-      return event_slow_timeout
-    }
-    if (this.bus?.event_handler_slow_timeout !== undefined) {
-      return this.bus.event_handler_slow_timeout
-    }
-    return this.bus?.event_slow_timeout ?? null
+    return original.event_handler_slow_timeout ?? this.bus.event_handler_slow_timeout ?? null
   }
 
   // Create a slow-handler warning timer that logs if the handler runs too long.
   _createSlowHandlerWarningTimer(effective_timeout: number | null): ReturnType<typeof setTimeout> | null {
     const handler_warn_timeout = this.handler_slow_timeout
-    const warn_ms = handler_warn_timeout === null ? null : handler_warn_timeout * 1000
-    const should_warn = warn_ms !== null && (effective_timeout === null || effective_timeout * 1000 > warn_ms)
+    const warn_ms = handler_warn_timeout === null || handler_warn_timeout <= 0 ? null : handler_warn_timeout * 1000
+    const should_warn = warn_ms !== null && (effective_timeout === null || effective_timeout <= 0 || effective_timeout * 1000 > warn_ms)
     if (!should_warn || warn_ms === null) {
       return null
     }

package/src/LockManager.ts

@@ -246,10 +246,14 @@ export class LockManager {
   }
 
   _getActiveHandlerResultForCurrentAsyncContext(): EventResult | undefined {
-    const result = handler_context_storage?.getStore() as EventResult | undefined
+    const result = this._getRawActiveHandlerResultForCurrentAsyncContext()
     return result?.status === 'started' ? result : undefined
   }
 
+  _getRawActiveHandlerResultForCurrentAsyncContext(): EventResult | undefined {
+    return handler_context_storage?.getStore() as EventResult | undefined
+  }
+
   _getActiveHandlerResults(): EventResult[] {
     return [...this.active_handler_results]
   }

package/src/events_suck.ts

@@ -75,7 +75,7 @@ export const wrap = <TEvents extends EventMap>(class_name: string, methods: TEve
     Object.defineProperty(WrappedClient.prototype, method_name, {
       value: async function (this: DynamicWrappedClient, init?: Record<string, unknown>, extra?: Record<string, unknown>) {
         const payload = { ...(init ?? {}), ...(extra ?? {}) }
-        return await this.bus.emit(new EventCtor(payload)).first()
+        return await this.bus.emit(new EventCtor(payload)).now({ first_result: true }).eventResult()
       },
       writable: true,
       configurable: true,

package/src/index.ts

@@ -1,4 +1,5 @@
 export { BaseEvent, BaseEventSchema } from './BaseEvent.js'
+export type { EventResultInclude, EventResultOptions, EventWaitOptions, EventWaitPromise } from './BaseEvent.js'
 export { EventHistory } from './EventHistory.js'
 export type { EventHistoryFilterOptions, EventHistoryFindOptions, EventHistoryTrimOptions } from './EventHistory.js'
 export { EventResult } from './EventResult.js'

package/src/timing.ts

@@ -1,6 +1,6 @@
 export async function _runWithTimeout<T>(timeout_seconds: number | null, on_timeout: () => Error, fn: () => Promise<T>): Promise<T> {
   const task = Promise.resolve().then(fn)
-  if (timeout_seconds === null) {
+  if (timeout_seconds === null || timeout_seconds <= 0) {
     return await task
   }
   const timeout_ms = timeout_seconds * 1000