abxbus 2.5.0 → 2.5.3

package/dist/cjs/CoreEventBus.d.ts

@@ -0,0 +1,334 @@
+import { RustCoreClient, type CoreMessage } from './CoreClient.js';
+import { BaseEvent } from './BaseEvent.js';
+import type { BaseEventJSON } from './BaseEvent.js';
+import { EventHandler } from './EventHandler.js';
+import type { EventHandlerJSON } from './EventHandler.js';
+import { EventResult } from './EventResult.js';
+import { AsyncLock, HandlerLock, type EventConcurrencyMode, type EventHandlerCompletionMode, type EventHandlerConcurrencyMode } from './LockManager.js';
+import type { EventBusMiddlewareInput } from './EventBusMiddleware.js';
+import { type EventHandlerCallable, type EventPattern, type FilterOptions, type FindOptions } from './types.js';
+export type CoreHandler<T extends BaseEvent = BaseEvent> = EventHandlerCallable<T>;
+export type RustCoreEventBusOptions = {
+    id?: string;
+    core?: RustCoreClient;
+    event_concurrency?: EventConcurrencyMode;
+    event_handler_concurrency?: EventHandlerConcurrencyMode;
+    event_handler_completion?: EventHandlerCompletionMode;
+    event_handler_detect_file_paths?: boolean;
+    event_timeout?: number | null;
+    event_slow_timeout?: number | null;
+    event_handler_timeout?: number | null;
+    event_handler_slow_timeout?: number | null;
+    max_history_size?: number | null;
+    max_history_drop?: boolean;
+    middlewares?: EventBusMiddlewareInput[];
+    background_worker?: boolean;
+};
+export type RustCoreHandlerOptions = {
+    id?: string;
+    handler_name?: string;
+    handler_registered_at?: string;
+    handler_file_path?: string | null;
+    handler_timeout?: number | null;
+    handler_slow_timeout?: number | null;
+    handler_concurrency?: EventHandlerConcurrencyMode | null;
+    handler_completion?: EventHandlerCompletionMode | null;
+    [key: string]: unknown;
+};
+export type RustCoreFilterOptions = {
+    limit?: number | null;
+    [field: string]: unknown;
+};
+export type RustCoreEventBusJSON = {
+    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_timeout: number | null;
+    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 CoreEventBusRegistry {
+    private _bus_refs;
+    private _bus_refs_by_id;
+    add(bus: RustCoreEventBus): void;
+    discard(bus: RustCoreEventBus): void;
+    has(bus: RustCoreEventBus): boolean;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<RustCoreEventBus>;
+    findBusById(bus_id: string): RustCoreEventBus | undefined;
+    findEventById(event_id: string): BaseEvent | null;
+}
+export declare const rustCoreEventBusRegistry: CoreEventBusRegistry;
+export declare class CoreEventHistory implements Iterable<[string, BaseEvent]> {
+    max_history_size: number | null;
+    max_history_drop: boolean;
+    private readonly bus;
+    constructor(bus: RustCoreEventBus, options?: {
+        max_history_size?: number | null;
+        max_history_drop?: boolean;
+    });
+    get size(): number;
+    [Symbol.iterator](): Iterator<[string, BaseEvent]>;
+    entries(): IterableIterator<[string, BaseEvent]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<BaseEvent>;
+    clear(): void;
+    get(event_id: string): BaseEvent | undefined;
+    set(event_id: string, event: BaseEvent): this;
+    has(event_id: string): boolean;
+    delete(event_id: string): boolean;
+    addEvent(event: BaseEvent): void;
+    getEvent(event_id: string): BaseEvent | undefined;
+    removeEvent(event_id: string): boolean;
+    hasEvent(event_id: string): boolean;
+    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>;
+    filter(event_pattern: '*', options?: FilterOptions<BaseEvent>): Promise<BaseEvent[]>;
+    filter(event_pattern: '*', where: (event: BaseEvent) => boolean, options?: FilterOptions<BaseEvent>): Promise<BaseEvent[]>;
+    filter<T extends BaseEvent>(event_pattern: EventPattern<T>, options?: FilterOptions<T>): Promise<T[]>;
+    filter<T extends BaseEvent>(event_pattern: EventPattern<T>, where: (event: T) => boolean, options?: FilterOptions<T>): Promise<T[]>;
+}
+export declare class CoreLockFacade {
+    private readonly bus;
+    private paused_count;
+    private pause_waiters;
+    private active_handler_results;
+    readonly bus_event_lock: AsyncLock;
+    constructor(bus: RustCoreEventBus);
+    _getActiveHandlerResultForCurrentAsyncContext(): EventResult | undefined;
+    _getActiveHandlerResults(): EventResult[];
+    _requestRunloopPause(): () => void;
+    _waitUntilRunloopResumed(): Promise<void>;
+    _isPaused(): boolean;
+    _notifyIdleListeners(): void;
+    _isAnyHandlerActive(): boolean;
+    getLockForEvent(event: BaseEvent): AsyncLock | null;
+    waitForIdle(timeout?: number | null): Promise<boolean>;
+    _runWithHandlerLock<T>(event: BaseEvent, default_concurrency: EventHandlerConcurrencyMode, fn: (handler_lock: HandlerLock | null) => Promise<T> | T): Promise<T>;
+    _runWithHandlerDispatchContext<T>(result: EventResult, fn: () => Promise<T> | T): Promise<T>;
+    _runWithEventLock<T>(event: BaseEvent, fn: () => Promise<T> | T, options?: {
+        bypass_event_locks?: boolean;
+        pre_acquired_lock?: AsyncLock | null;
+    }): Promise<T>;
+    clear(): void;
+}
+export declare class RustCoreEventBus {
+    readonly core: RustCoreClient;
+    readonly name: string;
+    readonly id: string;
+    readonly bus_id: string;
+    readonly label: string;
+    readonly event_concurrency: EventConcurrencyMode;
+    readonly event_handler_concurrency: EventHandlerConcurrencyMode;
+    readonly event_handler_completion: EventHandlerCompletionMode;
+    readonly event_handler_detect_file_paths: boolean;
+    readonly event_timeout: number | null;
+    readonly event_slow_timeout: number | null;
+    readonly event_handler_timeout: number | null;
+    readonly event_handler_slow_timeout: number | null;
+    readonly handlers: Map<string, EventHandler>;
+    readonly handlers_by_key: Map<string, string[]>;
+    readonly event_history: CoreEventHistory;
+    readonly locks: CoreLockFacade;
+    all_instances: CoreEventBusRegistry;
+    _lock_for_event_global_serial: AsyncLock;
+    in_flight_event_ids: Set<string>;
+    runloop_running: boolean;
+    private registered;
+    private events;
+    private processing;
+    private processing_tasks;
+    private middlewares;
+    private invocation_by_result_id;
+    private abort_by_invocation_id;
+    private event_types_by_pattern;
+    private event_timeout_causes;
+    private event_completion_waiters;
+    private event_emission_waiters;
+    private invocation_worker;
+    private background_worker_enabled;
+    private foreground_drain_task;
+    private foreground_drain_requested;
+    private serial_route_pause_releases;
+    private completed_event_refs;
+    private closed;
+    private readonly owns_shared_core;
+    private registered_max_history_size;
+    private registered_max_history_drop;
+    constructor(name?: string, options?: RustCoreEventBusOptions);
+    get pending_event_queue(): BaseEvent[];
+    get find_waiters(): Set<(event: BaseEvent) => void>;
+    set pending_event_queue(events: BaseEvent[]);
+    toString(): string;
+    defaultsRecord(): Record<string, unknown>;
+    private busRecord;
+    start(): void;
+    private syncBusHistoryPolicy;
+    on<T extends BaseEvent>(event_type: EventPattern<T>, handler: CoreHandler<T>, options?: RustCoreHandlerOptions): EventHandler;
+    on(event_type: '*', handler: CoreHandler, options?: RustCoreHandlerOptions): EventHandler;
+    off<T extends BaseEvent>(event_type: EventPattern<T> | '*', handler?: CoreHandler<T> | string | EventHandler): void;
+    emit<T extends BaseEvent>(event: T): T;
+    emit(event: Record<string, unknown>): Promise<CoreMessage>;
+    private scheduleForegroundDrain;
+    _onRunloopResumed(): void;
+    private drainForegroundCore;
+    private processAvailableCoreMessages;
+    private coreEventRecordForEmit;
+    private coreForwardControlOptions;
+    dispatch<T extends BaseEvent>(event: T): T;
+    onEventChange(_event: BaseEvent, _status: 'pending' | 'started' | 'completed'): Promise<void>;
+    onEventResultChange(_event: BaseEvent, _result: EventResult, _status: 'pending' | 'started' | 'completed'): Promise<void>;
+    hasMiddlewareHooks(): boolean;
+    hasEventChangeHooks(): boolean;
+    hasEventResultHooks(): boolean;
+    _notifyEventChange(event: BaseEvent, status: 'pending' | 'started' | 'completed'): void;
+    _notifyEventResultChange(event: BaseEvent, result: EventResult, status: 'pending' | 'started' | 'completed'): void;
+    findEventById(event_id: string): BaseEvent | null;
+    findLocalEventById(event_id: string): BaseEvent | undefined;
+    rememberEvent(event_id: string, event: BaseEvent): void;
+    rememberLiveEvent(event_id: string, event: BaseEvent): void;
+    forgetEvent(event_id: string): void;
+    localEvents(): IterableIterator<BaseEvent>;
+    importEventsToCore(events: BaseEvent[], pending_events?: BaseEvent[]): void;
+    historyRecords(event_pattern?: string, limit?: number | null): Record<string, unknown>[];
+    historyEventIds(event_pattern?: string, limit?: number | null, statuses?: string[] | null): string[];
+    coreRecordBelongsToThisBus(record: Record<string, unknown>): boolean;
+    activeHandlerResult(): EventResult | null;
+    _getEventProxyScopedToThisBus<T extends BaseEvent>(event: T, _handler_result?: EventResult): T;
+    _hasProcessedEvent(event: BaseEvent): boolean;
+    _getHandlersForEvent(event: BaseEvent): EventHandler[];
+    private ensurePendingLocalResults;
+    _processEventImmediately<T extends BaseEvent>(event: T, _handler_result?: EventResult): Promise<T>;
+    private findActiveInvocationForQueueJump;
+    private waitForLocalCompletionPush;
+    private waitForLocalCompletionOrProcessingDrain;
+    _waitForEventCompletedInQueueOrder<T extends BaseEvent>(event: T): Promise<T>;
+    private eventIsOwnedByActiveHandler;
+    private findParentInvocationForEvent;
+    private findBusForInvocation;
+    processUntilEventCompleted(event_id: string, initial_messages?: CoreMessage[] | null): Promise<BaseEvent>;
+    private waitForCoreCompletedEvent;
+    runUntilEventCompleted(event_id: string): Promise<BaseEvent>;
+    _syncEventRuntimeOptions(event: BaseEvent): void;
+    waitUntilIdle(timeout?: number | null): Promise<boolean>;
+    isIdle(): boolean;
+    isIdleAndQueueEmpty(): boolean;
+    removeEventFromPendingQueue(_event: BaseEvent): number;
+    isEventInFlightOrQueued(event_id: string): boolean;
+    removeEventFromHistory(event_id: string): boolean;
+    destroy(options?: number | {
+        timeout?: number | null;
+        clear?: boolean;
+    }): Promise<void>;
+    eventIsChildOf(child_event: BaseEvent, parent_event: BaseEvent): boolean;
+    eventIsParentOf(parent_event: BaseEvent, child_event: BaseEvent): boolean;
+    logTree(): string;
+    private applyAndRunMessagesUntilEventCompleted;
+    private runInvocationMessagesInCoreRouteOrder;
+    private completedSnapshotOrEvent;
+    private releaseCompletedLocalEvent;
+    private trackLocalEventUntilCoreEvictsIt;
+    collectEvictedCompletedEventRefs(visible_event_ids?: Set<string> | null): void;
+    private pendingQueueEventsFromCore;
+    private refreshPendingQueueFromCore;
+    private refreshKnownEventsFromCore;
+    private applyCoreSnapshotToEvent;
+    find<T extends BaseEvent>(event_type: EventPattern<T> | '*', where_or_options?: ((event: T) => boolean) | FindOptions<T>, maybe_options?: FindOptions<T>): Promise<T | null>;
+    filter<T extends BaseEvent>(event_type: EventPattern<T> | '*', where_or_options?: ((event: T) => boolean) | FilterOptions<T>, maybe_options?: FilterOptions<T>): Promise<T[]>;
+    disconnect(): void;
+    close(): void;
+    stop(): void;
+    scheduleMicrotask(fn: () => void): void;
+    toJSON(): RustCoreEventBusJSON;
+    eventFromCoreRecord<T extends BaseEvent>(event_type: EventPattern<T> | '*', record: Record<string, unknown>): BaseEvent;
+    private isStaleInvocationOutcomeError;
+    private eventSnapshotMessageForInvocation;
+    private completeHandlerOrSnapshot;
+    private completeHandlerNoPatchesOrSnapshot;
+    private canUsePatchlessCompletedOutcome;
+    private errorHandlerOrSnapshot;
+    private activeCoreOutcomeBatch;
+    private runWithCoreOutcomeBatch;
+    private runWithoutCoreOutcomeBatch;
+    private localOutcomePatchMessages;
+    private commitInvocationOutcomeMessages;
+    private invocationCanUseBatchedOutcome;
+    private invocationUsesFirstCompletion;
+    private eventForInvocation;
+    private runInvocationOutcome;
+    private runInvocation;
+    private startForegroundCoreSignalTimer;
+    private applyExpiredEventTimeout;
+    private startForegroundEventTimeoutTimer;
+    private startedAtForInvocation;
+    private eventTimeoutForInvocation;
+    private startForegroundEventSlowWarningTimer;
+    private eventSlowTimeoutForInvocation;
+    private abortResultForEventTimeout;
+    private invocationAbortError;
+    private eventTimeoutIpcGraceSeconds;
+    private processAvailableAfterHandlerOutcome;
+    private releaseSerialRoutePausesForInvocation;
+    private applyResultSnapshot;
+    private retargetErrorResult;
+    private orderedResultRecords;
+    private childIdsFromResultRecord;
+    private attachResultChildren;
+    private normalizeResultError;
+    private restoreCoreError;
+    private restoreGenericError;
+    private publicCoreErrorMessage;
+    private causeForCancellation;
+    private parentTimeoutEventIdFromMessage;
+    private eventTimeoutCause;
+    private timeoutSecondsForCoreError;
+    private eventTimeoutSecondsForResult;
+    private resolveTimeoutOverride;
+    private positiveTimeoutFromUnknown;
+    private numberFromUnknown;
+    private timestampMs;
+    private timestampBefore;
+    private warnSlowEvent;
+    private warnSlowResult;
+    runWithActiveHandlerResult<T>(result: EventResult, fn: () => T): T;
+    private startWorker;
+    private stopWorker;
+    private handleWorkerMessages;
+    private runAndApplyInvocationMessages;
+    private runInvocationMessages;
+    private resolveEventCompletionWaiters;
+    private notifyEventEmissionWaiters;
+    private waitForLocalEventEmission;
+    private waitForEventCompleted;
+    private localBusesForCoreSession;
+    private busForInvocation;
+    private applyCoreMessageToLocalBuses;
+    private targetBusesForCoreMessage;
+    private applyCoreMessage;
+    private applyCoreMessageFromSharedCursor;
+    private patchBelongsToThisBus;
+    private localResultIdExists;
+    private applyCoreMessageUnchecked;
+    private applyResultRecord;
+    private cancelFirstModeLosersForCompletedEvent;
+    private _runMiddlewareHook;
+    private _onBusHandlersChange;
+    private waitForFutureMatch;
+    private findCoreRecordCreatedAfter;
+    private waitForEventEmittedCancellable;
+}
+export declare const stableCoreBusId: (bus_name: string) => string;
+export declare const uniqueCoreBusId: () => string;
+export declare const defaultCoreBusId: (bus_name: string, registry: CoreEventBusRegistry) => string;

package/dist/cjs/base_event.d.ts

@@ -27,7 +27,7 @@ export declare const BaseEventSchema: z.ZodObject<{
     }>>;
     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_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";
@@ -133,7 +133,7 @@ export declare class BaseEvent {
         }>>;
         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_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";

package/dist/cjs/event_handler.d.ts

@@ -61,7 +61,6 @@ export declare class EventHandler {
         eventbus_id: string;
     });
     get _handler_async(): EventHandlerCallable;
-    static handlerNameFromCallable(handler: EventHandlerCallable): string;
     static computeHandlerId(params: {
         eventbus_id: string;
         handler_name: string;

package/dist/cjs/retry.d.ts

@@ -1,4 +1,11 @@
 type SemaphoreScope = 'multiprocess' | 'global' | 'class' | 'instance';
+type AnyFunction = (this: any, ...args: any[]) => any;
+type LegacyMethodDescriptor = TypedPropertyDescriptor<AnyFunction>;
+type RetryDecorator = {
+    <T extends AnyFunction>(target: T): T;
+    <T extends AnyFunction>(target: T, context: ClassMethodDecoratorContext): T;
+    (target: object, property_key: string | symbol, descriptor: LegacyMethodDescriptor): LegacyMethodDescriptor;
+};
 export interface RetryOptions {
     /** Total number of attempts including the initial call (1 = no retry, 3 = up to 2 retries). Default: 1 */
     max_attempts?: number;
@@ -51,5 +58,5 @@ export declare class SemaphoreTimeoutError extends Error {
 }
 /** Reset the global semaphore registry. Useful in tests. */
 export declare function clearSemaphoreRegistry(): void;
-export declare function retry(options?: RetryOptions): <T extends (...args: any[]) => any>(target: T, _context?: ClassMethodDecoratorContext) => T;
+export declare function retry(options?: RetryOptions): RetryDecorator;
 export {};