abxbus 2.5.0 → 2.5.3

package/dist/types/CoreClient.d.ts

@@ -0,0 +1,167 @@
+export declare const CORE_PROTOCOL_VERSION = 1;
+export type ProtocolEnvelope<TMessage = Record<string, unknown>> = {
+    protocol_version: number;
+    session_id: string;
+    request_id?: string;
+    last_patch_seq?: number;
+    message: TMessage;
+};
+export type CoreMessage = Record<string, unknown> & {
+    type?: string;
+};
+type FastCompletedHandlerOptions = {
+    result_is_event_reference?: boolean;
+    process_route_after?: boolean;
+    process_available_after?: boolean;
+    compact_response?: boolean;
+    include_patches?: boolean;
+};
+type ForwardEventOptions = {
+    parent_invocation_id?: string | null;
+    block_parent_completion?: boolean;
+    pause_parent_route?: boolean;
+    event_timeout?: number | null;
+    event_slow_timeout?: number | null;
+    event_concurrency?: string | null;
+    event_handler_timeout?: number | null;
+    event_handler_slow_timeout?: number | null;
+    event_handler_concurrency?: string | null;
+    event_handler_completion?: string | null;
+    event_blocks_parent_completion?: boolean | null;
+};
+export declare class RustCoreClient {
+    private static shared_named_clients;
+    private static cleanup_registered;
+    static acquireNamed(bus_name: string): RustCoreClient;
+    static releaseNamed(client: RustCoreClient, options?: {
+        stopCore?: boolean;
+    }): void;
+    private static registerProcessCleanup;
+    static stopIdleNamedClients(): void;
+    readonly session_id: string;
+    readonly command: string;
+    readonly args: string[];
+    readonly socket_path: string;
+    private process;
+    private rpc;
+    private last_patch_seq;
+    private request_seq;
+    private release_transport_timer;
+    private readonly kill_process_on_close;
+    private readonly owns_socket_path;
+    private readonly bus_name;
+    private readonly session_id_bytes;
+    constructor(options?: {
+        command?: string;
+        args?: string[];
+        session_id?: string;
+        socket_path?: string;
+        bus_name?: string;
+    });
+    request(message: CoreMessage, options?: {
+        includePatches?: boolean;
+        advancePatchSeq?: boolean;
+        advancePatchSeqWhenNoPatches?: boolean;
+    }): ProtocolEnvelope<CoreMessage>[];
+    private requestOnce;
+    requestMessages(message: CoreMessage, options?: {
+        includePatches?: boolean;
+        advancePatchSeq?: boolean;
+        advancePatchSeqWhenNoPatches?: boolean;
+    }): CoreMessage[];
+    getPatchSeq(): number;
+    setPatchSeq(last_patch_seq: number): void;
+    filterUnseenPatchMessages(messages: CoreMessage[]): CoreMessage[];
+    ackPatchMessages(messages: CoreMessage | CoreMessage[]): void;
+    registerBus(bus: Record<string, unknown>): CoreMessage[];
+    unregisterBus(bus_id: string): CoreMessage[];
+    registerHandler(handler: Record<string, unknown>): CoreMessage[];
+    importBusSnapshot(snapshot: {
+        bus: Record<string, unknown>;
+        handlers: Record<string, unknown>[];
+        events: Record<string, unknown>[];
+        pending_event_ids: string[];
+    }): CoreMessage[];
+    unregisterHandler(handler_id: string): CoreMessage[];
+    disconnectHost(host_id?: string | null): CoreMessage[];
+    closeSession(): void;
+    stopCore(): CoreMessage[];
+    emitEvent(event: Record<string, unknown>, bus_id: string, defer_start?: boolean, compact_response?: boolean, options?: {
+        parent_invocation_id?: string | null;
+        block_parent_completion?: boolean;
+        pause_parent_route?: boolean;
+    }): CoreMessage[];
+    forwardEvent(event_id: string, bus_id: string, defer_start?: boolean, compact_response?: boolean, options?: ForwardEventOptions): CoreMessage[];
+    updateEventOptions(event_id: string, options: {
+        event_handler_completion?: string | null;
+        event_blocks_parent_completion?: boolean | null;
+    }): CoreMessage[];
+    processNextRoute(bus_id: string, limit?: number | null, compact_response?: boolean): CoreMessage[];
+    waitInvocations(bus_id?: string | null, limit?: number | null): CoreMessage[];
+    waitEventCompleted(event_id: string): CoreMessage[];
+    waitEventEmitted(bus_id: string, event_pattern?: string, seen_event_ids?: string[], after_event_id?: string | null, after_created_at?: string | null): CoreMessage[];
+    waitBusIdle(bus_id: string, timeout?: number | null): boolean;
+    processRoute(route_id: string, limit?: number | null, compact_response?: boolean): CoreMessage[];
+    awaitEvent(event_id: string, parent_invocation_id?: string | null): CoreMessage[];
+    queueJumpEvent(event_id: string, parent_invocation_id: string, block_parent_completion?: boolean, pause_parent_route?: boolean): CoreMessage[];
+    getEvent(event_id: string): Record<string, unknown> | null;
+    listEvents(event_pattern?: string, limit?: number | null, bus_id?: string | null): Record<string, unknown>[];
+    listEventIds(event_pattern?: string, limit?: number | null, bus_id?: string | null, statuses?: string[] | null): string[];
+    listPendingEventIds(bus_id: string): string[];
+    completeHandler(invocation: Record<string, unknown>, value: unknown, options?: FastCompletedHandlerOptions): CoreMessage[];
+    completeHandlerNoPatches(invocation: Record<string, unknown>, value: unknown, options?: FastCompletedHandlerOptions): CoreMessage[];
+    private requestFastCompletedHandler;
+    private requestFastRegisterHandler;
+    private requestFastUnregisterHandler;
+    private requestFastQueueJumpEvent;
+    private waitFastCoreAck;
+    private waitFastCoreMessages;
+    private readFastPatchSeq;
+    private requiredString;
+    private requiredUint64;
+    completeHandlerOutcomes(outcomes: Record<string, unknown>[], options?: {
+        compact_response?: boolean;
+    }): CoreMessage[];
+    completedHandlerOutcome(value: unknown, result_is_event_reference?: boolean): CoreMessage;
+    handlerOutcomeRecord(invocation: Record<string, unknown>, outcome: CoreMessage, options?: {
+        process_available_after?: boolean;
+    }): CoreMessage;
+    errorHandler(invocation: Record<string, unknown>, error: unknown, options?: {
+        process_route_after?: boolean;
+        process_available_after?: boolean;
+        compact_response?: boolean;
+    }): CoreMessage[];
+    erroredHandlerOutcome(error: unknown): CoreMessage;
+    close(): void;
+    closeTransportOnly(options?: {
+        closeSession?: boolean;
+    }): void;
+    disconnect(): void;
+    stop(): void;
+    private cleanupFailedSpawn;
+    private connect;
+    private tryConnect;
+    private connectNamedBus;
+    private requestNamedSession;
+    private requestNamedStop;
+    private waitForNamedDaemonStopped;
+    private ensureNamedDaemon;
+    private coreProcessEnv;
+    private ensureRpc;
+    private configureRpc;
+    private closeTransport;
+    private cleanupOwnedSocketPath;
+    releaseTransportSoon(): void;
+    private sendCloseSession;
+}
+export declare const defaultCoreCommand: (socket_path: string, options?: {
+    daemon?: boolean;
+}) => {
+    command: string;
+    args: string[];
+};
+export declare const stableCoreSocketPath: (_bus_name: string) => string;
+export declare const coreNamespace: () => string;
+export declare const stableCoreSessionSocketPath: (bus_name: string) => string;
+export declare const namedCoreLockPath: (socket_path: string) => string;
+export {};

package/dist/types/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/types/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/types/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/types/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 {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abxbus",
-  "version": "2.5.0",
+  "version": "2.5.3",
   "description": "Event bus library for browsers and ESM Node.js",
   "type": "module",
   "sideEffects": false,

package/src/BaseEvent.ts

@@ -161,6 +161,7 @@ type ResultTypeFromEventResultTypeInput<TInput> = TInput extends z.ZodTypeAny
             : unknown
 
 type ResultSchemaFromShape<TShape> = TShape extends { event_result_type: infer S } ? ResultTypeFromEventResultTypeInput<S> : unknown
+type ResultSchemaFromEventSchema<TSchema> = TSchema extends z.ZodObject<infer TShape> ? ResultSchemaFromShape<TShape> : unknown
 export type EventResultInclude<TEvent extends BaseEvent> = (
   result: EventResult<TEvent>['result'],
   event_result: EventResult<TEvent>
@@ -465,7 +466,10 @@ export class BaseEvent {
 
   // main entry point for users to define their own event types
   // BaseEvent.extend("MyEvent", { some_custom_field: z.string(), event_result_type: z.string(), event_timeout: 25, ... }) -> MyEvent
-  static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(event_type: string, event_schema: TSchema): SchemaEventFactory<TSchema, unknown>
+  static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(
+    event_type: string,
+    event_schema: TSchema
+  ): SchemaEventFactory<TSchema, ResultSchemaFromEventSchema<TSchema>>
   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,