@psavelis/enterprise-blockchain 0.1.0 → 1.1.1

package/dist/stark-settlement/infrastructure/adapters/clock-adapter.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Clock Adapters
+ *
+ * Implementations of ClockPort for time and UUID operations.
+ * Enables deterministic testing with fixed timestamps.
+ *
+ * @see domain/ports.ts for ClockPort interface
+ */
+import type { ClockPort } from "../../domain/ports.js";
+/**
+ * Real clock adapter using system time.
+ */
+export declare class SystemClock implements ClockPort {
+    now(): number;
+    uuid(): string;
+}
+/**
+ * Fixed clock adapter for deterministic testing.
+ *
+ * Time advances manually or by a fixed increment per call.
+ */
+export declare class FixedClock implements ClockPort {
+    private currentTime;
+    private uuidCounter;
+    private readonly uuidPrefix;
+    private readonly autoAdvanceMs;
+    constructor(initialTime?: number, // 2024-01-01T00:00:00Z
+    options?: {
+        uuidPrefix?: string;
+        autoAdvanceMs?: number;
+    });
+    now(): number;
+    uuid(): string;
+    /**
+     * Manually advance time by the specified milliseconds.
+     */
+    advance(ms: number): void;
+    /**
+     * Set time to a specific value.
+     */
+    setTime(time: number): void;
+    /**
+     * Get the current time without advancing.
+     */
+    peek(): number;
+    /**
+     * Reset the clock to initial state.
+     */
+    reset(initialTime?: number): void;
+    /**
+     * Get the next UUID that will be generated (for assertions).
+     */
+    peekNextUuid(): string;
+}
+/**
+ * Default clock instance (system clock).
+ */
+export declare const defaultClock: ClockPort;
+//# sourceMappingURL=clock-adapter.d.ts.map

package/dist/stark-settlement/infrastructure/adapters/clock-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock-adapter.d.ts","sourceRoot":"","sources":["../../../../src/stark-settlement/infrastructure/adapters/clock-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;GAEG;AACH,qBAAa,WAAY,YAAW,SAAS;IAC3C,GAAG,IAAI,MAAM;IAIb,IAAI,IAAI,MAAM;CAGf;AAED;;;;GAIG;AACH,qBAAa,UAAW,YAAW,SAAS;IAC1C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAGrC,WAAW,GAAE,MAAsB,EAAE,uBAAuB;IAC5D,OAAO,GAAE;QACP,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;KACnB;IAOR,GAAG,IAAI,MAAM;IAQb,IAAI,IAAI,MAAM;IAMd;;OAEG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIzB;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI3B;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,KAAK,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAKjC;;OAEG;IACH,YAAY,IAAI,MAAM;CAIvB;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,SAA6B,CAAC"}

package/dist/stark-settlement/infrastructure/adapters/clock-adapter.js

@@ -0,0 +1,85 @@
+/**
+ * Clock Adapters
+ *
+ * Implementations of ClockPort for time and UUID operations.
+ * Enables deterministic testing with fixed timestamps.
+ *
+ * @see domain/ports.ts for ClockPort interface
+ */
+import { randomUUID } from "node:crypto";
+/**
+ * Real clock adapter using system time.
+ */
+export class SystemClock {
+    now() {
+        return Date.now();
+    }
+    uuid() {
+        return randomUUID();
+    }
+}
+/**
+ * Fixed clock adapter for deterministic testing.
+ *
+ * Time advances manually or by a fixed increment per call.
+ */
+export class FixedClock {
+    currentTime;
+    uuidCounter = 0;
+    uuidPrefix;
+    autoAdvanceMs;
+    constructor(initialTime = 1704067200000, // 2024-01-01T00:00:00Z
+    options = {}) {
+        this.currentTime = initialTime;
+        this.uuidPrefix = options.uuidPrefix ?? "00000000-0000-0000-0000";
+        this.autoAdvanceMs = options.autoAdvanceMs ?? 0;
+    }
+    now() {
+        const time = this.currentTime;
+        if (this.autoAdvanceMs > 0) {
+            this.currentTime += this.autoAdvanceMs;
+        }
+        return time;
+    }
+    uuid() {
+        const counter = this.uuidCounter++;
+        const suffix = counter.toString(16).padStart(12, "0");
+        return `${this.uuidPrefix}-${suffix}`;
+    }
+    /**
+     * Manually advance time by the specified milliseconds.
+     */
+    advance(ms) {
+        this.currentTime += ms;
+    }
+    /**
+     * Set time to a specific value.
+     */
+    setTime(time) {
+        this.currentTime = time;
+    }
+    /**
+     * Get the current time without advancing.
+     */
+    peek() {
+        return this.currentTime;
+    }
+    /**
+     * Reset the clock to initial state.
+     */
+    reset(initialTime) {
+        this.currentTime = initialTime ?? 1704067200000;
+        this.uuidCounter = 0;
+    }
+    /**
+     * Get the next UUID that will be generated (for assertions).
+     */
+    peekNextUuid() {
+        const suffix = this.uuidCounter.toString(16).padStart(12, "0");
+        return `${this.uuidPrefix}-${suffix}`;
+    }
+}
+/**
+ * Default clock instance (system clock).
+ */
+export const defaultClock = new SystemClock();

package/dist/stark-settlement/infrastructure/adapters/dilithium-adapter.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Dilithium (ML-DSA-65) Signing Adapter
+ *
+ * Wraps the existing MPC module's ML-DSA-65 implementation.
+ * Provides post-quantum signatures for transaction authentication.
+ *
+ * @see modules/mpc/src/dsa.ts for underlying implementation
+ * @see domain/ports.ts for DilithiumSigningPort interface
+ */
+import type { DilithiumSigningPort, TransactionSigningPort } from "../../domain/ports.js";
+import type { TransactionPayload } from "../../domain/entities.js";
+/**
+ * Adapter for ML-DSA-65 signing operations.
+ *
+ * Uses the existing MlDsaSigner from the MPC module.
+ */
+export declare class DilithiumSigningAdapter implements DilithiumSigningPort {
+    private readonly signer;
+    private readonly params;
+    constructor();
+    generateKeyPair(): {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    sign(message: Uint8Array, secretKey: Uint8Array): Uint8Array;
+    verify(message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean;
+    hashPublicKey(publicKey: Uint8Array): string;
+}
+/**
+ * Transaction signing adapter that combines payload serialization with ML-DSA-65 signing.
+ */
+export declare class TransactionSigningAdapter implements TransactionSigningPort {
+    private readonly dilithium;
+    constructor(dilithium: DilithiumSigningPort);
+    signPayload(payload: TransactionPayload, secretKey: Uint8Array): Uint8Array;
+    verifyPayload(payload: TransactionPayload, signature: Uint8Array, publicKey: Uint8Array): boolean;
+    serializePayload(payload: TransactionPayload): Uint8Array;
+}
+/**
+ * Mock Dilithium adapter for testing without crypto overhead.
+ */
+export declare class MockDilithiumAdapter implements DilithiumSigningPort {
+    private keyPairCounter;
+    generateKeyPair(): {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    sign(message: Uint8Array, secretKey: Uint8Array): Uint8Array;
+    verify(_message: Uint8Array, signature: Uint8Array, _publicKey: Uint8Array): boolean;
+    hashPublicKey(publicKey: Uint8Array): string;
+}
+/**
+ * Default Dilithium adapter instance.
+ */
+export declare const defaultDilithiumAdapter: DilithiumSigningPort;
+/**
+ * Create a transaction signing adapter with the default Dilithium adapter.
+ */
+export declare function createTransactionSigningAdapter(): TransactionSigningPort;
+//# sourceMappingURL=dilithium-adapter.d.ts.map

package/dist/stark-settlement/infrastructure/adapters/dilithium-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dilithium-adapter.d.ts","sourceRoot":"","sources":["../../../../src/stark-settlement/infrastructure/adapters/dilithium-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,KAAK,EACV,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;GAIG;AACH,qBAAa,uBAAwB,YAAW,oBAAoB;IAClE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;;IAM/C,eAAe,IAAI;QAAE,SAAS,EAAE,UAAU,CAAC;QAAC,SAAS,EAAE,UAAU,CAAA;KAAE;IAQnE,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,UAAU;IAK5D,MAAM,CACJ,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,UAAU,EACrB,SAAS,EAAE,UAAU,GACpB,OAAO;IAIV,aAAa,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM;CAG7C;AAED;;GAEG;AACH,qBAAa,yBAA0B,YAAW,sBAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,oBAAoB;IAE5D,WAAW,CAAC,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,UAAU,GAAG,UAAU;IAK3E,aAAa,CACX,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,UAAU,EACrB,SAAS,EAAE,UAAU,GACpB,OAAO;IAKV,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,UAAU;CAK1D;AAED;;GAEG;AACH,qBAAa,oBAAqB,YAAW,oBAAoB;IAC/D,OAAO,CAAC,cAAc,CAAK;IAE3B,eAAe,IAAI;QAAE,SAAS,EAAE,UAAU,CAAC;QAAC,SAAS,EAAE,UAAU,CAAA;KAAE;IAcnE,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,UAAU;IAQ5D,MAAM,CACJ,QAAQ,EAAE,UAAU,EACpB,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,UAAU,GACrB,OAAO;IAKV,aAAa,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM;CAG7C;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,oBACP,CAAC;AAEhC;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,sBAAsB,CAExE"}

package/dist/stark-settlement/infrastructure/adapters/dilithium-adapter.js

@@ -0,0 +1,104 @@
+/**
+ * Dilithium (ML-DSA-65) Signing Adapter
+ *
+ * Wraps the existing MPC module's ML-DSA-65 implementation.
+ * Provides post-quantum signatures for transaction authentication.
+ *
+ * @see modules/mpc/src/dsa.ts for underlying implementation
+ * @see domain/ports.ts for DilithiumSigningPort interface
+ */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { createHash } from "node:crypto";
+import { MlDsaSigner } from "../../../mpc/dsa.js";
+/**
+ * Adapter for ML-DSA-65 signing operations.
+ *
+ * Uses the existing MlDsaSigner from the MPC module.
+ */
+export class DilithiumSigningAdapter {
+    signer;
+    params = "ml-dsa-65";
+    constructor() {
+        this.signer = new MlDsaSigner();
+    }
+    generateKeyPair() {
+        const keypair = this.signer.generateKeyPair(this.params);
+        return {
+            publicKey: keypair.publicKey,
+            secretKey: keypair.secretKey,
+        };
+    }
+    sign(message, secretKey) {
+        const result = this.signer.sign(message, secretKey, this.params);
+        return result.signature;
+    }
+    verify(message, signature, publicKey) {
+        return this.signer.verify(message, signature, publicKey, this.params);
+    }
+    hashPublicKey(publicKey) {
+        return createHash("sha256").update(publicKey).digest("hex");
+    }
+}
+/**
+ * Transaction signing adapter that combines payload serialization with ML-DSA-65 signing.
+ */
+export class TransactionSigningAdapter {
+    dilithium;
+    constructor(dilithium) {
+        this.dilithium = dilithium;
+    }
+    signPayload(payload, secretKey) {
+        const serialized = this.serializePayload(payload);
+        return this.dilithium.sign(serialized, secretKey);
+    }
+    verifyPayload(payload, signature, publicKey) {
+        const serialized = this.serializePayload(payload);
+        return this.dilithium.verify(serialized, signature, publicKey);
+    }
+    serializePayload(payload) {
+        // Canonical JSON serialization (sorted keys, no whitespace)
+        const canonical = JSON.stringify(payload, Object.keys(payload).sort());
+        return new TextEncoder().encode(canonical);
+    }
+}
+/**
+ * Mock Dilithium adapter for testing without crypto overhead.
+ */
+export class MockDilithiumAdapter {
+    keyPairCounter = 0;
+    generateKeyPair() {
+        const id = this.keyPairCounter++;
+        const publicKey = new Uint8Array(32);
+        const secretKey = new Uint8Array(32);
+        // Fill with deterministic pattern
+        for (let i = 0; i < 32; i++) {
+            publicKey[i] = (id + i) & 0xff;
+            secretKey[i] = (id + i + 128) & 0xff;
+        }
+        return { publicKey, secretKey };
+    }
+    sign(message, secretKey) {
+        // Mock signature: hash of message + secretKey
+        const hash = createHash("sha256");
+        hash.update(message);
+        hash.update(secretKey);
+        return new Uint8Array(hash.digest());
+    }
+    verify(_message, signature, _publicKey) {
+        // Mock verification: signature must be 32 bytes
+        return signature.length === 32;
+    }
+    hashPublicKey(publicKey) {
+        return createHash("sha256").update(publicKey).digest("hex");
+    }
+}
+/**
+ * Default Dilithium adapter instance.
+ */
+export const defaultDilithiumAdapter = new DilithiumSigningAdapter();
+/**
+ * Create a transaction signing adapter with the default Dilithium adapter.
+ */
+export function createTransactionSigningAdapter() {
+    return new TransactionSigningAdapter(defaultDilithiumAdapter);
+}

package/dist/stark-settlement/infrastructure/adapters/event-emitter-adapter.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Event Emitter Adapter
+ *
+ * Implements EventEmitterPort for domain event publication.
+ * Uses a simple synchronous pub/sub pattern.
+ *
+ * @see domain/ports.ts for EventEmitterPort interface
+ */
+import type { Logger } from "../../../shared/logger.js";
+import type { SettlementEvent, EventEmitterPort } from "../../domain/ports.js";
+type EventHandler = (event: SettlementEvent) => void;
+type ErrorCallback = (error: unknown, event: SettlementEvent) => void;
+/**
+ * Configuration options for InMemoryEventEmitter.
+ */
+export interface EventEmitterOptions {
+    /** Maximum number of events to retain in history. Default: 1000 */
+    maxHistorySize?: number;
+    /** Logger for error reporting. Default: noopLogger (silent) */
+    logger?: Logger;
+    /** Optional callback for handler errors. Called instead of/in addition to logging. */
+    onHandlerError?: ErrorCallback;
+}
+/**
+ * In-memory event emitter for domain events.
+ *
+ * Handler errors are routed through an injected Logger instead of console.error,
+ * allowing library consumers to control logging behavior.
+ */
+export declare class InMemoryEventEmitter implements EventEmitterPort {
+    private readonly handlers;
+    private readonly typeHandlers;
+    private readonly eventHistory;
+    private readonly maxHistorySize;
+    private readonly logger;
+    private readonly onHandlerError;
+    constructor(options?: EventEmitterOptions);
+    emit(event: SettlementEvent): void;
+    /**
+     * Safely invoke a handler, routing errors through logger/callback.
+     */
+    private safeInvoke;
+    subscribe(handler: EventHandler): {
+        unsubscribe: () => void;
+    };
+    on<T extends SettlementEvent["type"]>(eventType: T, handler: (event: Extract<SettlementEvent, {
+        type: T;
+    }>) => void): {
+        unsubscribe: () => void;
+    };
+    /**
+     * Get all events of a specific type from history.
+     */
+    getEvents<T extends SettlementEvent["type"]>(eventType: T): Extract<SettlementEvent, {
+        type: T;
+    }>[];
+    /**
+     * Get all events from history.
+     */
+    getAllEvents(): readonly SettlementEvent[];
+    /**
+     * Get the count of subscribers.
+     */
+    getSubscriberCount(): {
+        general: number;
+        byType: Map<string, number>;
+    };
+    /**
+     * Clear all handlers and history.
+     */
+    clear(): void;
+    /**
+     * Clear only history, keep handlers.
+     */
+    clearHistory(): void;
+}
+/**
+ * Configuration options for AsyncEventEmitter.
+ */
+export interface AsyncEventEmitterOptions {
+    /** Logger for error reporting. Default: noopLogger (silent) */
+    logger?: Logger;
+    /** Optional callback for handler errors. */
+    onHandlerError?: ErrorCallback;
+}
+/**
+ * Async event emitter that handles async handlers.
+ *
+ * Handler errors are routed through an injected Logger instead of console.error,
+ * allowing library consumers to control logging behavior.
+ */
+export declare class AsyncEventEmitter implements EventEmitterPort {
+    private readonly handlers;
+    private readonly typeHandlers;
+    private readonly logger;
+    private readonly onHandlerError;
+    constructor(options?: AsyncEventEmitterOptions);
+    emit(event: SettlementEvent): void;
+    emitAsync(event: SettlementEvent): Promise<void>;
+    subscribe(handler: (event: SettlementEvent) => void | Promise<void>): {
+        unsubscribe: () => void;
+    };
+    on<T extends SettlementEvent["type"]>(eventType: T, handler: (event: Extract<SettlementEvent, {
+        type: T;
+    }>) => void | Promise<void>): {
+        unsubscribe: () => void;
+    };
+}
+/**
+ * Default event emitter instance.
+ * Uses noopLogger by default for library-friendly silent behavior.
+ */
+export declare const defaultEventEmitter: InMemoryEventEmitter;
+export {};
+//# sourceMappingURL=event-emitter-adapter.d.ts.map

package/dist/stark-settlement/infrastructure/adapters/event-emitter-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter-adapter.d.ts","sourceRoot":"","sources":["../../../../src/stark-settlement/infrastructure/adapters/event-emitter-adapter.ts"],"names":[],"mappings":"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"}

package/dist/stark-settlement/infrastructure/adapters/event-emitter-adapter.js

@@ -0,0 +1,191 @@
+/**
+ * Event Emitter Adapter
+ *
+ * Implements EventEmitterPort for domain event publication.
+ * Uses a simple synchronous pub/sub pattern.
+ *
+ * @see domain/ports.ts for EventEmitterPort interface
+ */
+import { noopLogger } from "../../../shared/logger.js";
+/**
+ * In-memory event emitter for domain events.
+ *
+ * Handler errors are routed through an injected Logger instead of console.error,
+ * allowing library consumers to control logging behavior.
+ */
+export class InMemoryEventEmitter {
+    handlers = new Set();
+    typeHandlers = new Map();
+    eventHistory = [];
+    maxHistorySize;
+    logger;
+    onHandlerError;
+    constructor(options = {}) {
+        this.maxHistorySize = options.maxHistorySize ?? 1000;
+        this.logger = options.logger ?? noopLogger;
+        this.onHandlerError = options.onHandlerError;
+    }
+    emit(event) {
+        // Store in history
+        this.eventHistory.push(event);
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory.shift();
+        }
+        // Notify general handlers
+        for (const handler of this.handlers) {
+            this.safeInvoke(handler, event);
+        }
+        // Notify type-specific handlers
+        const typeSet = this.typeHandlers.get(event.type);
+        if (typeSet) {
+            for (const handler of typeSet) {
+                this.safeInvoke(handler, event);
+            }
+        }
+    }
+    /**
+     * Safely invoke a handler, routing errors through logger/callback.
+     */
+    safeInvoke(handler, event) {
+        try {
+            handler(event);
+        }
+        catch (error) {
+            // Route error through injected logger instead of console.error
+            this.logger.error("Event handler error", {
+                eventType: event.type,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Also invoke callback if provided
+            if (this.onHandlerError) {
+                this.onHandlerError(error, event);
+            }
+        }
+    }
+    subscribe(handler) {
+        this.handlers.add(handler);
+        return {
+            unsubscribe: () => {
+                this.handlers.delete(handler);
+            },
+        };
+    }
+    on(eventType, handler) {
+        if (!this.typeHandlers.has(eventType)) {
+            this.typeHandlers.set(eventType, new Set());
+        }
+        const wrappedHandler = handler;
+        this.typeHandlers.get(eventType).add(wrappedHandler);
+        return {
+            unsubscribe: () => {
+                this.typeHandlers.get(eventType)?.delete(wrappedHandler);
+            },
+        };
+    }
+    // ─── Utilities ──────────────────────────────────────────────────────────
+    /**
+     * Get all events of a specific type from history.
+     */
+    getEvents(eventType) {
+        return this.eventHistory.filter((e) => e.type === eventType);
+    }
+    /**
+     * Get all events from history.
+     */
+    getAllEvents() {
+        return [...this.eventHistory];
+    }
+    /**
+     * Get the count of subscribers.
+     */
+    getSubscriberCount() {
+        const byType = new Map();
+        for (const [type, handlers] of this.typeHandlers) {
+            byType.set(type, handlers.size);
+        }
+        return {
+            general: this.handlers.size,
+            byType,
+        };
+    }
+    /**
+     * Clear all handlers and history.
+     */
+    clear() {
+        this.handlers.clear();
+        this.typeHandlers.clear();
+        this.eventHistory.length = 0;
+    }
+    /**
+     * Clear only history, keep handlers.
+     */
+    clearHistory() {
+        this.eventHistory.length = 0;
+    }
+}
+/**
+ * Async event emitter that handles async handlers.
+ *
+ * Handler errors are routed through an injected Logger instead of console.error,
+ * allowing library consumers to control logging behavior.
+ */
+export class AsyncEventEmitter {
+    handlers = new Set();
+    typeHandlers = new Map();
+    logger;
+    onHandlerError;
+    constructor(options = {}) {
+        this.logger = options.logger ?? noopLogger;
+        this.onHandlerError = options.onHandlerError;
+    }
+    emit(event) {
+        // Fire and forget for async handlers
+        this.emitAsync(event).catch((error) => {
+            this.logger.error("Async event emission error", {
+                eventType: event.type,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            if (this.onHandlerError) {
+                this.onHandlerError(error, event);
+            }
+        });
+    }
+    async emitAsync(event) {
+        const promises = [];
+        for (const handler of this.handlers) {
+            promises.push(Promise.resolve(handler(event)));
+        }
+        const typeSet = this.typeHandlers.get(event.type);
+        if (typeSet) {
+            for (const handler of typeSet) {
+                promises.push(Promise.resolve(handler(event)));
+            }
+        }
+        await Promise.all(promises);
+    }
+    subscribe(handler) {
+        this.handlers.add(handler);
+        return {
+            unsubscribe: () => {
+                this.handlers.delete(handler);
+            },
+        };
+    }
+    on(eventType, handler) {
+        if (!this.typeHandlers.has(eventType)) {
+            this.typeHandlers.set(eventType, new Set());
+        }
+        const wrappedHandler = handler;
+        this.typeHandlers.get(eventType).add(wrappedHandler);
+        return {
+            unsubscribe: () => {
+                this.typeHandlers.get(eventType)?.delete(wrappedHandler);
+            },
+        };
+    }
+}
+/**
+ * Default event emitter instance.
+ * Uses noopLogger by default for library-friendly silent behavior.
+ */
+export const defaultEventEmitter = new InMemoryEventEmitter();