abxbus 2.4.31 → 2.5.0

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.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    event_results: z.ZodOptional<z.ZodArray<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.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
         event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
             "global-serial": "global-serial";
             "bus-serial": "bus-serial";

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

@@ -61,6 +61,7 @@ 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/index.d.ts

@@ -1,4 +1,5 @@
 export { BaseEvent, BaseEventSchema } from './BaseEvent.js';
+export type { EventResultInclude, EventResultOptions, EventWaitOptions, EventWaitPromise } from './BaseEvent.js';
 export { EventHistory } from './EventHistory.js';
 export type { EventHistoryFilterOptions, EventHistoryFindOptions, EventHistoryTrimOptions } from './EventHistory.js';
 export { EventResult } from './EventResult.js';

package/dist/types/middleware_otel_tracing.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 './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 { 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abxbus",
-  "version": "2.4.31",
+  "version": "2.5.0",
   "description": "Event bus library for browsers and ESM Node.js",
   "type": "module",
   "sideEffects": false,
@@ -128,8 +128,9 @@
     "prettier": "prettier --write .",
     "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",
+    "test": "NODE_OPTIONS='--expose-gc' node --expose-gc --test --import tsx $(find tests -type f -name '*.test.ts' ! -name 'EventBus_performance.test.ts' | sort)",
+    "perf": "pnpm run perf:test && pnpm run perf:node && pnpm run perf:bun && pnpm run perf:deno && pnpm run perf:browser",
+    "perf:test": "NODE_OPTIONS='--expose-gc' node --expose-gc --test --import tsx tests/EventBus_performance.test.ts",
     "debug:node": "NODE_OPTIONS='--expose-gc' node --expose-gc --import tsx",
     "debug:bun": "bun --expose-gc run",
     "debug:deno": "deno run --sloppy-imports --v8-flags=--expose-gc",