bubus 1.8.1 → 2.2.1

package/dist/esm/event_history.js

@@ -0,0 +1,172 @@
+import { normalizeEventPattern } from "./types.js";
+import { monotonicDatetime } from "./helpers.js";
+class EventHistory {
+  max_history_size;
+  max_history_drop;
+  _events;
+  _warned_about_dropping_uncompleted_events;
+  constructor(options = {}) {
+    this.max_history_size = options.max_history_size === void 0 ? 100 : options.max_history_size;
+    this.max_history_drop = options.max_history_drop ?? false;
+    this._events = /* @__PURE__ */ new Map();
+    this._warned_about_dropping_uncompleted_events = false;
+  }
+  get size() {
+    return this._events.size;
+  }
+  [Symbol.iterator]() {
+    return this._events[Symbol.iterator]();
+  }
+  entries() {
+    return this._events.entries();
+  }
+  keys() {
+    return this._events.keys();
+  }
+  values() {
+    return this._events.values();
+  }
+  clear() {
+    this._events.clear();
+  }
+  get(event_id) {
+    return this._events.get(event_id);
+  }
+  set(event_id, event) {
+    this._events.set(event_id, event);
+    return this;
+  }
+  has(event_id) {
+    return this._events.has(event_id);
+  }
+  delete(event_id) {
+    return this._events.delete(event_id);
+  }
+  addEvent(event) {
+    this._events.set(event.event_id, event);
+  }
+  getEvent(event_id) {
+    return this._events.get(event_id);
+  }
+  removeEvent(event_id) {
+    return this._events.delete(event_id);
+  }
+  hasEvent(event_id) {
+    return this._events.has(event_id);
+  }
+  static normalizeEventPattern(event_pattern) {
+    return normalizeEventPattern(event_pattern);
+  }
+  async find(event_pattern, where = () => true, options = {}) {
+    const past = options.past ?? true;
+    const future = options.future ?? false;
+    const child_of = options.child_of ?? null;
+    const eventIsChildOf = options.event_is_child_of ?? ((event, ancestor) => this.eventIsChildOf(event, ancestor));
+    const waitForFutureMatch = options.wait_for_future_match;
+    if (past === false && future === false) {
+      return null;
+    }
+    const event_key = EventHistory.normalizeEventPattern(event_pattern);
+    const cutoff_at = past === true ? null : monotonicDatetime(new Date(Date.now() - Math.max(0, Number(past)) * 1e3).toISOString());
+    const event_field_filters = Object.entries(options).filter(
+      ([key, value]) => key !== "past" && key !== "future" && key !== "child_of" && key !== "event_is_child_of" && key !== "wait_for_future_match" && value !== void 0
+    );
+    const matches = (event) => (event_key === "*" || event.event_type === event_key) && (!child_of || eventIsChildOf(event, child_of)) && event_field_filters.every(([field_name, expected]) => event[field_name] === expected) && where(event);
+    if (past !== false) {
+      const history_values = Array.from(this._events.values());
+      for (let i = history_values.length - 1; i >= 0; i -= 1) {
+        const event = history_values[i];
+        if (cutoff_at !== null && event.event_created_at < cutoff_at) {
+          continue;
+        }
+        if (matches(event)) {
+          return event;
+        }
+      }
+    }
+    if (future === false || !waitForFutureMatch) {
+      return null;
+    }
+    return await waitForFutureMatch(event_key, matches, future);
+  }
+  trimEventHistory(options = {}) {
+    const max_history_size = options.max_history_size ?? this.max_history_size;
+    const max_history_drop = options.max_history_drop ?? this.max_history_drop;
+    if (max_history_size === null) {
+      return 0;
+    }
+    const is_event_complete = options.is_event_complete ?? ((event) => event.event_status === "completed");
+    const on_remove = options.on_remove;
+    if (max_history_size === 0) {
+      let removed_count2 = 0;
+      for (const [event_id, event] of Array.from(this._events.entries())) {
+        if (!is_event_complete(event)) {
+          continue;
+        }
+        this._events.delete(event_id);
+        on_remove?.(event);
+        removed_count2 += 1;
+      }
+      return removed_count2;
+    }
+    if (!max_history_drop || this.size <= max_history_size) {
+      return 0;
+    }
+    let remaining_overage = this.size - max_history_size;
+    let removed_count = 0;
+    const remove_event = (event_id, event) => {
+      this._events.delete(event_id);
+      on_remove?.(event);
+      removed_count += 1;
+    };
+    for (const [event_id, event] of Array.from(this._events.entries())) {
+      if (remaining_overage <= 0) {
+        break;
+      }
+      if (!is_event_complete(event)) {
+        continue;
+      }
+      remove_event(event_id, event);
+      remaining_overage -= 1;
+    }
+    let dropped_uncompleted = 0;
+    for (const [event_id, event] of Array.from(this._events.entries())) {
+      if (remaining_overage <= 0) {
+        break;
+      }
+      if (!is_event_complete(event)) {
+        dropped_uncompleted += 1;
+      }
+      remove_event(event_id, event);
+      remaining_overage -= 1;
+    }
+    if (dropped_uncompleted > 0 && !this._warned_about_dropping_uncompleted_events) {
+      this._warned_about_dropping_uncompleted_events = true;
+      const owner_label = options.owner_label ?? "EventBus";
+      console.error(
+        `[bubus] \u26A0\uFE0F Bus ${owner_label} has exceeded max_history_size=${max_history_size} and is dropping oldest history entries (even uncompleted events). Increase max_history_size or set max_history_drop=false to reject.`
+      );
+    }
+    return removed_count;
+  }
+  eventIsChildOf(event, ancestor) {
+    let current_parent_id = event.event_parent_id;
+    const visited = /* @__PURE__ */ new Set();
+    while (current_parent_id && !visited.has(current_parent_id)) {
+      if (current_parent_id === ancestor.event_id) {
+        return true;
+      }
+      visited.add(current_parent_id);
+      const parent = this._events.get(current_parent_id);
+      if (!parent) {
+        return false;
+      }
+      current_parent_id = parent.event_parent_id;
+    }
+    return false;
+  }
+}
+export {
+  EventHistory
+};
+//# sourceMappingURL=event_history.js.map

package/dist/esm/event_history.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/event_history.ts"],
+  "sourcesContent": ["import { BaseEvent } from './base_event.js'\nimport type { EventPattern, FindWindow } from './types.js'\nimport { normalizeEventPattern } from './types.js'\nimport { monotonicDatetime } from './helpers.js'\n\nexport type EventHistoryFindOptions = {\n  past?: FindWindow\n  future?: FindWindow\n  child_of?: BaseEvent | null\n  event_is_child_of?: (event: BaseEvent, ancestor: BaseEvent) => boolean\n  wait_for_future_match?: (\n    event_pattern: string | '*',\n    matches: (event: BaseEvent) => boolean,\n    future: FindWindow\n  ) => Promise<BaseEvent | null>\n} & Record<string, unknown>\n\nexport type EventHistoryTrimOptions<TEvent extends BaseEvent = BaseEvent> = {\n  is_event_complete?: (event: TEvent) => boolean\n  on_remove?: (event: TEvent) => void\n  owner_label?: string\n  max_history_size?: number | null\n  max_history_drop?: boolean\n}\n\nexport class EventHistory<TEvent extends BaseEvent = BaseEvent> implements Iterable<[string, TEvent]> {\n  max_history_size: number | null\n  max_history_drop: boolean\n\n  private _events: Map<string, TEvent>\n  private _warned_about_dropping_uncompleted_events: boolean\n\n  constructor(options: { max_history_size?: number | null; max_history_drop?: boolean } = {}) {\n    this.max_history_size = options.max_history_size === undefined ? 100 : options.max_history_size\n    this.max_history_drop = options.max_history_drop ?? false\n    this._events = new Map()\n    this._warned_about_dropping_uncompleted_events = false\n  }\n\n  get size(): number {\n    return this._events.size\n  }\n\n  [Symbol.iterator](): Iterator<[string, TEvent]> {\n    return this._events[Symbol.iterator]()\n  }\n\n  entries(): IterableIterator<[string, TEvent]> {\n    return this._events.entries()\n  }\n\n  keys(): IterableIterator<string> {\n    return this._events.keys()\n  }\n\n  values(): IterableIterator<TEvent> {\n    return this._events.values()\n  }\n\n  clear(): void {\n    this._events.clear()\n  }\n\n  get(event_id: string): TEvent | undefined {\n    return this._events.get(event_id)\n  }\n\n  set(event_id: string, event: TEvent): this {\n    this._events.set(event_id, event)\n    return this\n  }\n\n  has(event_id: string): boolean {\n    return this._events.has(event_id)\n  }\n\n  delete(event_id: string): boolean {\n    return this._events.delete(event_id)\n  }\n\n  addEvent(event: TEvent): void {\n    this._events.set(event.event_id, event)\n  }\n\n  getEvent(event_id: string): TEvent | undefined {\n    return this._events.get(event_id)\n  }\n\n  removeEvent(event_id: string): boolean {\n    return this._events.delete(event_id)\n  }\n\n  hasEvent(event_id: string): boolean {\n    return this._events.has(event_id)\n  }\n\n  static normalizeEventPattern(event_pattern: EventPattern | '*'): string | '*' {\n    return normalizeEventPattern(event_pattern)\n  }\n\n  find(event_pattern: '*', where?: (event: TEvent) => boolean, options?: EventHistoryFindOptions): Promise<TEvent | null>\n  find<TMatch extends TEvent>(\n    event_pattern: EventPattern<TMatch>,\n    where?: (event: TMatch) => boolean,\n    options?: EventHistoryFindOptions\n  ): Promise<TMatch | null>\n  async find(\n    event_pattern: EventPattern<TEvent> | '*',\n    where: (event: TEvent) => boolean = () => true,\n    options: EventHistoryFindOptions = {}\n  ): Promise<TEvent | null> {\n    const past = options.past ?? true\n    const future = options.future ?? false\n    const child_of = options.child_of ?? null\n    const eventIsChildOf = options.event_is_child_of ?? ((event: BaseEvent, ancestor: BaseEvent) => this.eventIsChildOf(event, ancestor))\n    const waitForFutureMatch = options.wait_for_future_match\n    if (past === false && future === false) {\n      return null\n    }\n\n    const event_key = EventHistory.normalizeEventPattern(event_pattern)\n    const cutoff_at = past === true ? null : monotonicDatetime(new Date(Date.now() - Math.max(0, Number(past)) * 1000).toISOString())\n\n    const event_field_filters = Object.entries(options).filter(\n      ([key, value]) =>\n        key !== 'past' &&\n        key !== 'future' &&\n        key !== 'child_of' &&\n        key !== 'event_is_child_of' &&\n        key !== 'wait_for_future_match' &&\n        value !== undefined\n    )\n\n    const matches = (event: BaseEvent): boolean =>\n      (event_key === '*' || event.event_type === event_key) &&\n      (!child_of || eventIsChildOf(event, child_of)) &&\n      event_field_filters.every(([field_name, expected]) => (event as unknown as Record<string, unknown>)[field_name] === expected) &&\n      where(event as TEvent)\n\n    if (past !== false) {\n      const history_values = Array.from(this._events.values())\n      for (let i = history_values.length - 1; i >= 0; i -= 1) {\n        const event = history_values[i]\n        if (cutoff_at !== null && event.event_created_at < cutoff_at) {\n          continue\n        }\n        if (matches(event)) {\n          return event\n        }\n      }\n    }\n\n    if (future === false || !waitForFutureMatch) {\n      return null\n    }\n\n    return (await waitForFutureMatch(event_key, matches, future)) as TEvent | null\n  }\n\n  trimEventHistory(options: EventHistoryTrimOptions<TEvent> = {}): number {\n    const max_history_size = options.max_history_size ?? this.max_history_size\n    const max_history_drop = options.max_history_drop ?? this.max_history_drop\n    if (max_history_size === null) {\n      return 0\n    }\n\n    const is_event_complete = options.is_event_complete ?? ((event: TEvent) => event.event_status === 'completed')\n    const on_remove = options.on_remove\n\n    if (max_history_size === 0) {\n      let removed_count = 0\n      for (const [event_id, event] of Array.from(this._events.entries())) {\n        if (!is_event_complete(event)) {\n          continue\n        }\n        this._events.delete(event_id)\n        on_remove?.(event)\n        removed_count += 1\n      }\n      return removed_count\n    }\n\n    if (!max_history_drop || this.size <= max_history_size) {\n      return 0\n    }\n\n    let remaining_overage = this.size - max_history_size\n    let removed_count = 0\n    const remove_event = (event_id: string, event: TEvent): void => {\n      this._events.delete(event_id)\n      on_remove?.(event)\n      removed_count += 1\n    }\n\n    for (const [event_id, event] of Array.from(this._events.entries())) {\n      if (remaining_overage <= 0) {\n        break\n      }\n      if (!is_event_complete(event)) {\n        continue\n      }\n      remove_event(event_id, event)\n      remaining_overage -= 1\n    }\n\n    let dropped_uncompleted = 0\n    for (const [event_id, event] of Array.from(this._events.entries())) {\n      if (remaining_overage <= 0) {\n        break\n      }\n      if (!is_event_complete(event)) {\n        dropped_uncompleted += 1\n      }\n      remove_event(event_id, event)\n      remaining_overage -= 1\n    }\n\n    if (dropped_uncompleted > 0 && !this._warned_about_dropping_uncompleted_events) {\n      this._warned_about_dropping_uncompleted_events = true\n      const owner_label = options.owner_label ?? 'EventBus'\n      console.error(\n        `[bubus] \u26A0\uFE0F Bus ${owner_label} has exceeded max_history_size=${max_history_size} and is dropping oldest history entries (even uncompleted events). Increase max_history_size or set max_history_drop=false to reject.`\n      )\n    }\n\n    return removed_count\n  }\n\n  private eventIsChildOf(event: BaseEvent, ancestor: BaseEvent): boolean {\n    let current_parent_id = event.event_parent_id\n    const visited = new Set<string>()\n\n    while (current_parent_id && !visited.has(current_parent_id)) {\n      if (current_parent_id === ancestor.event_id) {\n        return true\n      }\n      visited.add(current_parent_id)\n      const parent = this._events.get(current_parent_id)\n      if (!parent) {\n        return false\n      }\n      current_parent_id = parent.event_parent_id\n    }\n\n    return false\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["removed_count"]
+}

package/dist/esm/event_result.js

@@ -0,0 +1,426 @@
+import { v7 as uuidv7 } from "uuid";
+import { z } from "zod";
+import { BaseEvent } from "./base_event.js";
+import { EventHandler, EventHandlerCancelledError, EventHandlerResultSchemaError, EventHandlerTimeoutError } from "./event_handler.js";
+import { withResolvers } from "./lock_manager.js";
+import { isZodSchema } from "./types.js";
+import { _runWithAsyncContext } from "./async_context.js";
+import { RetryTimeoutError } from "./retry.js";
+import { _runWithAbortMonitor, _runWithSlowMonitor, _runWithTimeout } from "./timing.js";
+import { monotonicDatetime } from "./helpers.js";
+const EventResultJSONSchema = z.object({
+  id: z.string(),
+  status: z.enum(["pending", "started", "completed", "error"]),
+  event_id: z.string(),
+  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_registered_at: z.string().datetime().optional(),
+  handler_event_pattern: z.union([z.string(), z.literal("*")]).optional(),
+  eventbus_name: z.string(),
+  eventbus_id: z.string().uuid(),
+  started_at: z.string().datetime().nullable().optional(),
+  completed_at: z.string().datetime().nullable().optional(),
+  result: z.unknown().optional(),
+  error: z.unknown().optional(),
+  event_children: z.array(z.string())
+}).strict();
+class EventResult {
+  id;
+  // unique uuidv7 identifier for the event result
+  status;
+  // 'pending', 'started', 'completed', or 'error'
+  event;
+  // the Event that the handler is processing
+  handler;
+  // the EventHandler object that going to process the event
+  started_at;
+  completed_at;
+  result;
+  // parsed return value from the event handler
+  error;
+  // error object thrown by the event handler, or null if the handler completed successfully
+  event_children;
+  // list of emitted child events
+  // Abort signal: created when handler starts, rejected by _signalAbort() to
+  // interrupt runHandler's await via Promise.race.
+  _abort;
+  // Handler lock: tracks ownership of the handler concurrency lock
+  // during handler execution. Set by runHandler(), used by
+  // _processEventImmediately for yield-and-reacquire during queue-jumps.
+  _lock;
+  // Runloop pause releases keyed by bus for queue-jump; released when handler exits.
+  _queue_jump_pause_releases;
+  constructor(params) {
+    this.id = uuidv7();
+    this.status = "pending";
+    this.event = params.event;
+    this.handler = params.handler;
+    this.started_at = null;
+    this.completed_at = null;
+    this.result = void 0;
+    this.error = void 0;
+    this.event_children = [];
+    this._abort = null;
+    this._lock = null;
+    this._queue_jump_pause_releases = null;
+  }
+  toString() {
+    return `${this.result ?? "null"} (${this.status})`;
+  }
+  get event_id() {
+    return this.event.event_id;
+  }
+  get bus() {
+    return this.event.bus;
+  }
+  get handler_id() {
+    return this.handler.id;
+  }
+  get handler_name() {
+    return this.handler.handler_name;
+  }
+  get handler_file_path() {
+    return this.handler.handler_file_path;
+  }
+  get eventbus_name() {
+    return this.handler.eventbus_name;
+  }
+  get eventbus_id() {
+    return this.handler.eventbus_id;
+  }
+  get eventbus_label() {
+    return `${this.handler.eventbus_name}#${this.handler.eventbus_id.slice(-4)}`;
+  }
+  getHookBus() {
+    const root_bus = this.event.bus;
+    if (!root_bus) {
+      return void 0;
+    }
+    return root_bus.all_instances.findBusById(this.eventbus_id) ?? root_bus;
+  }
+  async _notifyStatusHook(status) {
+    const hook_bus = this.getHookBus();
+    if (!hook_bus) {
+      return;
+    }
+    const event_for_hook = hook_bus._getEventProxyScopedToThisBus(this.event._event_original ?? this.event, this);
+    await hook_bus.onEventResultChange(event_for_hook, this, status);
+  }
+  // shortcut for the result value so users can do event_result.value instead of event_result.result
+  get value() {
+    return this.result;
+  }
+  // Per-result schema reference derives from the parent event schema.
+  // It is intentionally not serialized with each EventResult to avoid duplication.
+  get result_type() {
+    const original_event = this.event._event_original ?? this.event;
+    return original_event.event_result_type;
+  }
+  // Link a child event emitted by this handler run to the parent event/result.
+  _linkEmittedChildEvent(child_event) {
+    const original_child = child_event._event_original ?? child_event;
+    const parent_event = this.event._event_original ?? this.event;
+    if (original_child.event_id === parent_event.event_id) {
+      return;
+    }
+    if (!original_child.event_parent_id) {
+      original_child.event_parent_id = parent_event.event_id;
+    }
+    if (!original_child.event_emitted_by_handler_id) {
+      original_child.event_emitted_by_handler_id = this.handler_id;
+    }
+    if (!this.event_children.some((child) => child.event_id === original_child.event_id)) {
+      this.event_children.push(original_child);
+    }
+  }
+  // Get the raw return value from the handler, even if it threw an error / failed validation
+  get raw_value() {
+    if (this.error && this.error.raw_value !== void 0) {
+      return this.error.raw_value;
+    }
+    return this.result;
+  }
+  // Resolve handler timeout in seconds using precedence: handler -> event -> bus defaults.
+  get handler_timeout() {
+    const original = this.event._event_original ?? this.event;
+    const resolved_event_timeout = original.event_timeout ?? this.bus.event_timeout;
+    let resolved_handler_timeout;
+    if (this.handler.handler_timeout !== void 0) {
+      resolved_handler_timeout = this.handler.handler_timeout;
+    } else if (original.event_handler_timeout !== void 0) {
+      resolved_handler_timeout = original.event_handler_timeout;
+    } else {
+      resolved_handler_timeout = this.bus.event_timeout;
+    }
+    if (resolved_handler_timeout === null && resolved_event_timeout === null) {
+      return null;
+    }
+    if (resolved_handler_timeout === null) {
+      return resolved_event_timeout;
+    }
+    if (resolved_event_timeout === null) {
+      return resolved_handler_timeout;
+    }
+    return Math.min(resolved_handler_timeout, resolved_event_timeout);
+  }
+  // Resolve slow handler warning threshold in seconds using precedence: handler -> event -> bus defaults.
+  get handler_slow_timeout() {
+    const original = this.event._event_original ?? this.event;
+    if (this.handler.handler_slow_timeout !== void 0) {
+      return this.handler.handler_slow_timeout;
+    }
+    if (original.event_handler_slow_timeout !== void 0) {
+      return original.event_handler_slow_timeout;
+    }
+    const event_slow_timeout = original.event_slow_timeout;
+    if (event_slow_timeout !== void 0) {
+      return event_slow_timeout;
+    }
+    if (this.bus?.event_handler_slow_timeout !== void 0) {
+      return this.bus.event_handler_slow_timeout;
+    }
+    return this.bus?.event_slow_timeout ?? null;
+  }
+  // Create a slow-handler warning timer that logs if the handler runs too long.
+  _createSlowHandlerWarningTimer(effective_timeout) {
+    const handler_warn_timeout = this.handler_slow_timeout;
+    const warn_ms = handler_warn_timeout === null ? null : handler_warn_timeout * 1e3;
+    const should_warn = warn_ms !== null && (effective_timeout === null || effective_timeout * 1e3 > warn_ms);
+    if (!should_warn || warn_ms === null) {
+      return null;
+    }
+    const event = this.event._event_original ?? this.event;
+    const bus_name = this.handler.eventbus_name;
+    const started_at_ms = performance.now();
+    return setTimeout(() => {
+      if (this.status !== "started") {
+        return;
+      }
+      const elapsed_ms = performance.now() - started_at_ms;
+      const elapsed_seconds = (elapsed_ms / 1e3).toFixed(1);
+      console.warn(
+        `[bubus] Slow event handler: ${bus_name}.on(${event.toString()}, ${this.handler.toString()}) still running after ${elapsed_seconds}s`
+      );
+    }, warn_ms);
+  }
+  _ensureQueueJumpPause(bus) {
+    if (!this._queue_jump_pause_releases) {
+      this._queue_jump_pause_releases = /* @__PURE__ */ new Map();
+    }
+    if (this._queue_jump_pause_releases.has(bus)) {
+      return;
+    }
+    this._queue_jump_pause_releases.set(bus, bus.locks._requestRunloopPause());
+  }
+  _releaseQueueJumpPauses() {
+    if (!this._queue_jump_pause_releases) {
+      return;
+    }
+    for (const release of this._queue_jump_pause_releases.values()) {
+      release();
+    }
+    this._queue_jump_pause_releases.clear();
+  }
+  update(params) {
+    const has_status = "status" in params;
+    const has_result = "result" in params;
+    const has_error = "error" in params;
+    if (has_result) {
+      const raw_result = params.result;
+      this.status = "completed";
+      if (this.event.event_result_type && raw_result !== void 0 && !(raw_result instanceof BaseEvent) && isZodSchema(this.event.event_result_type)) {
+        const parsed = this.event.event_result_type.safeParse(raw_result);
+        if (parsed.success) {
+          this.result = parsed.data;
+        } else {
+          const error = new EventHandlerResultSchemaError(
+            `Event handler return value ${JSON.stringify(raw_result).slice(0, 20)}... did not match event_result_type: ${parsed.error.message}`,
+            { event_result: this, cause: parsed.error, raw_value: raw_result }
+          );
+          this.error = error;
+          this.result = void 0;
+          this.status = "error";
+        }
+      } else {
+        this.result = raw_result;
+      }
+    }
+    if (has_error) {
+      this.error = params.error;
+      this.status = "error";
+    }
+    if (has_status && params.status !== void 0) {
+      this.status = params.status;
+    }
+    if (this.status !== "pending" && this.started_at === null) {
+      this.started_at = monotonicDatetime();
+    }
+    if ((this.status === "completed" || this.status === "error") && this.completed_at === null) {
+      this.completed_at = monotonicDatetime();
+    }
+    return this;
+  }
+  _createHandlerTimeoutError(event) {
+    return new EventHandlerTimeoutError(
+      `${this.bus.toString()}.on(${event.toString()}, ${this.handler.toString()}) timed out after ${this.handler_timeout}s`,
+      {
+        event_result: this,
+        timeout_seconds: this.handler_timeout
+      }
+    );
+  }
+  _handleHandlerError(event, error) {
+    const normalized_error = error instanceof RetryTimeoutError ? new EventHandlerTimeoutError(error.message, { event_result: this, timeout_seconds: error.timeout_seconds, cause: error }) : error;
+    if (normalized_error instanceof EventHandlerTimeoutError) {
+      this._markError(normalized_error, false);
+      event._cancelPendingChildProcessing(normalized_error);
+    } else {
+      this._markError(normalized_error, false);
+    }
+  }
+  _onHandlerExit(slow_handler_warning_timer) {
+    this._abort = null;
+    this._lock = null;
+    this._releaseQueueJumpPauses();
+    if (slow_handler_warning_timer) {
+      clearTimeout(slow_handler_warning_timer);
+    }
+  }
+  // Run one handler invocation with timeout/slow-monitor/error handling.
+  // Handler lock acquisition is owned by BaseEvent._runHandlers(...).
+  async runHandler(handler_lock) {
+    if (this.status === "error" && this.error instanceof EventHandlerCancelledError) {
+      return;
+    }
+    const event = this.event._event_original ?? this.event;
+    const handler_event = this.bus._getEventProxyScopedToThisBus(event, this);
+    if (this._lock) {
+      this._lock.exitHandlerRun();
+    }
+    let slow_handler_warning_timer = null;
+    if (this.status === "error" || this.status === "completed") {
+      return;
+    }
+    this._lock = handler_lock;
+    await this.bus.locks._runWithHandlerDispatchContext(this, async () => {
+      await _runWithAsyncContext(event._getDispatchContext() ?? null, async () => {
+        try {
+          const should_notify_started = this.status === "pending";
+          const abort_signal = this._markStarted(false);
+          if (should_notify_started) {
+            await this._notifyStatusHook("started");
+          }
+          slow_handler_warning_timer = this._createSlowHandlerWarningTimer(this.handler_timeout);
+          const handler_result = await _runWithTimeout(
+            this.handler_timeout,
+            () => this._createHandlerTimeoutError(event),
+            () => _runWithSlowMonitor(
+              slow_handler_warning_timer,
+              () => _runWithAbortMonitor(() => this.handler._handler_async(handler_event), abort_signal)
+            )
+          );
+          this._markCompleted(handler_result, false);
+        } catch (error) {
+          this._handleHandlerError(event, error);
+        } finally {
+          if (this.status === "completed" || this.status === "error") {
+            await this._notifyStatusHook("completed");
+          }
+          this._onHandlerExit(slow_handler_warning_timer);
+        }
+      });
+    });
+  }
+  // Reject the abort promise, causing runHandler's Promise.race to
+  // throw immediately — even if the handler has no timeout.
+  _signalAbort(error) {
+    if (this._abort) {
+      this._abort.reject(error);
+      this._abort = null;
+    }
+  }
+  // Mark started and return the abort promise for Promise.race.
+  _markStarted(notify_hook = true) {
+    if (!this._abort) {
+      this._abort = withResolvers();
+    }
+    if (this.status === "pending") {
+      this.update({ status: "started" });
+      if (notify_hook) {
+        void this._notifyStatusHook("started");
+      }
+    }
+    return this._abort.promise;
+  }
+  _markCompleted(result, notify_hook = true) {
+    if (this.status === "completed" || this.status === "error") return;
+    this.update({ result });
+    if (notify_hook) {
+      void this._notifyStatusHook("completed");
+    }
+  }
+  _markError(error, notify_hook = true) {
+    if (this.status === "completed" || this.status === "error") return;
+    this.update({ error });
+    if (notify_hook) {
+      void this._notifyStatusHook("completed");
+    }
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      status: this.status,
+      event_id: this.event.event_id,
+      handler_id: this.handler_id,
+      handler_name: this.handler_name,
+      handler_file_path: this.handler_file_path,
+      handler_timeout: this.handler.handler_timeout,
+      handler_slow_timeout: this.handler.handler_slow_timeout,
+      handler_registered_at: this.handler.handler_registered_at,
+      handler_event_pattern: this.handler.event_pattern,
+      eventbus_name: this.eventbus_name,
+      eventbus_id: this.eventbus_id,
+      started_at: this.started_at,
+      completed_at: this.completed_at,
+      result: this.result,
+      error: this.error,
+      event_children: this.event_children.map((child) => child.event_id)
+    };
+  }
+  static fromJSON(event, data) {
+    const record = EventResultJSONSchema.parse(data);
+    const handler_record = {
+      id: record.handler_id,
+      eventbus_name: record.eventbus_name,
+      eventbus_id: record.eventbus_id,
+      event_pattern: record.handler_event_pattern ?? event.event_type,
+      handler_name: record.handler_name,
+      handler_file_path: record.handler_file_path ?? null,
+      handler_timeout: record.handler_timeout,
+      handler_slow_timeout: record.handler_slow_timeout,
+      handler_registered_at: record.handler_registered_at ?? event.event_created_at
+    };
+    const handler_stub = EventHandler.fromJSON(handler_record, (() => void 0));
+    const result = new EventResult({ event, handler: handler_stub });
+    result.id = record.id;
+    result.status = record.status;
+    result.started_at = record.started_at === null || record.started_at === void 0 ? null : monotonicDatetime(record.started_at);
+    result.completed_at = record.completed_at === null || record.completed_at === void 0 ? null : monotonicDatetime(record.completed_at);
+    if ("result" in record) {
+      result.result = record.result;
+    }
+    if ("error" in record) {
+      result.error = record.error;
+    }
+    result.event_children = [];
+    return result;
+  }
+}
+export {
+  EventResult,
+  EventResultJSONSchema
+};
+//# sourceMappingURL=event_result.js.map