abxbus 2.4.32 → 2.5.1

package/dist/cjs/event_result.d.ts

@@ -1,86 +0,0 @@
-import { z } from 'zod';
-import { BaseEvent } from './base_event.js';
-import type { EventBus } from './event_bus.js';
-import { EventHandler } from './event_handler.js';
-import { type HandlerLock } from './lock_manager.js';
-import type { Deferred } from './lock_manager.js';
-import type { EventResultType } from './types.js';
-export type EventResultStatus = 'pending' | 'started' | 'completed' | 'error';
-export declare const EventResultJSONSchema: z.ZodObject<{
-    id: z.ZodString;
-    status: z.ZodEnum<{
-        pending: "pending";
-        started: "started";
-        completed: "completed";
-        error: "error";
-    }>;
-    event_id: z.ZodString;
-    handler_id: z.ZodString;
-    handler_name: z.ZodString;
-    handler_file_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    handler_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    handler_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    handler_registered_at: z.ZodOptional<z.ZodString>;
-    handler_event_pattern: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"*">]>>;
-    eventbus_name: z.ZodString;
-    eventbus_id: z.ZodString;
-    started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    error: z.ZodOptional<z.ZodUnknown>;
-    event_children: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type EventResultJSON = z.infer<typeof EventResultJSONSchema>;
-export declare class EventResult<TEvent extends BaseEvent = BaseEvent> {
-    id: string;
-    status: EventResultStatus;
-    event: TEvent;
-    handler: EventHandler;
-    started_at: string | null;
-    completed_at: string | null;
-    result?: EventResultType<TEvent>;
-    error?: unknown;
-    event_children: BaseEvent[];
-    _abort: Deferred<never> | null;
-    _lock: HandlerLock | null;
-    _queue_jump_pause_releases: Map<EventBus, () => void> | null;
-    constructor(params: {
-        event: TEvent;
-        handler: EventHandler;
-    });
-    toString(): string;
-    get event_id(): string;
-    get bus(): EventBus;
-    get handler_id(): string;
-    get handler_name(): string;
-    get handler_file_path(): string | null;
-    get eventbus_name(): string;
-    get eventbus_id(): string;
-    get eventbus_label(): string;
-    private getHookBus;
-    private _notifyStatusHook;
-    get value(): EventResultType<TEvent> | undefined;
-    get result_type(): TEvent['event_result_type'];
-    _linkEmittedChildEvent(child_event: BaseEvent): void;
-    get raw_value(): EventResultType<TEvent> | undefined;
-    get handler_timeout(): number | null;
-    get handler_slow_timeout(): number | null;
-    _createSlowHandlerWarningTimer(effective_timeout: number | null): ReturnType<typeof setTimeout> | null;
-    _ensureQueueJumpPause(bus: EventBus): void;
-    _releaseQueueJumpPauses(): void;
-    update(params: {
-        status?: EventResultStatus;
-        result?: EventResultType<TEvent> | BaseEvent | undefined;
-        error?: unknown;
-    }): this;
-    private _createHandlerTimeoutError;
-    private _handleHandlerError;
-    private _onHandlerExit;
-    runHandler(handler_lock: HandlerLock | null): Promise<void>;
-    _signalAbort(error: Error): void;
-    _markStarted(notify_hook?: boolean): Promise<never>;
-    _markCompleted(result: EventResultType<TEvent> | BaseEvent | undefined, notify_hook?: boolean): void;
-    _markError(error: unknown, notify_hook?: boolean): void;
-    toJSON(): EventResultJSON;
-    static fromJSON<TEvent extends BaseEvent>(event: TEvent, data: unknown): EventResult<TEvent>;
-}

package/dist/cjs/lock_manager.d.ts

@@ -1,70 +0,0 @@
-import type { BaseEvent } from './base_event.js';
-import type { EventResult } from './event_result.js';
-export type Deferred<T> = {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: unknown) => void;
-};
-export declare const withResolvers: <T>() => Deferred<T>;
-export declare const EVENT_CONCURRENCY_MODES: readonly ["global-serial", "bus-serial", "parallel"];
-export type EventConcurrencyMode = (typeof EVENT_CONCURRENCY_MODES)[number];
-export declare const EVENT_HANDLER_CONCURRENCY_MODES: readonly ["serial", "parallel"];
-export type EventHandlerConcurrencyMode = (typeof EVENT_HANDLER_CONCURRENCY_MODES)[number];
-export declare const EVENT_HANDLER_COMPLETION_MODES: readonly ["all", "first"];
-export type EventHandlerCompletionMode = (typeof EVENT_HANDLER_COMPLETION_MODES)[number];
-export declare class AsyncLock {
-    size: number;
-    in_use: number;
-    waiters: Array<() => void>;
-    constructor(size: number);
-    acquire(): Promise<void>;
-    release(): void;
-}
-export declare const runWithLock: <T>(lock: AsyncLock | null, fn: () => Promise<T>) => Promise<T>;
-export type HandlerExecutionState = 'held' | 'yielded' | 'closed';
-export declare class HandlerLock {
-    private lock;
-    private state;
-    constructor(lock: AsyncLock | null);
-    yieldHandlerLockForChildRun(): boolean;
-    reclaimHandlerLockIfRunning(): Promise<boolean>;
-    exitHandlerRun(): void;
-    runQueueJump<T>(fn: () => Promise<T>): Promise<T>;
-}
-export type EventBusInterfaceForLockManager = {
-    isIdleAndQueueEmpty: () => boolean;
-    event_concurrency: EventConcurrencyMode;
-    _lock_for_event_global_serial: AsyncLock;
-};
-export type LockManagerOptions = {
-    auto_schedule_idle_checks?: boolean;
-};
-export declare class LockManager {
-    private bus;
-    private auto_schedule_idle_checks;
-    readonly bus_event_lock: AsyncLock;
-    private pause_depth;
-    private pause_waiters;
-    private active_handler_results;
-    private idle_waiters;
-    private idle_check_pending;
-    private idle_check_streak;
-    constructor(bus: EventBusInterfaceForLockManager, options?: LockManagerOptions);
-    _requestRunloopPause(): () => void;
-    _waitUntilRunloopResumed(): Promise<void>;
-    _isPaused(): boolean;
-    _runWithHandlerDispatchContext<T>(result: EventResult, fn: () => Promise<T>): Promise<T>;
-    _getActiveHandlerResultForCurrentAsyncContext(): EventResult | undefined;
-    _getActiveHandlerResults(): EventResult[];
-    _isAnyHandlerActive(): boolean;
-    waitForIdle(timeout_seconds?: number | null): Promise<boolean>;
-    _notifyIdleListeners(): void;
-    getLockForEvent(event: BaseEvent): AsyncLock | null;
-    _runWithEventLock<T>(event: BaseEvent, fn: () => Promise<T>, options?: {
-        bypass_event_locks?: boolean;
-        pre_acquired_lock?: AsyncLock | null;
-    }): Promise<T>;
-    _runWithHandlerLock<T>(event: BaseEvent, default_handler_concurrency: EventHandlerConcurrencyMode | undefined, fn: (lock: HandlerLock | null) => Promise<T>): Promise<T>;
-    private scheduleIdleCheck;
-    clear(): void;
-}

package/dist/types/base_event.d.ts

@@ -1,211 +0,0 @@
-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_blocks_parent_completion: z.ZodOptional<z.ZodBoolean>;
-    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.ZodRecord<z.ZodString, 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_blocks_parent_completion' | '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_blocks_parent_completion: boolean;
-    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_blocks_parent_completion: z.ZodOptional<z.ZodBoolean>;
-        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.ZodRecord<z.ZodString, 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>;
-    event_bus?: EventBus;
-    _event_original?: BaseEvent;
-    _event_dispatch_context?: unknown | null;
-    _event_completed_signal: Deferred<this> | null;
-    _lock_for_event_handler: AsyncLock | null;
-    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[];
-    emit<T extends BaseEvent>(event: T): T;
-    _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>;
-    _markBlocksParentCompletionIfAwaitedFromEmittingHandler(): void;
-    _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(visited?: Set<string>): boolean;
-    private _notifyDoneListeners;
-    _gc(): void;
-}
-export {};

package/dist/types/bridge_jsonl.d.ts

@@ -1,26 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-/**
- * 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

@@ -1,30 +0,0 @@
-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/event_bus.d.ts

@@ -1,125 +0,0 @@
-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;
-    private _startRunloop;
-    private _processEvent;
-    _processEventImmediately<T extends BaseEvent>(event: T, handler_result?: EventResult): Promise<T>;
-    private _processEventImmediatelyAcrossBuses;
-    private _runloop;
-    _hasProcessedEvent(event: BaseEvent): boolean;
-    _getEventProxyScopedToThisBus<T extends BaseEvent>(event: T, handler_result?: EventResult): T;
-    private _resolveFindWaiters;
-    _getHandlersForEvent(event: BaseEvent): EventHandler[];
-    private _removeIndexedHandler;
-}