bubus 1.8.1 → 2.2.1

package/dist/types/event_handler.d.ts

@@ -1,63 +1,92 @@
 import { z } from 'zod';
-import type { EventHandlerFunction, EventKey } from './types.js';
+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_key: EventKey;
+    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_key: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"*">]>;
+    event_pattern: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"*">]>;
     handler_name: z.ZodString;
-    handler_file_path: z.ZodOptional<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;
-    handler_registered_ts: z.ZodNumber;
 }, z.core.$strict>;
 export type EventHandlerJSON = z.infer<typeof EventHandlerJSONSchema>;
 export declare class EventHandler {
     id: string;
-    handler: EventHandlerFunction;
+    handler: EventHandlerCallable;
     handler_name: string;
-    handler_file_path?: string;
+    handler_file_path: string | null;
     handler_timeout?: number | null;
     handler_slow_timeout?: number | null;
     handler_registered_at: string;
-    handler_registered_ts: number;
-    event_key: string | '*';
+    event_pattern: string | '*';
     eventbus_name: string;
     eventbus_id: string;
     constructor(params: {
         id?: string;
-        handler: EventHandlerFunction;
+        handler: EventHandlerCallable;
         handler_name: string;
-        handler_file_path?: string;
+        handler_file_path?: string | null;
         handler_timeout?: number | null;
         handler_slow_timeout?: number | null;
         handler_registered_at: string;
-        handler_registered_ts: number;
-        event_key: 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;
+        handler_file_path?: string | null;
         handler_registered_at: string;
-        handler_registered_ts: number;
-        event_key: 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;
+    _detectHandlerFilePath(): void;
     toJSON(): EventHandlerJSON;
-    static fromJSON(data: unknown, handler?: EventHandlerFunction): EventHandler;
+    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);

package/dist/types/event_history.d.ts

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

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { BaseEvent } from './base_event.js';
 import type { EventBus } from './event_bus.js';
 import { EventHandler } from './event_handler.js';
-import { HandlerLock } from './lock_manager.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';
@@ -15,25 +15,20 @@ export declare const EventResultJSONSchema: z.ZodObject<{
         error: "error";
     }>;
     event_id: z.ZodString;
-    handler: z.ZodObject<{
-        id: z.ZodString;
-        eventbus_name: z.ZodString;
-        eventbus_id: z.ZodString;
-        event_key: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"*">]>;
-        handler_name: z.ZodString;
-        handler_file_path: z.ZodOptional<z.ZodString>;
-        handler_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        handler_slow_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        handler_registered_at: z.ZodString;
-        handler_registered_ts: z.ZodNumber;
-    }, z.core.$strict>;
-    started_at: z.ZodOptional<z.ZodString>;
-    started_ts: z.ZodOptional<z.ZodNumber>;
-    completed_at: z.ZodOptional<z.ZodString>;
-    completed_ts: z.ZodOptional<z.ZodNumber>;
+    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.ZodOptional<z.ZodArray<z.ZodString>>;
+    event_children: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 export type EventResultJSON = z.infer<typeof EventResultJSONSchema>;
 export declare class EventResult<TEvent extends BaseEvent = BaseEvent> {
@@ -41,13 +36,11 @@ export declare class EventResult<TEvent extends BaseEvent = BaseEvent> {
     status: EventResultStatus;
     event: TEvent;
     handler: EventHandler;
-    started_at?: string;
-    started_ts?: number;
-    completed_at?: string;
-    completed_ts?: number;
+    started_at: string | null;
+    completed_at: string | null;
     result?: EventResultType<TEvent>;
     error?: unknown;
-    event_children: BaseEvent[] | undefined;
+    event_children: BaseEvent[];
     _abort: Deferred<never> | null;
     _lock: HandlerLock | null;
     _queue_jump_pause_releases: Map<EventBus, () => void> | null;
@@ -60,23 +53,34 @@ export declare class EventResult<TEvent extends BaseEvent = BaseEvent> {
     get bus(): EventBus;
     get handler_id(): string;
     get handler_name(): string;
-    get handler_file_path(): string | undefined;
+    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;
-    linkEmittedChildEvent(child_event: BaseEvent): void;
+    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;
-    runHandler(): Promise<void>;
-    signalAbort(error: Error): void;
-    markStarted(): Promise<never>;
-    markCompleted(result: EventResultType<TEvent> | undefined): void;
-    markError(error: unknown): void;
+    _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/events_suck.d.ts

@@ -0,0 +1,40 @@
+import { EventBus } from './event_bus.js';
+import { BaseEvent } from './base_event.js';
+import type { EventClass, EventResultType } from './types.js';
+type EventMap = Record<string, EventClass<BaseEvent>>;
+type AnyFn = (...args: any[]) => any;
+type FunctionMap = Record<string, AnyFn>;
+type ExtraDict = Record<string, unknown>;
+type EventFieldsFromFn<TFunc extends AnyFn> = Parameters<TFunc> extends [infer TArg] ? (TArg extends Record<string, unknown> ? TArg : ExtraDict) : ExtraDict;
+type GeneratedEvent<TFunc extends AnyFn> = {
+    (data: EventFieldsFromFn<TFunc> & ExtraDict): BaseEvent & EventFieldsFromFn<TFunc> & {
+        __event_result_type__?: Awaited<ReturnType<TFunc>>;
+    };
+    new (data: EventFieldsFromFn<TFunc> & ExtraDict): BaseEvent & EventFieldsFromFn<TFunc> & {
+        __event_result_type__?: Awaited<ReturnType<TFunc>>;
+    };
+    event_type?: string;
+};
+export type GeneratedEvents<TEvents extends FunctionMap> = {
+    by_name: {
+        [K in keyof TEvents]: GeneratedEvent<TEvents[K]>;
+    };
+} & {
+    [K in keyof TEvents]: GeneratedEvent<TEvents[K]>;
+};
+type EventInit<TEventClass extends EventClass<BaseEvent>> = ConstructorParameters<TEventClass> extends [infer TInit, ...unknown[]] ? TInit : never;
+type EventMethodArgs<TEventClass extends EventClass<BaseEvent>> = {} extends EventInit<TEventClass> ? [init?: EventInit<TEventClass>, extra?: Record<string, unknown>] : [init: EventInit<TEventClass>, extra?: Record<string, unknown>];
+type EventMethodResult<TEventClass extends EventClass<BaseEvent>> = EventResultType<InstanceType<TEventClass>> | undefined;
+export type EventsSuckClient<TEvents extends EventMap> = {
+    bus: EventBus;
+} & {
+    [K in keyof TEvents]: (...args: EventMethodArgs<TEvents[K]>) => Promise<EventMethodResult<TEvents[K]>>;
+};
+export type EventsSuckClientClass<TEvents extends EventMap> = new (bus?: EventBus) => EventsSuckClient<TEvents>;
+export declare const make_events: <TEvents extends FunctionMap>(events: TEvents) => GeneratedEvents<TEvents>;
+export declare const wrap: <TEvents extends EventMap>(class_name: string, methods: TEvents) => EventsSuckClientClass<TEvents>;
+export declare const events_suck: {
+    readonly make_events: <TEvents extends FunctionMap>(events: TEvents) => GeneratedEvents<TEvents>;
+    readonly wrap: <TEvents extends EventMap>(class_name: string, methods: TEvents) => EventsSuckClientClass<TEvents>;
+};
+export {};

package/dist/types/helpers.d.ts

@@ -0,0 +1 @@
+export declare function monotonicDatetime(isostring?: string): string;

package/dist/types/index.d.ts

@@ -1,8 +1,17 @@
 export { BaseEvent, BaseEventSchema } from './base_event.js';
+export { EventHistory } from './event_history.js';
+export type { EventHistoryFindOptions, EventHistoryTrimOptions } from './event_history.js';
 export { EventResult } from './event_result.js';
 export { EventBus } from './event_bus.js';
+export type { EventBusJSON, EventBusOptions } from './event_bus.js';
+export { monotonicDatetime } from './helpers.js';
+export type { EventBusMiddleware, EventBusMiddlewareCtor, EventBusMiddlewareInput } from './middlewares.js';
 export { EventHandlerTimeoutError, EventHandlerCancelledError, EventHandlerAbortedError, EventHandlerResultSchemaError, } from './event_handler.js';
 export type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, EventBusInterfaceForLockManager, } from './lock_manager.js';
-export type { EventClass, EventHandlerFunction as EventHandler, EventKey, EventStatus, FindOptions, FindWindow } from './types.js';
+export type { EventClass, EventHandlerCallable as EventHandler, EventPattern, EventStatus, FindOptions, FindWindow } from './types.js';
 export { retry, clearSemaphoreRegistry, RetryTimeoutError, SemaphoreTimeoutError } from './retry.js';
 export type { RetryOptions } from './retry.js';
+export { HTTPEventBridge, SocketEventBridge, NATSEventBridge, RedisEventBridge, PostgresEventBridge, JSONLEventBridge, SQLiteEventBridge, } from './bridges.js';
+export type { HTTPEventBridgeOptions } from './bridges.js';
+export { events_suck } from './events_suck.js';
+export type { EventsSuckClient, EventsSuckClientClass, GeneratedEvents } from './events_suck.js';

package/dist/types/lock_manager.d.ts

@@ -12,7 +12,7 @@ export declare const EVENT_HANDLER_CONCURRENCY_MODES: readonly ["serial", "paral
 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 AsyncSemaphore {
+export declare class AsyncLock {
     size: number;
     in_use: number;
     waiters: Array<() => void>;
@@ -20,12 +20,12 @@ export declare class AsyncSemaphore {
     acquire(): Promise<void>;
     release(): void;
 }
-export declare const runWithSemaphore: <T>(semaphore: AsyncSemaphore | null, fn: () => Promise<T>) => Promise<T>;
+export declare const runWithLock: <T>(lock: AsyncLock | null, fn: () => Promise<T>) => Promise<T>;
 export type HandlerExecutionState = 'held' | 'yielded' | 'closed';
 export declare class HandlerLock {
-    private semaphore;
+    private lock;
     private state;
-    constructor(semaphore: AsyncSemaphore | null);
+    constructor(lock: AsyncLock | null);
     yieldHandlerLockForChildRun(): boolean;
     reclaimHandlerLockIfRunning(): Promise<boolean>;
     exitHandlerRun(): void;
@@ -33,29 +33,38 @@ export declare class HandlerLock {
 }
 export type EventBusInterfaceForLockManager = {
     isIdleAndQueueEmpty: () => boolean;
-    event_concurrency_default: EventConcurrencyMode;
+    event_concurrency: EventConcurrencyMode;
+    _lock_for_event_global_serial: AsyncLock;
+};
+export type LockManagerOptions = {
+    auto_schedule_idle_checks?: boolean;
 };
 export declare class LockManager {
     private bus;
-    static global_event_semaphore: AsyncSemaphore;
-    readonly bus_event_semaphore: AsyncSemaphore;
+    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);
-    requestRunloopPause(): () => void;
-    waitUntilRunloopResumed(): Promise<void>;
-    isPaused(): boolean;
-    enterActiveHandlerContext(result: EventResult): void;
-    exitActiveHandlerContext(result: EventResult): void;
-    getActiveHandlerResult(): EventResult | undefined;
-    isAnyHandlerActive(): boolean;
-    waitForIdle(): Promise<void>;
-    notifyIdleListeners(): void;
-    getSemaphoreForEvent(event: BaseEvent): AsyncSemaphore | null;
+    constructor(bus: EventBusInterfaceForLockManager, options?: LockManagerOptions);
+    _requestRunloopPause(): () => void;
+    _waitUntilRunloopResumed(): Promise<void>;
+    _isPaused(): boolean;
+    _runWithHandlerDispatchContext<T>(result: EventResult, fn: () => Promise<T>): Promise<T>;
+    _getActiveHandlerResult(): 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/logging.d.ts

@@ -2,7 +2,10 @@ import { BaseEvent } from './base_event.js';
 import { EventResult } from './event_result.js';
 type LogTreeBus = {
     name: string;
-    event_history: Map<string, BaseEvent>;
+    event_history: {
+        values(): IterableIterator<BaseEvent>;
+        has(event_id: string): boolean;
+    };
     toString?: () => string;
 };
 export declare const logTree: (bus: LogTreeBus) => string;

package/dist/types/middlewares.d.ts

@@ -0,0 +1,13 @@
+import type { BaseEvent } from './base_event.js';
+import type { EventBus } from './event_bus.js';
+import type { EventHandler } from './event_handler.js';
+import type { EventResult } from './event_result.js';
+import type { EventStatus } from './types.js';
+export type { EventStatus } from './types.js';
+export interface EventBusMiddleware {
+    onEventChange?(eventbus: EventBus, event: BaseEvent, status: EventStatus): void | Promise<void>;
+    onEventResultChange?(eventbus: EventBus, event: BaseEvent, event_result: EventResult, status: EventStatus): void | Promise<void>;
+    onBusHandlersChange?(eventbus: EventBus, handler: EventHandler, registered: boolean): void | Promise<void>;
+}
+export type EventBusMiddlewareCtor = new () => EventBusMiddleware;
+export type EventBusMiddlewareInput = EventBusMiddleware | EventBusMiddlewareCtor;

package/dist/types/optional_deps.d.ts

@@ -0,0 +1,3 @@
+export declare const isNodeRuntime: () => boolean;
+export declare const assertOptionalDependencyAvailable: (bridge_name: string, package_name: string) => void;
+export declare const importOptionalDependency: (bridge_name: string, package_name: string) => Promise<any>;

package/dist/types/timing.d.ts

@@ -0,0 +1,3 @@
+export declare function _runWithTimeout<T>(timeout_seconds: number | null, on_timeout: () => Error, fn: () => Promise<T>): Promise<T>;
+export declare function _runWithSlowMonitor<T>(slow_timer: ReturnType<typeof setTimeout> | null, fn: () => Promise<T>): Promise<T>;
+export declare function _runWithAbortMonitor<T>(fn: () => T | Promise<T>, abort_signal: Promise<never>): Promise<T>;

package/dist/types/types.d.ts

@@ -4,22 +4,33 @@ export type EventStatus = 'pending' | 'started' | 'completed';
 export type EventClass<T extends BaseEvent = BaseEvent> = {
     event_type?: string;
 } & (new (...args: any[]) => T);
-export type EventKey<T extends BaseEvent = BaseEvent> = string | EventClass<T>;
-export type EventWithResult<TResult> = BaseEvent & {
+export type EventPattern<T extends BaseEvent = BaseEvent> = string | EventClass<T>;
+export type EventWithResultSchema<TResult> = BaseEvent & {
     __event_result_type__?: TResult;
 };
 export type EventResultType<TEvent extends BaseEvent> = TEvent extends {
     __event_result_type__?: infer TResult;
 } ? TResult : unknown;
-export type EventHandlerFunction<T extends BaseEvent = BaseEvent> = (event: T) => void | EventResultType<T> | Promise<void | EventResultType<T>>;
-export type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (event: T) => void | unknown | Promise<void | unknown>;
+export type EventResultTypeConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
+export type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | unknown;
+export type EventHandlerReturn<T extends BaseEvent = BaseEvent> = EventResultType<T> | BaseEvent | null | void;
+export type EventHandlerCallable<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | Promise<EventHandlerReturn<T>>;
+export type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | unknown | Promise<EventHandlerReturn<T> | unknown>;
 export type FindWindow = boolean | number;
-export type FindOptions = {
+type FindReservedOptionKeys = 'past' | 'future' | 'child_of';
+type EventFilterFields<T extends BaseEvent> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K extends FindReservedOptionKeys ? never : T[K] extends (...args: any[]) => any ? never : K]?: T[K];
+};
+export type FindOptions<T extends BaseEvent = BaseEvent> = {
     past?: FindWindow;
     future?: FindWindow;
     child_of?: BaseEvent | null;
-};
+} & EventFilterFields<T> & Record<string, unknown>;
+export declare const normalizeEventPattern: (event_pattern: EventPattern | "*") => string | "*";
 export declare const isZodSchema: (value: unknown) => value is z.ZodTypeAny;
+export declare const eventResultTypeFromConstructor: (value: unknown) => z.ZodTypeAny | undefined;
 export declare const extractZodShape: (raw: Record<string, unknown>) => z.ZodRawShape;
 export declare const toJsonSchema: (schema: unknown) => unknown;
-export declare const getStringTypeName: (schema?: z.ZodTypeAny) => string | undefined;
+export declare const fromJsonSchema: (schema: unknown) => z.ZodTypeAny;
+export declare const normalizeEventResultType: (value: EventResultTypeInput) => z.ZodTypeAny | undefined;
+export {};

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "bubus",
-  "version": "1.8.1",
+  "version": "2.2.1",
   "description": "Event bus library for browsers and ESM Node.js",
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
@@ -11,6 +12,11 @@
       "types": "./dist/types/index.d.ts",
       "import": "./dist/esm/index.js",
       "default": "./dist/esm/index.js"
+    },
+    "./*": {
+      "types": "./dist/types/*.d.ts",
+      "import": "./dist/esm/*.js",
+      "default": "./dist/esm/*.js"
     }
   },
   "files": [
@@ -25,12 +31,14 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^8.46.0",
-    "@typescript-eslint/parser": "^8.46.0",
-    "esbuild": "^0.27.2",
+    "@types/node": "^25.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
+    "@typescript-eslint/parser": "^8.55.0",
+    "esbuild": "^0.27.3",
     "eslint": "^9.39.2",
     "prettier": "^3.8.1",
-    "tsx": "^4.20.6",
+    "tsc-files": "^1.1.4",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
   "repository": {
@@ -46,22 +54,28 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "optionalDependencies": {
+    "ioredis": "^5.9.3",
+    "nats": "^2.29.3",
+    "pg": "^8.18.0"
+  },
   "scripts": {
     "build": "pnpm run build:esm && pnpm run build:types",
-    "build:esm": "esbuild src/index.ts --bundle --format=esm --platform=neutral --target=es2022 --sourcemap --outdir=dist/esm",
+    "build:esm": "node ./scripts/build_esm.mjs",
     "build:types": "tsc -p tsconfig.json --emitDeclarationOnly",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "lint": "pnpm run prettier && eslint . && pnpm run typecheck",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
     "prettier": "prettier --write .",
-    "test": "NODE_OPTIONS='--expose-gc' node --expose-gc --test --import tsx tests/**/*.test.ts",
+    "eslint": "eslint .",
+    "lint": "pnpm run prettier && pnpm run eslint && pnpm run typecheck",
+    "test": "NODE_OPTIONS='--expose-gc' node --expose-gc --test --import tsx \"tests/**/*.test.ts\"",
     "perf": "pnpm run perf:node && pnpm run perf:bun && pnpm run perf:deno && pnpm run perf:browser",
     "debug:node": "NODE_OPTIONS='--expose-gc' node --expose-gc --import tsx",
     "debug:bun": "bun --expose-gc run",
-    "debug:deno": "deno run --v8-flags=--expose-gc",
+    "debug:deno": "deno run --sloppy-imports --v8-flags=--expose-gc",
     "perf:node": "pnpm run build && pnpm run debug:node -- tests/performance.runtime.ts --scenario 50k-events && pnpm run debug:node -- tests/performance.runtime.ts --scenario 500-buses-x-100-events && pnpm run debug:node -- tests/performance.runtime.ts --scenario 1-event-x-50k-parallel-handlers && pnpm run debug:node -- tests/performance.runtime.ts --scenario 50k-one-off-handlers && pnpm run debug:node -- tests/performance.runtime.ts --scenario worst-case-forwarding-timeouts && pnpm run debug:node -- tests/performance.runtime.ts --scenario cleanup-equivalence",
     "perf:bun": "pnpm run build && pnpm run debug:bun -- tests/performance.runtime.ts --scenario 50k-events && pnpm run debug:bun -- tests/performance.runtime.ts --scenario 500-buses-x-100-events && pnpm run debug:bun -- tests/performance.runtime.ts --scenario 1-event-x-50k-parallel-handlers && pnpm run debug:bun -- tests/performance.runtime.ts --scenario 50k-one-off-handlers && pnpm run debug:bun -- tests/performance.runtime.ts --scenario worst-case-forwarding-timeouts && pnpm run debug:bun -- tests/performance.runtime.ts --scenario cleanup-equivalence",
     "perf:deno": "pnpm run build && pnpm run debug:deno -- tests/performance.runtime.ts --scenario 50k-events && pnpm run debug:deno -- tests/performance.runtime.ts --scenario 500-buses-x-100-events && pnpm run debug:deno -- tests/performance.runtime.ts --scenario 1-event-x-50k-parallel-handlers && pnpm run debug:deno -- tests/performance.runtime.ts --scenario 50k-one-off-handlers && pnpm run debug:deno -- tests/performance.runtime.ts --scenario worst-case-forwarding-timeouts && pnpm run debug:deno -- tests/performance.runtime.ts --scenario cleanup-equivalence",
-    "perf:browser": "pnpm run build && npx --yes --package=playwright -c 'PW_BIN=\"$(command -v playwright)\"; PW_NODE_MODULES=\"$(cd \"$(dirname \"$PW_BIN\")/..\" && pwd)\"; NODE_PATH=\"$PW_NODE_MODULES\" playwright test tests/performance.browser.spec.cjs --browser=chromium --workers=1 --reporter=line --output=/tmp/bubus-playwright-results'",
+    "perf:browser": "pnpm run build && bash ./scripts/run_browser_perf.sh",
     "release:dry-run": "pnpm publish --access public --dry-run --no-git-checks",
     "release:check": "pnpm run typecheck && pnpm test && pnpm run build"
   }