abxbus 2.4.1

package/dist/esm/types.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+const normalizeEventPattern = (event_pattern) => {
+  if (event_pattern === "*") {
+    return "*";
+  }
+  if (typeof event_pattern === "string") {
+    return event_pattern;
+  }
+  const event_type = event_pattern.event_type;
+  if (typeof event_type === "string" && event_type.length > 0 && event_type !== "BaseEvent") {
+    return event_type;
+  }
+  const class_name = event_pattern.name;
+  if (typeof class_name === "string" && class_name.length > 0 && class_name !== "BaseEvent") {
+    return class_name;
+  }
+  let preview;
+  try {
+    const encoded = JSON.stringify(event_pattern);
+    preview = typeof encoded === "string" ? encoded.slice(0, 30) : String(event_pattern).slice(0, 30);
+  } catch {
+    preview = String(event_pattern).slice(0, 30);
+  }
+  throw new Error('bus.on(match_pattern, ...) must be a string event type, "*", or a BaseEvent class, got: ' + preview);
+};
+const isZodSchema = (value) => !!value && typeof value.safeParse === "function";
+const eventResultTypeFromConstructor = (value) => {
+  if (value === String) {
+    return z.string();
+  }
+  if (value === Number) {
+    return z.number();
+  }
+  if (value === Boolean) {
+    return z.boolean();
+  }
+  if (value === Array) {
+    return z.array(z.unknown());
+  }
+  if (value === Object) {
+    return z.record(z.string(), z.unknown());
+  }
+  return void 0;
+};
+const extractZodShape = (raw) => {
+  const shape = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (key === "event_result_type") continue;
+    if (isZodSchema(value)) shape[key] = value;
+  }
+  return shape;
+};
+const toJsonSchema = (schema) => {
+  if (!schema || !isZodSchema(schema)) return schema;
+  const zod_any = z;
+  return zod_any.toJSONSchema(schema);
+};
+const fromJsonSchema = (schema) => {
+  const zod_any = z;
+  return zod_any.fromJSONSchema(schema);
+};
+const normalizeEventResultType = (value) => {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (isZodSchema(value)) {
+    return value;
+  }
+  const constructor_schema = eventResultTypeFromConstructor(value);
+  if (constructor_schema) {
+    return constructor_schema;
+  }
+  return fromJsonSchema(value);
+};
+export {
+  eventResultTypeFromConstructor,
+  extractZodShape,
+  fromJsonSchema,
+  isZodSchema,
+  normalizeEventPattern,
+  normalizeEventResultType,
+  toJsonSchema
+};
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/types.ts"],
+  "sourcesContent": ["import { z } from 'zod'\nimport type { BaseEvent } from './base_event.js'\n\nexport type EventStatus = 'pending' | 'started' | 'completed'\n\nexport type EventClass<T extends BaseEvent = BaseEvent> = { event_type?: string } & (new (...args: any[]) => T)\n\nexport type EventPattern<T extends BaseEvent = BaseEvent> = string | EventClass<T>\n\nexport type EventWithResultSchema<TResult> = BaseEvent & { __event_result_type__?: TResult }\n\nexport type EventResultType<TEvent extends BaseEvent> = TEvent extends { __event_result_type__?: infer TResult } ? TResult : unknown\n\nexport type EventResultTypeConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor\n\nexport type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | unknown\n\nexport type EventHandlerReturn<T extends BaseEvent = BaseEvent> = EventResultType<T> | BaseEvent | null | void\n\nexport type EventHandlerCallable<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | Promise<EventHandlerReturn<T>>\n\n// For string and wildcard subscriptions we cannot reliably infer which event\n// type will arrive, so return type checking intentionally degrades to unknown.\nexport type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (\n  event: T\n) => EventHandlerReturn<T> | unknown | Promise<EventHandlerReturn<T> | unknown>\n\nexport type FindWindow = boolean | number\n\ntype FindReservedOptionKeys = 'past' | 'future' | 'child_of'\n\ntype EventFilterFields<T extends BaseEvent> = {\n  [K in keyof T as string extends K\n    ? never\n    : number extends K\n      ? never\n      : symbol extends K\n        ? never\n        : K extends FindReservedOptionKeys\n          ? never\n          : T[K] extends (...args: any[]) => any\n            ? never\n            : K]?: T[K]\n}\n\nexport type FindOptions<T extends BaseEvent = BaseEvent> = {\n  past?: FindWindow\n  future?: FindWindow\n  child_of?: BaseEvent | null\n} & EventFilterFields<T> &\n  Record<string, unknown>\n\nexport const normalizeEventPattern = (event_pattern: EventPattern | '*'): string | '*' => {\n  if (event_pattern === '*') {\n    return '*'\n  }\n  if (typeof event_pattern === 'string') {\n    return event_pattern\n  }\n  const event_type = (event_pattern as { event_type?: unknown }).event_type\n  if (typeof event_type === 'string' && event_type.length > 0 && event_type !== 'BaseEvent') {\n    return event_type\n  }\n  const class_name = (event_pattern as { name?: unknown }).name\n  if (typeof class_name === 'string' && class_name.length > 0 && class_name !== 'BaseEvent') {\n    return class_name\n  }\n  let preview: string\n  try {\n    const encoded = JSON.stringify(event_pattern)\n    preview = typeof encoded === 'string' ? encoded.slice(0, 30) : String(event_pattern).slice(0, 30)\n  } catch {\n    preview = String(event_pattern).slice(0, 30)\n  }\n  throw new Error('bus.on(match_pattern, ...) must be a string event type, \"*\", or a BaseEvent class, got: ' + preview)\n}\n\nexport const isZodSchema = (value: unknown): value is z.ZodTypeAny => !!value && typeof (value as z.ZodTypeAny).safeParse === 'function'\n\nexport const eventResultTypeFromConstructor = (value: unknown): z.ZodTypeAny | undefined => {\n  if (value === String) {\n    return z.string()\n  }\n  if (value === Number) {\n    return z.number()\n  }\n  if (value === Boolean) {\n    return z.boolean()\n  }\n  if (value === Array) {\n    return z.array(z.unknown())\n  }\n  if (value === Object) {\n    return z.record(z.string(), z.unknown())\n  }\n  return undefined\n}\n\nexport const extractZodShape = (raw: Record<string, unknown>): z.ZodRawShape => {\n  const shape: Record<string, z.ZodTypeAny> = {}\n  for (const [key, value] of Object.entries(raw)) {\n    if (key === 'event_result_type') continue\n    if (isZodSchema(value)) shape[key] = value\n  }\n  return shape as z.ZodRawShape\n}\n\nexport const toJsonSchema = (schema: unknown): unknown => {\n  if (!schema || !isZodSchema(schema)) return schema\n  const zod_any = z as unknown as { toJSONSchema: (input: z.ZodTypeAny) => unknown }\n  // Cross-language roundtrips preserve core structural types; constraint keywords may not roundtrip exactly.\n  return zod_any.toJSONSchema(schema)\n}\n\nexport const fromJsonSchema = (schema: unknown): z.ZodTypeAny => {\n  const zod_any = z as unknown as { fromJSONSchema: (input: unknown) => z.ZodTypeAny }\n  return zod_any.fromJSONSchema(schema)\n}\n\nexport const normalizeEventResultType = (value: EventResultTypeInput): z.ZodTypeAny | undefined => {\n  if (value === undefined || value === null) {\n    return undefined\n  }\n  if (isZodSchema(value)) {\n    return value\n  }\n  const constructor_schema = eventResultTypeFromConstructor(value)\n  if (constructor_schema) {\n    return constructor_schema\n  }\n  return fromJsonSchema(value)\n}\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAoDX,MAAM,wBAAwB,CAAC,kBAAoD;AACxF,MAAI,kBAAkB,KAAK;AACzB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,kBAAkB,UAAU;AACrC,WAAO;AAAA,EACT;AACA,QAAM,aAAc,cAA2C;AAC/D,MAAI,OAAO,eAAe,YAAY,WAAW,SAAS,KAAK,eAAe,aAAa;AACzF,WAAO;AAAA,EACT;AACA,QAAM,aAAc,cAAqC;AACzD,MAAI,OAAO,eAAe,YAAY,WAAW,SAAS,KAAK,eAAe,aAAa;AACzF,WAAO;AAAA,EACT;AACA,MAAI;AACJ,MAAI;AACF,UAAM,UAAU,KAAK,UAAU,aAAa;AAC5C,cAAU,OAAO,YAAY,WAAW,QAAQ,MAAM,GAAG,EAAE,IAAI,OAAO,aAAa,EAAE,MAAM,GAAG,EAAE;AAAA,EAClG,QAAQ;AACN,cAAU,OAAO,aAAa,EAAE,MAAM,GAAG,EAAE;AAAA,EAC7C;AACA,QAAM,IAAI,MAAM,6FAA6F,OAAO;AACtH;AAEO,MAAM,cAAc,CAAC,UAA0C,CAAC,CAAC,SAAS,OAAQ,MAAuB,cAAc;AAEvH,MAAM,iCAAiC,CAAC,UAA6C;AAC1F,MAAI,UAAU,QAAQ;AACpB,WAAO,EAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,EAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,SAAS;AACrB,WAAO,EAAE,QAAQ;AAAA,EACnB;AACA,MAAI,UAAU,OAAO;AACnB,WAAO,EAAE,MAAM,EAAE,QAAQ,CAAC;AAAA,EAC5B;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC;AAAA,EACzC;AACA,SAAO;AACT;AAEO,MAAM,kBAAkB,CAAC,QAAgD;AAC9E,QAAM,QAAsC,CAAC;AAC7C,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,QAAI,QAAQ,oBAAqB;AACjC,QAAI,YAAY,KAAK,EAAG,OAAM,GAAG,IAAI;AAAA,EACvC;AACA,SAAO;AACT;AAEO,MAAM,eAAe,CAAC,WAA6B;AACxD,MAAI,CAAC,UAAU,CAAC,YAAY,MAAM,EAAG,QAAO;AAC5C,QAAM,UAAU;AAEhB,SAAO,QAAQ,aAAa,MAAM;AACpC;AAEO,MAAM,iBAAiB,CAAC,WAAkC;AAC/D,QAAM,UAAU;AAChB,SAAO,QAAQ,eAAe,MAAM;AACtC;AAEO,MAAM,2BAA2B,CAAC,UAA0D;AACjG,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,WAAO;AAAA,EACT;AACA,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO;AAAA,EACT;AACA,QAAM,qBAAqB,+BAA+B,KAAK;AAC/D,MAAI,oBAAoB;AACtB,WAAO;AAAA,EACT;AACA,SAAO,eAAe,KAAK;AAC7B;",
+  "names": []
+}

package/dist/types/async_context.d.ts

@@ -0,0 +1,12 @@
+type AsyncLocalStorageLike = {
+    getStore(): unknown;
+    run<T>(store: unknown, callback: () => T): T;
+    enterWith?(store: unknown): void;
+};
+export type { AsyncLocalStorageLike };
+/** Create a new AsyncLocalStorage instance, or null if unavailable (e.g. in browsers). */
+export declare const createAsyncLocalStorage: () => AsyncLocalStorageLike | null;
+export declare let async_local_storage: AsyncLocalStorageLike | null;
+export declare const captureAsyncContext: () => unknown | null;
+export declare const _runWithAsyncContext: <T>(context: unknown | null, fn: () => T) => T;
+export declare const hasAsyncLocalStorage: () => boolean;

package/dist/types/base_event.d.ts

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+import { EventBus } from './event_bus.js';
+import { EventResult } from './event_result.js';
+import { EventHandler } from './event_handler.js';
+import type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, Deferred } from './lock_manager.js';
+import { AsyncLock } from './lock_manager.js';
+import type { EventHandlerCallable, EventResultType } from './types.js';
+export declare const BaseEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    event_created_at: z.ZodString;
+    event_type: z.ZodString;
+    event_version: z.ZodDefault<z.ZodString>;
+    event_timeout: z.ZodNullable<z.ZodNumber>;
+    event_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    event_handler_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    event_handler_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    event_parent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    event_result_type: z.ZodOptional<z.ZodUnknown>;
+    event_emitted_by_handler_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_pending_bus_count: z.ZodOptional<z.ZodNumber>;
+    event_status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        started: "started";
+        completed: "completed";
+    }>>;
+    event_started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        "global-serial": "global-serial";
+        "bus-serial": "bus-serial";
+        parallel: "parallel";
+    }>>>;
+    event_handler_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        parallel: "parallel";
+        serial: "serial";
+    }>>>;
+    event_handler_completion: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        all: "all";
+        first: "first";
+    }>>>;
+}, z.core.$loose>;
+export type BaseEventData = z.infer<typeof BaseEventSchema>;
+export type BaseEventJSON = BaseEventData & Record<string, unknown>;
+type BaseEventFields = Pick<BaseEventData, 'event_id' | 'event_created_at' | 'event_type' | 'event_version' | 'event_timeout' | 'event_slow_timeout' | 'event_handler_timeout' | 'event_handler_slow_timeout' | 'event_parent_id' | 'event_path' | 'event_result_type' | 'event_emitted_by_handler_id' | 'event_pending_bus_count' | 'event_status' | 'event_started_at' | 'event_completed_at' | 'event_results' | 'event_concurrency' | 'event_handler_concurrency' | 'event_handler_completion'>;
+export type BaseEventInit<TFields extends Record<string, unknown>> = TFields & Partial<BaseEventFields>;
+type BaseEventSchemaShape = typeof BaseEventSchema.shape;
+export type EventSchema<TShape extends z.ZodRawShape> = z.ZodObject<BaseEventSchemaShape & TShape>;
+type EventPayload<TShape extends z.ZodRawShape> = TShape extends Record<string, never> ? {} : z.infer<z.ZodObject<TShape>>;
+type EventInput<TShape extends z.ZodRawShape> = z.input<EventSchema<TShape>>;
+export type EventInit<TShape extends z.ZodRawShape> = Omit<EventInput<TShape>, keyof BaseEventFields> & Partial<BaseEventFields>;
+type EventWithResultSchema<TResult> = BaseEvent & {
+    __event_result_type__?: TResult;
+};
+type ResultTypeFromEventResultTypeInput<TInput> = TInput extends z.ZodTypeAny ? z.infer<TInput> : TInput extends StringConstructor ? string : TInput extends NumberConstructor ? number : TInput extends BooleanConstructor ? boolean : TInput extends ArrayConstructor ? unknown[] : TInput extends ObjectConstructor ? Record<string, unknown> : unknown;
+type ResultSchemaFromShape<TShape> = TShape extends {
+    event_result_type: infer S;
+} ? ResultTypeFromEventResultTypeInput<S> : unknown;
+type EventResultsListInclude<TEvent extends BaseEvent> = (result: EventResultType<TEvent> | undefined, event_result: EventResult<TEvent>) => boolean;
+type EventResultsListOptions<TEvent extends BaseEvent> = {
+    timeout?: number | null;
+    include?: EventResultsListInclude<TEvent>;
+    raise_if_any?: boolean;
+    raise_if_none?: boolean;
+};
+type EventDoneOptions = {
+    raise_if_any?: boolean;
+};
+type EventResultUpdateOptions<TEvent extends BaseEvent> = {
+    eventbus?: EventBus;
+    status?: 'pending' | 'started' | 'completed' | 'error';
+    result?: EventResultType<TEvent> | BaseEvent | undefined;
+    error?: unknown;
+};
+export type EventFactory<TShape extends z.ZodRawShape, TResult = unknown> = {
+    (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>;
+    new (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>;
+    schema: EventSchema<TShape>;
+    class?: new (data: EventInit<TShape>) => EventWithResultSchema<TResult> & EventPayload<TShape>;
+    event_type?: string;
+    event_version?: string;
+    event_result_type?: z.ZodTypeAny;
+    fromJSON?: (data: unknown) => EventWithResultSchema<TResult> & EventPayload<TShape>;
+};
+type ZodShapeFrom<TShape extends Record<string, unknown>> = {
+    [K in keyof TShape as K extends 'event_result_type' ? never : TShape[K] extends z.ZodTypeAny ? K : never]: Extract<TShape[K], z.ZodTypeAny>;
+};
+export declare class BaseEvent {
+    event_id: string;
+    event_created_at: string;
+    event_type: string;
+    event_version: string;
+    event_timeout: number | null;
+    event_slow_timeout?: number | null;
+    event_handler_timeout?: number | null;
+    event_handler_slow_timeout?: number | null;
+    event_parent_id: string | null;
+    event_path: string[];
+    event_result_type?: z.ZodTypeAny;
+    event_results: Map<string, EventResult<this>>;
+    event_emitted_by_handler_id: string | null;
+    event_pending_bus_count: number;
+    event_status: 'pending' | 'started' | 'completed';
+    event_started_at: string | null;
+    event_completed_at: string | null;
+    event_concurrency?: EventConcurrencyMode | null;
+    event_handler_concurrency?: EventHandlerConcurrencyMode | null;
+    event_handler_completion?: EventHandlerCompletionMode | null;
+    static event_type?: string;
+    static event_version: string;
+    static schema: z.ZodObject<{
+        event_id: z.ZodString;
+        event_created_at: z.ZodString;
+        event_type: z.ZodString;
+        event_version: z.ZodDefault<z.ZodString>;
+        event_timeout: z.ZodNullable<z.ZodNumber>;
+        event_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        event_handler_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        event_handler_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        event_parent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        event_result_type: z.ZodOptional<z.ZodUnknown>;
+        event_emitted_by_handler_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_pending_bus_count: z.ZodOptional<z.ZodNumber>;
+        event_status: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            started: "started";
+            completed: "completed";
+        }>>;
+        event_started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            "global-serial": "global-serial";
+            "bus-serial": "bus-serial";
+            parallel: "parallel";
+        }>>>;
+        event_handler_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            parallel: "parallel";
+            serial: "serial";
+        }>>>;
+        event_handler_completion: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            all: "all";
+            first: "first";
+        }>>>;
+    }, z.core.$loose>;
+    bus?: EventBus;
+    _event_original?: BaseEvent;
+    _event_dispatch_context?: unknown | null;
+    _event_completed_signal: Deferred<this> | null;
+    _lock_for_event_handler: AsyncLock | null;
+    get event_bus(): EventBus;
+    constructor(data?: BaseEventInit<Record<string, unknown>>);
+    toString(): string;
+    static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventFactory<TShape, ResultSchemaFromShape<TShape>>;
+    static extend<TShape extends Record<string, unknown>>(event_type: string, shape?: TShape): EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>>;
+    static fromJSON<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T>;
+    static toJSONArray(events: Iterable<BaseEvent>): BaseEventJSON[];
+    static fromJSONArray(data: unknown): BaseEvent[];
+    toJSON(): BaseEventJSON;
+    _createSlowEventWarningTimer(): ReturnType<typeof setTimeout> | null;
+    eventResultUpdate(handler: EventHandler | EventHandlerCallable<this>, options?: EventResultUpdateOptions<this>): EventResult<this>;
+    _createPendingHandlerResults(bus: EventBus): Array<{
+        handler: EventHandler;
+        result: EventResult;
+    }>;
+    private _collectPendingResults;
+    private _isFirstModeWinningResult;
+    private _markFirstModeWinnerIfNeeded;
+    private _runHandlerWithLock;
+    _runHandlers(pending_entries?: Array<{
+        handler: EventHandler;
+        result: EventResult;
+    }>): Promise<void>;
+    _getHandlerLock(default_concurrency?: EventHandlerConcurrencyMode): AsyncLock | null;
+    _setHandlerLock(lock: AsyncLock | null): void;
+    _getDispatchContext(): unknown | null | undefined;
+    _setDispatchContext(dispatch_context: unknown | null | undefined): void;
+    get event_parent(): BaseEvent | undefined;
+    get event_children(): BaseEvent[];
+    get event_descendants(): BaseEvent[];
+    _cancelPendingChildProcessing(reason: unknown): void;
+    _markRemainingFirstModeResultCancelled(winner: EventResult): void;
+    _markCancelled(cause: Error): void;
+    _notifyEventParentsOfCompletion(): void;
+    done(options?: EventDoneOptions): Promise<this>;
+    first(): Promise<EventResultType<this> | undefined>;
+    eventResultsList(include: EventResultsListInclude<this>, options?: EventResultsListOptions<this>): Promise<Array<EventResultType<this> | undefined>>;
+    eventResultsList(options?: EventResultsListOptions<this>): Promise<Array<EventResultType<this> | undefined>>;
+    eventCompleted(): Promise<this>;
+    _markPending(): this;
+    eventReset(): this;
+    _markStarted(started_at?: string | null, notify_hook?: boolean): void;
+    _markCompleted(force?: boolean, notify_parents?: boolean): void;
+    private dropFromZeroHistoryBuses;
+    get event_errors(): unknown[];
+    private _isFirstModeControlError;
+    _firstProcessingError(options?: {
+        ignore_first_mode_control_errors?: boolean;
+    }): unknown | undefined;
+    get event_result(): EventResultType<this> | undefined;
+    _areAllChildrenComplete(): boolean;
+    private _notifyDoneListeners;
+    _gc(): void;
+}
+export {};

package/dist/types/bridge_jsonl.d.ts

@@ -0,0 +1,26 @@
+import { BaseEvent } from './base_event.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class JSONLEventBridge {
+    readonly path: string;
+    readonly poll_interval: number;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private byte_offset;
+    private pending_line;
+    private listener_task;
+    constructor(path: string, poll_interval?: number, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private listenLoop;
+    private pollNewLines;
+    private dispatchInboundPayload;
+    private readAppended;
+    private dirname;
+    private loadFs;
+}

package/dist/types/bridge_nats.d.ts

@@ -0,0 +1,20 @@
+import { BaseEvent } from './base_event.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class NATSEventBridge {
+    readonly server: string;
+    readonly subject: string;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private nc;
+    private sub_task;
+    constructor(server: string, subject: string, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private dispatchInboundPayload;
+}

package/dist/types/bridge_postgres.d.ts

@@ -0,0 +1,31 @@
+/**
+ * PostgreSQL LISTEN/NOTIFY + flat-table bridge for forwarding events.
+ */
+import { BaseEvent } from './base_event.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class PostgresEventBridge {
+    readonly table_url: string;
+    readonly dsn: string;
+    readonly table: string;
+    readonly channel: string;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private client;
+    private table_columns;
+    private notification_handler;
+    constructor(table_url: string, channel?: string, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private dispatchByEventId;
+    private dispatchInboundPayload;
+    private ensureTableExists;
+    private ensureBaseIndexes;
+    private refreshColumnCache;
+    private ensureColumns;
+}

package/dist/types/bridge_redis.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Redis pub/sub bridge for forwarding events between runtimes.
+ *
+ * Usage:
+ *   // channel from URL path
+ *   const bridge = new RedisEventBridge('redis://user:pass@localhost:6379/1/my_channel')
+ *
+ *   // explicit channel override
+ *   const bridge2 = new RedisEventBridge('redis://user:pass@localhost:6379/1', 'my_channel')
+ *
+ * URL format:
+ *   redis://user:pass@host:6379/<db>/<optional_channel>
+ */
+import { BaseEvent } from './base_event.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class RedisEventBridge {
+    readonly url: string;
+    readonly channel: string;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private start_promise;
+    private redis_pub;
+    private redis_sub;
+    constructor(redis_url: string, channel?: string, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private dispatchInboundPayload;
+}

package/dist/types/bridge_sqlite.d.ts

@@ -0,0 +1,30 @@
+import { BaseEvent } from './base_event.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class SQLiteEventBridge {
+    readonly path: string;
+    readonly table: string;
+    readonly poll_interval: number;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private last_seen_event_created_at;
+    private last_seen_event_id;
+    private listener_task;
+    private start_task;
+    private db;
+    private table_columns;
+    constructor(path: string, table?: string, poll_interval?: number, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private listenLoop;
+    private dispatchInboundPayload;
+    private refreshColumnCache;
+    private ensureColumns;
+    private ensureBaseIndexes;
+    private setCursorToLatestRow;
+}

package/dist/types/bridges.d.ts

@@ -0,0 +1,49 @@
+import { BaseEvent } from './base_event.js';
+import { EventBus } from './event_bus.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+type EndpointScheme = 'unix' | 'http' | 'https';
+type ParsedEndpoint = {
+    raw: string;
+    scheme: EndpointScheme;
+    host?: string;
+    port?: number;
+    path?: string;
+};
+export type HTTPEventBridgeOptions = {
+    send_to?: string | null;
+    listen_on?: string | null;
+    name?: string;
+};
+declare class _EventBridge {
+    readonly send_to: ParsedEndpoint | null;
+    readonly listen_on: ParsedEndpoint | null;
+    readonly name: string;
+    protected readonly inbound_bus: EventBus;
+    private start_promise;
+    private node_server;
+    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureListenerStarted;
+    private handleIncomingPayload;
+    private sendHttp;
+    private sendUnix;
+    private startHttpListener;
+    private startUnixListener;
+}
+export declare class HTTPEventBridge extends _EventBridge {
+    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
+    constructor(options?: HTTPEventBridgeOptions);
+}
+export declare class SocketEventBridge extends _EventBridge {
+    constructor(path?: string | null, name?: string);
+}
+export { NATSEventBridge } from './bridge_nats.js';
+export { RedisEventBridge } from './bridge_redis.js';
+export { PostgresEventBridge } from './bridge_postgres.js';
+export { JSONLEventBridge } from './bridge_jsonl.js';
+export { SQLiteEventBridge } from './bridge_sqlite.js';

package/dist/types/event_bus.d.ts

@@ -0,0 +1,127 @@
+import { BaseEvent, type BaseEventJSON } from './base_event.js';
+import { EventHistory } from './event_history.js';
+import { EventResult } from './event_result.js';
+import { AsyncLock, type EventConcurrencyMode, type EventHandlerConcurrencyMode, type EventHandlerCompletionMode, LockManager } from './lock_manager.js';
+import { EventHandler, type EphemeralFindEventHandler, type EventHandlerJSON } from './event_handler.js';
+import type { EventBusMiddleware, EventBusMiddlewareInput } from './middlewares.js';
+import type { EventClass, EventHandlerCallable, EventPattern, FindOptions, UntypedEventHandlerFunction } from './types.js';
+export type EventBusOptions = {
+    id?: string;
+    max_history_size?: number | null;
+    max_history_drop?: boolean;
+    event_concurrency?: EventConcurrencyMode | null;
+    event_timeout?: number | null;
+    event_slow_timeout?: number | null;
+    event_handler_concurrency?: EventHandlerConcurrencyMode | null;
+    event_handler_completion?: EventHandlerCompletionMode;
+    event_handler_slow_timeout?: number | null;
+    event_handler_detect_file_paths?: boolean;
+    middlewares?: EventBusMiddlewareInput[];
+};
+export type EventBusJSON = {
+    id: string;
+    name: string;
+    max_history_size: number | null;
+    max_history_drop: boolean;
+    event_concurrency: EventConcurrencyMode;
+    event_timeout: number | null;
+    event_slow_timeout: number | null;
+    event_handler_concurrency: EventHandlerConcurrencyMode;
+    event_handler_completion: EventHandlerCompletionMode;
+    event_handler_slow_timeout: number | null;
+    event_handler_detect_file_paths: boolean;
+    handlers: Record<string, EventHandlerJSON>;
+    handlers_by_key: Record<string, string[]>;
+    event_history: Record<string, BaseEventJSON>;
+    pending_event_queue: string[];
+};
+export declare class GlobalEventBusRegistry {
+    private _bus_refs;
+    add(bus: EventBus): void;
+    discard(bus: EventBus): void;
+    has(bus: EventBus): boolean;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<EventBus>;
+    findBusById(bus_id: string): EventBus | undefined;
+    findEventById(event_id: string): BaseEvent | null;
+}
+export declare class EventBus {
+    private static _registry_by_constructor;
+    private static _global_event_lock_by_constructor;
+    private static getRegistryForConstructor;
+    private static getGlobalEventLockForConstructor;
+    static get all_instances(): GlobalEventBusRegistry;
+    get all_instances(): GlobalEventBusRegistry;
+    get _lock_for_event_global_serial(): AsyncLock;
+    id: string;
+    name: string;
+    event_timeout: number | null;
+    event_concurrency: EventConcurrencyMode;
+    event_handler_concurrency: EventHandlerConcurrencyMode;
+    event_handler_completion: EventHandlerCompletionMode;
+    event_handler_detect_file_paths: boolean;
+    event_handler_slow_timeout: number | null;
+    event_slow_timeout: number | null;
+    handlers: Map<string, EventHandler>;
+    handlers_by_key: Map<string, string[]>;
+    event_history: EventHistory<BaseEvent>;
+    pending_event_queue: BaseEvent[];
+    in_flight_event_ids: Set<string>;
+    runloop_running: boolean;
+    locks: LockManager;
+    find_waiters: Set<EphemeralFindEventHandler>;
+    middlewares: EventBusMiddleware[];
+    private static normalizeMiddlewares;
+    constructor(name?: string, options?: EventBusOptions);
+    toString(): string;
+    scheduleMicrotask(fn: () => void): void;
+    private _runMiddlewareHook;
+    onEventChange(event: BaseEvent, status: 'pending' | 'started' | 'completed'): Promise<void>;
+    onEventResultChange(event: BaseEvent, result: EventResult, status: 'pending' | 'started' | 'completed'): Promise<void>;
+    private _onEventChange;
+    private _onEventResultChange;
+    private _onBusHandlersChange;
+    private _finalizeEventTimeout;
+    private _createEventTimeoutError;
+    private _runHandlersWithTimeout;
+    private _markEventCompletedIfNeeded;
+    toJSON(): EventBusJSON;
+    private static _stubHandlerFn;
+    private static _upsertHandlerIndex;
+    private static _linkEventResultHandlers;
+    static fromJSON(data: unknown): EventBus;
+    get label(): string;
+    removeEventFromPendingQueue(event: BaseEvent): number;
+    isEventInFlightOrQueued(event_id: string): boolean;
+    removeEventFromHistory(event_id: string): boolean;
+    destroy(): void;
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>, options?: Partial<EventHandler>): EventHandler;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>, options?: Partial<EventHandler>): EventHandler;
+    off<T extends BaseEvent>(event_pattern: EventPattern<T> | '*', handler?: EventHandlerCallable<T> | string | EventHandler): void;
+    emit<T extends BaseEvent>(event: T): T;
+    dispatch<T extends BaseEvent>(event: T): T;
+    find(event_pattern: '*', options?: FindOptions<BaseEvent>): Promise<BaseEvent | null>;
+    find(event_pattern: '*', where: (event: BaseEvent) => boolean, options?: FindOptions<BaseEvent>): Promise<BaseEvent | null>;
+    find<T extends BaseEvent>(event_pattern: EventPattern<T>, options?: FindOptions<T>): Promise<T | null>;
+    find<T extends BaseEvent>(event_pattern: EventPattern<T>, where: (event: T) => boolean, options?: FindOptions<T>): Promise<T | null>;
+    private _waitForFutureMatch;
+    waitUntilIdle(timeout?: number | null): Promise<boolean>;
+    isIdle(): boolean;
+    isIdleAndQueueEmpty(): boolean;
+    eventIsChildOf(child_event: BaseEvent, parent_event: BaseEvent): boolean;
+    eventIsParentOf(parent_event: BaseEvent, child_event: BaseEvent): boolean;
+    logTree(): string;
+    findEventById(event_id: string): BaseEvent | null;
+    _getParentEventResultAcrossAllBuses(event: BaseEvent): EventResult | null;
+    private _startRunloop;
+    private _processEvent;
+    _processEventImmediately<T extends BaseEvent>(event: T, handler_result?: EventResult): Promise<T>;
+    private _processEventImmediatelyAcrossBuses;
+    private _runloop;
+    _hasProcessedEvent(event: BaseEvent): boolean;
+    private _resolveImplicitParentHandlerResult;
+    _getEventProxyScopedToThisBus<T extends BaseEvent>(event: T, handler_result?: EventResult): T;
+    private _resolveFindWaiters;
+    _getHandlersForEvent(event: BaseEvent): EventHandler[];
+    private _removeIndexedHandler;
+}