asljs-eventful 0.2.3 → 0.4.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) 2025 Alexandrite Software Ltd
+Copyright (c) 2026 Alexandrite Software Ltd
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -36,7 +36,10 @@ obj.emit('greet', 'Hello');
 ```ts
 import { eventful, type Eventful } from 'asljs-eventful';
 
-const obj: Eventful<{ name: string }> =
+type Events =
+  { greet: [msg: string] };
+
+const obj: { name: string } & Eventful<Events> =
   eventful({ name: 'Alice' });
 
 obj.on('greet',
@@ -72,6 +75,7 @@ class MyClass extends EventfulBase {
 
 ```ts
 import { EventfulBase } from 'asljs-eventful';
+
 class MyClass extends EventfulBase {
   name: string;
 
@@ -158,12 +162,12 @@ const obj =
             payload);
         } });
 
-// Tracing actions include:
-// - 'new' on creation: payload { object }
-// - 'on' when subscribing: payload { object, event, listener }
-// - 'off' when unsubscribing: payload { object, event, listener }
-// - 'emit' for sync emit: payload { object, event, args, listeners }
-// - 'emitAsync' for async emit: payload { object, event, args, listeners }
+// Tracing (event, payload):
+// - 'new' on creation, { object }
+// - 'on' when subscribing, { object, event, listener }
+// - 'off' when unsubscribing, { object, event, listener }
+// - 'emit' for sync emit, { object, event, args, listeners }
+// - 'emitAsync' for async emit, { object, event, args, listeners }
 ```
 
 Custom error handler for listener errors:
@@ -191,7 +195,9 @@ const obj =
 
 ### Global Events
 
-`eventful` is also a global emitter. When you create an enhanced object via `eventful(target, options)`, its lifecycle and actions are traced via the per-instance `trace` hook and also emitted as global events on `eventful`.
+`eventful` is also a global emitter. When you create an enhanced object via
+`eventful(target, options)`, its lifecycle and actions are traced via the
+per-instance `trace` hook and also emitted as global events on `eventful`.
 
 ```js
 const offNew =
@@ -213,7 +219,9 @@ offNew();
 offError();
 ```
 
-Note: if a **global** `eventful.on('error', ...)` listener throws, `eventful` throws a `ListenerError` (an `Error` subclass with fields `{ error, object, event, listener }`) to avoid an infinite error loop.
+Note: if a **global** `eventful.on('error', ...)` listener throws, `eventful`
+throws a `ListenerError` (an `Error` subclass with fields
+`{ error, object, event, listener }`) to avoid an infinite error loop.
 
 ## API
 
@@ -224,8 +232,10 @@ a new empty object is created.
 
 - `target` (Object): The object to be enhanced with event capabilities.
 - `options` (Object): Configuration options.
-  - `error` (Function | null): Optional error hook called with `{ error, object, event, listener }`.
-  - `trace` (Function | null): Optional trace hook called with `(action, payload)`.
+  - `error` (Function | null): Optional error hook called with
+    `{ error, object, event, listener }`.
+  - `trace` (Function | null): Optional trace hook called with
+    `(action, payload)`.
   - `strict` (Boolean): If true, propagates listener errors; otherwise they
     are isolated. Defaults to false.
 

package/dist/eventful-base.js

@@ -0,0 +1,6 @@
+import { eventful, } from './eventful.js';
+export class EventfulBase {
+    constructor(options = {}) {
+        eventful(this, options);
+    }
+}

package/dist/eventful-base.test.js

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventfulBase, } from './eventful-base.js';
+test('EventfulBase wires eventful methods in constructor', () => {
+    class Demo extends EventfulBase {
+    }
+    const demo = new Demo();
+    let seen = null;
+    demo.on('ping', value => seen = value);
+    demo.emit('ping', 7);
+    assert.equal(seen, 7);
+});
+test('EventfulBase passes options to eventful setup', () => {
+    class Demo extends EventfulBase {
+    }
+    const demo = new Demo({ strict: true,
+        error: () => { } });
+    demo.on('boom', () => {
+        throw new Error('boom');
+    });
+    assert.throws(() => demo.emit('boom'), Error);
+});

package/dist/eventful-like.js

@@ -0,0 +1,14 @@
+import { isFunction, isObject, } from './guards.js';
+export function isEvenfulLike(value) {
+    if (!isObject(value)
+        && !isFunction(value)) {
+        return false;
+    }
+    return typeof value.on === 'function';
+}
+export function asEventfulLike(value) {
+    if (isEvenfulLike(value)) {
+        return value;
+    }
+    return undefined;
+}

package/dist/eventful-like.test.js

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { eventful, } from './eventful.js';
+import { asEventfulLike, isEvenfulLike, } from './eventful-like.js';
+test('isEvenfulLike returns true for eventful instances', () => {
+    const value = eventful();
+    assert.equal(isEvenfulLike(value), true);
+});
+test('isEvenfulLike returns true for plain object with on method', () => {
+    const value = { on: () => () => true };
+    assert.equal(isEvenfulLike(value), true);
+});
+test('isEvenfulLike returns false for non-like values', () => {
+    assert.equal(isEvenfulLike(undefined), false);
+    assert.equal(isEvenfulLike(null), false);
+    assert.equal(isEvenfulLike({}), false);
+    assert.equal(isEvenfulLike({ on: 1 }), false);
+});
+test('asEventfulLike returns value when compatible', () => {
+    const value = eventful();
+    const converted = asEventfulLike(value);
+    assert.equal(converted, value);
+    const typed = converted;
+    assert.ok(typed);
+});
+test('asEventfulLike returns undefined when incompatible', () => {
+    assert.equal(asEventfulLike({}), undefined);
+    assert.equal(asEventfulLike(42), undefined);
+});

package/dist/eventful.js

@@ -1,12 +1,13 @@
-import { ListenerError } from './types.js';
-import { eventTypeGuard, functionTypeGuard, isFunction, isObject, } from './guards.js';
+import { ListenerError, } from './types.js';
+import { asEventfulLike, isEvenfulLike, } from './eventful-like.js';
+import { eventNameTypeGuard, functionTypeGuard, isFunction, isObject, } from './guards.js';
 const eventfulImpl = (object = Object.create(null), options = {}) => {
     if (!isObject(object)
         && !isFunction(object)) {
         throw new TypeError('Expect an object or a function.');
     }
     for (const method of ['on', 'once', 'off', 'emit', 'emitAsync', 'has']) {
-        if (object[method] !== undefined) {
+        if (method in object) {
             throw new Error(`Method "${method}" already exists.`);
         }
     }
@@ -66,7 +67,7 @@ const eventfulImpl = (object = Object.create(null), options = {}) => {
         eventful.emit('error', errorArgs);
     }
     function on(event, listener) {
-        eventTypeGuard(event);
+        eventNameTypeGuard(event);
         functionTypeGuard(listener);
         traceFn('on', { object,
             event,
@@ -78,7 +79,7 @@ const eventfulImpl = (object = Object.create(null), options = {}) => {
             : false;
     }
     function once(event, listener) {
-        eventTypeGuard(event);
+        eventNameTypeGuard(event);
         functionTypeGuard(listener);
         const off = on(event, (...args) => {
             off();
@@ -87,7 +88,7 @@ const eventfulImpl = (object = Object.create(null), options = {}) => {
         return off;
     }
     function off(event, listener) {
-        eventTypeGuard(event);
+        eventNameTypeGuard(event);
         functionTypeGuard(listener);
         traceFn('off', { object,
             event,
@@ -95,11 +96,11 @@ const eventfulImpl = (object = Object.create(null), options = {}) => {
         return remove(event, listener);
     }
     function has(event) {
-        eventTypeGuard(event);
+        eventNameTypeGuard(event);
         return (map.get(event)?.size ?? 0) > 0;
     }
     function emit(event, ...args) {
-        eventTypeGuard(event);
+        eventNameTypeGuard(event);
         const listeners = map.get(event)
             || emptySet;
         traceFn('emit', { object,
@@ -120,7 +121,7 @@ const eventfulImpl = (object = Object.create(null), options = {}) => {
         }
     }
     async function emitAsync(event, ...args) {
-        eventTypeGuard(event);
+        eventNameTypeGuard(event);
         const listeners = map.get(event)
             || emptySet;
         traceFn('emitAsync', { object,
@@ -145,9 +146,5 @@ const eventfulImpl = (object = Object.create(null), options = {}) => {
     }
 };
 export const eventful = eventfulImpl;
+export { isEvenfulLike, asEventfulLike, };
 eventful(eventful);
-export class EventfulBase {
-    constructor(options = {}) {
-        eventful(this, options);
-    }
-}

package/dist/eventful.test.js

@@ -0,0 +1,206 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { eventful, } from './eventful.js';
+import { EventfulBase, } from './eventful-base.js';
+test('eventful extends an object', () => {
+    const original = {};
+    const enhanced = eventful(original);
+    assert.equal(enhanced, original);
+    assertEventfulMethods(enhanced);
+});
+test('eventful extends a function', () => {
+    const original = () => { };
+    const enhanced = eventful(original);
+    assert.equal(enhanced, original);
+    assertEventfulMethods(enhanced);
+});
+test('eventful can be called without arguments', () => {
+    const enhanced = eventful();
+    assert.ok(enhanced !== null);
+    assertEventfulMethods(enhanced);
+});
+test('eventful can be extended by inheritance', () => {
+    class MyClass extends EventfulBase {
+        constructor(name) {
+            super();
+            this.name = name;
+        }
+        greet() {
+            this.emit('greet', `Hello, ${this.name}`);
+        }
+    }
+    const instance = new MyClass('Alice');
+    let greeting = null;
+    instance.on('greet', message => greeting = message);
+    instance.greet();
+    assert.equal(greeting, 'Hello, Alice');
+});
+test('eventful can be added during construction', () => {
+    class MyClass {
+        constructor(name) {
+            eventful(this);
+            this.name = name;
+        }
+        greet() {
+            this.emit('greet', `Hello, ${this.name}`);
+        }
+    }
+    const instance = new MyClass('Alice');
+    let greeting = null;
+    instance.on('greet', message => greeting = message);
+    instance.greet();
+    assert.equal(greeting, 'Hello, Alice');
+});
+test('trace is called on creation with action "new"', () => {
+    const recorder = createRecorder();
+    const object = eventful({}, { trace: recorder.write });
+    const creation = recorder.records().find(item => item.action === 'new');
+    assert.ok(creation);
+    assert.equal(creation.payload.object, object);
+});
+test('global trace is called on creation with action "new"', () => {
+    const recorder = createRecorder();
+    const off = eventful.on('new', (...args) => recorder.write('new', args[0]));
+    try {
+        const object = eventful({}, { trace: recorder.write });
+        const creation = recorder.records().find(item => item.action === 'new');
+        assert.ok(creation);
+        assert.equal(creation.payload.object, object);
+    }
+    finally {
+        off();
+    }
+});
+test('eventful throws when an object has one of the event emitter methods', () => {
+    for (const method of ['on', 'once', 'off', 'emit', 'emitAsync', 'has']) {
+        assert.throws(() => eventful({
+            [method]: () => { }
+        }));
+    }
+});
+test('exceptions in listeners are suppressed in async emit by default', async () => {
+    const obj = eventful();
+    obj.on('test', () => { throw new Error('test error'); });
+    await assert.doesNotReject(() => obj.emitAsync('test'));
+});
+function assertEventfulMethods(object) {
+    const candidate = object;
+    assert.equal(typeof candidate.on, 'function');
+    assert.equal(typeof candidate.off, 'function');
+    assert.equal(typeof candidate.emit, 'function');
+    assert.equal(typeof candidate.emitAsync, 'function');
+    assert.equal(typeof candidate.has, 'function');
+}
+test('exceptions in listeners are suppressed in async emit by default', async () => {
+    const obj = eventful();
+    obj.on('test', () => { throw new Error('test error'); });
+    await assert.doesNotReject(() => obj.emitAsync('test'));
+});
+test('exceptions in listeners are suppressed in emit by default', () => {
+    const obj = eventful();
+    obj.on('test', () => { throw new Error('test error'); });
+    assert.doesNotThrow(() => obj.emit('test'));
+});
+test('strict mode propagates exceptions in listeners in async emit', async () => {
+    const obj = eventful({}, { error: () => { },
+        strict: true });
+    obj.on('test', () => { throw new Error('test error'); });
+    await assert.rejects(() => obj.emitAsync('test'));
+});
+test('strict mode propagates exceptions in listeners in emit', () => {
+    const obj = eventful({}, { error: () => { },
+        strict: true });
+    obj.on('test', () => { throw new Error('test error'); });
+    assert.throws(() => obj.emit('test'), Error);
+});
+test('non-strict runs other listeners even if one fails', async () => {
+    const obj = eventful({}, { error: () => { } });
+    let ran = 0;
+    obj.on('test', () => ran += 1);
+    obj.on('test', () => { throw new Error('boom'); });
+    obj.on('test', () => ran += 1);
+    await assert.doesNotReject(() => obj.emitAsync('test'));
+    assert.equal(ran, 2);
+});
+test('trace receives safe payload and action names', async () => {
+    const recorder = createRecorder();
+    const obj = eventful({}, { trace: recorder.write });
+    const off = obj.on('e', () => { });
+    obj.emit('e', 1, 2);
+    await obj.emitAsync('e', 3, 4);
+    off();
+    assert.ok(recorder.records().find(item => item.action === 'on'));
+    assert.ok(recorder.records().find(item => item.action === 'emit'));
+    assert.ok(recorder.records().find(item => item.action === 'emitAsync'));
+    const emitTrace = recorder.records().find(item => item.action === 'emit');
+    assert.ok(emitTrace);
+    assert.ok(Array.isArray(emitTrace.payload.listeners));
+    assert.equal(emitTrace.payload.event, 'e');
+    assert.deepEqual(emitTrace.payload.args, [1, 2]);
+    const emitAsyncTrace = recorder.records().find(item => item.action === 'emitAsync');
+    assert.ok(emitAsyncTrace);
+    assert.ok(Array.isArray(emitAsyncTrace.payload.listeners));
+    assert.equal(emitAsyncTrace.payload.event, 'e');
+    assert.deepEqual(emitAsyncTrace.payload.args, [3, 4]);
+});
+test('error hook runs for async rejection (non-strict)', async () => {
+    let errors = 0;
+    const obj = eventful({}, { error: () => errors += 1 });
+    obj.on('e', async () => { throw new Error('reject'); });
+    await assert.doesNotReject(() => obj.emitAsync('e'));
+    assert.equal(errors, 1);
+});
+test('has reflects subscribe and unsubscribe', () => {
+    const obj = eventful();
+    assert.equal(obj.has('x'), false);
+    const off = obj.on('x', () => { });
+    assert.equal(obj.has('x'), true);
+    off();
+    assert.equal(obj.has('x'), false);
+});
+test('strict mode propagates async rejections', async () => {
+    const obj = eventful({}, { error: () => { },
+        strict: true });
+    obj.on('e', async () => { throw new Error('nope'); });
+    await assert.rejects(() => obj.emitAsync('e'));
+});
+test('emit ignores errors when no error hook (non-strict)', () => {
+    const obj = eventful();
+    obj.on('x', () => { throw new Error('boom'); });
+    assert.doesNotThrow(() => obj.emit('x'));
+});
+test('throw in global error listener does not loop', () => {
+    let globalErrorCalls = 0;
+    const off = eventful.on('error', () => {
+        globalErrorCalls += 1;
+        if (globalErrorCalls > 1)
+            throw new Error('global error listener loop');
+        throw new Error('boom');
+    });
+    try {
+        const obj = eventful();
+        obj.on('e', () => { throw new Error('listener failed'); });
+        assert.throws(() => obj.emit('e'), Error);
+        assert.equal(globalErrorCalls, 1);
+    }
+    finally {
+        off();
+    }
+});
+test('event must be string or symbol', () => {
+    const obj = eventful();
+    assert.throws(() => obj.on(123, () => { }), TypeError);
+    assert.throws(() => obj.emit(123), TypeError);
+    const s = Symbol('e');
+    assert.doesNotThrow(() => obj.on(s, () => { }));
+    assert.doesNotThrow(() => obj.emit(s));
+});
+export function createRecorder() {
+    const records = [];
+    return {
+        write: (action, payload) => {
+            records.push({ action, payload });
+        },
+        records: () => records
+    };
+}

package/dist/guards.js

@@ -1,4 +1,4 @@
-export function eventTypeGuard(value) {
+export function eventNameTypeGuard(value) {
     if (typeof value !== 'string'
         && typeof value !== 'symbol') {
         throw new TypeError('Expect event to be a string or symbol.');

package/dist/guards.test.js

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { eventNameTypeGuard, functionTypeGuard, isFunction, isObject, } from './guards.js';
+test('eventNameTypeGuard accepts string and symbol', () => {
+    assert.doesNotThrow(() => eventNameTypeGuard('event'));
+    assert.doesNotThrow(() => eventNameTypeGuard(Symbol('event')));
+});
+test('eventNameTypeGuard throws for invalid values', () => {
+    assert.throws(() => eventNameTypeGuard(42), TypeError);
+    assert.throws(() => eventNameTypeGuard(null), TypeError);
+});
+test('isFunction returns expected result', () => {
+    assert.equal(isFunction(() => { }), true);
+    assert.equal(isFunction({}), false);
+});
+test('isObject returns expected result', () => {
+    assert.equal(isObject({ key: 'value' }), true);
+    assert.equal(isObject(null), false);
+    assert.equal(isObject(() => { }), false);
+});
+test('functionTypeGuard validates value', () => {
+    assert.doesNotThrow(() => functionTypeGuard(() => { }));
+    assert.throws(() => functionTypeGuard('nope'), TypeError);
+});

package/dist/types.test.js

@@ -0,0 +1,16 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { ListenerError, } from './types.js';
+test('ListenerError extends Error and stores context', () => {
+    const inner = new Error('inner');
+    const object = { id: 1 };
+    const listener = () => { };
+    const error = new ListenerError('failed', inner, object, 'test', listener);
+    assert.ok(error instanceof Error);
+    assert.equal(error.name, 'ListenerError');
+    assert.equal(error.message, 'failed');
+    assert.equal(error.error, inner);
+    assert.equal(error.object, object);
+    assert.equal(error.event, 'test');
+    assert.equal(error.listener, listener);
+});

package/eventful.d.ts

@@ -1,15 +1,24 @@
 export {
   eventful,
-  EventfulBase
+  isEvenfulLike,
+  asEventfulLike
 } from './dist/eventful.js';
 
+export {
+  EventfulBase
+} from './dist/eventful-base.js';
+
 export type {
-  EventName,
-  EventMap,
-  Eventful,
-  EventfulFactory,
-  EventfulOptions,
-  Listener,
+  EventfulLike
+} from './dist/eventful-like.js';
+
+export {
+  type EventName,
+  type EventMap,
+  type Eventful,
+  type EventfulFactory,
+  type EventfulOptions,
+  type Listener,
   ListenerError,
-  TraceFn
+  type TraceFn
 } from './dist/types.js';

package/eventful.js

@@ -1,4 +1,13 @@
 export {
   eventful,
-  EventfulBase
+  isEvenfulLike,
+  asEventfulLike,
 } from './dist/eventful.js';
+
+export {
+  EventfulBase,
+} from './dist/eventful-base.js';
+
+export {
+    ListenerError
+  } from './dist/types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asljs-eventful",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "description": "Lightweight event helper adding on/off/emit to any object.",
   "files": [
     "dist/**",
@@ -37,13 +37,14 @@
     "doc": "docs"
   },
   "scripts": {
-    "build": "tsc -p .",
-    "build:tests": "tsc -p tsconfig.tests.json",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "prepack": "npm run build",
-    "test": "npm run build && npm run build:tests && node --test .tests/*.test.js",
-    "test:watch": "npm run build && npm run build:tests && node --watch --test .tests/*.test.js",
-    "coverage": "npm run build && npm run build:tests && NODE_V8_COVERAGE=.coverage node --test .tests/*.test.js && node -e \"console.log('Coverage in .coverage (use c8/istanbul if you want reports)')\""
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npx tsc -p tsconfig.json",
+    "build:test": "npx tsc -p tsconfig.test.json",
+    "lint": "npx eslint .",
+    "lint:fix": "npx eslint . --fix",
+    "prepack": "npm run clean && npm run build",
+    "test": "npm run build:test && node --test dist/*.test.js",
+    "test:watch": "npm run build:test && node --watch --test dist/*.test.js",
+    "coverage": "npm run build:test && NODE_V8_COVERAGE=.coverage node --test dist/*.test.js && node -e \"console.log('Coverage in .coverage (use c8/istanbul if you want reports)')\""
   }
 }

package/dist/eventful.d.ts

@@ -1,11 +0,0 @@
-import type { EventMap, Eventful, EventfulFn, EventfulOptions } from './types.js';
-export declare const eventful: EventfulFn;
-export declare class EventfulBase<E extends EventMap = EventMap> implements Eventful<E> {
-    on: Eventful<E>['on'];
-    once: Eventful<E>['once'];
-    off: Eventful<E>['off'];
-    emit: Eventful<E>['emit'];
-    emitAsync: Eventful<E>['emitAsync'];
-    has: Eventful<E>['has'];
-    constructor(options?: EventfulOptions);
-}

package/dist/guards.d.ts

@@ -1,5 +0,0 @@
-import type { EventName } from './types.js';
-export declare function eventTypeGuard(value: any): asserts value is EventName;
-export declare function isFunction(value: any): value is Function;
-export declare function isObject(value: any): value is object;
-export declare function functionTypeGuard(value: any): asserts value is Function;

package/dist/types.d.ts

@@ -1,97 +0,0 @@
-export type EventName = string | symbol;
-export type EventMap = Record<EventName, any[]>;
-export type Listener<Args extends any[] = any[]> = (...args: Args) => any;
-export interface ListenerErrorArgs {
-    error: any;
-    object: object | Function;
-    event: EventName;
-    listener: Function;
-}
-export declare class ListenerError extends Error implements ListenerErrorArgs {
-    error: any;
-    object: object | Function;
-    event: EventName;
-    listener: Function;
-    constructor(message: string, error: any, object: object | Function, event: EventName, listener: Function);
-}
-type TraceAction = 'new' | 'on' | 'off' | 'emit' | 'emitAsync';
-type TracePayloadByAction = {
-    new: {
-        object: object | Function;
-    };
-    on: {
-        object: object | Function;
-        event: EventName;
-        listener: Function;
-    };
-    off: {
-        object: object | Function;
-        event: EventName;
-        listener: Function;
-    };
-    emit: {
-        object: object | Function;
-        listeners: Function[];
-        event: EventName;
-        args: any[];
-    };
-    emitAsync: {
-        object: object | Function;
-        listeners: Function[];
-        event: EventName;
-        args: any[];
-    };
-};
-export type TraceFn = <A extends TraceAction>(action: A, args: TracePayloadByAction[A]) => void;
-export type EventfulFn = EventfulFactory & Eventful;
-export interface EventfulFactory {
-    <T extends object | Function | undefined, E extends EventMap = EventMap>(object?: T, options?: EventfulOptions): (T extends undefined ? {} : T) & Eventful<E>;
-}
-export interface EventfulOptions {
-    /**
-     * If true, exceptions from listeners are propagated (fail fast).
-     * When false, errors are isolated (ignored) after calling `error` hook.
-     */
-    strict?: boolean;
-    /**
-     * Optional tracing hook. Receives action name and a safe payload.
-     * Actions include: 'new', 'on', 'off', 'emit', 'emitAsync'.
-     * Use to integrate with your logger without exposing internals.
-     */
-    trace?: TraceFn | null;
-    /**
-     * Optional error hook. Receives structured context of listener failures
-     * (error, object, event, listener). Called for sync and async errors.
-     */
-    error?: ((error: ListenerErrorArgs) => void) | null;
-}
-export interface Eventful<E extends EventMap = EventMap> {
-    /**
-     * Subscribe to an event. Returns an unsubscribe function.
-     */
-    on(event: keyof E & EventName, listener: Listener<E[keyof E & EventName]>): () => boolean;
-    /**
-     * Subscribe once to an event. Returns an unsubscribe function
-     * (called automatically).
-     */
-    once(event: keyof E & EventName, listener: Listener<E[keyof E & EventName]>): () => boolean;
-    /**
-     * Unsubscribe a previously registered listener. Returns true if removed.
-     */
-    off(event: keyof E & EventName, listener: Listener<E[keyof E & EventName]>): boolean;
-    /**
-     * Emit an event synchronously. All listeners run in order.
-     * Errors are isolated (ignored) unless `strict` is true.
-     */
-    emit(event: keyof E & EventName, ...args: E[keyof E & EventName]): void;
-    /**
-     * Emit an event and wait for all listeners (run in parallel).
-     * Errors are isolated (ignored) unless `strict` is true.
-     */
-    emitAsync(event: keyof E & EventName, ...args: E[keyof E & EventName]): Promise<void>;
-    /**
-     * Returns true if there is at least one listener for the event.
-     */
-    has(event: keyof E & EventName): boolean;
-}
-export {};