abxbus 2.4.32 → 2.5.1

package/dist/types/event_handler.d.ts

@@ -1,139 +0,0 @@
-import { z } from 'zod';
-import { type EventHandlerCallable, type EventPattern } from './types.js';
-import { BaseEvent } from './base_event.js';
-import type { EventResult } from './event_result.js';
-export type EphemeralFindEventHandler = {
-    event_pattern: string | '*';
-    matches: (event: BaseEvent) => boolean;
-    resolve: (event: BaseEvent) => void;
-    timeout_id?: ReturnType<typeof setTimeout>;
-};
-export declare const FindWaiterJSONSchema: z.ZodObject<{
-    event_pattern: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"*">]>;
-    has_timeout: z.ZodBoolean;
-}, z.core.$strict>;
-export type FindWaiterJSON = z.infer<typeof FindWaiterJSONSchema>;
-export declare class FindWaiter {
-    static toJSON(waiter: EphemeralFindEventHandler): FindWaiterJSON;
-    static fromJSON(data: unknown, overrides?: {
-        matches?: (event: BaseEvent) => boolean;
-        resolve?: (event: BaseEvent) => void;
-    }): EphemeralFindEventHandler;
-    static toJSONArray(waiters: Iterable<EphemeralFindEventHandler>): FindWaiterJSON[];
-    static fromJSONArray(data: unknown, overrides?: {
-        matches?: (event: BaseEvent) => boolean;
-        resolve?: (event: BaseEvent) => void;
-    }): EphemeralFindEventHandler[];
-}
-export declare const EventHandlerJSONSchema: z.ZodObject<{
-    id: z.ZodString;
-    eventbus_name: z.ZodString;
-    eventbus_id: z.ZodString;
-    event_pattern: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"*">]>;
-    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.ZodString;
-}, z.core.$strict>;
-export type EventHandlerJSON = z.infer<typeof EventHandlerJSONSchema>;
-export declare class EventHandler {
-    id: string;
-    handler: EventHandlerCallable;
-    handler_name: string;
-    handler_file_path: string | null;
-    handler_timeout?: number | null;
-    handler_slow_timeout?: number | null;
-    handler_registered_at: string;
-    event_pattern: string | '*';
-    eventbus_name: string;
-    eventbus_id: string;
-    constructor(params: {
-        id?: string;
-        handler: EventHandlerCallable;
-        handler_name: string;
-        handler_file_path?: string | null;
-        handler_timeout?: number | null;
-        handler_slow_timeout?: number | null;
-        handler_registered_at: string;
-        event_pattern: string | '*';
-        eventbus_name: string;
-        eventbus_id: string;
-    });
-    get _handler_async(): EventHandlerCallable;
-    static computeHandlerId(params: {
-        eventbus_id: string;
-        handler_name: string;
-        handler_file_path?: string | null;
-        handler_registered_at: string;
-        event_pattern: string | '*';
-    }): string;
-    static fromCallable<TEvent extends BaseEvent = BaseEvent>(params: {
-        handler: EventHandlerCallable<TEvent>;
-        event_pattern: EventPattern | '*';
-        eventbus_name: string;
-        eventbus_id: string;
-        detect_handler_file_path?: boolean;
-        id?: string;
-        handler_file_path?: string | null;
-        handler_timeout?: number | null;
-        handler_slow_timeout?: number | null;
-        handler_registered_at?: string;
-    }): EventHandler;
-    toString(): string;
-    _detectHandlerFilePath(): void;
-    toJSON(): EventHandlerJSON;
-    static fromJSON(data: unknown, handler?: EventHandlerCallable): EventHandler;
-    static toJSONArray(handlers: Iterable<EventHandler>): EventHandlerJSON[];
-    static fromJSONArray(data: unknown, handler?: EventHandlerCallable): EventHandler[];
-    get eventbus_label(): string;
-}
-export declare class TimeoutError extends Error {
-    constructor(message: string);
-}
-export declare class EventHandlerError extends Error {
-    event_result: EventResult;
-    timeout_seconds: number | null;
-    cause: Error;
-    constructor(message: string, params: {
-        event_result: EventResult;
-        timeout_seconds?: number | null;
-        cause: Error;
-    });
-    get event(): BaseEvent;
-    get event_type(): string;
-    get handler_name(): string;
-    get handler_id(): string;
-    get event_timeout(): number | null;
-}
-export declare class EventHandlerTimeoutError extends EventHandlerError {
-    constructor(message: string, params: {
-        event_result: EventResult;
-        timeout_seconds?: number | null;
-        cause?: Error;
-    });
-}
-export declare class EventHandlerCancelledError extends EventHandlerError {
-    constructor(message: string, params: {
-        event_result: EventResult;
-        timeout_seconds?: number | null;
-        cause: Error;
-    });
-}
-export declare class EventHandlerAbortedError extends EventHandlerError {
-    constructor(message: string, params: {
-        event_result: EventResult;
-        timeout_seconds?: number | null;
-        cause: Error;
-    });
-}
-export declare class EventHandlerResultSchemaError extends EventHandlerError {
-    raw_value: unknown;
-    constructor(message: string, params: {
-        event_result: EventResult;
-        timeout_seconds?: number | null;
-        cause: Error;
-        raw_value: unknown;
-    });
-    get expected_schema(): any;
-}

package/dist/types/event_history.d.ts

@@ -1,45 +0,0 @@
-import { BaseEvent } from './base_event.js';
-import type { EventPattern, FindWindow } from './types.js';
-export type EventHistoryFindOptions = {
-    past?: FindWindow;
-    future?: FindWindow;
-    child_of?: BaseEvent | null;
-    event_is_child_of?: (event: BaseEvent, ancestor: BaseEvent) => boolean;
-    wait_for_future_match?: (event_pattern: string | '*', matches: (event: BaseEvent) => boolean, future: FindWindow) => Promise<BaseEvent | null>;
-} & Record<string, unknown>;
-export type EventHistoryTrimOptions<TEvent extends BaseEvent = BaseEvent> = {
-    is_event_complete?: (event: TEvent) => boolean;
-    on_remove?: (event: TEvent) => void;
-    owner_label?: string;
-    max_history_size?: number | null;
-    max_history_drop?: boolean;
-};
-export declare class EventHistory<TEvent extends BaseEvent = BaseEvent> implements Iterable<[string, TEvent]> {
-    max_history_size: number | null;
-    max_history_drop: boolean;
-    private _events;
-    private _warned_about_dropping_uncompleted_events;
-    constructor(options?: {
-        max_history_size?: number | null;
-        max_history_drop?: boolean;
-    });
-    get size(): number;
-    [Symbol.iterator](): Iterator<[string, TEvent]>;
-    entries(): IterableIterator<[string, TEvent]>;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<TEvent>;
-    clear(): void;
-    get(event_id: string): TEvent | undefined;
-    set(event_id: string, event: TEvent): this;
-    has(event_id: string): boolean;
-    delete(event_id: string): boolean;
-    addEvent(event: TEvent): void;
-    getEvent(event_id: string): TEvent | undefined;
-    removeEvent(event_id: string): boolean;
-    hasEvent(event_id: string): boolean;
-    static normalizeEventPattern(event_pattern: EventPattern | '*'): string | '*';
-    find(event_pattern: '*', where?: (event: TEvent) => boolean, options?: EventHistoryFindOptions): Promise<TEvent | null>;
-    find<TMatch extends TEvent>(event_pattern: EventPattern<TMatch>, where?: (event: TMatch) => boolean, options?: EventHistoryFindOptions): Promise<TMatch | null>;
-    trimEventHistory(options?: EventHistoryTrimOptions<TEvent>): number;
-    private eventIsChildOf;
-}

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