bubus 1.7.3

package/dist/types/async_context.d.ts

@@ -0,0 +1,10 @@
+type AsyncLocalStorageLike = {
+    getStore(): unknown;
+    run<T>(store: unknown, callback: () => T): T;
+    enterWith?(store: unknown): void;
+};
+export declare let async_local_storage: AsyncLocalStorageLike | null;
+export declare const captureAsyncContext: () => unknown | null;
+export declare const runWithAsyncContext: <T>(context: unknown | null, fn: () => T) => T;
+export declare const hasAsyncLocalStorage: () => boolean;
+export {};

package/dist/types/base_event.d.ts

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+import type { EventBus } from './event_bus.js';
+import { EventResult } from './event_result.js';
+import type { ConcurrencyMode, Deferred } from './lock_manager.js';
+export declare const BaseEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    event_created_at: z.ZodString;
+    event_created_ts: z.ZodOptional<z.ZodNumber>;
+    event_type: z.ZodString;
+    event_timeout: z.ZodNullable<z.ZodNumber>;
+    event_parent_id: z.ZodOptional<z.ZodString>;
+    event_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    event_result_type: z.ZodOptional<z.ZodString>;
+    event_result_schema: z.ZodOptional<z.ZodUnknown>;
+    event_emitted_by_handler_id: z.ZodOptional<z.ZodString>;
+    event_pending_bus_count: z.ZodOptional<z.ZodNumber>;
+    event_status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        started: "started";
+        completed: "completed";
+    }>>;
+    event_started_at: z.ZodOptional<z.ZodString>;
+    event_started_ts: z.ZodOptional<z.ZodNumber>;
+    event_completed_at: z.ZodOptional<z.ZodString>;
+    event_completed_ts: z.ZodOptional<z.ZodNumber>;
+    event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    event_concurrency: z.ZodOptional<z.ZodEnum<{
+        "global-serial": "global-serial";
+        "bus-serial": "bus-serial";
+        parallel: "parallel";
+        auto: "auto";
+    }>>;
+    event_handler_concurrency: z.ZodOptional<z.ZodEnum<{
+        "global-serial": "global-serial";
+        "bus-serial": "bus-serial";
+        parallel: "parallel";
+        auto: "auto";
+    }>>;
+}, z.core.$loose>;
+export type BaseEventData = z.infer<typeof BaseEventSchema>;
+type BaseEventFields = Pick<BaseEventData, 'event_id' | 'event_created_at' | 'event_created_ts' | 'event_type' | 'event_timeout' | 'event_parent_id' | 'event_path' | 'event_result_type' | 'event_result_schema' | 'event_emitted_by_handler_id' | 'event_pending_bus_count' | 'event_status' | 'event_started_at' | 'event_started_ts' | 'event_completed_at' | 'event_completed_ts' | 'event_results' | 'event_concurrency' | 'event_handler_concurrency'>;
+export type BaseEventInit<TFields extends Record<string, unknown>> = TFields & Partial<BaseEventFields>;
+type BaseEventSchemaShape = typeof BaseEventSchema.shape;
+export type EventSchema<TShape extends z.ZodRawShape> = z.ZodObject<BaseEventSchemaShape & TShape>;
+type EventPayload<TShape extends z.ZodRawShape> = z.infer<z.ZodObject<TShape>>;
+type EventInput<TShape extends z.ZodRawShape> = z.input<EventSchema<TShape>>;
+export type EventInit<TShape extends z.ZodRawShape> = Omit<EventInput<TShape>, keyof BaseEventFields> & Partial<BaseEventFields>;
+type EventWithResult<TResult> = BaseEvent & {
+    __event_result_type__?: TResult;
+};
+type ResultTypeFromShape<TShape> = TShape extends {
+    event_result_schema: infer S;
+} ? S extends z.ZodTypeAny ? z.infer<S> : unknown : unknown;
+export type EventFactory<TShape extends z.ZodRawShape, TResult = unknown> = {
+    (data: EventInit<TShape>): EventWithResult<TResult> & EventPayload<TShape>;
+    new (data: EventInit<TShape>): EventWithResult<TResult> & EventPayload<TShape>;
+    schema: EventSchema<TShape>;
+    event_type?: string;
+    event_result_schema?: z.ZodTypeAny;
+    event_result_type?: string;
+    fromJSON?: (data: unknown) => EventWithResult<TResult> & EventPayload<TShape>;
+};
+type ZodShapeFrom<TShape extends Record<string, unknown>> = {
+    [K in keyof TShape as K extends 'event_result_schema' | 'event_result_type' | 'event_result_schema_json' ? never : TShape[K] extends z.ZodTypeAny ? K : never]: Extract<TShape[K], z.ZodTypeAny>;
+};
+export declare class BaseEvent {
+    event_id: string;
+    event_created_at: string;
+    event_created_ts: number;
+    event_type: string;
+    event_timeout: number | null;
+    event_parent_id?: string;
+    event_path: string[];
+    event_result_schema?: z.ZodTypeAny;
+    event_result_type?: string;
+    event_results: Map<string, EventResult<this>>;
+    event_emitted_by_handler_id?: string;
+    event_pending_bus_count: number;
+    event_status: 'pending' | 'started' | 'completed';
+    event_started_at?: string;
+    event_started_ts?: number;
+    event_completed_at?: string;
+    event_completed_ts?: number;
+    event_concurrency?: ConcurrencyMode;
+    event_handler_concurrency?: ConcurrencyMode;
+    static event_type?: string;
+    static schema: z.ZodObject<{
+        event_id: z.ZodString;
+        event_created_at: z.ZodString;
+        event_created_ts: z.ZodOptional<z.ZodNumber>;
+        event_type: z.ZodString;
+        event_timeout: z.ZodNullable<z.ZodNumber>;
+        event_parent_id: z.ZodOptional<z.ZodString>;
+        event_path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        event_result_type: z.ZodOptional<z.ZodString>;
+        event_result_schema: z.ZodOptional<z.ZodUnknown>;
+        event_emitted_by_handler_id: z.ZodOptional<z.ZodString>;
+        event_pending_bus_count: z.ZodOptional<z.ZodNumber>;
+        event_status: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            started: "started";
+            completed: "completed";
+        }>>;
+        event_started_at: z.ZodOptional<z.ZodString>;
+        event_started_ts: z.ZodOptional<z.ZodNumber>;
+        event_completed_at: z.ZodOptional<z.ZodString>;
+        event_completed_ts: z.ZodOptional<z.ZodNumber>;
+        event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        event_concurrency: z.ZodOptional<z.ZodEnum<{
+            "global-serial": "global-serial";
+            "bus-serial": "bus-serial";
+            parallel: "parallel";
+            auto: "auto";
+        }>>;
+        event_handler_concurrency: z.ZodOptional<z.ZodEnum<{
+            "global-serial": "global-serial";
+            "bus-serial": "bus-serial";
+            parallel: "parallel";
+            auto: "auto";
+        }>>;
+    }, z.core.$loose>;
+    bus?: EventBus;
+    _event_original?: BaseEvent;
+    _event_dispatch_context?: unknown | null;
+    _event_done_signal: Deferred<this> | null;
+    constructor(data?: BaseEventInit<Record<string, unknown>>);
+    toString(): string;
+    static nextTimestamp(): {
+        date: Date;
+        isostring: string;
+        ts: number;
+    };
+    static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventFactory<TShape, ResultTypeFromShape<TShape>>;
+    static extend<TShape extends Record<string, unknown>>(event_type: string, shape?: TShape): EventFactory<ZodShapeFrom<TShape>, ResultTypeFromShape<TShape>>;
+    static parse<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T>;
+    static fromJSON<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T>;
+    toJSON(): BaseEventData;
+    get event_parent(): BaseEvent | undefined;
+    get event_children(): BaseEvent[];
+    get event_descendants(): BaseEvent[];
+    done(): Promise<this>;
+    immediate(): Promise<this>;
+    waitForCompletion(): Promise<this>;
+    finished(): Promise<this>;
+    markStarted(): void;
+    markCompleted(force?: boolean): void;
+    get event_errors(): unknown[];
+    eventAreAllChildrenComplete(): boolean;
+    _notifyDoneListeners(): void;
+    _gc(): void;
+}
+export {};

package/dist/types/event_bus.d.ts

@@ -0,0 +1,96 @@
+import { BaseEvent } from './base_event.js';
+import { EventResult } from './event_result.js';
+import { type ConcurrencyMode, LockManager } from './lock_manager.js';
+import { EventHandler } from './event_handler.js';
+import type { EventClass, EventHandlerFunction, EventKey, FindOptions, UntypedEventHandlerFunction } from './types.js';
+type FindWaiter = {
+    event_key: EventKey;
+    matches: (event: BaseEvent) => boolean;
+    resolve: (event: BaseEvent) => void;
+    timeout_id?: ReturnType<typeof setTimeout>;
+};
+type EventBusOptions = {
+    max_history_size?: number | null;
+    event_concurrency?: ConcurrencyMode;
+    event_handler_concurrency?: ConcurrencyMode;
+    event_timeout?: number | null;
+    event_handler_slow_timeout?: number | null;
+    event_slow_timeout?: number | null;
+};
+declare class GlobalEventBusInstanceRegistry {
+    private _refs;
+    private _lookup;
+    private _gc;
+    add(bus: EventBus): void;
+    delete(bus: EventBus): void;
+    has(bus: EventBus): boolean;
+    get size(): number;
+    [Symbol.iterator](): Iterator<EventBus>;
+    findEventById(event_id: string): BaseEvent | null;
+}
+export declare class EventBus {
+    static _all_instances: GlobalEventBusInstanceRegistry;
+    name: string;
+    max_history_size: number | null;
+    event_concurrency_default: ConcurrencyMode;
+    event_handler_concurrency_default: ConcurrencyMode;
+    event_timeout_default: number | null;
+    event_handler_slow_timeout: number | null;
+    event_slow_timeout: number | null;
+    handlers: Map<string, EventHandler>;
+    event_history: Map<string, BaseEvent>;
+    pending_event_queue: BaseEvent[];
+    in_flight_event_ids: Set<string>;
+    runloop_running: boolean;
+    locks: LockManager;
+    find_waiters: Set<FindWaiter>;
+    constructor(name?: string, options?: EventBusOptions);
+    toString(): string;
+    destroy(): void;
+    on<T extends BaseEvent>(event_key: EventClass<T>, handler: EventHandlerFunction<T>, options?: {
+        event_handler_concurrency?: ConcurrencyMode;
+        handler_timeout?: number | null;
+    }): EventHandler;
+    on<T extends BaseEvent>(event_key: string | '*', handler: UntypedEventHandlerFunction<T>, options?: {
+        event_handler_concurrency?: ConcurrencyMode;
+        handler_timeout?: number | null;
+    }): EventHandler;
+    off<T extends BaseEvent>(event_key: EventKey<T> | '*', handler?: EventHandlerFunction<T> | string | EventHandler): void;
+    dispatch<T extends BaseEvent>(event: T, _event_key?: EventKey<T>): T;
+    emit<T extends BaseEvent>(event: T, event_key?: EventKey<T>): T;
+    find<T extends BaseEvent>(event_key: EventKey<T>, options?: FindOptions): Promise<T | null>;
+    find<T extends BaseEvent>(event_key: EventKey<T>, where: (event: T) => boolean, options?: FindOptions): Promise<T | null>;
+    processEventImmediately<T extends BaseEvent>(event: T, handler_result?: EventResult): Promise<T>;
+    waitUntilIdle(): Promise<void>;
+    isIdle(): boolean;
+    isIdleAndQueueEmpty(): boolean;
+    eventIsChildOf(event: BaseEvent, ancestor: BaseEvent): boolean;
+    eventIsParentOf(parent_event: BaseEvent, child_event: BaseEvent): boolean;
+    logTree(): string;
+    findEventById(event_id: string): BaseEvent | null;
+    getParentEventResultAcrossAllBusses(event: BaseEvent): EventResult | null;
+    private runImmediatelyAcrossBuses;
+    private getBusesForImmediateRun;
+    private startRunloop;
+    private scheduleEventProcessing;
+    private runloop;
+    private processEvent;
+    runEventHandler(event: BaseEvent, handler: EventHandler, result: EventResult): Promise<void>;
+    private runHandlerWithTimeout;
+    private createSlowEventWarningTimer;
+    private createSlowHandlerWarningTimer;
+    private resolveEffectiveTimeout;
+    hasProcessedEvent(event: BaseEvent): boolean;
+    private notifyEventParentsOfCompletion;
+    getEventProxyScopedToThisBus<T extends BaseEvent>(event: T, handler_result?: EventResult): T;
+    cancelPendingDescendants(event: BaseEvent, reason: unknown): void;
+    private normalizeCancellationCause;
+    private cancelEvent;
+    private notifyFindListeners;
+    private createPendingHandlerResults;
+    getHandlersForEvent(event: BaseEvent): EventHandler[];
+    private eventMatchesKey;
+    private normalizeEventKey;
+    private trimHistory;
+}
+export {};

package/dist/types/event_handler.d.ts

@@ -0,0 +1,85 @@
+import type { ConcurrencyMode } from './lock_manager.js';
+import type { EventHandlerFunction } from './types.js';
+import { BaseEvent } from './base_event.js';
+import { EventResult } from './event_result.js';
+export declare class EventHandler {
+    id: string;
+    handler: EventHandlerFunction;
+    handler_name: string;
+    handler_file_path?: string;
+    handler_timeout: number | null;
+    event_handler_concurrency?: ConcurrencyMode;
+    handler_registered_at: string;
+    handler_registered_ts: number;
+    event_key: string | '*';
+    eventbus_name: string;
+    constructor(params: {
+        id?: string;
+        handler: EventHandlerFunction;
+        handler_name: string;
+        handler_file_path?: string;
+        handler_timeout: number | null;
+        event_handler_concurrency?: ConcurrencyMode;
+        handler_registered_at: string;
+        handler_registered_ts: number;
+        event_key: string | '*';
+        eventbus_name: string;
+    });
+    static computeHandlerId(params: {
+        eventbus_name: string;
+        handler_name: string;
+        handler_file_path?: string;
+        handler_registered_at: string;
+        event_key: string | '*';
+    }): string;
+    toString(): string;
+    private static detectHandlerFilePath;
+}
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}
+export declare class EventHandlerError extends Error {
+    event_result: EventResult;
+    timeout_seconds: number | null;
+    cause: Error;
+    constructor(message: string, params: {
+        event_result: EventResult;
+        timeout_seconds?: number | null;
+        cause: Error;
+    });
+    get event(): BaseEvent;
+    get event_type(): string;
+    get handler_name(): string;
+    get handler_id(): string;
+    get event_timeout(): number | null;
+}
+export declare class EventHandlerTimeoutError extends EventHandlerError {
+    constructor(message: string, params: {
+        event_result: EventResult;
+        timeout_seconds?: number | null;
+        cause?: Error;
+    });
+}
+export declare class EventHandlerCancelledError extends EventHandlerError {
+    constructor(message: string, params: {
+        event_result: EventResult;
+        timeout_seconds?: number | null;
+        cause: Error;
+    });
+}
+export declare class EventHandlerAbortedError extends EventHandlerError {
+    constructor(message: string, params: {
+        event_result: EventResult;
+        timeout_seconds?: number | null;
+        cause: Error;
+    });
+}
+export declare class EventHandlerResultSchemaError extends EventHandlerError {
+    raw_value: unknown;
+    constructor(message: string, params: {
+        event_result: EventResult;
+        timeout_seconds?: number | null;
+        cause: Error;
+        raw_value: unknown;
+    });
+}

package/dist/types/event_result.d.ts

@@ -0,0 +1,64 @@
+import { BaseEvent } from './base_event.js';
+import type { EventHandler } from './event_handler.js';
+import { HandlerLock, type ConcurrencyMode } from './lock_manager.js';
+import type { Deferred } from './lock_manager.js';
+import type { EventResultType } from './types.js';
+export type EventResultStatus = 'pending' | 'started' | 'completed' | 'error';
+export type EventResultData = {
+    id?: string;
+    status?: EventResultStatus;
+    event_id?: string;
+    handler?: {
+        id?: string;
+        handler_name?: string;
+        handler_file_path?: string;
+        handler_timeout?: number | null;
+        event_handler_concurrency?: ConcurrencyMode;
+        handler_registered_at?: string;
+        handler_registered_ts?: number;
+        event_key?: string | '*';
+        eventbus_name?: string;
+    };
+    started_at?: string;
+    started_ts?: number;
+    completed_at?: string;
+    completed_ts?: number;
+    result?: unknown;
+    error?: unknown;
+    event_children?: string[];
+};
+export declare class EventResult<TEvent extends BaseEvent = BaseEvent> {
+    id: string;
+    status: EventResultStatus;
+    event: TEvent;
+    handler: EventHandler;
+    started_at?: string;
+    started_ts?: number;
+    completed_at?: string;
+    completed_ts?: number;
+    result?: EventResultType<TEvent>;
+    error?: unknown;
+    event_children: BaseEvent[];
+    _abort: Deferred<never> | null;
+    _lock: HandlerLock | null;
+    constructor(params: {
+        event: TEvent;
+        handler: EventHandler;
+    });
+    toString(): string;
+    get event_id(): string;
+    get handler_id(): string;
+    get handler_name(): string;
+    get handler_file_path(): string | undefined;
+    get handler_timeout(): number | null;
+    get eventbus_name(): string;
+    get value(): EventResultType<TEvent> | undefined;
+    linkEmittedChildEvent(child_event: BaseEvent): void;
+    get raw_value(): EventResultType<TEvent> | undefined;
+    signalAbort(error: Error): void;
+    markStarted(): Promise<never>;
+    markCompleted(result: EventResultType<TEvent> | undefined): void;
+    markError(error: unknown): void;
+    toJSON(): EventResultData;
+    static fromJSON<TEvent extends BaseEvent>(event: TEvent, data: unknown): EventResult<TEvent> | null;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { BaseEvent, BaseEventSchema } from './base_event.js';
+export { EventResult } from './event_result.js';
+export { EventBus } from './event_bus.js';
+export { EventHandlerTimeoutError, EventHandlerCancelledError, EventHandlerAbortedError, EventHandlerResultSchemaError, } from './event_handler.js';
+export type { ConcurrencyMode, EventBusInterfaceForLockManager } from './lock_manager.js';
+export type { EventClass, EventHandlerFunction as EventHandler, EventKey, EventStatus, FindOptions, FindWindow } from './types.js';

package/dist/types/lock_manager.d.ts

@@ -0,0 +1,68 @@
+import type { BaseEvent } from './base_event.js';
+import type { EventHandler } from './event_handler.js';
+import type { EventResult } from './event_result.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 CONCURRENCY_MODES: readonly ["global-serial", "bus-serial", "parallel", "auto"];
+export type ConcurrencyMode = (typeof CONCURRENCY_MODES)[number];
+export declare const DEFAULT_CONCURRENCY_MODE = "bus-serial";
+export declare const resolveConcurrencyMode: (mode: ConcurrencyMode | undefined, fallback: ConcurrencyMode) => ConcurrencyMode;
+export declare class AsyncSemaphore {
+    size: number;
+    in_use: number;
+    waiters: Array<() => void>;
+    constructor(size: number);
+    acquire(): Promise<void>;
+    release(): void;
+}
+export declare const semaphoreForMode: (mode: ConcurrencyMode, global_semaphore: AsyncSemaphore, bus_semaphore: AsyncSemaphore) => AsyncSemaphore | null;
+export declare const runWithSemaphore: <T>(semaphore: AsyncSemaphore | null, fn: () => Promise<T>) => Promise<T>;
+export type HandlerExecutionState = 'held' | 'yielded' | 'closed';
+export declare class HandlerLock {
+    private semaphore;
+    private state;
+    constructor(semaphore: AsyncSemaphore | null);
+    yieldHandlerLockForChildRun(): boolean;
+    reclaimHandlerLockIfRunning(): Promise<boolean>;
+    exitHandlerRun(): void;
+    runQueueJump<T>(fn: () => Promise<T>): Promise<T>;
+}
+export type EventBusInterfaceForLockManager = {
+    isIdleAndQueueEmpty: () => boolean;
+    event_concurrency_default: ConcurrencyMode;
+    event_handler_concurrency_default: ConcurrencyMode;
+};
+export declare class LockManager {
+    static global_event_semaphore: AsyncSemaphore;
+    static global_handler_semaphore: AsyncSemaphore;
+    private bus;
+    readonly bus_event_semaphore: AsyncSemaphore;
+    readonly bus_handler_semaphore: AsyncSemaphore;
+    private pause_depth;
+    private pause_waiters;
+    private queue_jump_pause_releases;
+    private active_handler_results;
+    private idle_waiters;
+    private idle_check_pending;
+    private idle_check_streak;
+    constructor(bus: EventBusInterfaceForLockManager);
+    requestPause(): () => void;
+    waitUntilRunloopResumed(): Promise<void>;
+    isPaused(): boolean;
+    enterActiveHandlerContext(result: EventResult): void;
+    exitActiveHandlerContext(result: EventResult): void;
+    getActiveHandlerResult(): EventResult | undefined;
+    isAnyHandlerActive(): boolean;
+    requestRunloopPauseForQueueJumpEvent(result: EventResult): void;
+    releaseRunloopPauseForQueueJumpEvent(result: EventResult): void;
+    waitForIdle(): Promise<void>;
+    notifyIdleListeners(): void;
+    getSemaphoreForEvent(event: BaseEvent): AsyncSemaphore | null;
+    getSemaphoreForHandler(event: BaseEvent, handler?: Pick<EventHandler, 'event_handler_concurrency'>): AsyncSemaphore | null;
+    private scheduleIdleCheck;
+    clear(): void;
+}

package/dist/types/logging.d.ts

@@ -0,0 +1,12 @@
+import { BaseEvent } from './base_event.js';
+import { EventResult } from './event_result.js';
+type LogTreeBus = {
+    name: string;
+    event_history: Map<string, BaseEvent>;
+};
+export declare const logTree: (bus: LogTreeBus) => string;
+export declare const buildTreeLine: (event: BaseEvent, indent: string, is_last: boolean, parent_to_children: Map<string, BaseEvent[]>, visited: Set<string>) => string;
+export declare const buildResultLine: (result: EventResult, indent: string, is_last: boolean, parent_to_children: Map<string, BaseEvent[]>, visited: Set<string>) => string;
+export declare const formatTimestamp: (value?: string) => string;
+export declare const formatResultValue: (value: unknown) => string;
+export {};

package/dist/types/type_inference.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import type { BaseEvent } from './base_event.js';
+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 & {
+    __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 FindWindow = boolean | number;
+export type FindOptions = {
+    past?: FindWindow;
+    future?: FindWindow;
+    child_of?: BaseEvent | null;
+};
+export declare const isZodSchema: (value: unknown) => value is z.ZodTypeAny;
+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;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "bubus",
+  "version": "1.7.3",
+  "description": "Event bus library for browsers and ESM Node.js",
+  "type": "module",
+  "main": "./dist/esm/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "dist/esm",
+    "dist/types"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "uuid": "^11.1.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.46.0",
+    "@typescript-eslint/parser": "^8.46.0",
+    "esbuild": "^0.27.2",
+    "eslint": "^9.39.2",
+    "prettier": "^3.8.1",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pirate/bbus.git",
+    "directory": "bubus-ts"
+  },
+  "bugs": {
+    "url": "https://github.com/pirate/bbus/issues"
+  },
+  "homepage": "https://github.com/pirate/bbus/tree/main/bubus-ts",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "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:types": "tsc -p tsconfig.json --emitDeclarationOnly",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "NODE_OPTIONS='--expose-gc' node --expose-gc --test --import tsx tests/**/*.test.ts",
+    "release:dry-run": "pnpm publish --access public --dry-run --no-git-checks",
+    "release:check": "pnpm run typecheck && pnpm test && pnpm run build"
+  }
+}