abxbus 2.4.26 → 2.4.27

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

@@ -0,0 +1,49 @@
+import { trace, type Span, type SpanAttributes, type SpanContext, type TimeInput, type Tracer } from '@opentelemetry/api';
+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 = {
+    name: string;
+    span_context: SpanContext;
+    parent_span_context?: SpanContext;
+    attributes: SpanAttributes;
+    start_time?: TimeInput;
+};
+export type OtelTracingSpanFactory = (input: OtelTracingSpanFactoryInput) => Span;
+export type OtelTracingSpanProvider = object;
+export type OtelTracingMiddlewareOptions = {
+    tracer?: Tracer;
+    trace_api?: OpenTelemetryTraceApi;
+    span_provider?: OtelTracingSpanProvider;
+    span_factory?: OtelTracingSpanFactory;
+    otlp_endpoint?: string;
+    service_name?: string;
+    instrumentation_name?: string;
+    root_span_attributes?: SpanAttributes | ((eventbus: EventBus, event: BaseEvent) => SpanAttributes);
+};
+export declare class OtelTracingMiddleware implements EventBusMiddleware {
+    private readonly tracer;
+    private readonly trace_api;
+    private readonly span_factory?;
+    private readonly span_provider?;
+    private readonly root_span_attributes;
+    private readonly event_spans;
+    private readonly event_contexts;
+    private readonly handler_spans;
+    private readonly handler_contexts;
+    constructor(options?: OtelTracingMiddlewareOptions);
+    onEventChange(eventbus: EventBus, event: BaseEvent, status: EventStatus): void;
+    onEventResultChange(eventbus: EventBus, event: BaseEvent, event_result: EventResult, status: EventStatus): void;
+    private startEventSpan;
+    private completeEventSpan;
+    private startHandlerSpan;
+    private completeHandlerSpan;
+    private parentContextForEvent;
+    private completeEventSpanWithFactory;
+    private exportEventTreeWithFactory;
+    private exportHandlerSpanWithFactory;
+}
+export {};

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

@@ -0,0 +1,45 @@
+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;
+};
+export 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 {};

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/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.27",
   "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'