abxbus 2.4.26 → 2.4.28

package/dist/types/JSONLEventBridge.d.ts

@@ -0,0 +1,26 @@
+import { BaseEvent } from './BaseEvent.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class JSONLEventBridge {
+    readonly path: string;
+    readonly poll_interval: number;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private byte_offset;
+    private pending_line;
+    private listener_task;
+    constructor(path: string, poll_interval?: number, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private listenLoop;
+    private pollNewLines;
+    private dispatchInboundPayload;
+    private readAppended;
+    private dirname;
+    private loadFs;
+}

package/dist/types/LockManager.d.ts

@@ -0,0 +1,70 @@
+import type { BaseEvent } from './BaseEvent.js';
+import type { EventResult } from './EventResult.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;
+}

package/dist/types/NATSEventBridge.d.ts

@@ -0,0 +1,20 @@
+import { BaseEvent } from './BaseEvent.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class NATSEventBridge {
+    readonly server: string;
+    readonly subject: string;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private nc;
+    private sub_task;
+    constructor(server: string, subject: string, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private dispatchInboundPayload;
+}

package/dist/types/{middleware_otel_tracing.d.ts → OtelTracingMiddleware.d.ts}

@@ -1,8 +1,8 @@
 import { trace, type Span, type SpanAttributes, type SpanContext, type TimeInput, type Tracer } from '@opentelemetry/api';
-import type { BaseEvent } from './base_event.js';
-import type { EventBus } from './event_bus.js';
-import type { EventResult } from './event_result.js';
-import type { EventBusMiddleware } from './middlewares.js';
+import type { BaseEvent } from './BaseEvent.js';
+import type { EventBus } from './EventBus.js';
+import type { EventResult } from './EventResult.js';
+import type { EventBusMiddleware } from './EventBusMiddleware.js';
 import type { EventStatus } from './types.js';
 type OpenTelemetryTraceApi = Pick<typeof trace, 'getTracer' | 'setSpan'> & Partial<Pick<typeof trace, 'setSpanContext'>>;
 export type OtelTracingSpanFactoryInput = {

package/dist/types/PostgresEventBridge.d.ts

@@ -0,0 +1,31 @@
+/**
+ * PostgreSQL LISTEN/NOTIFY + flat-table bridge for forwarding events.
+ */
+import { BaseEvent } from './BaseEvent.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class PostgresEventBridge {
+    readonly table_url: string;
+    readonly dsn: string;
+    readonly table: string;
+    readonly channel: string;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private client;
+    private table_columns;
+    private notification_handler;
+    constructor(table_url: string, channel?: string, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private dispatchByEventId;
+    private dispatchInboundPayload;
+    private ensureTableExists;
+    private ensureBaseIndexes;
+    private refreshColumnCache;
+    private ensureColumns;
+}

package/dist/types/RedisEventBridge.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Redis pub/sub bridge for forwarding events between runtimes.
+ *
+ * Usage:
+ *   // channel from URL path
+ *   const bridge = new RedisEventBridge('redis://user:pass@localhost:6379/1/my_channel')
+ *
+ *   // explicit channel override
+ *   const bridge2 = new RedisEventBridge('redis://user:pass@localhost:6379/1', 'my_channel')
+ *
+ * URL format:
+ *   redis://user:pass@host:6379/<db>/<optional_channel>
+ */
+import { BaseEvent } from './BaseEvent.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class RedisEventBridge {
+    readonly url: string;
+    readonly channel: string;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private start_promise;
+    private redis_pub;
+    private redis_sub;
+    constructor(redis_url: string, channel?: string, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private dispatchInboundPayload;
+}

package/dist/types/SQLiteEventBridge.d.ts

@@ -0,0 +1,30 @@
+import { BaseEvent } from './BaseEvent.js';
+import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
+export declare class SQLiteEventBridge {
+    readonly path: string;
+    readonly table: string;
+    readonly poll_interval: number;
+    readonly name: string;
+    private readonly inbound_bus;
+    private running;
+    private last_seen_event_created_at;
+    private last_seen_event_id;
+    private listener_task;
+    private start_task;
+    private db;
+    private table_columns;
+    constructor(path: string, table?: string, poll_interval?: number, name?: string);
+    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
+    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
+    emit<T extends BaseEvent>(event: T): Promise<void>;
+    dispatch<T extends BaseEvent>(event: T): Promise<void>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private ensureStarted;
+    private listenLoop;
+    private dispatchInboundPayload;
+    private refreshColumnCache;
+    private ensureColumns;
+    private ensureBaseIndexes;
+    private setCursorToLatestRow;
+}

package/dist/types/SocketEventBridge.d.ts

@@ -0,0 +1,4 @@
+import { EventBridge } from './EventBridge.js';
+export declare class SocketEventBridge extends EventBridge {
+    constructor(path?: string | null, name?: 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/bridges.d.ts

@@ -1,49 +1,9 @@
-import { BaseEvent } from './base_event.js';
-import { EventBus } from './event_bus.js';
-import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
-type EndpointScheme = 'unix' | 'http' | 'https';
-type ParsedEndpoint = {
-    raw: string;
-    scheme: EndpointScheme;
-    host?: string;
-    port?: number;
-    path?: string;
-};
-export type HTTPEventBridgeOptions = {
-    send_to?: string | null;
-    listen_on?: string | null;
-    name?: string;
-};
-declare class _EventBridge {
-    readonly send_to: ParsedEndpoint | null;
-    readonly listen_on: ParsedEndpoint | null;
-    readonly name: string;
-    protected readonly inbound_bus: EventBus;
-    private start_promise;
-    private node_server;
-    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
-    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
-    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
-    emit<T extends BaseEvent>(event: T): Promise<void>;
-    dispatch<T extends BaseEvent>(event: T): Promise<void>;
-    start(): Promise<void>;
-    close(): Promise<void>;
-    private ensureListenerStarted;
-    private handleIncomingPayload;
-    private sendHttp;
-    private sendUnix;
-    private startHttpListener;
-    private startUnixListener;
-}
-export declare class HTTPEventBridge extends _EventBridge {
-    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
-    constructor(options?: HTTPEventBridgeOptions);
-}
-export declare class SocketEventBridge extends _EventBridge {
-    constructor(path?: string | null, name?: string);
-}
-export { NATSEventBridge } from './bridge_nats.js';
-export { RedisEventBridge } from './bridge_redis.js';
-export { PostgresEventBridge } from './bridge_postgres.js';
-export { JSONLEventBridge } from './bridge_jsonl.js';
-export { SQLiteEventBridge } from './bridge_sqlite.js';
+export { EventBridge } from './EventBridge.js';
+export { HTTPEventBridge } from './HTTPEventBridge.js';
+export type { HTTPEventBridgeOptions } from './HTTPEventBridge.js';
+export { SocketEventBridge } from './SocketEventBridge.js';
+export { JSONLEventBridge } from './JSONLEventBridge.js';
+export { SQLiteEventBridge } from './SQLiteEventBridge.js';
+export { NATSEventBridge } from './NATSEventBridge.js';
+export { RedisEventBridge } from './RedisEventBridge.js';
+export { PostgresEventBridge } from './PostgresEventBridge.js';

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,5 +1,5 @@
-import { EventBus } from './event_bus.js';
-import { BaseEvent } from './base_event.js';
+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;

package/dist/types/index.d.ts

@@ -1,20 +1,21 @@
-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 { BaseEvent, BaseEventSchema } from './BaseEvent.js';
+export { EventHistory } from './EventHistory.js';
+export type { EventHistoryFindOptions, EventHistoryTrimOptions } from './EventHistory.js';
+export { EventResult } from './EventResult.js';
+export { EventBus } from './EventBus.js';
+export type { EventBusJSON, EventBusOptions } from './EventBus.js';
+export { EventBridge } from './EventBridge.js';
+export { HTTPEventBridge } from './HTTPEventBridge.js';
+export type { HTTPEventBridgeOptions } from './HTTPEventBridge.js';
+export { SocketEventBridge } from './SocketEventBridge.js';
+export { JSONLEventBridge } from './JSONLEventBridge.js';
+export { SQLiteEventBridge } from './SQLiteEventBridge.js';
+export type { EventBusMiddleware, EventBusMiddlewareCtor, EventBusMiddlewareInput } from './EventBusMiddleware.js';
 export { monotonicDatetime } from './helpers.js';
-export type { EventBusMiddleware, EventBusMiddlewareCtor, EventBusMiddlewareInput } from './middlewares.js';
-export { OtelTracingMiddleware } from './middleware_otel_tracing.js';
-export type { OtelTracingMiddlewareOptions } from './middleware_otel_tracing.js';
-export type { OtelTracingSpanFactory, OtelTracingSpanFactoryInput, OtelTracingSpanProvider } from './middleware_otel_tracing.js';
-export { EventHandlerTimeoutError, EventHandlerCancelledError, EventHandlerAbortedError, EventHandlerResultSchemaError, } from './event_handler.js';
-export type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, EventBusInterfaceForLockManager, } from './lock_manager.js';
+export { EventHandlerTimeoutError, EventHandlerCancelledError, EventHandlerAbortedError, EventHandlerResultSchemaError, } from './EventHandler.js';
+export type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, EventBusInterfaceForLockManager, } from './LockManager.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/logging.d.ts

@@ -1,5 +1,5 @@
-import { BaseEvent } from './base_event.js';
-import { EventResult } from './event_result.js';
+import { BaseEvent } from './BaseEvent.js';
+import { EventResult } from './EventResult.js';
 type LogTreeBus = {
     name: string;
     event_history: {

package/dist/types/middlewares.d.ts

@@ -1,13 +1 @@
-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;
+export type { EventBusMiddleware, EventBusMiddlewareCtor, EventBusMiddlewareInput } from './EventBusMiddleware.js';

package/dist/types/types.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { BaseEvent } from './base_event.js';
+import type { BaseEvent } from './BaseEvent.js';
 export type EventStatus = 'pending' | 'started' | 'completed';
 export type EventClass<T extends BaseEvent = BaseEvent> = {
     event_type?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abxbus",
-  "version": "2.4.26",
+  "version": "2.4.28",
   "description": "Event bus library for browsers and ESM Node.js",
   "type": "module",
   "sideEffects": false,
@@ -15,6 +15,18 @@
       "require": "./dist/cjs/index.js",
       "default": "./dist/esm/index.js"
     },
+    "./source": {
+      "source": "./src/index.ts",
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./source/*": {
+      "source": "./src/*.ts",
+      "types": "./src/*.ts",
+      "import": "./src/*.ts",
+      "default": "./src/*.ts"
+    },
     "./*": {
       "source": "./src/*.ts",
       "types": "./dist/types/*.d.ts",
@@ -34,24 +46,59 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.215.0",
-    "@opentelemetry/resources": "^2.7.0",
-    "@opentelemetry/sdk-trace-base": "^2.7.0",
     "uuid": "^13.0.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.215.0",
+    "@opentelemetry/resources": "^2.7.0",
+    "@opentelemetry/sdk-trace-base": "^2.7.0",
     "@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",
+    "ioredis": "^5.9.3",
+    "nats": "^2.29.3",
+    "pg": "^8.18.0",
     "prettier": "^3.8.1",
     "tsc-files": "^1.1.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.215.0",
+    "@opentelemetry/resources": "^2.7.0",
+    "@opentelemetry/sdk-trace-base": "^2.7.0",
+    "ioredis": "^5.9.3",
+    "nats": "^2.29.3",
+    "pg": "^8.18.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    },
+    "@opentelemetry/exporter-trace-otlp-http": {
+      "optional": true
+    },
+    "@opentelemetry/resources": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-trace-base": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "nats": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ArchiveBox/abxbus.git",
@@ -65,11 +112,6 @@
     "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:cjs && pnpm run build:types && pnpm run build:cjs:types",
     "build:esm": "node ./scripts/build_esm.mjs",

package/src/{base_event.ts → BaseEvent.ts}

@@ -1,17 +1,17 @@
 import { z } from 'zod'
 import { v7 as uuidv7 } from 'uuid'
 
-import { EventBus } from './event_bus.js'
-import { EventResult } from './event_result.js'
-import { EventHandler, EventHandlerAbortedError, EventHandlerCancelledError, EventHandlerTimeoutError } from './event_handler.js'
-import type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, Deferred } from './lock_manager.js'
+import { EventBus } from './EventBus.js'
+import { EventResult } from './EventResult.js'
+import { EventHandler, EventHandlerAbortedError, EventHandlerCancelledError, EventHandlerTimeoutError } from './EventHandler.js'
+import type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, Deferred } from './LockManager.js'
 import {
   AsyncLock,
   EVENT_CONCURRENCY_MODES,
   EVENT_HANDLER_CONCURRENCY_MODES,
   EVENT_HANDLER_COMPLETION_MODES,
   withResolvers,
-} from './lock_manager.js'
+} from './LockManager.js'
 import { _runWithTimeout } from './timing.js'
 import { extractZodShape, normalizeEventResultType, toJsonSchema } from './types.js'
 import type { EventHandlerCallable, EventResultType } from './types.js'
@@ -71,7 +71,7 @@ export const BaseEventSchema = z
     event_status: z.enum(['pending', 'started', 'completed']).optional(),
     event_started_at: z.string().datetime().nullable().optional(),
     event_completed_at: z.string().datetime().nullable().optional(),
-    event_results: z.array(z.unknown()).optional(),
+    event_results: z.record(z.string(), z.unknown()).optional(),
     event_concurrency: z.enum(EVENT_CONCURRENCY_MODES).nullable().optional(),
     event_handler_concurrency: z.enum(EVENT_HANDLER_CONCURRENCY_MODES).nullable().optional(),
     event_handler_completion: z.enum(EVENT_HANDLER_COMPLETION_MODES).nullable().optional(),
@@ -379,7 +379,9 @@ export class BaseEvent {
       if (value === undefined || typeof value === 'function') continue
       record[key] = value
     }
-    const event_results = Array.from(this.event_results.values()).map((result) => result.toJSON())
+    const event_results = Object.fromEntries(
+      Array.from(this.event_results.entries()).map(([handler_id, result]) => [handler_id, result.toJSON()])
+    )
 
     return {
       ...record,
@@ -411,7 +413,7 @@ export class BaseEvent {
       event_completed_at: this.event_completed_at ?? null,
 
       // mutable result state
-      ...(event_results.length > 0 ? { event_results } : {}),
+      ...(Object.keys(event_results).length > 0 ? { event_results } : {}),
     }
   }
 
@@ -1189,13 +1191,19 @@ export class BaseEvent {
 
 const hydrateEventResults = <TEvent extends BaseEvent>(event: TEvent, raw_event_results: unknown): Map<string, EventResult<TEvent>> => {
   const event_results = new Map<string, EventResult<TEvent>>()
-  if (!Array.isArray(raw_event_results)) {
+  if (raw_event_results == null) {
     return event_results
   }
-  for (const item of raw_event_results) {
-    const result = EventResult.fromJSON(event, item)
-    const map_key = typeof result.handler_id === 'string' && result.handler_id.length > 0 ? result.handler_id : result.id
-    event_results.set(map_key, result)
+  if (typeof raw_event_results !== 'object' || Array.isArray(raw_event_results)) {
+    throw new Error('BaseEvent.event_results must be an object keyed by handler id')
+  }
+  for (const [handler_id, item] of Object.entries(raw_event_results)) {
+    if (item == null || typeof item !== 'object' || Array.isArray(item)) continue
+    const result = EventResult.fromJSON(event, {
+      handler_id,
+      ...(item as Record<string, unknown>),
+    })
+    event_results.set(handler_id, result)
   }
   return event_results
 }