evnty 5.0.0 → 5.0.1-rc.0

package/README.md

@@ -23,7 +23,7 @@ Async-first, reactive event handling library for complex event flows with three
 - [Features](#features)
 - [Platform Support](#platform-support)
 - [Installing](#installing)
-- [Documentation](https://3axap4ehko.github.io/evnty/)
+- [Documentation](https://3axap4ehko.github.io/evnty/) <!--API_TOC-->
 - [Examples](#examples)
 - [License](#license)
 
@@ -113,17 +113,17 @@ Traditional event handling in JavaScript/TypeScript has limitations:
 Evnty solves these problems by providing:
 - **Type-safe events** with full TypeScript inference
 - **Three specialized primitives** for different async patterns
-- **Rich functional operators** (map, filter, reduce, debounce, batch, etc.)
+- **Async iterator transformations** via `AsyncIteratorObject` (map, filter, reduce, expand, etc.)
 - **Composable abstractions** that work together seamlessly
 
 ## Features
 
 - **Async-First Design**: Built from the ground up for asynchronous event handling with full Promise support
-- **Functional Programming**: Rich set of operators including map, filter, reduce, debounce, batch, and expand for event stream transformations
+- **Iterator Transformations**: `AsyncIteratorObject` provides map, filter, reduce, take, drop, flatMap, and expand operators
 - **Type-Safe**: Full TypeScript support with strong typing and inference throughout the event pipeline
-- **Async Iteration**: Events can be consumed as async iterables using for-await-of loops
-- **Event Composition**: Merge, combine, and transform multiple event streams into new events
-- **Minimal Dependencies**: Lightweight with only essential dependencies for optimal bundle size
+- **Async Iteration**: Events, Signals, and Sequences can be consumed as async iterables using for-await-of loops
+- **Event Composition**: Merge multiple event streams into unified events
+- **Zero Dependencies**: Lightweight with no external dependencies for optimal bundle size
 - **Universal**: Works seamlessly in both browser and Node.js environments, including service workers
 
 ## Platform Support
@@ -176,10 +176,8 @@ userEvent.on(user => saveToCache(user));
 // Emit - all listeners are called
 userEvent({ id: 1, name: 'Alice' });
 
-// Functional transformations
-const adminEvent = userEvent
-  .filter(user => user.id < 100)
-  .map(user => ({ ...user, role: 'admin' }));
+// One-time listener
+userEvent.once(user => console.log('First user only:', user));
 
 // Async iteration
 for await (const user of userEvent) {
@@ -260,6 +258,8 @@ for await (const data of processQueue) {
 }
 ```
 
+<!--API_REFERENCE-->
+
 ## License
 
 License [The MIT License](./LICENSE)

package/build/__bench__/event.cjs

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+require("overtake");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const suite = benchmark('evnty benchmark', ()=>({}));
+const current = suite.target('current Event', async ()=>{
+    const { Event } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../../build/index.js")));
+    const event = new Event();
+    const events = new Event();
+    let i = 1000;
+    while(i--){
+        events.on(()=>{});
+    }
+    const gc = [];
+    return {
+        Event,
+        gc,
+        event,
+        events
+    };
+});
+current.measure('instantiation', ({ Event, gc })=>{
+    gc.push(new Event());
+});
+current.measure('invoke', ({ event, gc })=>{
+    gc.push(event());
+});
+current.measure('invokes', ({ events, gc })=>{
+    gc.push(events());
+});
+const release = suite.target('release Event', async ()=>{
+    const { Event } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("evnty")));
+    const event = new Event();
+    const events = new Event();
+    let i = 10000;
+    while(i--){
+        events.on(()=>{});
+    }
+    const gc = [];
+    return {
+        Event,
+        gc,
+        event,
+        events
+    };
+});
+release.measure('instantiation', ({ Event, gc })=>{
+    gc.push(new Event());
+});
+release.measure('invoke', ({ event, gc })=>{
+    gc.push(event());
+});
+release.measure('invokes', ({ events, gc })=>{
+    gc.push(events());
+});
+
+//# sourceMappingURL=event.cjs.map

package/build/__bench__/event.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/__bench__/event.ts"],"sourcesContent":["import 'overtake';\n\nconst suite = benchmark('evnty benchmark', () => ({}));\n\nconst current = suite.target('current Event', async () => {\n  const { Event } = await import('../../build/index.js');\n  const event = new Event<void>();\n  const events = new Event<void>();\n  let i = 1000;\n  while (i--) {\n    events.on(() => {});\n  }\n  const gc: unknown[] = [];\n  return { Event, gc, event, events };\n});\n\ncurrent.measure('instantiation', ({ Event, gc }) => {\n  gc.push(new Event());\n});\n\ncurrent.measure('invoke', ({ event, gc }) => {\n  gc.push(event());\n});\n\ncurrent.measure('invokes', ({ events, gc }) => {\n  gc.push(events());\n});\n\nconst release = suite.target('release Event', async () => {\n  const { Event } = await import('evnty');\n  const event = new Event<void>();\n  const events = new Event<void>();\n  let i = 10000;\n  while (i--) {\n    events.on(() => {});\n  }\n  const gc: unknown[] = [];\n  return { Event, gc, event, events };\n});\n\nrelease.measure('instantiation', ({ Event, gc }) => {\n  gc.push(new Event());\n});\n\nrelease.measure('invoke', ({ event, gc }) => {\n  gc.push(event());\n});\n\nrelease.measure('invokes', ({ events, gc }) => {\n  gc.push(events());\n});\n\n"],"names":["suite","benchmark","current","target","Event","event","events","i","on","gc","measure","push","release"],"mappings":";;;;QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEP,MAAMA,QAAQC,UAAU,mBAAmB,IAAO,CAAA,CAAC,CAAA;AAEnD,MAAMC,UAAUF,MAAMG,MAAM,CAAC,iBAAiB;IAC5C,MAAM,EAAEC,KAAK,EAAE,GAAG,MAAM,mEAAA,QAAO;IAC/B,MAAMC,QAAQ,IAAID;IAClB,MAAME,SAAS,IAAIF;IACnB,IAAIG,IAAI;IACR,MAAOA,IAAK;QACVD,OAAOE,EAAE,CAAC,KAAO;IACnB;IACA,MAAMC,KAAgB,EAAE;IACxB,OAAO;QAAEL;QAAOK;QAAIJ;QAAOC;IAAO;AACpC;AAEAJ,QAAQQ,OAAO,CAAC,iBAAiB,CAAC,EAAEN,KAAK,EAAEK,EAAE,EAAE;IAC7CA,GAAGE,IAAI,CAAC,IAAIP;AACd;AAEAF,QAAQQ,OAAO,CAAC,UAAU,CAAC,EAAEL,KAAK,EAAEI,EAAE,EAAE;IACtCA,GAAGE,IAAI,CAACN;AACV;AAEAH,QAAQQ,OAAO,CAAC,WAAW,CAAC,EAAEJ,MAAM,EAAEG,EAAE,EAAE;IACxCA,GAAGE,IAAI,CAACL;AACV;AAEA,MAAMM,UAAUZ,MAAMG,MAAM,CAAC,iBAAiB;IAC5C,MAAM,EAAEC,KAAK,EAAE,GAAG,MAAM,mEAAA,QAAO;IAC/B,MAAMC,QAAQ,IAAID;IAClB,MAAME,SAAS,IAAIF;IACnB,IAAIG,IAAI;IACR,MAAOA,IAAK;QACVD,OAAOE,EAAE,CAAC,KAAO;IACnB;IACA,MAAMC,KAAgB,EAAE;IACxB,OAAO;QAAEL;QAAOK;QAAIJ;QAAOC;IAAO;AACpC;AAEAM,QAAQF,OAAO,CAAC,iBAAiB,CAAC,EAAEN,KAAK,EAAEK,EAAE,EAAE;IAC7CA,GAAGE,IAAI,CAAC,IAAIP;AACd;AAEAQ,QAAQF,OAAO,CAAC,UAAU,CAAC,EAAEL,KAAK,EAAEI,EAAE,EAAE;IACtCA,GAAGE,IAAI,CAACN;AACV;AAEAO,QAAQF,OAAO,CAAC,WAAW,CAAC,EAAEJ,MAAM,EAAEG,EAAE,EAAE;IACxCA,GAAGE,IAAI,CAACL;AACV"}

package/build/__bench__/event.js

@@ -0,0 +1,54 @@
+import 'overtake';
+const suite = benchmark('evnty benchmark', ()=>({}));
+const current = suite.target('current Event', async ()=>{
+    const { Event } = await import('../../build/index.js');
+    const event = new Event();
+    const events = new Event();
+    let i = 1000;
+    while(i--){
+        events.on(()=>{});
+    }
+    const gc = [];
+    return {
+        Event,
+        gc,
+        event,
+        events
+    };
+});
+current.measure('instantiation', ({ Event, gc })=>{
+    gc.push(new Event());
+});
+current.measure('invoke', ({ event, gc })=>{
+    gc.push(event());
+});
+current.measure('invokes', ({ events, gc })=>{
+    gc.push(events());
+});
+const release = suite.target('release Event', async ()=>{
+    const { Event } = await import('evnty');
+    const event = new Event();
+    const events = new Event();
+    let i = 10000;
+    while(i--){
+        events.on(()=>{});
+    }
+    const gc = [];
+    return {
+        Event,
+        gc,
+        event,
+        events
+    };
+});
+release.measure('instantiation', ({ Event, gc })=>{
+    gc.push(new Event());
+});
+release.measure('invoke', ({ event, gc })=>{
+    gc.push(event());
+});
+release.measure('invokes', ({ events, gc })=>{
+    gc.push(events());
+});
+
+//# sourceMappingURL=event.js.map

package/build/__bench__/event.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/__bench__/event.ts"],"sourcesContent":["import 'overtake';\n\nconst suite = benchmark('evnty benchmark', () => ({}));\n\nconst current = suite.target('current Event', async () => {\n  const { Event } = await import('../../build/index.js');\n  const event = new Event<void>();\n  const events = new Event<void>();\n  let i = 1000;\n  while (i--) {\n    events.on(() => {});\n  }\n  const gc: unknown[] = [];\n  return { Event, gc, event, events };\n});\n\ncurrent.measure('instantiation', ({ Event, gc }) => {\n  gc.push(new Event());\n});\n\ncurrent.measure('invoke', ({ event, gc }) => {\n  gc.push(event());\n});\n\ncurrent.measure('invokes', ({ events, gc }) => {\n  gc.push(events());\n});\n\nconst release = suite.target('release Event', async () => {\n  const { Event } = await import('evnty');\n  const event = new Event<void>();\n  const events = new Event<void>();\n  let i = 10000;\n  while (i--) {\n    events.on(() => {});\n  }\n  const gc: unknown[] = [];\n  return { Event, gc, event, events };\n});\n\nrelease.measure('instantiation', ({ Event, gc }) => {\n  gc.push(new Event());\n});\n\nrelease.measure('invoke', ({ event, gc }) => {\n  gc.push(event());\n});\n\nrelease.measure('invokes', ({ events, gc }) => {\n  gc.push(events());\n});\n\n"],"names":["suite","benchmark","current","target","Event","event","events","i","on","gc","measure","push","release"],"mappings":"AAAA,OAAO,WAAW;AAElB,MAAMA,QAAQC,UAAU,mBAAmB,IAAO,CAAA,CAAC,CAAA;AAEnD,MAAMC,UAAUF,MAAMG,MAAM,CAAC,iBAAiB;IAC5C,MAAM,EAAEC,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC;IAC/B,MAAMC,QAAQ,IAAID;IAClB,MAAME,SAAS,IAAIF;IACnB,IAAIG,IAAI;IACR,MAAOA,IAAK;QACVD,OAAOE,EAAE,CAAC,KAAO;IACnB;IACA,MAAMC,KAAgB,EAAE;IACxB,OAAO;QAAEL;QAAOK;QAAIJ;QAAOC;IAAO;AACpC;AAEAJ,QAAQQ,OAAO,CAAC,iBAAiB,CAAC,EAAEN,KAAK,EAAEK,EAAE,EAAE;IAC7CA,GAAGE,IAAI,CAAC,IAAIP;AACd;AAEAF,QAAQQ,OAAO,CAAC,UAAU,CAAC,EAAEL,KAAK,EAAEI,EAAE,EAAE;IACtCA,GAAGE,IAAI,CAACN;AACV;AAEAH,QAAQQ,OAAO,CAAC,WAAW,CAAC,EAAEJ,MAAM,EAAEG,EAAE,EAAE;IACxCA,GAAGE,IAAI,CAACL;AACV;AAEA,MAAMM,UAAUZ,MAAMG,MAAM,CAAC,iBAAiB;IAC5C,MAAM,EAAEC,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC;IAC/B,MAAMC,QAAQ,IAAID;IAClB,MAAME,SAAS,IAAIF;IACnB,IAAIG,IAAI;IACR,MAAOA,IAAK;QACVD,OAAOE,EAAE,CAAC,KAAO;IACnB;IACA,MAAMC,KAAgB,EAAE;IACxB,OAAO;QAAEL;QAAOK;QAAIJ;QAAOC;IAAO;AACpC;AAEAM,QAAQF,OAAO,CAAC,iBAAiB,CAAC,EAAEN,KAAK,EAAEK,EAAE,EAAE;IAC7CA,GAAGE,IAAI,CAAC,IAAIP;AACd;AAEAQ,QAAQF,OAAO,CAAC,UAAU,CAAC,EAAEL,KAAK,EAAEI,EAAE,EAAE;IACtCA,GAAGE,IAAI,CAACN;AACV;AAEAO,QAAQF,OAAO,CAAC,WAAW,CAAC,EAAEJ,MAAM,EAAEG,EAAE,EAAE;IACxCA,GAAGE,IAAI,CAACL;AACV"}

package/build/callable.cjs

@@ -58,12 +58,12 @@ class CallableAsyncIterator extends AsyncCallable {
                     };
                 }
             },
-            return: ()=>{
-                this[Symbol.dispose]();
-                return Promise.resolve({
+            return: async ()=>{
+                await this.return?.();
+                return {
                     value: undefined,
                     done: true
-                });
+                };
             }
         };
     }

package/build/callable.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/callable.ts"],"sourcesContent":["import { Fn, Promiseable } from './types.js';\n/**\n * @internal\n */\nexport interface Callable<T extends unknown[], R> {\n  (...args: T): R;\n}\n\n/**\n * An abstract class that extends the built-in Function class. It allows instances of the class\n * to be called as functions. When an instance of Callable is called as a function, it will\n * call the function passed to its constructor with the same arguments.\n * @internal\n */\n\nexport abstract class Callable<T, R> {\n  static {\n    Object.setPrototypeOf(Callable.prototype, Function.prototype);\n  }\n\n  constructor(func: Fn<T, R>) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\n/**\n * @internal\n */\nexport abstract class AsyncCallable<T, R> extends Callable<[T], R> implements Promiseable<T>, Promise<T> {\n  constructor(func: Fn<[T], R>) {\n    super(func);\n  }\n\n  abstract [Symbol.toStringTag]: string;\n  abstract next(): Promise<T>;\n\n  catch<OK = never>(onrejected?: ((reason: any) => OK | PromiseLike<OK>) | null): Promise<T | OK> {\n    return this.next().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    return this.next().finally(onfinally);\n  }\n\n  then<OK = T, ERR = never>(\n    onfulfilled?: ((value: T) => OK | PromiseLike<OK>) | null,\n    onrejected?: ((reason: unknown) => ERR | PromiseLike<ERR>) | null,\n  ): Promise<OK | ERR> {\n    return this.next().then(onfulfilled, onrejected);\n  }\n}\n\n/**\n * @internal\n */\nexport abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T>, Disposable {\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return {\n      next: async () => {\n        try {\n          const value = await this.next();\n          return { value, done: false };\n        } catch {\n          return { value: undefined, done: true };\n        }\n      },\n      return: () => {\n        this[Symbol.dispose]();\n        return Promise.resolve({ value: undefined, done: true });\n      },\n    };\n  }\n  abstract [Symbol.dispose](): void;\n}\n"],"names":["AsyncCallable","Callable","CallableAsyncIterator","Object","setPrototypeOf","prototype","Function","func","catch","onrejected","next","finally","onfinally","then","onfulfilled","Symbol","asyncIterator","value","done","undefined","return","dispose","Promise","resolve"],"mappings":";;;;;;;;;;;QA6BsBA;eAAAA;;QAdAC;eAAAA;;QAyCAC;eAAAA;;;AAzCf,MAAeD;IACpB,MAAO;QACLE,OAAOC,cAAc,CAACH,SAASI,SAAS,EAAEC,SAASD,SAAS;IAC9D,CAAC;IAED,YAAYE,IAAc,CAAE;QAE1B,OAAOJ,OAAOC,cAAc,CAACG,MAAM,WAAWF,SAAS;IACzD;AACF;AAKO,MAAeL,sBAA4BC;IAChD,YAAYM,IAAgB,CAAE;QAC5B,KAAK,CAACA;IACR;IAKAC,MAAkBC,UAA2D,EAAmB;QAC9F,OAAO,IAAI,CAACC,IAAI,GAAGF,KAAK,CAACC;IAC3B;IAEAE,QAAQC,SAA+B,EAAc;QACnD,OAAO,IAAI,CAACF,IAAI,GAAGC,OAAO,CAACC;IAC7B;IAEAC,KACEC,WAAyD,EACzDL,UAAiE,EAC9C;QACnB,OAAO,IAAI,CAACC,IAAI,GAAGG,IAAI,CAACC,aAAaL;IACvC;AACF;AAKO,MAAeP,8BAAoCF;IACxD,CAACe,OAAOC,aAAa,CAAC,GAAiC;QACrD,OAAO;YACLN,MAAM;gBACJ,IAAI;oBACF,MAAMO,QAAQ,MAAM,IAAI,CAACP,IAAI;oBAC7B,OAAO;wBAAEO;wBAAOC,MAAM;oBAAM;gBAC9B,EAAE,OAAM;oBACN,OAAO;wBAAED,OAAOE;wBAAWD,MAAM;oBAAK;gBACxC;YACF;YACAE,QAAQ;gBACN,IAAI,CAACL,OAAOM,OAAO,CAAC;gBACpB,OAAOC,QAAQC,OAAO,CAAC;oBAAEN,OAAOE;oBAAWD,MAAM;gBAAK;YACxD;QACF;IACF;AAEF"}
+{"version":3,"sources":["../src/callable.ts"],"sourcesContent":["import { Fn, Promiseable } from './types.js';\n\n/**\n * Makes subclasses callable like plain functions by returning the provided delegate\n * with the subclass prototype applied. Instances can be invoked directly while\n * retaining class semantics.\n * @internal\n */\nexport interface Callable<T extends unknown[], R> {\n  (...args: T): R;\n}\n\n/**\n * An abstract class that extends the built-in Function class. It allows instances of the class\n * to be called as functions. When an instance of Callable is called as a function, it will\n * call the function passed to its constructor with the same arguments.\n * @internal\n */\n\nexport abstract class Callable<T, R> {\n  static {\n    Object.setPrototypeOf(Callable.prototype, Function.prototype);\n  }\n\n  constructor(func: Fn<T, R>) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\n/**\n * Promise-like callable base. Subclasses implement `next()`, and the Promise methods\n * delegate to that, so instances can be awaited or chained while remaining callable.\n * @internal\n */\nexport abstract class AsyncCallable<T, R> extends Callable<[T], R> implements Promiseable<T>, Promise<T> {\n  constructor(func: Fn<[T], R>) {\n    super(func);\n  }\n\n  abstract [Symbol.toStringTag]: string;\n  abstract next(): Promise<T>;\n\n  catch<OK = never>(onrejected?: ((reason: any) => OK | PromiseLike<OK>) | null): Promise<T | OK> {\n    return this.next().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    return this.next().finally(onfinally);\n  }\n\n  then<OK = T, ERR = never>(\n    onfulfilled?: ((value: T) => OK | PromiseLike<OK>) | null,\n    onrejected?: ((reason: unknown) => ERR | PromiseLike<ERR>) | null,\n  ): Promise<OK | ERR> {\n    return this.next().then(onfulfilled, onrejected);\n  }\n}\n\n/**\n * Callable async iterator base. Adds `for await` support and disposal on return\n * while delegating iteration to `next()`. Subclasses become callable, awaitable,\n * and async-iterable with a single `next()` implementation.\n * @internal\n */\nexport abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T> {\n  return?(): Promise<undefined>;\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return {\n      next: async () => {\n        try {\n          const value = await this.next();\n          return { value, done: false };\n        } catch {\n          return { value: undefined, done: true };\n        }\n      },\n      return: async () => {\n        await this.return?.();\n        return { value: undefined, done: true };\n      },\n    };\n  }\n}\n"],"names":["AsyncCallable","Callable","CallableAsyncIterator","Object","setPrototypeOf","prototype","Function","func","catch","onrejected","next","finally","onfinally","then","onfulfilled","Symbol","asyncIterator","value","done","undefined","return"],"mappings":";;;;;;;;;;;QAmCsBA;eAAAA;;QAhBAC;eAAAA;;QA8CAC;eAAAA;;;AA9Cf,MAAeD;IACpB,MAAO;QACLE,OAAOC,cAAc,CAACH,SAASI,SAAS,EAAEC,SAASD,SAAS;IAC9D,CAAC;IAED,YAAYE,IAAc,CAAE;QAE1B,OAAOJ,OAAOC,cAAc,CAACG,MAAM,WAAWF,SAAS;IACzD;AACF;AAOO,MAAeL,sBAA4BC;IAChD,YAAYM,IAAgB,CAAE;QAC5B,KAAK,CAACA;IACR;IAKAC,MAAkBC,UAA2D,EAAmB;QAC9F,OAAO,IAAI,CAACC,IAAI,GAAGF,KAAK,CAACC;IAC3B;IAEAE,QAAQC,SAA+B,EAAc;QACnD,OAAO,IAAI,CAACF,IAAI,GAAGC,OAAO,CAACC;IAC7B;IAEAC,KACEC,WAAyD,EACzDL,UAAiE,EAC9C;QACnB,OAAO,IAAI,CAACC,IAAI,GAAGG,IAAI,CAACC,aAAaL;IACvC;AACF;AAQO,MAAeP,8BAAoCF;IAGxD,CAACe,OAAOC,aAAa,CAAC,GAAiC;QACrD,OAAO;YACLN,MAAM;gBACJ,IAAI;oBACF,MAAMO,QAAQ,MAAM,IAAI,CAACP,IAAI;oBAC7B,OAAO;wBAAEO;wBAAOC,MAAM;oBAAM;gBAC9B,EAAE,OAAM;oBACN,OAAO;wBAAED,OAAOE;wBAAWD,MAAM;oBAAK;gBACxC;YACF;YACAE,QAAQ;gBACN,MAAM,IAAI,CAACA,MAAM;gBACjB,OAAO;oBAAEH,OAAOE;oBAAWD,MAAM;gBAAK;YACxC;QACF;IACF;AACF"}

package/build/callable.d.ts

@@ -1,5 +1,8 @@
 import { Fn, Promiseable } from './types.js';
 /**
+ * Makes subclasses callable like plain functions by returning the provided delegate
+ * with the subclass prototype applied. Instances can be invoked directly while
+ * retaining class semantics.
  * @internal
  */
 export interface Callable<T extends unknown[], R> {
@@ -15,6 +18,8 @@ export declare abstract class Callable<T, R> {
     constructor(func: Fn<T, R>);
 }
 /**
+ * Promise-like callable base. Subclasses implement `next()`, and the Promise methods
+ * delegate to that, so instances can be awaited or chained while remaining callable.
  * @internal
  */
 export declare abstract class AsyncCallable<T, R> extends Callable<[T], R> implements Promiseable<T>, Promise<T> {
@@ -26,9 +31,12 @@ export declare abstract class AsyncCallable<T, R> extends Callable<[T], R> imple
     then<OK = T, ERR = never>(onfulfilled?: ((value: T) => OK | PromiseLike<OK>) | null, onrejected?: ((reason: unknown) => ERR | PromiseLike<ERR>) | null): Promise<OK | ERR>;
 }
 /**
+ * Callable async iterator base. Adds `for await` support and disposal on return
+ * while delegating iteration to `next()`. Subclasses become callable, awaitable,
+ * and async-iterable with a single `next()` implementation.
  * @internal
  */
-export declare abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T>, Disposable {
+export declare abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T> {
+    return?(): Promise<undefined>;
     [Symbol.asyncIterator](): AsyncIterator<T, void, void>;
-    abstract [Symbol.dispose](): void;
 }

package/build/callable.js

@@ -37,12 +37,12 @@ export class CallableAsyncIterator extends AsyncCallable {
                     };
                 }
             },
-            return: ()=>{
-                this[Symbol.dispose]();
-                return Promise.resolve({
+            return: async ()=>{
+                await this.return?.();
+                return {
                     value: undefined,
                     done: true
-                });
+                };
             }
         };
     }

package/build/callable.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/callable.ts"],"sourcesContent":["import { Fn, Promiseable } from './types.js';\n/**\n * @internal\n */\nexport interface Callable<T extends unknown[], R> {\n  (...args: T): R;\n}\n\n/**\n * An abstract class that extends the built-in Function class. It allows instances of the class\n * to be called as functions. When an instance of Callable is called as a function, it will\n * call the function passed to its constructor with the same arguments.\n * @internal\n */\n\nexport abstract class Callable<T, R> {\n  static {\n    Object.setPrototypeOf(Callable.prototype, Function.prototype);\n  }\n\n  constructor(func: Fn<T, R>) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\n/**\n * @internal\n */\nexport abstract class AsyncCallable<T, R> extends Callable<[T], R> implements Promiseable<T>, Promise<T> {\n  constructor(func: Fn<[T], R>) {\n    super(func);\n  }\n\n  abstract [Symbol.toStringTag]: string;\n  abstract next(): Promise<T>;\n\n  catch<OK = never>(onrejected?: ((reason: any) => OK | PromiseLike<OK>) | null): Promise<T | OK> {\n    return this.next().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    return this.next().finally(onfinally);\n  }\n\n  then<OK = T, ERR = never>(\n    onfulfilled?: ((value: T) => OK | PromiseLike<OK>) | null,\n    onrejected?: ((reason: unknown) => ERR | PromiseLike<ERR>) | null,\n  ): Promise<OK | ERR> {\n    return this.next().then(onfulfilled, onrejected);\n  }\n}\n\n/**\n * @internal\n */\nexport abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T>, Disposable {\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return {\n      next: async () => {\n        try {\n          const value = await this.next();\n          return { value, done: false };\n        } catch {\n          return { value: undefined, done: true };\n        }\n      },\n      return: () => {\n        this[Symbol.dispose]();\n        return Promise.resolve({ value: undefined, done: true });\n      },\n    };\n  }\n  abstract [Symbol.dispose](): void;\n}\n"],"names":["Callable","Object","setPrototypeOf","prototype","Function","func","AsyncCallable","catch","onrejected","next","finally","onfinally","then","onfulfilled","CallableAsyncIterator","Symbol","asyncIterator","value","done","undefined","return","dispose","Promise","resolve"],"mappings":"AAeA,OAAO,MAAeA;IACpB,MAAO;QACLC,OAAOC,cAAc,CAACF,SAASG,SAAS,EAAEC,SAASD,SAAS;IAC9D,CAAC;IAED,YAAYE,IAAc,CAAE;QAE1B,OAAOJ,OAAOC,cAAc,CAACG,MAAM,WAAWF,SAAS;IACzD;AACF;AAKA,OAAO,MAAeG,sBAA4BN;IAChD,YAAYK,IAAgB,CAAE;QAC5B,KAAK,CAACA;IACR;IAKAE,MAAkBC,UAA2D,EAAmB;QAC9F,OAAO,IAAI,CAACC,IAAI,GAAGF,KAAK,CAACC;IAC3B;IAEAE,QAAQC,SAA+B,EAAc;QACnD,OAAO,IAAI,CAACF,IAAI,GAAGC,OAAO,CAACC;IAC7B;IAEAC,KACEC,WAAyD,EACzDL,UAAiE,EAC9C;QACnB,OAAO,IAAI,CAACC,IAAI,GAAGG,IAAI,CAACC,aAAaL;IACvC;AACF;AAKA,OAAO,MAAeM,8BAAoCR;IACxD,CAACS,OAAOC,aAAa,CAAC,GAAiC;QACrD,OAAO;YACLP,MAAM;gBACJ,IAAI;oBACF,MAAMQ,QAAQ,MAAM,IAAI,CAACR,IAAI;oBAC7B,OAAO;wBAAEQ;wBAAOC,MAAM;oBAAM;gBAC9B,EAAE,OAAM;oBACN,OAAO;wBAAED,OAAOE;wBAAWD,MAAM;oBAAK;gBACxC;YACF;YACAE,QAAQ;gBACN,IAAI,CAACL,OAAOM,OAAO,CAAC;gBACpB,OAAOC,QAAQC,OAAO,CAAC;oBAAEN,OAAOE;oBAAWD,MAAM;gBAAK;YACxD;QACF;IACF;AAEF"}
+{"version":3,"sources":["../src/callable.ts"],"sourcesContent":["import { Fn, Promiseable } from './types.js';\n\n/**\n * Makes subclasses callable like plain functions by returning the provided delegate\n * with the subclass prototype applied. Instances can be invoked directly while\n * retaining class semantics.\n * @internal\n */\nexport interface Callable<T extends unknown[], R> {\n  (...args: T): R;\n}\n\n/**\n * An abstract class that extends the built-in Function class. It allows instances of the class\n * to be called as functions. When an instance of Callable is called as a function, it will\n * call the function passed to its constructor with the same arguments.\n * @internal\n */\n\nexport abstract class Callable<T, R> {\n  static {\n    Object.setPrototypeOf(Callable.prototype, Function.prototype);\n  }\n\n  constructor(func: Fn<T, R>) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\n/**\n * Promise-like callable base. Subclasses implement `next()`, and the Promise methods\n * delegate to that, so instances can be awaited or chained while remaining callable.\n * @internal\n */\nexport abstract class AsyncCallable<T, R> extends Callable<[T], R> implements Promiseable<T>, Promise<T> {\n  constructor(func: Fn<[T], R>) {\n    super(func);\n  }\n\n  abstract [Symbol.toStringTag]: string;\n  abstract next(): Promise<T>;\n\n  catch<OK = never>(onrejected?: ((reason: any) => OK | PromiseLike<OK>) | null): Promise<T | OK> {\n    return this.next().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    return this.next().finally(onfinally);\n  }\n\n  then<OK = T, ERR = never>(\n    onfulfilled?: ((value: T) => OK | PromiseLike<OK>) | null,\n    onrejected?: ((reason: unknown) => ERR | PromiseLike<ERR>) | null,\n  ): Promise<OK | ERR> {\n    return this.next().then(onfulfilled, onrejected);\n  }\n}\n\n/**\n * Callable async iterator base. Adds `for await` support and disposal on return\n * while delegating iteration to `next()`. Subclasses become callable, awaitable,\n * and async-iterable with a single `next()` implementation.\n * @internal\n */\nexport abstract class CallableAsyncIterator<T, R> extends AsyncCallable<T, R> implements Promiseable<T>, Promise<T>, AsyncIterable<T> {\n  return?(): Promise<undefined>;\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return {\n      next: async () => {\n        try {\n          const value = await this.next();\n          return { value, done: false };\n        } catch {\n          return { value: undefined, done: true };\n        }\n      },\n      return: async () => {\n        await this.return?.();\n        return { value: undefined, done: true };\n      },\n    };\n  }\n}\n"],"names":["Callable","Object","setPrototypeOf","prototype","Function","func","AsyncCallable","catch","onrejected","next","finally","onfinally","then","onfulfilled","CallableAsyncIterator","Symbol","asyncIterator","value","done","undefined","return"],"mappings":"AAmBA,OAAO,MAAeA;IACpB,MAAO;QACLC,OAAOC,cAAc,CAACF,SAASG,SAAS,EAAEC,SAASD,SAAS;IAC9D,CAAC;IAED,YAAYE,IAAc,CAAE;QAE1B,OAAOJ,OAAOC,cAAc,CAACG,MAAM,WAAWF,SAAS;IACzD;AACF;AAOA,OAAO,MAAeG,sBAA4BN;IAChD,YAAYK,IAAgB,CAAE;QAC5B,KAAK,CAACA;IACR;IAKAE,MAAkBC,UAA2D,EAAmB;QAC9F,OAAO,IAAI,CAACC,IAAI,GAAGF,KAAK,CAACC;IAC3B;IAEAE,QAAQC,SAA+B,EAAc;QACnD,OAAO,IAAI,CAACF,IAAI,GAAGC,OAAO,CAACC;IAC7B;IAEAC,KACEC,WAAyD,EACzDL,UAAiE,EAC9C;QACnB,OAAO,IAAI,CAACC,IAAI,GAAGG,IAAI,CAACC,aAAaL;IACvC;AACF;AAQA,OAAO,MAAeM,8BAAoCR;IAGxD,CAACS,OAAOC,aAAa,CAAC,GAAiC;QACrD,OAAO;YACLP,MAAM;gBACJ,IAAI;oBACF,MAAMQ,QAAQ,MAAM,IAAI,CAACR,IAAI;oBAC7B,OAAO;wBAAEQ;wBAAOC,MAAM;oBAAM;gBAC9B,EAAE,OAAM;oBACN,OAAO;wBAAED,OAAOE;wBAAWD,MAAM;oBAAK;gBACxC;YACF;YACAE,QAAQ;gBACN,MAAM,IAAI,CAACA,MAAM;gBACjB,OAAO;oBAAEH,OAAOE;oBAAWD,MAAM;gBAAK;YACxC;QACF;IACF;AACF"}

package/build/event.cjs

@@ -31,37 +31,44 @@ _export(exports, {
         return merge;
     }
 });
-const _fastds = require("fastds");
 const _typescjs = require("./types.cjs");
 const _callablecjs = require("./callable.cjs");
 const _sequencecjs = require("./sequence.cjs");
+const _listenerregistrycjs = require("./listener-registry.cjs");
+const isThenable = (value)=>value !== null && typeof value === 'object' && typeof value.then === 'function';
 class Unsubscribe extends _callablecjs.Callable {
     _done = false;
     constructor(callback){
-        super(async ()=>{
+        super(()=>{
             this._done = true;
-            await callback();
+            return callback();
         });
     }
     get done() {
         return this._done;
     }
     pre(callback) {
-        return new Unsubscribe(async ()=>{
-            await callback();
-            await this();
+        return new Unsubscribe(()=>{
+            const result = callback();
+            if (isThenable(result)) {
+                return result.then(()=>this());
+            }
+            return this();
         });
     }
     post(callback) {
-        return new Unsubscribe(async ()=>{
-            await this();
-            await callback();
+        return new Unsubscribe(()=>{
+            const result = this();
+            if (isThenable(result)) {
+                return result.then(()=>callback());
+            }
+            return callback();
         });
     }
     countdown(count) {
-        return new Unsubscribe(async ()=>{
+        return new Unsubscribe(()=>{
             if (!--count) {
-                await this();
+                return this();
             }
         });
     }
@@ -84,25 +91,34 @@ class EventResult {
 }
 class Event extends _callablecjs.CallableAsyncIterator {
     listeners;
-    hooks = new _fastds.RingBuffer();
+    hooks = new _listenerregistrycjs.ListenerRegistry();
     _disposed = false;
+    pending;
     dispose;
     [Symbol.toStringTag] = 'Event';
     constructor(dispose){
-        const listeners = new _fastds.RingBuffer();
+        const listeners = new _listenerregistrycjs.ListenerRegistry();
         super((value)=>{
-            const results = listeners.toArray().map(async (listener)=>listener(await value));
+            if (this.pending) {
+                this.pending.resolve(value);
+                this.pending = undefined;
+            }
+            const results = listeners.dispatch(value);
             return new EventResult(results);
         });
         this.listeners = listeners;
         this.dispose = ()=>{
             this._disposed = true;
+            if (this.pending) {
+                this.pending.reject(new Error('Event disposed'));
+                this.pending = undefined;
+            }
             void this.clear();
             void dispose?.();
         };
     }
     get size() {
-        return this.listeners.length;
+        return this.listeners.size;
     }
     get disposed() {
         return this._disposed;
@@ -114,51 +130,47 @@ class Event extends _callablecjs.CallableAsyncIterator {
         return this.listeners.has(listener);
     }
     off(listener) {
-        if (this.listeners.compact((l)=>l !== listener) && this.hooks.length) {
-            [
-                ...this.hooks
-            ].forEach((hook)=>hook(listener, _typescjs.HookType.Remove));
+        if (this.listeners.off(listener)) {
+            void this.hooks.dispatch(listener, _typescjs.HookType.Remove);
         }
         return this;
     }
     on(listener) {
-        this.listeners.push(listener);
-        if (this.hooks.length) {
-            [
-                ...this.hooks
-            ].forEach((hook)=>hook(listener, _typescjs.HookType.Add));
+        if (this.listeners.on(listener)) {
+            void this.hooks.dispatch(listener, _typescjs.HookType.Add);
         }
         return new Unsubscribe(()=>{
             void this.off(listener);
         });
     }
     once(listener) {
-        const oneTimeListener = (event)=>{
-            void this.off(oneTimeListener);
-            return listener(event);
-        };
-        return this.on(oneTimeListener);
+        if (this.listeners.once(listener)) {
+            void this.hooks.dispatch(listener, _typescjs.HookType.Add);
+        }
+        return new Unsubscribe(()=>{
+            void this.off(listener);
+        });
     }
     clear() {
         this.listeners.clear();
-        if (this.hooks.length) {
-            [
-                ...this.hooks
-            ].forEach((hook)=>hook(undefined, _typescjs.HookType.Remove));
-        }
+        void this.hooks.dispatch(undefined, _typescjs.HookType.Remove);
         return this;
     }
-    async next() {
-        const { promise, resolve } = Promise.withResolvers();
-        this.listeners.push(resolve);
-        return promise.finally(()=>{
-            this.listeners.removeFirst(resolve);
-        });
-    }
-    async settle() {
-        return await Promise.allSettled([
-            this.next()
-        ]).then(([settled])=>settled);
+    next() {
+        if (this._disposed) {
+            return Promise.reject(new Error('Event disposed'));
+        }
+        this.pending ??= Promise.withResolvers();
+        return this.pending.promise;
+    }
+    settle() {
+        return this.next().then((value)=>({
+                status: 'fulfilled',
+                value
+            })).catch((reason)=>({
+                status: 'rejected',
+                reason
+            }));
     }
     [Symbol.asyncIterator]() {
         const ctrl = new AbortController();
@@ -166,23 +178,41 @@ class Event extends _callablecjs.CallableAsyncIterator {
         const emitEvent = (value)=>{
             sequence(value);
         };
-        this.listeners.push(emitEvent);
+        this.listeners.on(emitEvent);
         const hook = (target = emitEvent, action)=>{
             if (target === emitEvent && action === _typescjs.HookType.Remove) {
                 ctrl.abort('done');
-                this.listeners.removeFirst(emitEvent);
+                this.hooks.off(hook);
+            }
+        };
+        this.hooks.on(hook);
+        const iterator = sequence[Symbol.asyncIterator]();
+        return {
+            next: (...args)=>{
+                return iterator.next(...args);
+            },
+            return: async ()=>{
+                void this.off(emitEvent);
+                return iterator.return?.() ?? {
+                    value: undefined,
+                    done: true
+                };
             }
         };
-        this.hooks.push(hook);
-        return sequence[Symbol.asyncIterator]();
     }
     [Symbol.dispose]() {
         void this.dispose();
     }
 }
 const merge = (...events)=>{
-    const mergedEvent = new Event();
-    events.forEach((event)=>event.on(mergedEvent));
+    const mergedEvent = new Event(()=>{
+        for (const event of events){
+            event.off(mergedEvent);
+        }
+    });
+    for (const event of events){
+        event.on(mergedEvent);
+    }
     return mergedEvent;
 };
 const createInterval = (interval)=>{