abxbus 2.5.6 → 2.5.9

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/events_suck.d.ts

@@ -1,26 +1,19 @@
 import { EventBus } from './EventBus.js';
 import { BaseEvent } from './BaseEvent.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 EventMap = Record<string, EventClass<BaseEvent, never>>;
+type FunctionMap = Record<string, (...args: never[]) => unknown>;
 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;
+type EventFieldsFromFn<TFunc extends FunctionMap[string]> = Parameters<TFunc> extends [infer TArg, ...unknown[]] ? (TArg extends Record<string, unknown> ? TArg : ExtraDict) : ExtraDict;
+type EventFromFn<TFunc extends FunctionMap[string]> = BaseEvent & EventFieldsFromFn<TFunc> & {
+    __event_result_type__?: Awaited<ReturnType<TFunc>>;
 };
 export type GeneratedEvents<TEvents extends FunctionMap> = {
     by_name: {
-        [K in keyof TEvents]: GeneratedEvent<TEvents[K]>;
+        [K in keyof TEvents]: EventClass<EventFromFn<TEvents[K]>, EventFieldsFromFn<TEvents[K]> & ExtraDict>;
     };
 } & {
-    [K in keyof TEvents]: GeneratedEvent<TEvents[K]>;
+    [K in keyof TEvents]: EventClass<EventFromFn<TEvents[K]>, EventFieldsFromFn<TEvents[K]> & ExtraDict>;
 };
 type EventInit<TEventClass extends EventClass<BaseEvent>> = [ConstructorParameters<TEventClass>[0]] extends [undefined] ? {} : NonNullable<ConstructorParameters<TEventClass>[0]>;
 type EventMethodArgs<TEventClass extends EventClass<BaseEvent>> = {} extends EventInit<TEventClass> ? [init?: EventInit<TEventClass>, extra?: Record<string, unknown>] : [init: EventInit<TEventClass>, extra?: Record<string, unknown>];

package/dist/types/retry.d.ts

@@ -19,6 +19,8 @@ export interface RetryOptions {
     retry_on_errors?: Array<(new (...args: any[]) => Error) | string | RegExp>;
     /** Per-attempt timeout in seconds. Default: undefined (no per-attempt timeout) */
     timeout?: number | null;
+    /** Emit a warning when a decorated call exceeds this many seconds. Default: undefined (disabled) */
+    slow_timeout?: number | null;
     /** Maximum concurrent executions sharing this semaphore. Default: undefined (no concurrency limit) */
     semaphore_limit?: number | null;
     /** Semaphore identifier. Functions with the same name share the same concurrency slot pool. Default: function name.

package/dist/types/types.d.ts

@@ -1,11 +1,9 @@
 import { z } from 'zod';
-import type { BaseEvent } from './BaseEvent.js';
+import type { BaseEvent, EventClass as BaseEventClass } from './BaseEvent.js';
 import { type JsonSchema } from './jsonschema.js';
 export type EventStatus = 'pending' | 'started' | 'completed';
-export type EventClass<T extends BaseEvent = BaseEvent> = {
-    event_type?: string;
-} & (new (...args: any[]) => T);
-export type EventPattern<T extends BaseEvent = BaseEvent> = string | EventClass<T>;
+export type { EventClass } from './BaseEvent.js';
+export type EventPattern<T extends BaseEvent = BaseEvent> = string | BaseEventClass<T>;
 export type EventWithResultSchema<TResult> = BaseEvent & {
     __event_result_type__?: TResult;
 };
@@ -35,4 +33,3 @@ 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 function normalizeEventResultType(value: unknown): z.ZodTypeAny | undefined;
-export {};

package/package.json

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

package/src/BaseEvent.ts

@@ -151,8 +151,7 @@ type EventPayloadShape<TShape extends z.ZodRawShape> = {
 }
 type EventPayload<TShape extends z.ZodRawShape> =
   EventPayloadShape<TShape> extends Record<string, never> ? {} : z.infer<z.ZodObject<EventPayloadShape<TShape>>>
-type EventFactoryMetadataFieldName =
-  | 'class'
+type EventClassMetadataFieldName =
   | 'fromJSON'
   | 'prototype'
   | 'event_schema'
@@ -165,7 +164,7 @@ type EventModelFields<TShape extends z.ZodRawShape> = {
   readonly [K in keyof TShape]: TShape[K]
 }
 type StaticEventDefaultValues<TShape extends z.ZodRawShape> = {
-  readonly [K in keyof TShape as K extends EventFactoryMetadataFieldName
+  readonly [K in keyof TShape as K extends EventClassMetadataFieldName
     ? never
     : TShape[K] extends StaticDefaultSchema
       ? K
@@ -243,7 +242,7 @@ type ShortcutZodModelFields<TShape> = {
   [K in keyof ShortcutModelFields<TShape>]: ShortcutModelFields<TShape>[K] extends z.ZodTypeAny ? ShortcutModelFields<TShape>[K] : never
 }
 type ShortcutStaticDefaultValues<TShape, TModelFields extends z.ZodRawShape> = StaticEventDefaultValues<TModelFields> & {
-  readonly [K in keyof TShape as K extends EventFactoryMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K]
+  readonly [K in keyof TShape as K extends EventClassMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K]
 }
 export type EventResultInclude<TEvent extends BaseEvent> = (
   result: EventResult<TEvent>['result'],
@@ -271,45 +270,22 @@ type EventResultUpdateOptions<TEvent extends BaseEvent> = {
 
 const ROOT_EVENTBUS_ID = '00000000-0000-0000-0000-000000000000'
 
-export type EventFactoryClass<TShape extends z.ZodRawShape, TResult = unknown> = (new (
-  ...args: OptionalFactoryArgs<EventInit<TShape>>
-) => EventWithResultSchema<TResult> & EventPayload<TShape>) &
-  StaticEventDefaultValues<TShape> & {
-    event_schema: EventSchema<TShape>
-    model_fields: EventModelFields<TShape>
-  }
-
-export type EventFactory<
-  TShape extends z.ZodRawShape,
-  TResult = unknown,
-  TStaticFields = StaticEventDefaultValues<TShape>,
+export type EventClass<
+  TEvent extends BaseEvent = BaseEvent,
+  TInit = never,
+  TSchema extends z.ZodTypeAny = AnyEventSchema,
+  TModelFields extends z.ZodRawShape = z.ZodRawShape,
+  TResultSchema extends z.ZodTypeAny | undefined = z.ZodTypeAny | undefined,
+  TStaticFields = {},
 > = TStaticFields & {
-  (...args: OptionalFactoryArgs<EventInit<TShape>>): EventWithResultSchema<TResult> & EventPayload<TShape>
-  new (...args: OptionalFactoryArgs<EventInit<TShape>>): EventWithResultSchema<TResult> & EventPayload<TShape>
-  event_schema: EventSchema<TShape>
-  model_fields: EventModelFields<TShape>
-  class: EventFactoryClass<TShape, TResult>
-  event_type: string
-  event_version: string
-  event_result_type: ResultTypeSchemaFromShape<TShape>
-  fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayload<TShape>
-}
-
-export type SchemaEventFactoryClass<TSchema extends AnyEventSchema, TResult = unknown> = (new (
-  ...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>
-) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>) &
-  StaticEventDefaultValuesFromSchema<TSchema> & { event_schema: TSchema; model_fields: EventModelFieldsFromSchema<TSchema> }
-
-export type SchemaEventFactory<TSchema extends AnyEventSchema, TResult = unknown> = StaticEventDefaultValuesFromSchema<TSchema> & {
-  (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
-  new (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
+  (...args: OptionalFactoryArgs<TInit>): TEvent
+  new (...args: OptionalFactoryArgs<TInit>): TEvent
   event_schema: TSchema
-  model_fields: EventModelFieldsFromSchema<TSchema>
-  class: SchemaEventFactoryClass<TSchema, TResult>
+  model_fields: TModelFields
   event_type: string
   event_version: string
-  event_result_type: ResultTypeSchemaFromEventSchema<TSchema>
-  fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
+  event_result_type: TResultSchema
+  fromJSON: (data: unknown) => TEvent
 }
 
 type ZodShapeFrom<TShape extends Record<string, unknown>> = {
@@ -680,20 +656,56 @@ export class BaseEvent {
   static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(
     event_type: string,
     event_schema: TSchema
-  ): SchemaEventFactory<TSchema, ResultSchemaFromEventSchema<TSchema>>
+  ): EventClass<
+    EventWithResultSchema<ResultSchemaFromEventSchema<TSchema>> & EventPayloadFromSchema<TSchema>,
+    EventInitFromSchema<TSchema>,
+    TSchema,
+    EventModelFieldsFromSchema<TSchema>,
+    ResultTypeSchemaFromEventSchema<TSchema>,
+    StaticEventDefaultValuesFromSchema<TSchema>
+  >
   static extend<const TShape extends Record<string, unknown>>(
     event_type: string,
     shape?: TShape
-  ): EventFactory<
-    ShortcutZodModelFields<TShape>,
-    ResultSchemaFromShape<ShortcutZodModelFields<TShape>>,
+  ): EventClass<
+    EventWithResultSchema<ResultSchemaFromShape<ShortcutZodModelFields<TShape>>> & EventPayload<ShortcutZodModelFields<TShape>>,
+    EventInit<ShortcutZodModelFields<TShape>>,
+    EventSchema<ShortcutZodModelFields<TShape>>,
+    EventModelFields<ShortcutZodModelFields<TShape>>,
+    ResultTypeSchemaFromShape<ShortcutZodModelFields<TShape>>,
     ShortcutStaticDefaultValues<TShape, ShortcutZodModelFields<TShape>>
   >
-  static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventFactory<TShape, ResultSchemaFromShape<TShape>>
+  static extend<TShape extends z.ZodRawShape>(
+    event_type: string,
+    shape?: TShape
+  ): EventClass<
+    EventWithResultSchema<ResultSchemaFromShape<TShape>> & EventPayload<TShape>,
+    EventInit<TShape>,
+    EventSchema<TShape>,
+    EventModelFields<TShape>,
+    ResultTypeSchemaFromShape<TShape>,
+    StaticEventDefaultValues<TShape>
+  >
   static extend<const TShape extends Record<string, unknown>>(
     event_type: string,
     shape?: TShape
-  ): EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>> | SchemaEventFactory<AnyEventSchema, unknown> {
+  ):
+    | EventClass<
+        EventWithResultSchema<ResultSchemaFromShape<ZodShapeFrom<TShape>>> & EventPayload<ZodShapeFrom<TShape>>,
+        EventInit<ZodShapeFrom<TShape>>,
+        EventSchema<ZodShapeFrom<TShape>>,
+        EventModelFields<ZodShapeFrom<TShape>>,
+        ResultTypeSchemaFromShape<ZodShapeFrom<TShape>>,
+        StaticEventDefaultValues<ZodShapeFrom<TShape>>
+      >
+    | EventClass<
+        EventWithResultSchema<ResultSchemaFromEventSchema<AnyEventSchema>> & EventPayloadFromSchema<AnyEventSchema>,
+        EventInitFromSchema<AnyEventSchema>,
+        AnyEventSchema,
+        EventModelFieldsFromSchema<AnyEventSchema>,
+        ResultTypeSchemaFromEventSchema<AnyEventSchema>,
+        StaticEventDefaultValuesFromSchema<AnyEventSchema>
+      > {
     const built = buildFullEventSchema(event_type, shape ?? {})
     const full_schema = built.event_schema
     const event_parse_schema = built.event_parse_schema
@@ -701,41 +713,47 @@ export class BaseEvent {
     const event_result_type = built.event_result_type
     const event_version = built.event_version
 
-    // create a new event class that extends BaseEvent and adds the custom fields
-    class ExtendedEvent extends BaseEvent {
-      static event_schema = full_schema
-      static model_fields = full_schema.shape
-      static _event_parse_schema = event_parse_schema
-      static event_type = event_type
-      static event_version = event_version ?? BaseEvent.event_version
-      static event_result_type = event_result_type
-
-      constructor(data?: EventInit<ZodShapeFrom<TShape>> | EventInitFromSchema<AnyEventSchema>) {
-        super(data as BaseEventInit<Record<string, unknown>>)
+    const EventClass = class extends BaseEvent {
+      static override event_schema = full_schema as EventSchema<ZodShapeFrom<TShape>>
+      static override model_fields = full_schema.shape as EventModelFields<ZodShapeFrom<TShape>>
+      static override _event_parse_schema = event_parse_schema
+      static override event_type = event_type
+      static override event_version = event_version ?? BaseEvent.event_version
+      static override event_result_type = event_result_type
+
+      constructor(data?: EventInit<ZodShapeFrom<TShape>>) {
+        super(data)
       }
     }
 
-    type FactoryResult = EventWithResultSchema<ResultSchemaFromShape<TShape>> & EventPayload<ZodShapeFrom<TShape>>
-
-    function EventFactory(data?: EventInit<ZodShapeFrom<TShape>>): FactoryResult {
-      return new ExtendedEvent(data) as FactoryResult
-    }
+    Object.defineProperty(EventClass, 'name', { value: event_type, configurable: true })
+    defineStaticEventFields(EventClass, static_field_defaults)
 
-    EventFactory.event_schema = full_schema as EventSchema<ZodShapeFrom<TShape>>
-    EventFactory.model_fields = EventFactory.event_schema.shape as EventModelFields<ZodShapeFrom<TShape>>
-    EventFactory.event_type = event_type
-    EventFactory.event_version = event_version ?? BaseEvent.event_version
-    EventFactory.event_result_type = event_result_type
-    EventFactory.class = ExtendedEvent as unknown as new (
-      data: EventInit<ZodShapeFrom<TShape>>
-    ) => EventWithResultSchema<ResultSchemaFromShape<TShape>> & EventPayload<ZodShapeFrom<TShape>>
-    EventFactory.fromJSON = (data: unknown) => ExtendedEvent.fromJSON(data) as FactoryResult
-    EventFactory.prototype = ExtendedEvent.prototype
-    defineStaticEventFields(ExtendedEvent, static_field_defaults)
-    defineStaticEventFields(EventFactory, static_field_defaults)
-    EVENT_TYPE_REGISTRY.set(event_type, ExtendedEvent)
+    let CallableEventClass: typeof EventClass
+    CallableEventClass = new Proxy(EventClass, {
+      apply(target, _this_arg, args) {
+        return Reflect.construct(target, args, target)
+      },
+      construct(target, args, new_target) {
+        return Reflect.construct(target, args, new_target === CallableEventClass ? target : new_target)
+      },
+    })
 
-    return EventFactory as unknown as EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>>
+    Object.defineProperty(EventClass.prototype, 'constructor', {
+      value: CallableEventClass,
+      writable: true,
+      configurable: true,
+    })
+    EVENT_TYPE_REGISTRY.set(event_type, CallableEventClass as unknown as typeof BaseEvent)
+
+    return CallableEventClass as unknown as EventClass<
+      EventWithResultSchema<ResultSchemaFromShape<ZodShapeFrom<TShape>>> & EventPayload<ZodShapeFrom<TShape>>,
+      EventInit<ZodShapeFrom<TShape>>,
+      EventSchema<ZodShapeFrom<TShape>>,
+      EventModelFields<ZodShapeFrom<TShape>>,
+      ResultTypeSchemaFromShape<ZodShapeFrom<TShape>>,
+      StaticEventDefaultValues<ZodShapeFrom<TShape>>
+    >
   }
 
   static fromJSON<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T> {