evnty 5.0.0 → 5.1.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)
 
@@ -42,7 +42,7 @@ clickEvent.on(({ x, y }) => console.log(`Click at ${x},${y}`));
 clickEvent.on(({ x, y }) => updateUI(x, y));
 
 // All listeners receive the value
-clickEvent({ x: 100, y: 200 });
+clickEvent.emit({ x: 100, y: 200 });
 ```
 
 **Use Event when:**
@@ -57,11 +57,11 @@ Signals are for coordinating async operations. When a value is sent, ALL waiting
 const signal = new Signal<string>();
 
 // Multiple consumers can wait
-const promise1 = signal.next();
-const promise2 = signal.next();
+const promise1 = signal.receive();
+const promise2 = signal.receive();
 
 // Send value - all waiting consumers receive it
-signal('data');
+signal.emit('data');
 const [result1, result2] = await Promise.all([promise1, promise2]);
 // result1 === 'data' && result2 === 'data'
 ```
@@ -78,9 +78,9 @@ Sequences are FIFO queues for single-consumer scenarios. Values are consumed in
 const taskQueue = new Sequence<Task>();
 
 // Producer adds tasks
-taskQueue(task1);
-taskQueue(task2);
-taskQueue(task3);
+taskQueue.emit(task1);
+taskQueue.emit(task2);
+taskQueue.emit(task3);
 
 // Single consumer processes in order
 for await (const task of taskQueue) {
@@ -100,7 +100,7 @@ for await (const task of taskQueue) {
 | **Consumers** | Multiple persistent listeners | Multiple one-time receivers | Single consumer |
 | **Delivery** | All listeners called | All waiting get same value | Each value consumed once |
 | **Pattern** | Pub/Sub | Broadcast coordination | Queue/Stream |
-| **Persistence** | Listeners stay registered | Resolves once per `next()` | Values queued until consumed |
+| **Persistence** | Listeners stay registered | Resolves once per `receive()` | Values queued until consumed |
 
 ## Motivation
 
@@ -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
@@ -174,12 +174,10 @@ userEvent.on(user => updateUI(user));
 userEvent.on(user => saveToCache(user));
 
 // Emit - all listeners are called
-userEvent({ id: 1, name: 'Alice' });
+userEvent.emit({ 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) {
@@ -196,12 +194,12 @@ const dataSignal = new Signal<Buffer>();
 
 // Multiple operations wait for the same data
 async function processA() {
-  const data = await dataSignal.next();
+  const data = await dataSignal.receive();
   // Process data in way A
 }
 
 async function processB() {
-  const data = await dataSignal.next();
+  const data = await dataSignal.receive();
   // Process data in way B
 }
 
@@ -209,7 +207,7 @@ async function processB() {
 Promise.all([processA(), processB()]);
 
 // Both receive the same data when it arrives
-dataSignal(Buffer.from('shared data'));
+dataSignal.emit(Buffer.from('shared data'));
 ```
 
 ### Sequence - Task Queue
@@ -228,13 +226,13 @@ const taskQueue = new Sequence<() => Promise<void>>();
 })();
 
 // Multiple producers add tasks
-taskQueue(async () => fetchData());
-taskQueue(async () => processData());
-taskQueue(async () => saveResults());
+taskQueue.emit(async () => fetchData());
+taskQueue.emit(async () => processData());
+taskQueue.emit(async () => saveResults());
 
 // Backpressure control
 await taskQueue.reserve(10); // Wait until queue has ≤10 items
-taskQueue(async () => nonUrgentTask());
+taskQueue.emit(async () => nonUrgentTask());
 ```
 
 ### Combining Primitives
@@ -245,14 +243,14 @@ const responseSignal = new Signal<Response>();
 
 requestEvent.on(async (req) => {
   const response = await handleRequest(req);
-  responseSignal(response);
+  responseSignal.emit(response);
 });
 
 // Event + Sequence for buffered processing
 const dataEvent = createEvent<Data>();
 const processQueue = new Sequence<Data>();
 
-dataEvent.on(data => processQueue(data));
+dataEvent.on(data => processQueue.emit(data));
 
 // Process with controlled concurrency
 for await (const data of processQueue) {
@@ -260,6 +258,8 @@ for await (const data of processQueue) {
 }
 ```
 
+<!--API_REFERENCE-->
+
 ## License
 
 License [The MIT License](./LICENSE)

package/build/async.cjs

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Async () {
+        return Async;
+    },
+    get Disposer () {
+        return Disposer;
+    }
+});
+class Disposer {
+    #target;
+    #abortSignal;
+    constructor(target, abortSignal){
+        if (abortSignal?.aborted) return;
+        this.#target = target;
+        if (abortSignal) {
+            this.#abortSignal = abortSignal;
+            abortSignal.addEventListener('abort', this);
+        }
+    }
+    get disposed() {
+        return !this.#target;
+    }
+    [Symbol.dispose]() {
+        if (!this.#target) return false;
+        this.#target = undefined;
+        if (this.#abortSignal) {
+            this.#abortSignal.removeEventListener('abort', this);
+            this.#abortSignal = undefined;
+        }
+        return true;
+    }
+    handleEvent() {
+        this.#target?.[Symbol.dispose]();
+    }
+}
+class Async {
+    #sink;
+    #disposer;
+    constructor(abortSignal){
+        this.#disposer = new Disposer(this, abortSignal);
+    }
+    get disposed() {
+        return this.#disposer.disposed;
+    }
+    get sink() {
+        return this.#sink ??= this.emit.bind(this);
+    }
+    handleEvent(event) {
+        this.emit(event);
+    }
+    catch(onrejected) {
+        return this.receive().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.receive().finally(onfinally);
+    }
+    then(onfulfilled, onrejected) {
+        return this.receive().then(onfulfilled, onrejected);
+    }
+    async next() {
+        try {
+            const value = await this.receive();
+            return {
+                value,
+                done: false
+            };
+        } catch  {
+            return {
+                value: undefined,
+                done: true
+            };
+        }
+    }
+    async return() {
+        this.dispose?.();
+        return {
+            value: undefined,
+            done: true
+        };
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    [Symbol.dispose]() {
+        if (this.#disposer[Symbol.dispose]()) {
+            this.dispose?.();
+        }
+    }
+}
+
+//# sourceMappingURL=async.cjs.map

package/build/async.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/async.ts"],"sourcesContent":["import { Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';\n\n/**\n * @internal\n */\nexport class Disposer {\n  #target?: Disposable;\n  #abortSignal?: AbortSignal;\n\n  constructor(target: Disposable, abortSignal?: AbortSignal) {\n    if (abortSignal?.aborted) return;\n    this.#target = target;\n    if (abortSignal) {\n      this.#abortSignal = abortSignal;\n      abortSignal.addEventListener('abort', this);\n    }\n  }\n\n  get disposed(): boolean {\n    return !this.#target;\n  }\n\n  [Symbol.dispose](): boolean {\n    if (!this.#target) return false;\n    this.#target = undefined;\n    // Stryker disable all: cleanup is memory optimization, no observable behavior after disposal\n    if (this.#abortSignal) {\n      this.#abortSignal.removeEventListener('abort', this);\n      this.#abortSignal = undefined;\n    }\n    // Stryker restore all\n    return true;\n  }\n\n  handleEvent(): void {\n    // Stryker disable next-line OptionalChaining: #target is always set when abort listener fires (synchronous code)\n    this.#target?.[Symbol.dispose]();\n  }\n}\n\n/**\n * @internal\n */\nexport interface Async<T, R> extends Emitter<T, R>, Disposable {}\n\n/**\n * @internal\n */\nexport abstract class Async<T, R> implements Emitter<T, R>, Promiseable<T>, Promise<T>, AsyncIterator<T, void, void>, AsyncIterable<T> {\n  abstract [Symbol.toStringTag]: string;\n  abstract emit(value: T): R;\n  abstract receive(): Promise<T>;\n\n  dispose?(): void;\n\n  #sink?: Fn<[T], R>;\n  #disposer: Disposer;\n\n  constructor(abortSignal?: AbortSignal) {\n    this.#disposer = new Disposer(this, abortSignal);\n  }\n\n  get disposed(): boolean {\n    return this.#disposer.disposed;\n  }\n\n  get sink(): Fn<[T], R> {\n    return (this.#sink ??= this.emit.bind(this));\n  }\n\n  handleEvent(event: T) {\n    this.emit(event);\n  }\n\n  catch<OK = never>(onrejected?: Fn<[unknown], MaybePromise<OK>> | null): Promise<T | OK> {\n    return this.receive().catch(onrejected);\n  }\n\n  finally(onfinally?: Action | null): Promise<T> {\n    return this.receive().finally(onfinally);\n  }\n\n  then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR> {\n    return this.receive().then(onfulfilled, onrejected);\n  }\n\n  async next(): Promise<IteratorResult<T, void>> {\n    try {\n      const value = await this.receive();\n      return { value, done: false };\n    } catch {\n      return { value: undefined, done: true };\n    }\n  }\n\n  async return(): Promise<IteratorResult<T, void>> {\n    // Stryker disable next-line OptionalChaining: all subclasses define dispose()\n    this.dispose?.();\n    return { value: undefined, done: true };\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return this;\n  }\n\n  [Symbol.dispose](): void {\n    if (this.#disposer[Symbol.dispose]()) {\n      // Stryker disable next-line OptionalChaining: all subclasses define dispose()\n      this.dispose?.();\n    }\n  }\n}\n"],"names":["Async","Disposer","target","abortSignal","aborted","addEventListener","disposed","Symbol","dispose","undefined","removeEventListener","handleEvent","sink","emit","bind","event","catch","onrejected","receive","finally","onfinally","then","onfulfilled","next","value","done","return","asyncIterator"],"mappings":";;;;;;;;;;;QAgDsBA;eAAAA;;QA3CTC;eAAAA;;;AAAN,MAAMA;IACX,CAAA,MAAO,CAAc;IACrB,CAAA,WAAY,CAAe;IAE3B,YAAYC,MAAkB,EAAEC,WAAyB,CAAE;QACzD,IAAIA,aAAaC,SAAS;QAC1B,IAAI,CAAC,CAAA,MAAO,GAAGF;QACf,IAAIC,aAAa;YACf,IAAI,CAAC,CAAA,WAAY,GAAGA;YACpBA,YAAYE,gBAAgB,CAAC,SAAS,IAAI;QAC5C;IACF;IAEA,IAAIC,WAAoB;QACtB,OAAO,CAAC,IAAI,CAAC,CAAA,MAAO;IACtB;IAEA,CAACC,OAAOC,OAAO,CAAC,GAAY;QAC1B,IAAI,CAAC,IAAI,CAAC,CAAA,MAAO,EAAE,OAAO;QAC1B,IAAI,CAAC,CAAA,MAAO,GAAGC;QAEf,IAAI,IAAI,CAAC,CAAA,WAAY,EAAE;YACrB,IAAI,CAAC,CAAA,WAAY,CAACC,mBAAmB,CAAC,SAAS,IAAI;YACnD,IAAI,CAAC,CAAA,WAAY,GAAGD;QACtB;QAEA,OAAO;IACT;IAEAE,cAAoB;QAElB,IAAI,CAAC,CAAA,MAAO,EAAE,CAACJ,OAAOC,OAAO,CAAC;IAChC;AACF;AAUO,MAAeR;IAOpB,CAAA,IAAK,CAAc;IACnB,CAAA,QAAS,CAAW;IAEpB,YAAYG,WAAyB,CAAE;QACrC,IAAI,CAAC,CAAA,QAAS,GAAG,IAAIF,SAAS,IAAI,EAAEE;IACtC;IAEA,IAAIG,WAAoB;QACtB,OAAO,IAAI,CAAC,CAAA,QAAS,CAACA,QAAQ;IAChC;IAEA,IAAIM,OAAmB;QACrB,OAAQ,IAAI,CAAC,CAAA,IAAK,KAAK,IAAI,CAACC,IAAI,CAACC,IAAI,CAAC,IAAI;IAC5C;IAEAH,YAAYI,KAAQ,EAAE;QACpB,IAAI,CAACF,IAAI,CAACE;IACZ;IAEAC,MAAkBC,UAAmD,EAAmB;QACtF,OAAO,IAAI,CAACC,OAAO,GAAGF,KAAK,CAACC;IAC9B;IAEAE,QAAQC,SAAyB,EAAc;QAC7C,OAAO,IAAI,CAACF,OAAO,GAAGC,OAAO,CAACC;IAChC;IAEAC,KAA0BC,WAA8C,EAAEL,UAAoD,EAAqB;QACjJ,OAAO,IAAI,CAACC,OAAO,GAAGG,IAAI,CAACC,aAAaL;IAC1C;IAEA,MAAMM,OAAyC;QAC7C,IAAI;YACF,MAAMC,QAAQ,MAAM,IAAI,CAACN,OAAO;YAChC,OAAO;gBAAEM;gBAAOC,MAAM;YAAM;QAC9B,EAAE,OAAM;YACN,OAAO;gBAAED,OAAOf;gBAAWgB,MAAM;YAAK;QACxC;IACF;IAEA,MAAMC,SAA2C;QAE/C,IAAI,CAAClB,OAAO;QACZ,OAAO;YAAEgB,OAAOf;YAAWgB,MAAM;QAAK;IACxC;IAEA,CAAClB,OAAOoB,aAAa,CAAC,GAAiC;QACrD,OAAO,IAAI;IACb;IAEA,CAACpB,OAAOC,OAAO,CAAC,GAAS;QACvB,IAAI,IAAI,CAAC,CAAA,QAAS,CAACD,OAAOC,OAAO,CAAC,IAAI;YAEpC,IAAI,CAACA,OAAO;QACd;IACF;AACF"}

package/build/async.d.ts

@@ -0,0 +1,37 @@
+import { Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';
+/**
+ * @internal
+ */
+export declare class Disposer {
+    #private;
+    constructor(target: Disposable, abortSignal?: AbortSignal);
+    get disposed(): boolean;
+    [Symbol.dispose](): boolean;
+    handleEvent(): void;
+}
+/**
+ * @internal
+ */
+export interface Async<T, R> extends Emitter<T, R>, Disposable {
+}
+/**
+ * @internal
+ */
+export declare abstract class Async<T, R> implements Emitter<T, R>, Promiseable<T>, Promise<T>, AsyncIterator<T, void, void>, AsyncIterable<T> {
+    #private;
+    abstract [Symbol.toStringTag]: string;
+    abstract emit(value: T): R;
+    abstract receive(): Promise<T>;
+    dispose?(): void;
+    constructor(abortSignal?: AbortSignal);
+    get disposed(): boolean;
+    get sink(): Fn<[T], R>;
+    handleEvent(event: T): void;
+    catch<OK = never>(onrejected?: Fn<[unknown], MaybePromise<OK>> | null): Promise<T | OK>;
+    finally(onfinally?: Action | null): Promise<T>;
+    then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR>;
+    next(): Promise<IteratorResult<T, void>>;
+    return(): Promise<IteratorResult<T, void>>;
+    [Symbol.asyncIterator](): AsyncIterator<T, void, void>;
+    [Symbol.dispose](): void;
+}

package/build/async.js

@@ -0,0 +1,83 @@
+export class Disposer {
+    #target;
+    #abortSignal;
+    constructor(target, abortSignal){
+        if (abortSignal?.aborted) return;
+        this.#target = target;
+        if (abortSignal) {
+            this.#abortSignal = abortSignal;
+            abortSignal.addEventListener('abort', this);
+        }
+    }
+    get disposed() {
+        return !this.#target;
+    }
+    [Symbol.dispose]() {
+        if (!this.#target) return false;
+        this.#target = undefined;
+        if (this.#abortSignal) {
+            this.#abortSignal.removeEventListener('abort', this);
+            this.#abortSignal = undefined;
+        }
+        return true;
+    }
+    handleEvent() {
+        this.#target?.[Symbol.dispose]();
+    }
+}
+export class Async {
+    #sink;
+    #disposer;
+    constructor(abortSignal){
+        this.#disposer = new Disposer(this, abortSignal);
+    }
+    get disposed() {
+        return this.#disposer.disposed;
+    }
+    get sink() {
+        return this.#sink ??= this.emit.bind(this);
+    }
+    handleEvent(event) {
+        this.emit(event);
+    }
+    catch(onrejected) {
+        return this.receive().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.receive().finally(onfinally);
+    }
+    then(onfulfilled, onrejected) {
+        return this.receive().then(onfulfilled, onrejected);
+    }
+    async next() {
+        try {
+            const value = await this.receive();
+            return {
+                value,
+                done: false
+            };
+        } catch  {
+            return {
+                value: undefined,
+                done: true
+            };
+        }
+    }
+    async return() {
+        this.dispose?.();
+        return {
+            value: undefined,
+            done: true
+        };
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    [Symbol.dispose]() {
+        if (this.#disposer[Symbol.dispose]()) {
+            this.dispose?.();
+        }
+    }
+}
+
+//# sourceMappingURL=async.js.map

package/build/async.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/async.ts"],"sourcesContent":["import { Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';\n\n/**\n * @internal\n */\nexport class Disposer {\n  #target?: Disposable;\n  #abortSignal?: AbortSignal;\n\n  constructor(target: Disposable, abortSignal?: AbortSignal) {\n    if (abortSignal?.aborted) return;\n    this.#target = target;\n    if (abortSignal) {\n      this.#abortSignal = abortSignal;\n      abortSignal.addEventListener('abort', this);\n    }\n  }\n\n  get disposed(): boolean {\n    return !this.#target;\n  }\n\n  [Symbol.dispose](): boolean {\n    if (!this.#target) return false;\n    this.#target = undefined;\n    // Stryker disable all: cleanup is memory optimization, no observable behavior after disposal\n    if (this.#abortSignal) {\n      this.#abortSignal.removeEventListener('abort', this);\n      this.#abortSignal = undefined;\n    }\n    // Stryker restore all\n    return true;\n  }\n\n  handleEvent(): void {\n    // Stryker disable next-line OptionalChaining: #target is always set when abort listener fires (synchronous code)\n    this.#target?.[Symbol.dispose]();\n  }\n}\n\n/**\n * @internal\n */\nexport interface Async<T, R> extends Emitter<T, R>, Disposable {}\n\n/**\n * @internal\n */\nexport abstract class Async<T, R> implements Emitter<T, R>, Promiseable<T>, Promise<T>, AsyncIterator<T, void, void>, AsyncIterable<T> {\n  abstract [Symbol.toStringTag]: string;\n  abstract emit(value: T): R;\n  abstract receive(): Promise<T>;\n\n  dispose?(): void;\n\n  #sink?: Fn<[T], R>;\n  #disposer: Disposer;\n\n  constructor(abortSignal?: AbortSignal) {\n    this.#disposer = new Disposer(this, abortSignal);\n  }\n\n  get disposed(): boolean {\n    return this.#disposer.disposed;\n  }\n\n  get sink(): Fn<[T], R> {\n    return (this.#sink ??= this.emit.bind(this));\n  }\n\n  handleEvent(event: T) {\n    this.emit(event);\n  }\n\n  catch<OK = never>(onrejected?: Fn<[unknown], MaybePromise<OK>> | null): Promise<T | OK> {\n    return this.receive().catch(onrejected);\n  }\n\n  finally(onfinally?: Action | null): Promise<T> {\n    return this.receive().finally(onfinally);\n  }\n\n  then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR> {\n    return this.receive().then(onfulfilled, onrejected);\n  }\n\n  async next(): Promise<IteratorResult<T, void>> {\n    try {\n      const value = await this.receive();\n      return { value, done: false };\n    } catch {\n      return { value: undefined, done: true };\n    }\n  }\n\n  async return(): Promise<IteratorResult<T, void>> {\n    // Stryker disable next-line OptionalChaining: all subclasses define dispose()\n    this.dispose?.();\n    return { value: undefined, done: true };\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return this;\n  }\n\n  [Symbol.dispose](): void {\n    if (this.#disposer[Symbol.dispose]()) {\n      // Stryker disable next-line OptionalChaining: all subclasses define dispose()\n      this.dispose?.();\n    }\n  }\n}\n"],"names":["Disposer","target","abortSignal","aborted","addEventListener","disposed","Symbol","dispose","undefined","removeEventListener","handleEvent","Async","sink","emit","bind","event","catch","onrejected","receive","finally","onfinally","then","onfulfilled","next","value","done","return","asyncIterator"],"mappings":"AAKA,OAAO,MAAMA;IACX,CAAA,MAAO,CAAc;IACrB,CAAA,WAAY,CAAe;IAE3B,YAAYC,MAAkB,EAAEC,WAAyB,CAAE;QACzD,IAAIA,aAAaC,SAAS;QAC1B,IAAI,CAAC,CAAA,MAAO,GAAGF;QACf,IAAIC,aAAa;YACf,IAAI,CAAC,CAAA,WAAY,GAAGA;YACpBA,YAAYE,gBAAgB,CAAC,SAAS,IAAI;QAC5C;IACF;IAEA,IAAIC,WAAoB;QACtB,OAAO,CAAC,IAAI,CAAC,CAAA,MAAO;IACtB;IAEA,CAACC,OAAOC,OAAO,CAAC,GAAY;QAC1B,IAAI,CAAC,IAAI,CAAC,CAAA,MAAO,EAAE,OAAO;QAC1B,IAAI,CAAC,CAAA,MAAO,GAAGC;QAEf,IAAI,IAAI,CAAC,CAAA,WAAY,EAAE;YACrB,IAAI,CAAC,CAAA,WAAY,CAACC,mBAAmB,CAAC,SAAS,IAAI;YACnD,IAAI,CAAC,CAAA,WAAY,GAAGD;QACtB;QAEA,OAAO;IACT;IAEAE,cAAoB;QAElB,IAAI,CAAC,CAAA,MAAO,EAAE,CAACJ,OAAOC,OAAO,CAAC;IAChC;AACF;AAUA,OAAO,MAAeI;IAOpB,CAAA,IAAK,CAAc;IACnB,CAAA,QAAS,CAAW;IAEpB,YAAYT,WAAyB,CAAE;QACrC,IAAI,CAAC,CAAA,QAAS,GAAG,IAAIF,SAAS,IAAI,EAAEE;IACtC;IAEA,IAAIG,WAAoB;QACtB,OAAO,IAAI,CAAC,CAAA,QAAS,CAACA,QAAQ;IAChC;IAEA,IAAIO,OAAmB;QACrB,OAAQ,IAAI,CAAC,CAAA,IAAK,KAAK,IAAI,CAACC,IAAI,CAACC,IAAI,CAAC,IAAI;IAC5C;IAEAJ,YAAYK,KAAQ,EAAE;QACpB,IAAI,CAACF,IAAI,CAACE;IACZ;IAEAC,MAAkBC,UAAmD,EAAmB;QACtF,OAAO,IAAI,CAACC,OAAO,GAAGF,KAAK,CAACC;IAC9B;IAEAE,QAAQC,SAAyB,EAAc;QAC7C,OAAO,IAAI,CAACF,OAAO,GAAGC,OAAO,CAACC;IAChC;IAEAC,KAA0BC,WAA8C,EAAEL,UAAoD,EAAqB;QACjJ,OAAO,IAAI,CAACC,OAAO,GAAGG,IAAI,CAACC,aAAaL;IAC1C;IAEA,MAAMM,OAAyC;QAC7C,IAAI;YACF,MAAMC,QAAQ,MAAM,IAAI,CAACN,OAAO;YAChC,OAAO;gBAAEM;gBAAOC,MAAM;YAAM;QAC9B,EAAE,OAAM;YACN,OAAO;gBAAED,OAAOhB;gBAAWiB,MAAM;YAAK;QACxC;IACF;IAEA,MAAMC,SAA2C;QAE/C,IAAI,CAACnB,OAAO;QACZ,OAAO;YAAEiB,OAAOhB;YAAWiB,MAAM;QAAK;IACxC;IAEA,CAACnB,OAAOqB,aAAa,CAAC,GAAiC;QACrD,OAAO,IAAI;IACb;IAEA,CAACrB,OAAOC,OAAO,CAAC,GAAS;QACvB,IAAI,IAAI,CAAC,CAAA,QAAS,CAACD,OAAOC,OAAO,CAAC,IAAI;YAEpC,IAAI,CAACA,OAAO;QACd;IACF;AACF"}

package/build/broadcast.cjs

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Broadcast () {
+        return Broadcast;
+    },
+    get BroadcastIterator () {
+        return BroadcastIterator;
+    },
+    get ConsumerHandle () {
+        return ConsumerHandle;
+    }
+});
+const _ringbuffercjs = require("./ring-buffer.cjs");
+const _signalcjs = require("./signal.cjs");
+const _asynccjs = require("./async.cjs");
+const _utilscjs = require("./utils.cjs");
+class ConsumerHandle {
+    #broadcast;
+    constructor(broadcast){
+        this.#broadcast = broadcast;
+    }
+    get cursor() {
+        return this.#broadcast.getCursor(this);
+    }
+    [Symbol.dispose]() {
+        this.#broadcast.leave(this);
+    }
+}
+class BroadcastIterator {
+    #broadcast;
+    #signal;
+    #handle;
+    constructor(broadcast, signal, handle){
+        this.#broadcast = broadcast;
+        this.#signal = signal;
+        this.#handle = handle;
+    }
+    async next() {
+        try {
+            while(true){
+                const result = this.#broadcast.tryConsume(this.#handle);
+                if (!result.done) {
+                    return {
+                        value: result.value,
+                        done: false
+                    };
+                }
+                await this.#signal.receive();
+            }
+        } catch  {
+            return {
+                value: undefined,
+                done: true
+            };
+        }
+    }
+    async return() {
+        this.#broadcast.leave(this.#handle);
+        return {
+            value: undefined,
+            done: true
+        };
+    }
+}
+class Broadcast {
+    #buffer = new _ringbuffercjs.RingBuffer();
+    #signal = new _signalcjs.Signal();
+    #disposer;
+    #sink;
+    #nextId = 0;
+    #cursors = new Map();
+    #handles = new WeakMap();
+    #minCursor = 0;
+    #registry = new FinalizationRegistry((id)=>{
+        const cursor = this.#cursors.get(id);
+        this.#cursors.delete(id);
+        if (cursor === this.#minCursor) {
+            this.#minCursor = (0, _utilscjs.min)(this.#cursors.values(), this.#buffer.right);
+            const shift = this.#minCursor - this.#buffer.left;
+            if (shift > 0) this.#buffer.shiftN(shift);
+        }
+    });
+    [Symbol.toStringTag] = 'Broadcast';
+    constructor(){
+        this.#disposer = new _asynccjs.Disposer(this);
+    }
+    get sink() {
+        return this.#sink ??= this.emit.bind(this);
+    }
+    handleEvent(event) {
+        this.emit(event);
+    }
+    get size() {
+        return this.#cursors.size;
+    }
+    emit(value) {
+        if (this.#disposer.disposed) {
+            return false;
+        }
+        this.#buffer.push(value);
+        this.#signal.emit(value);
+        return true;
+    }
+    receive() {
+        return this.#signal.receive();
+    }
+    then(onfulfilled, onrejected) {
+        return this.receive().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.receive().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.receive().finally(onfinally);
+    }
+    join() {
+        const id = this.#nextId++;
+        const cursor = this.#buffer.right;
+        const handle = new ConsumerHandle(this);
+        this.#handles.set(handle, id);
+        this.#cursors.set(id, cursor);
+        if (this.#cursors.size === 1 || cursor < this.#minCursor) {
+            this.#minCursor = cursor;
+        }
+        this.#registry.register(handle, id, handle);
+        return handle;
+    }
+    getCursor(handle) {
+        const id = this.#handles.get(handle);
+        if (id === undefined) throw new Error('Invalid handle');
+        const cursor = this.#cursors.get(id);
+        if (cursor === undefined) throw new Error('Invalid handle');
+        return cursor;
+    }
+    leave(handle) {
+        const id = this.#handles.get(handle);
+        if (id === undefined) return;
+        const cursor = this.#cursors.get(id);
+        this.#handles.delete(handle);
+        this.#cursors.delete(id);
+        this.#registry.unregister(handle);
+        if (cursor === this.#minCursor) {
+            this.#minCursor = (0, _utilscjs.min)(this.#cursors.values(), this.#buffer.right);
+            const shift = this.#minCursor - this.#buffer.left;
+            if (shift > 0) this.#buffer.shiftN(shift);
+        }
+    }
+    consume(handle) {
+        const result = this.tryConsume(handle);
+        if (result.done) {
+            throw new Error('No value available');
+        }
+        return result.value;
+    }
+    tryConsume(handle) {
+        const id = this.#handles.get(handle);
+        if (id === undefined) throw new Error('Invalid handle');
+        const cursor = this.#cursors.get(id);
+        if (cursor === undefined) throw new Error('Invalid handle');
+        if (cursor >= this.#buffer.right) {
+            return {
+                value: undefined,
+                done: true
+            };
+        }
+        const value = this.#buffer.peekAt(cursor);
+        this.#cursors.set(id, cursor + 1);
+        if (cursor === this.#minCursor) {
+            this.#minCursor = (0, _utilscjs.min)(this.#cursors.values(), this.#buffer.right);
+            const shift = this.#minCursor - this.#buffer.left;
+            if (shift > 0) this.#buffer.shiftN(shift);
+        }
+        return {
+            value,
+            done: false
+        };
+    }
+    readable(handle) {
+        return this.getCursor(handle) < this.#buffer.right;
+    }
+    [Symbol.asyncIterator]() {
+        return new BroadcastIterator(this, this.#signal, this.join());
+    }
+    dispose() {
+        this[Symbol.dispose]();
+    }
+    [Symbol.dispose]() {
+        if (this.#disposer[Symbol.dispose]()) {
+            this.#signal[Symbol.dispose]();
+            this.#buffer.clear();
+            this.#cursors.clear();
+        }
+    }
+}
+
+//# sourceMappingURL=broadcast.cjs.map

package/build/broadcast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/broadcast.ts"],"sourcesContent":["import { RingBuffer } from './ring-buffer.js';\nimport { Signal } from './signal.js';\nimport { Disposer } from './async.js';\nimport { min } from './utils.js';\nimport { Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';\n\n/**\n * A handle representing a consumer's position in a Broadcast.\n * Returned by `Broadcast.join()` and used to consume values.\n * Implements Disposable for automatic cleanup via `using` keyword.\n *\n * @example\n * ```typescript\n * const broadcast = new Broadcast<number>();\n * using handle = broadcast.join();\n * broadcast.emit(42);\n * const value = broadcast.consume(handle); // 42\n * ```\n */\nexport class ConsumerHandle<T> implements Disposable {\n  #broadcast: Broadcast<T>;\n\n  constructor(broadcast: Broadcast<T>) {\n    this.#broadcast = broadcast;\n  }\n\n  /**\n   * The current position of this consumer in the buffer.\n   */\n  get cursor(): number {\n    return this.#broadcast.getCursor(this);\n  }\n\n  /**\n   * Leaves the broadcast, releasing this consumer's position.\n   */\n  [Symbol.dispose](): void {\n    this.#broadcast.leave(this);\n  }\n}\n\n/**\n * @internal\n */\nexport class BroadcastIterator<T> implements AsyncIterator<T, void, void> {\n  #broadcast: Broadcast<T>;\n  #signal: Signal<T>;\n  #handle: ConsumerHandle<T>;\n\n  constructor(broadcast: Broadcast<T>, signal: Signal<T>, handle: ConsumerHandle<T>) {\n    this.#broadcast = broadcast;\n    this.#signal = signal;\n    this.#handle = handle;\n  }\n\n  async next(): Promise<IteratorResult<T, void>> {\n    try {\n      while (true) {\n        const result = this.#broadcast.tryConsume(this.#handle);\n        if (!result.done) {\n          return { value: result.value, done: false };\n        }\n        await this.#signal.receive();\n      }\n    } catch {\n      return { value: undefined, done: true };\n    }\n  }\n\n  async return(): Promise<IteratorResult<T, void>> {\n    this.#broadcast.leave(this.#handle);\n    return { value: undefined, done: true };\n  }\n}\n\n/**\n * A multi-consumer FIFO queue where each consumer maintains its own read position.\n * Values are buffered and each consumer can read them independently at their own pace.\n * The buffer automatically compacts when all consumers have read past a position.\n *\n * Key characteristics:\n * - Multiple consumers - each gets their own cursor position\n * - Buffered delivery - values are stored until all consumers read them\n * - Late joiners only see values emitted after joining\n * - Automatic cleanup via FinalizationRegistry when handles are garbage collected\n *\n * Differs from:\n * - Event: Broadcast buffers values, Event does not\n * - Sequence: Broadcast supports multiple consumers, Sequence is single-consumer\n * - Signal: Broadcast buffers values, Signal only notifies current waiters\n *\n * @template T - The type of values in the broadcast\n *\n * @example\n * ```typescript\n * const broadcast = new Broadcast<number>();\n *\n * const handle1 = broadcast.join();\n * const handle2 = broadcast.join();\n *\n * broadcast.emit(1);\n * broadcast.emit(2);\n *\n * broadcast.consume(handle1); // 1\n * broadcast.consume(handle2); // 1\n * broadcast.consume(handle1); // 2\n * ```\n */\nexport class Broadcast<T> implements Emitter<T, boolean>, Promiseable<T>, Promise<T>, Disposable, AsyncIterable<T> {\n  #buffer = new RingBuffer<T>();\n  #signal = new Signal<T>();\n  #disposer: Disposer;\n  #sink?: Fn<[T], boolean>;\n  #nextId = 0;\n  #cursors = new Map<number, number>();\n  #handles = new WeakMap<ConsumerHandle<T>, number>();\n  #minCursor = 0;\n\n  // Stryker disable all: FinalizationRegistry callback only testable via GC, excluded from mutation testing\n  #registry = new FinalizationRegistry<number>((id) => {\n    const cursor = this.#cursors.get(id)!;\n    this.#cursors.delete(id);\n\n    if (cursor === this.#minCursor) {\n      this.#minCursor = min(this.#cursors.values(), this.#buffer.right);\n      const shift = this.#minCursor - this.#buffer.left;\n      if (shift > 0) this.#buffer.shiftN(shift);\n    }\n  });\n  // Stryker restore all\n\n  readonly [Symbol.toStringTag] = 'Broadcast';\n\n  constructor() {\n    this.#disposer = new Disposer(this);\n  }\n\n  /**\n   * Returns a bound emit function for use as a callback.\n   */\n  get sink(): Fn<[T], boolean> {\n    return (this.#sink ??= this.emit.bind(this));\n  }\n\n  /**\n   * DOM EventListener interface compatibility.\n   */\n  handleEvent(event: T): void {\n    this.emit(event);\n  }\n\n  /**\n   * The number of active consumers.\n   */\n  get size(): number {\n    return this.#cursors.size;\n  }\n\n  /**\n   * Emits a value to all consumers. The value is buffered for consumption.\n   *\n   * @param value - The value to emit.\n   * @returns `true` if the value was emitted.\n   */\n  emit(value: T): boolean {\n    if (this.#disposer.disposed) {\n      return false;\n    }\n    this.#buffer.push(value);\n    this.#signal.emit(value);\n    return true;\n  }\n\n  /**\n   * Waits for the next emitted value without joining as a consumer.\n   * Does not buffer - only receives values emitted after calling.\n   *\n   * @returns A promise that resolves with the next emitted value.\n   */\n  receive(): Promise<T> {\n    return this.#signal.receive();\n  }\n\n  then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR> {\n    return this.receive().then(onfulfilled, onrejected);\n  }\n\n  catch<ERR = never>(onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<T | ERR> {\n    return this.receive().catch(onrejected);\n  }\n\n  finally(onfinally?: Action | null): Promise<T> {\n    return this.receive().finally(onfinally);\n  }\n\n  /**\n   * Joins the broadcast as a consumer. Returns a handle used to consume values.\n   * The consumer starts at the current buffer position and will only see\n   * values emitted after joining.\n   *\n   * @example\n   * ```typescript\n   * const handle = broadcast.join();\n   * // Use handle with consume(), readable(), leave()\n   * ```\n   */\n  join(): ConsumerHandle<T> {\n    // Stryker disable next-line UpdateOperator: IDs only need uniqueness, direction is irrelevant\n    const id = this.#nextId++;\n    const cursor = this.#buffer.right;\n    const handle = new ConsumerHandle<T>(this);\n\n    this.#handles.set(handle, id);\n    this.#cursors.set(id, cursor);\n\n    // Stryker disable all: minCursor is an optimization hint; tryConsume recalculates on use\n    if (this.#cursors.size === 1 || cursor < this.#minCursor) {\n      this.#minCursor = cursor;\n    }\n    // Stryker restore all\n\n    this.#registry.register(handle, id, handle);\n    return handle;\n  }\n\n  /**\n   * Gets the current cursor position for a consumer handle.\n   *\n   * @param handle - The consumer handle.\n   * @returns The cursor position.\n   * @throws If the handle is invalid (already left or never joined).\n   */\n  getCursor(handle: ConsumerHandle<T>): number {\n    const id = this.#handles.get(handle);\n    // Stryker disable next-line ConditionalExpression: second cursor check catches invalid handles\n    if (id === undefined) throw new Error('Invalid handle');\n    const cursor = this.#cursors.get(id);\n    if (cursor === undefined) throw new Error('Invalid handle');\n    return cursor;\n  }\n\n  /**\n   * Removes a consumer from the broadcast. The handle becomes invalid after this call.\n   * Idempotent - calling multiple times has no effect.\n   *\n   * @param handle - The consumer handle to remove.\n   */\n  leave(handle: ConsumerHandle<T>): void {\n    const id = this.#handles.get(handle);\n    // Stryker disable next-line ConditionalExpression,EqualityOperator: subsequent ops are safe with undefined id\n    if (id === undefined) return;\n\n    const cursor = this.#cursors.get(id)!;\n    this.#handles.delete(handle);\n    this.#cursors.delete(id);\n    this.#registry.unregister(handle);\n\n    // Stryker disable all: compaction condition is optimization; buffer reads are correct regardless\n    if (cursor === this.#minCursor) {\n      this.#minCursor = min(this.#cursors.values(), this.#buffer.right);\n      const shift = this.#minCursor - this.#buffer.left;\n      if (shift > 0) this.#buffer.shiftN(shift);\n    }\n    // Stryker restore all\n  }\n\n  /**\n   * Consumes and returns the next value for a consumer.\n   * Advances the consumer's cursor position.\n   *\n   * @param handle - The consumer handle.\n   * @throws If no value is available or the handle is invalid.\n   *\n   * @example\n   * ```typescript\n   * if (broadcast.readable(handle)) {\n   *   const value = broadcast.consume(handle);\n   * }\n   * ```\n   */\n  consume(handle: ConsumerHandle<T>): T {\n    const result = this.tryConsume(handle);\n    if (result.done) {\n      throw new Error('No value available');\n    }\n    return result.value;\n  }\n\n  /**\n   * Attempts to consume the next value for a consumer.\n   * Returns `{ done: true }` when no value is currently available.\n   *\n   * @param handle - The consumer handle.\n   * @returns The next value, or `{ done: true }` when nothing is available.\n   * @throws If the handle is invalid.\n   */\n  tryConsume(handle: ConsumerHandle<T>): IteratorResult<T, void> {\n    const id = this.#handles.get(handle);\n    // Stryker disable next-line ConditionalExpression: second cursor check catches invalid handles\n    if (id === undefined) throw new Error('Invalid handle');\n\n    const cursor = this.#cursors.get(id);\n    if (cursor === undefined) throw new Error('Invalid handle');\n    if (cursor >= this.#buffer.right) {\n      return { value: undefined, done: true };\n    }\n\n    const value = this.#buffer.peekAt(cursor)!;\n    this.#cursors.set(id, cursor + 1);\n\n    // Stryker disable all: compaction condition is optimization; buffer reads are correct regardless\n    if (cursor === this.#minCursor) {\n      this.#minCursor = min(this.#cursors.values(), this.#buffer.right);\n      const shift = this.#minCursor - this.#buffer.left;\n      if (shift > 0) this.#buffer.shiftN(shift);\n    }\n    // Stryker restore all\n\n    return { value, done: false };\n  }\n\n  /**\n   * Checks if there are values available for a consumer to read.\n   *\n   * @param handle - The consumer handle.\n   * @returns `true` if there are unread values, `false` otherwise.\n   */\n  readable(handle: ConsumerHandle<T>): boolean {\n    return this.getCursor(handle) < this.#buffer.right;\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return new BroadcastIterator(this, this.#signal, this.join());\n  }\n\n  dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  [Symbol.dispose](): void {\n    // Stryker disable next-line ConditionalExpression: double-dispose re-clears empty collections, no observable effect\n    if (this.#disposer[Symbol.dispose]()) {\n      this.#signal[Symbol.dispose]();\n      this.#buffer.clear();\n      this.#cursors.clear();\n    }\n  }\n}\n"],"names":["Broadcast","BroadcastIterator","ConsumerHandle","broadcast","cursor","getCursor","Symbol","dispose","leave","signal","handle","next","result","tryConsume","done","value","receive","undefined","return","RingBuffer","Signal","Map","WeakMap","FinalizationRegistry","id","get","delete","min","values","right","shift","left","shiftN","toStringTag","Disposer","sink","emit","bind","handleEvent","event","size","disposed","push","then","onfulfilled","onrejected","catch","finally","onfinally","join","set","register","Error","unregister","consume","peekAt","readable","asyncIterator","clear"],"mappings":"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"}