evnty 5.0.0 → 5.1.0

package/build/sequence.js

@@ -1,58 +1,57 @@
-import { RingBuffer } from 'fastds';
-import { CallableAsyncIterator } from "./callable.js";
+import { Async } from "./async.js";
 import { Signal } from "./signal.js";
-export class Sequence extends CallableAsyncIterator {
-    abortSignal;
-    queue;
-    nextSignal;
-    sendSignal;
+import { RingBuffer } from "./ring-buffer.js";
+export class Sequence extends Async {
+    #queue;
+    #nextSignal;
+    #sendSignal;
     [Symbol.toStringTag] = 'Sequence';
     static merge(target, ...sequences) {
         for (const source of sequences){
             queueMicrotask(async ()=>{
-                try {
+                if (!target.disposed) try {
+                    const sink = target.sink;
                     for await (const value of source){
-                        target(value);
+                        if (!sink(value)) {
+                            return;
+                        }
                     }
                 } catch  {}
             });
         }
     }
     constructor(abortSignal){
-        super((value)=>{
-            if (this.abortSignal?.aborted) {
-                this.nextSignal(false);
-                return false;
-            } else {
-                this.queue.push(value);
-                this.nextSignal(true);
-                return true;
-            }
-        }), this.abortSignal = abortSignal;
-        this.queue = new RingBuffer();
-        this.nextSignal = new Signal(this.abortSignal);
-        this.sendSignal = new Signal(this.abortSignal);
-        this.abortSignal?.addEventListener('abort', ()=>this.nextSignal(false), {
-            once: true
-        });
+        super(abortSignal);
+        this.#queue = new RingBuffer();
+        this.#nextSignal = new Signal(abortSignal);
+        this.#sendSignal = new Signal(abortSignal);
     }
     get size() {
-        return this.queue.length;
+        return this.#queue.length;
     }
     async reserve(capacity) {
-        while(this.queue.length > capacity){
-            await this.sendSignal;
+        while(this.#queue.length > capacity){
+            await this.#sendSignal;
         }
     }
-    async next() {
-        while(!this.queue.length){
-            await this.nextSignal;
+    emit(value) {
+        const ok = !this.disposed;
+        if (ok) {
+            this.#queue.push(value);
         }
-        this.sendSignal();
-        return this.queue.shift();
+        this.#nextSignal.emit();
+        return ok;
     }
-    [Symbol.dispose]() {
-        this.nextSignal(false);
+    async receive() {
+        while(!this.#queue.length){
+            await this.#nextSignal;
+        }
+        this.#sendSignal.emit();
+        return this.#queue.shift();
+    }
+    dispose() {
+        this.#sendSignal[Symbol.dispose]();
+        this.#nextSignal[Symbol.dispose]();
     }
 }
 

package/build/sequence.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/sequence.ts"],"sourcesContent":["import { RingBuffer } from 'fastds';\nimport { CallableAsyncIterator } from './callable.js';\nimport { Signal } from './signal.js';\n\n/**\n * A sequence is a FIFO (First-In-First-Out) queue for async consumption.\n * Designed for single consumer with multiple producers pattern.\n * Values are queued and consumed in order, with backpressure support.\n *\n * Key characteristics:\n * - Single consumer - values are consumed once, in order\n * - Multiple producers can push values concurrently\n * - FIFO ordering - first value in is first value out\n * - Backpressure control via reserve() method\n * - Async iteration support for continuous consumption\n *\n * @template T The type of values in the sequence.\n *\n * ```typescript\n * // Create a sequence for processing tasks\n * const tasks = new Sequence<string>();\n *\n * // Producer: Add tasks to the queue\n * tasks('task1');\n * tasks('task2');\n * tasks('task3');\n *\n * // Consumer: Process tasks in order\n * const task1 = await tasks.next(); // 'task1'\n * const task2 = await tasks.next(); // 'task2'\n * const task3 = await tasks.next(); // 'task3'\n * ```\n */\nexport class Sequence<T> extends CallableAsyncIterator<T, boolean> {\n  private queue: RingBuffer<T>;\n  private nextSignal: Signal<boolean>;\n  private sendSignal: Signal<void>;\n\n  readonly [Symbol.toStringTag] = 'Sequence';\n\n  /**\n   * Merges multiple source sequences into a target sequence.\n   * Values from all sources are forwarded to the target sequence.\n   * Each source is consumed independently and concurrently.\n   *\n   * @param target The sequence that will receive values from all sources\n   * @param sequences The source sequences to merge from\n   *\n   * ```typescript\n   * // Create target and source sequences\n   * const target = new Sequence<number>();\n   * const source1 = new Sequence<number>();\n   * const source2 = new Sequence<number>();\n   *\n   * // Merge sources into target\n   * Sequence.merge(target, source1, source2);\n   *\n   * // Values from both sources appear in target\n   * source1(1);\n   * source2(2);\n   * source1(3);\n   *\n   * // Consumer gets values as they arrive\n   * await target.next(); // Could be 1, 2, or 3 depending on timing\n   * ```\n   */\n  static merge<T>(target: Sequence<T>, ...sequences: Sequence<T>[]): void {\n    for (const source of sequences) {\n      queueMicrotask(async () => {\n        try {\n          for await (const value of source) {\n            target(value);\n          }\n        } catch {\n          // sequence is aborted\n        }\n      });\n    }\n  }\n\n  constructor(private readonly abortSignal?: AbortSignal) {\n    super((value: T) => {\n      if (this.abortSignal?.aborted) {\n        this.nextSignal(false);\n        return false;\n      } else {\n        this.queue.push(value);\n        this.nextSignal(true);\n        return true;\n      }\n    });\n    this.queue = new RingBuffer();\n    this.nextSignal = new Signal(this.abortSignal);\n    this.sendSignal = new Signal(this.abortSignal);\n    this.abortSignal?.addEventListener('abort', () => this.nextSignal(false), { once: true });\n  }\n\n  /**\n   * Returns the number of values currently queued.\n   *\n   * @returns The current queue size\n   */\n  get size(): number {\n    return this.queue.length;\n  }\n\n  /**\n   * Waits until the queue size drops to or below the specified capacity.\n   * Useful for implementing backpressure - producers can wait before adding more items.\n   *\n   * @param capacity The maximum queue size to wait for\n   * @returns A promise that resolves when the queue size is at or below capacity\n   *\n   * ```typescript\n   * // Producer with backpressure control\n   * const sequence = new Sequence<string>();\n   *\n   * // Wait if queue has more than 10 items\n   * await sequence.reserve(10);\n   * sequence('new item'); // Safe to add, queue has space\n   * ```\n   */\n  async reserve(capacity: number): Promise<void> {\n    while (this.queue.length > capacity) {\n      await this.sendSignal;\n    }\n  }\n\n  /**\n   * Consumes and returns the next value from the queue.\n   * If the queue is empty, waits for a value to be added.\n   * Values are consumed in FIFO order.\n   *\n   * @returns A promise that resolves with the next value\n   *\n   * ```typescript\n   * const sequence = new Sequence<number>();\n   *\n   * // Consumer waits for values\n   * const valuePromise = sequence.next();\n   *\n   * // Producer adds value\n   * sequence(42);\n   *\n   * // Consumer receives it\n   * const value = await valuePromise; // 42\n   * ```\n   */\n  async next(): Promise<T> {\n    while (!this.queue.length) {\n      await this.nextSignal;\n    }\n    this.sendSignal();\n    return this.queue.shift()!;\n  }\n\n  /**\n   * Disposes of the sequence, signaling any waiting consumers.\n   * Called automatically when used with `using` declaration.\n   */\n  [Symbol.dispose](): void {\n    this.nextSignal(false);\n  }\n}\n"],"names":["RingBuffer","CallableAsyncIterator","Signal","Sequence","queue","nextSignal","sendSignal","Symbol","toStringTag","merge","target","sequences","source","queueMicrotask","value","abortSignal","aborted","push","addEventListener","once","size","length","reserve","capacity","next","shift","dispose"],"mappings":"AAAA,SAASA,UAAU,QAAQ,SAAS;AACpC,SAASC,qBAAqB,QAAQ,gBAAgB;AACtD,SAASC,MAAM,QAAQ,cAAc;AA+BrC,OAAO,MAAMC,iBAAoBF;;IACvBG,MAAqB;IACrBC,WAA4B;IAC5BC,WAAyB;IAExB,CAACC,OAAOC,WAAW,CAAC,GAAG,WAAW;IA4B3C,OAAOC,MAASC,MAAmB,EAAE,GAAGC,SAAwB,EAAQ;QACtE,KAAK,MAAMC,UAAUD,UAAW;YAC9BE,eAAe;gBACb,IAAI;oBACF,WAAW,MAAMC,SAASF,OAAQ;wBAChCF,OAAOI;oBACT;gBACF,EAAE,OAAM,CAER;YACF;QACF;IACF;IAEA,YAAY,AAAiBC,WAAyB,CAAE;QACtD,KAAK,CAAC,CAACD;YACL,IAAI,IAAI,CAACC,WAAW,EAAEC,SAAS;gBAC7B,IAAI,CAACX,UAAU,CAAC;gBAChB,OAAO;YACT,OAAO;gBACL,IAAI,CAACD,KAAK,CAACa,IAAI,CAACH;gBAChB,IAAI,CAACT,UAAU,CAAC;gBAChB,OAAO;YACT;QACF,SAV2BU,cAAAA;QAW3B,IAAI,CAACX,KAAK,GAAG,IAAIJ;QACjB,IAAI,CAACK,UAAU,GAAG,IAAIH,OAAO,IAAI,CAACa,WAAW;QAC7C,IAAI,CAACT,UAAU,GAAG,IAAIJ,OAAO,IAAI,CAACa,WAAW;QAC7C,IAAI,CAACA,WAAW,EAAEG,iBAAiB,SAAS,IAAM,IAAI,CAACb,UAAU,CAAC,QAAQ;YAAEc,MAAM;QAAK;IACzF;IAOA,IAAIC,OAAe;QACjB,OAAO,IAAI,CAAChB,KAAK,CAACiB,MAAM;IAC1B;IAkBA,MAAMC,QAAQC,QAAgB,EAAiB;QAC7C,MAAO,IAAI,CAACnB,KAAK,CAACiB,MAAM,GAAGE,SAAU;YACnC,MAAM,IAAI,CAACjB,UAAU;QACvB;IACF;IAsBA,MAAMkB,OAAmB;QACvB,MAAO,CAAC,IAAI,CAACpB,KAAK,CAACiB,MAAM,CAAE;YACzB,MAAM,IAAI,CAAChB,UAAU;QACvB;QACA,IAAI,CAACC,UAAU;QACf,OAAO,IAAI,CAACF,KAAK,CAACqB,KAAK;IACzB;IAMA,CAAClB,OAAOmB,OAAO,CAAC,GAAS;QACvB,IAAI,CAACrB,UAAU,CAAC;IAClB;AACF"}
+{"version":3,"sources":["../src/sequence.ts"],"sourcesContent":["import { Async } from './async.js';\nimport { Signal } from './signal.js';\nimport { RingBuffer } from './ring-buffer.js';\n\n/**\n * A sequence is a FIFO (First-In-First-Out) queue for async consumption.\n * Designed for single consumer with multiple producers pattern.\n * Values are queued and consumed in order, with backpressure support.\n * Respects an optional AbortSignal: emit() returns false when aborted; waits reject.\n *\n * Key characteristics:\n * - Single consumer - values are consumed once, in order\n * - Multiple producers can push values concurrently\n * - FIFO ordering - first value in is first value out\n * - Backpressure control via reserve() method\n * - Async iteration support for continuous consumption\n *\n * @template T The type of values in the sequence.\n *\n * @example\n * ```typescript\n * // Create a sequence for processing tasks\n * const tasks = new Sequence<string>();\n *\n * // Producer: Add tasks to the queue\n * tasks.emit('task1');\n * tasks.emit('task2');\n * tasks.emit('task3');\n *\n * // Consumer: Process tasks in order\n * const task1 = await tasks.receive(); // 'task1'\n * const task2 = await tasks.receive(); // 'task2'\n * const task3 = await tasks.receive(); // 'task3'\n * ```\n */\nexport class Sequence<T> extends Async<T, boolean> {\n  #queue: RingBuffer<T>;\n  #nextSignal: Signal<void>;\n  #sendSignal: Signal<void>;\n\n  readonly [Symbol.toStringTag] = 'Sequence';\n\n  /**\n   * Merges multiple source sequences into a target sequence.\n   * Values from all sources are forwarded to the target sequence.\n   * Each source is consumed independently and concurrently.\n   *\n   * @param target The sequence that will receive values from all sources\n   * @param sequences The source sequences to merge from\n   *\n   * @example\n   * ```typescript\n   * // Create target and source sequences\n   * const target = new Sequence<number>();\n   * const source1 = new Sequence<number>();\n   * const source2 = new Sequence<number>();\n   *\n   * // Merge sources into target\n   * Sequence.merge(target, source1, source2);\n   *\n   * // Values from both sources appear in target\n   * source1.emit(1);\n   * source2.emit(2);\n   * source1.emit(3);\n   *\n   * // Consumer gets values as they arrive\n   * await target.receive(); // Could be 1, 2, or 3 depending on timing\n   * ```\n   */\n  static merge<T>(target: Sequence<T>, ...sequences: Sequence<T>[]): void {\n    for (const source of sequences) {\n      queueMicrotask(async () => {\n        if (!target.disposed)\n          try {\n            const sink = target.sink;\n            for await (const value of source) {\n              if (!sink(value)) {\n                return;\n              }\n            }\n          } catch {\n            // sequence is disposed\n          }\n      });\n    }\n  }\n\n  /**\n   * Creates a new Sequence instance.\n   * @param abortSignal - Optional AbortSignal to cancel pending operations\n   */\n  constructor(abortSignal?: AbortSignal) {\n    super(abortSignal);\n    this.#queue = new RingBuffer();\n    this.#nextSignal = new Signal(abortSignal);\n    this.#sendSignal = new Signal(abortSignal);\n  }\n\n  /**\n   * Returns the number of values currently queued.\n   *\n   * @returns The current queue size\n   */\n  get size(): number {\n    return this.#queue.length;\n  }\n\n  /**\n   * Waits until the queue size drops to or below the specified capacity.\n   * Useful for implementing backpressure - producers can wait before adding more items.\n   *\n   * @param capacity The maximum queue size to wait for\n   * @returns A promise that resolves when the queue size is at or below capacity\n   *\n   * @example\n   * ```typescript\n   * // Producer with backpressure control\n   * const sequence = new Sequence<string>();\n   *\n   * // Wait if queue has more than 10 items\n   * await sequence.reserve(10);\n   * sequence.emit('new item'); // Safe to add, queue has space\n   * ```\n   */\n  async reserve(capacity: number): Promise<void> {\n    while (this.#queue.length > capacity) {\n      await this.#sendSignal;\n    }\n  }\n\n  /**\n   * Pushes a value onto the queue. Wakes any pending `receive()` waiter.\n   *\n   * @param value - The value to enqueue.\n   * @returns `true` if the sequence is still active.\n   */\n  emit(value: T): boolean {\n    const ok = !this.disposed;\n    if (ok) {\n      this.#queue.push(value);\n    }\n    this.#nextSignal.emit();\n    return ok;\n  }\n\n  /**\n   * Consumes and returns the next value from the queue.\n   * If the queue is empty, waits for a value to be added.\n   * Values are consumed in FIFO order.\n   * If the sequence has been aborted or disposed, this method rejects with Error('Disposed').\n   *\n   * @returns A promise that resolves with the next value\n   *\n   * @example\n   * ```typescript\n   * const sequence = new Sequence<number>();\n   *\n   * // Consumer waits for values\n   * const valuePromise = sequence.receive();\n   *\n   * // Producer adds value\n   * sequence.emit(42);\n   *\n   * // Consumer receives it\n   * const value = await valuePromise; // 42\n   * ```\n   */\n  async receive(): Promise<T> {\n    while (!this.#queue.length) {\n      await this.#nextSignal;\n    }\n    this.#sendSignal.emit();\n    return this.#queue.shift()!;\n  }\n\n  /**\n   * Disposes of the sequence, rejecting any pending `receive()` waiters.\n   * Called by `[Symbol.dispose]()` (inherited from Async) when using the `using` declaration.\n   */\n  dispose(): void {\n    this.#sendSignal[Symbol.dispose]();\n    this.#nextSignal[Symbol.dispose]();\n  }\n}\n"],"names":["Async","Signal","RingBuffer","Sequence","Symbol","toStringTag","merge","target","sequences","source","queueMicrotask","disposed","sink","value","abortSignal","size","length","reserve","capacity","emit","ok","push","receive","shift","dispose"],"mappings":"AAAA,SAASA,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,QAAQ,cAAc;AACrC,SAASC,UAAU,QAAQ,mBAAmB;AAiC9C,OAAO,MAAMC,iBAAoBH;IAC/B,CAAA,KAAM,CAAgB;IACtB,CAAA,UAAW,CAAe;IAC1B,CAAA,UAAW,CAAe;IAEjB,CAACI,OAAOC,WAAW,CAAC,GAAG,WAAW;IA6B3C,OAAOC,MAASC,MAAmB,EAAE,GAAGC,SAAwB,EAAQ;QACtE,KAAK,MAAMC,UAAUD,UAAW;YAC9BE,eAAe;gBACb,IAAI,CAACH,OAAOI,QAAQ,EAClB,IAAI;oBACF,MAAMC,OAAOL,OAAOK,IAAI;oBACxB,WAAW,MAAMC,SAASJ,OAAQ;wBAChC,IAAI,CAACG,KAAKC,QAAQ;4BAChB;wBACF;oBACF;gBACF,EAAE,OAAM,CAER;YACJ;QACF;IACF;IAMA,YAAYC,WAAyB,CAAE;QACrC,KAAK,CAACA;QACN,IAAI,CAAC,CAAA,KAAM,GAAG,IAAIZ;QAClB,IAAI,CAAC,CAAA,UAAW,GAAG,IAAID,OAAOa;QAC9B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIb,OAAOa;IAChC;IAOA,IAAIC,OAAe;QACjB,OAAO,IAAI,CAAC,CAAA,KAAM,CAACC,MAAM;IAC3B;IAmBA,MAAMC,QAAQC,QAAgB,EAAiB;QAC7C,MAAO,IAAI,CAAC,CAAA,KAAM,CAACF,MAAM,GAAGE,SAAU;YACpC,MAAM,IAAI,CAAC,CAAA,UAAW;QACxB;IACF;IAQAC,KAAKN,KAAQ,EAAW;QACtB,MAAMO,KAAK,CAAC,IAAI,CAACT,QAAQ;QACzB,IAAIS,IAAI;YACN,IAAI,CAAC,CAAA,KAAM,CAACC,IAAI,CAACR;QACnB;QACA,IAAI,CAAC,CAAA,UAAW,CAACM,IAAI;QACrB,OAAOC;IACT;IAwBA,MAAME,UAAsB;QAC1B,MAAO,CAAC,IAAI,CAAC,CAAA,KAAM,CAACN,MAAM,CAAE;YAC1B,MAAM,IAAI,CAAC,CAAA,UAAW;QACxB;QACA,IAAI,CAAC,CAAA,UAAW,CAACG,IAAI;QACrB,OAAO,IAAI,CAAC,CAAA,KAAM,CAACI,KAAK;IAC1B;IAMAC,UAAgB;QACd,IAAI,CAAC,CAAA,UAAW,CAACpB,OAAOoB,OAAO,CAAC;QAChC,IAAI,CAAC,CAAA,UAAW,CAACpB,OAAOoB,OAAO,CAAC;IAClC;AACF"}

package/build/signal.cjs

@@ -8,55 +8,46 @@ Object.defineProperty(exports, "Signal", {
         return Signal;
     }
 });
-const _callablecjs = require("./callable.cjs");
-class Signal extends _callablecjs.CallableAsyncIterator {
-    abortSignal;
-    rx;
+const _asynccjs = require("./async.cjs");
+class Signal extends _asynccjs.Async {
+    #rx;
     [Symbol.toStringTag] = 'Signal';
     static merge(target, ...signals) {
+        if (target.disposed) {
+            return;
+        }
         for (const source of signals){
-            queueMicrotask(async ()=>{
+            void (async ()=>{
                 try {
+                    const sink = target.sink;
                     for await (const value of source){
-                        if (target.aborted) break;
-                        target(value);
+                        if (!sink(value) && target.disposed) {
+                            return;
+                        }
                     }
                 } catch  {}
-            });
+            })();
         }
     }
     constructor(abortSignal){
-        super((value)=>{
-            if (this.rx) {
-                this.rx.resolve(value);
-                this.rx = undefined;
-                return true;
-            } else {
-                return false;
-            }
-        }), this.abortSignal = abortSignal;
-        this.abortSignal?.addEventListener('abort', ()=>{
-            this.rx?.reject(this.abortSignal.reason);
-            this.rx = undefined;
-        }, {
-            once: true
-        });
+        super(abortSignal);
     }
-    get aborted() {
-        return !!this.abortSignal?.aborted;
+    emit(value) {
+        if (!this.#rx) return false;
+        this.#rx.resolve(value);
+        this.#rx = undefined;
+        return true;
     }
-    next() {
-        if (this.abortSignal?.aborted) {
-            return Promise.reject(this.abortSignal.reason);
-        }
-        if (!this.rx) {
-            this.rx = Promise.withResolvers();
+    receive() {
+        if (this.disposed) {
+            return Promise.reject(new Error('Disposed'));
         }
-        return this.rx.promise;
+        this.#rx ??= Promise.withResolvers();
+        return this.#rx.promise;
     }
-    [Symbol.dispose]() {
-        this.rx?.reject(new Error('Disposed'));
-        this.rx = undefined;
+    dispose() {
+        this.#rx?.reject(new Error('Disposed'));
+        this.#rx = undefined;
     }
 }
 

package/build/signal.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/signal.ts"],"sourcesContent":["import { CallableAsyncIterator } from './callable.js';\n\n/**\n * A signal is a broadcast async primitive for coordinating between producers and consumers.\n * When a value is sent, ALL waiting consumers receive the same value (broadcast pattern).\n * Signals can be reused - each call to next() creates a new promise for the next value.\n *\n * Key characteristics:\n * - Multiple consumers can wait simultaneously\n * - All waiting consumers receive the same value when sent\n * - Reusable - can send multiple values over time\n * - Supports async iteration for continuous value streaming\n *\n * @template T The type of value that this signal carries.\n *\n * ```typescript\n * // Create a signal for string values\n * const signal = new Signal<string>();\n *\n * // Multiple consumers wait for the same value\n * const promise1 = signal.next();\n * const promise2 = signal.next();\n *\n * // Send a value - both consumers receive it\n * signal('Hello World');\n *\n * const [value1, value2] = await Promise.all([promise1, promise2]);\n * console.log(value1 === value2); // true - both got 'Hello World'\n * ```\n */\nexport class Signal<T> extends CallableAsyncIterator<T, boolean> {\n  private rx?: PromiseWithResolvers<T>;\n\n  readonly [Symbol.toStringTag] = 'Signal';\n\n  /**\n   * Merges multiple source signals into a target signal.\n   * Values from any source signal are forwarded to the target signal.\n   * The merge continues until the target signal is aborted.\n   *\n   * @param target The signal that will receive values from all sources\n   * @param signals The source signals to merge from\n   *\n   * ```typescript\n   * // Create a target signal and source signals\n   * const target = new Signal<string>();\n   * const source1 = new Signal<string>();\n   * const source2 = new Signal<string>();\n   *\n   * // Merge sources into target\n   * Signal.merge(target, source1, source2);\n   *\n   * // Values from any source appear in target\n   * source1('Hello');\n   * const value = await target; // 'Hello'\n   * ```\n   */\n  static merge<T>(target: Signal<T>, ...signals: Signal<T>[]): void {\n    for (const source of signals) {\n      queueMicrotask(async () => {\n        try {\n          for await (const value of source) {\n            if (target.aborted) break;\n            target(value);\n          }\n        } catch {\n          // ignore aborted signal\n        }\n      });\n    }\n  }\n\n  /**\n   * Creates a new Signal instance.\n   *\n   * @param abortSignal An optional AbortSignal that can be used to cancel the signal operation.\n   *\n   * ```typescript\n   * // Create a signal with abort capability\n   * const controller = new AbortController();\n   * const signal = new Signal<number>(controller.signal);\n   *\n   * // Signal can be cancelled\n   * controller.abort('Operation cancelled');\n   * ```\n   */\n  constructor(private readonly abortSignal?: AbortSignal) {\n    super((value: T) => {\n      if (this.rx) {\n        this.rx.resolve(value);\n        this.rx = undefined;\n        return true;\n      } else {\n        return false;\n      }\n    });\n    this.abortSignal?.addEventListener(\n      'abort',\n      () => {\n        this.rx?.reject(this.abortSignal!.reason);\n        this.rx = undefined;\n      },\n      { once: true },\n    );\n  }\n\n  get aborted(): boolean {\n    return !!this.abortSignal?.aborted;\n  }\n\n  /**\n   * Waits for the next value to be sent to this signal. If the signal has been aborted,\n   * this method will reject with the abort reason.\n   *\n   * @returns A promise that resolves with the next value sent to the signal.\n   *\n   * ```typescript\n   * const signal = new Signal<string>();\n   *\n   * // Wait for a value\n   * const valuePromise = signal.next();\n   *\n   * // Send a value from elsewhere\n   * signal('Hello');\n   *\n   * const value = await valuePromise; // 'Hello'\n   * ```\n   */\n  next(): Promise<T> {\n    if (this.abortSignal?.aborted) {\n      return Promise.reject(this.abortSignal.reason);\n    }\n    if (!this.rx) {\n      this.rx = Promise.withResolvers<T>();\n    }\n    return this.rx.promise;\n  }\n\n  /**\n   * Disposes of the signal, cleaning up any pending promise resolvers.\n   * This method is called automatically when the signal is used with a `using` declaration.\n   */\n  [Symbol.dispose](): void {\n    this.rx?.reject(new Error('Disposed'));\n    this.rx = undefined;\n  }\n}\n"],"names":["Signal","CallableAsyncIterator","rx","Symbol","toStringTag","merge","target","signals","source","queueMicrotask","value","aborted","abortSignal","resolve","undefined","addEventListener","reject","reason","once","next","Promise","withResolvers","promise","dispose","Error"],"mappings":";;;;+BA8BaA;;;eAAAA;;;6BA9ByB;AA8B/B,MAAMA,eAAkBC,kCAAqB;;IAC1CC,GAA6B;IAE5B,CAACC,OAAOC,WAAW,CAAC,GAAG,SAAS;IAwBzC,OAAOC,MAASC,MAAiB,EAAE,GAAGC,OAAoB,EAAQ;QAChE,KAAK,MAAMC,UAAUD,QAAS;YAC5BE,eAAe;gBACb,IAAI;oBACF,WAAW,MAAMC,SAASF,OAAQ;wBAChC,IAAIF,OAAOK,OAAO,EAAE;wBACpBL,OAAOI;oBACT;gBACF,EAAE,OAAM,CAER;YACF;QACF;IACF;IAgBA,YAAY,AAAiBE,WAAyB,CAAE;QACtD,KAAK,CAAC,CAACF;YACL,IAAI,IAAI,CAACR,EAAE,EAAE;gBACX,IAAI,CAACA,EAAE,CAACW,OAAO,CAACH;gBAChB,IAAI,CAACR,EAAE,GAAGY;gBACV,OAAO;YACT,OAAO;gBACL,OAAO;YACT;QACF,SAT2BF,cAAAA;QAU3B,IAAI,CAACA,WAAW,EAAEG,iBAChB,SACA;YACE,IAAI,CAACb,EAAE,EAAEc,OAAO,IAAI,CAACJ,WAAW,CAAEK,MAAM;YACxC,IAAI,CAACf,EAAE,GAAGY;QACZ,GACA;YAAEI,MAAM;QAAK;IAEjB;IAEA,IAAIP,UAAmB;QACrB,OAAO,CAAC,CAAC,IAAI,CAACC,WAAW,EAAED;IAC7B;IAoBAQ,OAAmB;QACjB,IAAI,IAAI,CAACP,WAAW,EAAED,SAAS;YAC7B,OAAOS,QAAQJ,MAAM,CAAC,IAAI,CAACJ,WAAW,CAACK,MAAM;QAC/C;QACA,IAAI,CAAC,IAAI,CAACf,EAAE,EAAE;YACZ,IAAI,CAACA,EAAE,GAAGkB,QAAQC,aAAa;QACjC;QACA,OAAO,IAAI,CAACnB,EAAE,CAACoB,OAAO;IACxB;IAMA,CAACnB,OAAOoB,OAAO,CAAC,GAAS;QACvB,IAAI,CAACrB,EAAE,EAAEc,OAAO,IAAIQ,MAAM;QAC1B,IAAI,CAACtB,EAAE,GAAGY;IACZ;AACF"}
+{"version":3,"sources":["../src/signal.ts"],"sourcesContent":["import { Async } from './async.js';\n\n/**\n * Promise-based async coordination primitive.\n * `emit()` resolves the pending `receive()` promise (shared across callers).\n * Reusable - after each emission a new round of `receive()` calls can be made.\n * Disposable via `[Symbol.dispose]()` or an optional AbortSignal.\n *\n * @template T The type of value that this signal carries.\n *\n * @example\n * ```typescript\n * const signal = new Signal<string>();\n *\n * const promise = signal.receive();\n * signal.emit('hello');\n * await promise; // 'hello'\n * ```\n */\nexport class Signal<T> extends Async<T, boolean> {\n  #rx?: PromiseWithResolvers<T>;\n\n  readonly [Symbol.toStringTag] = 'Signal';\n\n  /**\n   * Merges multiple source signals into a target signal.\n   * Values from any source signal are emitted to the target signal.\n   * The merge continues until the target signal is disposed.\n   *\n   * Note: When the target is disposed, iteration stops after the next value\n   * from each source. For immediate cleanup, dispose source signals directly.\n   *\n   * @param target The signal that will receive values from all sources\n   * @param signals The source signals to merge from\n   *\n   * @example\n   * ```typescript\n   * // Create a target signal and source signals\n   * const target = new Signal<string>();\n   * const source1 = new Signal<string>();\n   * const source2 = new Signal<string>();\n   *\n   * // Merge sources into target\n   * Signal.merge(target, source1, source2);\n   *\n   * // Values from any source appear in target\n   * const promise = target.receive();\n   * source1.emit('Hello');\n   * const value = await promise; // 'Hello'\n   * ```\n   */\n  static merge<T>(target: Signal<T>, ...signals: Signal<T>[]): void {\n    if (target.disposed) {\n      return;\n    }\n    for (const source of signals) {\n      void (async () => {\n        try {\n          const sink = target.sink;\n          for await (const value of source) {\n            if (!sink(value) && target.disposed) {\n              return;\n            }\n          }\n        } catch {\n          // ignore disposed signal\n        }\n      })();\n    }\n  }\n\n  /**\n   * Creates a new Signal instance.\n   *\n   * @param abortSignal An optional AbortSignal that can be used to cancel the signal operation.\n   *\n   * @example\n   * ```typescript\n   * // Create a signal with abort capability\n   * const controller = new AbortController();\n   * const signal = new Signal<number>(controller.signal);\n   *\n   * // Signal can be cancelled\n   * controller.abort('Operation cancelled');\n   * ```\n   */\n  constructor(abortSignal?: AbortSignal) {\n    super(abortSignal);\n  }\n\n  /**\n   * Sends a value to the waiting receiver, if any.\n   *\n   * @param value - The value to send.\n   * @returns `true` if the value was emitted.\n   */\n  emit(value: T): boolean {\n    if (!this.#rx) return false;\n    this.#rx.resolve(value);\n    this.#rx = undefined;\n    return true;\n  }\n\n  /**\n   * Waits for the next value to be sent to this signal. If the signal has been aborted\n   * or disposed, this method rejects with Error('Disposed').\n   *\n   * @returns A promise that resolves with the next value sent to the signal.\n   *\n   * @example\n   * ```typescript\n   * const signal = new Signal<string>();\n   *\n   * // Wait for a value\n   * const valuePromise = signal.receive();\n   *\n   * // Send a value from elsewhere\n   * signal.emit('Hello');\n   *\n   * const value = await valuePromise; // 'Hello'\n   * ```\n   */\n  receive(): Promise<T> {\n    if (this.disposed) {\n      return Promise.reject(new Error('Disposed'));\n    }\n    this.#rx ??= Promise.withResolvers<T>();\n    return this.#rx.promise;\n  }\n\n  dispose(): void {\n    this.#rx?.reject(new Error('Disposed'));\n    this.#rx = undefined;\n  }\n}\n"],"names":["Signal","Async","Symbol","toStringTag","merge","target","signals","disposed","source","sink","value","abortSignal","emit","resolve","undefined","receive","Promise","reject","Error","withResolvers","promise","dispose"],"mappings":";;;;+BAmBaA;;;eAAAA;;;0BAnBS;AAmBf,MAAMA,eAAkBC,eAAK;IAClC,CAAA,EAAG,CAA2B;IAErB,CAACC,OAAOC,WAAW,CAAC,GAAG,SAAS;IA6BzC,OAAOC,MAASC,MAAiB,EAAE,GAAGC,OAAoB,EAAQ;QAChE,IAAID,OAAOE,QAAQ,EAAE;YACnB;QACF;QACA,KAAK,MAAMC,UAAUF,QAAS;YAC5B,KAAK,AAAC,CAAA;gBACJ,IAAI;oBACF,MAAMG,OAAOJ,OAAOI,IAAI;oBACxB,WAAW,MAAMC,SAASF,OAAQ;wBAChC,IAAI,CAACC,KAAKC,UAAUL,OAAOE,QAAQ,EAAE;4BACnC;wBACF;oBACF;gBACF,EAAE,OAAM,CAER;YACF,CAAA;QACF;IACF;IAiBA,YAAYI,WAAyB,CAAE;QACrC,KAAK,CAACA;IACR;IAQAC,KAAKF,KAAQ,EAAW;QACtB,IAAI,CAAC,IAAI,CAAC,CAAA,EAAG,EAAE,OAAO;QACtB,IAAI,CAAC,CAAA,EAAG,CAACG,OAAO,CAACH;QACjB,IAAI,CAAC,CAAA,EAAG,GAAGI;QACX,OAAO;IACT;IAqBAC,UAAsB;QACpB,IAAI,IAAI,CAACR,QAAQ,EAAE;YACjB,OAAOS,QAAQC,MAAM,CAAC,IAAIC,MAAM;QAClC;QACA,IAAI,CAAC,CAAA,EAAG,KAAKF,QAAQG,aAAa;QAClC,OAAO,IAAI,CAAC,CAAA,EAAG,CAACC,OAAO;IACzB;IAEAC,UAAgB;QACd,IAAI,CAAC,CAAA,EAAG,EAAEJ,OAAO,IAAIC,MAAM;QAC3B,IAAI,CAAC,CAAA,EAAG,GAAGJ;IACb;AACF"}

package/build/signal.d.ts

@@ -1,44 +1,36 @@
-import { CallableAsyncIterator } from './callable.js';
+import { Async } from './async.js';
 /**
- * A signal is a broadcast async primitive for coordinating between producers and consumers.
- * When a value is sent, ALL waiting consumers receive the same value (broadcast pattern).
- * Signals can be reused - each call to next() creates a new promise for the next value.
- *
- * Key characteristics:
- * - Multiple consumers can wait simultaneously
- * - All waiting consumers receive the same value when sent
- * - Reusable - can send multiple values over time
- * - Supports async iteration for continuous value streaming
+ * Promise-based async coordination primitive.
+ * `emit()` resolves the pending `receive()` promise (shared across callers).
+ * Reusable - after each emission a new round of `receive()` calls can be made.
+ * Disposable via `[Symbol.dispose]()` or an optional AbortSignal.
  *
  * @template T The type of value that this signal carries.
  *
+ * @example
  * ```typescript
- * // Create a signal for string values
  * const signal = new Signal<string>();
  *
- * // Multiple consumers wait for the same value
- * const promise1 = signal.next();
- * const promise2 = signal.next();
- *
- * // Send a value - both consumers receive it
- * signal('Hello World');
- *
- * const [value1, value2] = await Promise.all([promise1, promise2]);
- * console.log(value1 === value2); // true - both got 'Hello World'
+ * const promise = signal.receive();
+ * signal.emit('hello');
+ * await promise; // 'hello'
  * ```
  */
-export declare class Signal<T> extends CallableAsyncIterator<T, boolean> {
-    private readonly abortSignal?;
-    private rx?;
+export declare class Signal<T> extends Async<T, boolean> {
+    #private;
     readonly [Symbol.toStringTag] = "Signal";
     /**
      * Merges multiple source signals into a target signal.
-     * Values from any source signal are forwarded to the target signal.
-     * The merge continues until the target signal is aborted.
+     * Values from any source signal are emitted to the target signal.
+     * The merge continues until the target signal is disposed.
+     *
+     * Note: When the target is disposed, iteration stops after the next value
+     * from each source. For immediate cleanup, dispose source signals directly.
      *
      * @param target The signal that will receive values from all sources
      * @param signals The source signals to merge from
      *
+     * @example
      * ```typescript
      * // Create a target signal and source signals
      * const target = new Signal<string>();
@@ -49,8 +41,9 @@ export declare class Signal<T> extends CallableAsyncIterator<T, boolean> {
      * Signal.merge(target, source1, source2);
      *
      * // Values from any source appear in target
-     * source1('Hello');
-     * const value = await target; // 'Hello'
+     * const promise = target.receive();
+     * source1.emit('Hello');
+     * const value = await promise; // 'Hello'
      * ```
      */
     static merge<T>(target: Signal<T>, ...signals: Signal<T>[]): void;
@@ -59,6 +52,7 @@ export declare class Signal<T> extends CallableAsyncIterator<T, boolean> {
      *
      * @param abortSignal An optional AbortSignal that can be used to cancel the signal operation.
      *
+     * @example
      * ```typescript
      * // Create a signal with abort capability
      * const controller = new AbortController();
@@ -68,30 +62,33 @@ export declare class Signal<T> extends CallableAsyncIterator<T, boolean> {
      * controller.abort('Operation cancelled');
      * ```
      */
-    constructor(abortSignal?: AbortSignal | undefined);
-    get aborted(): boolean;
+    constructor(abortSignal?: AbortSignal);
     /**
-     * Waits for the next value to be sent to this signal. If the signal has been aborted,
-     * this method will reject with the abort reason.
+     * Sends a value to the waiting receiver, if any.
+     *
+     * @param value - The value to send.
+     * @returns `true` if the value was emitted.
+     */
+    emit(value: T): boolean;
+    /**
+     * Waits for the next value to be sent to this signal. If the signal has been aborted
+     * or disposed, this method rejects with Error('Disposed').
      *
      * @returns A promise that resolves with the next value sent to the signal.
      *
+     * @example
      * ```typescript
      * const signal = new Signal<string>();
      *
      * // Wait for a value
-     * const valuePromise = signal.next();
+     * const valuePromise = signal.receive();
      *
      * // Send a value from elsewhere
-     * signal('Hello');
+     * signal.emit('Hello');
      *
      * const value = await valuePromise; // 'Hello'
      * ```
      */
-    next(): Promise<T>;
-    /**
-     * Disposes of the signal, cleaning up any pending promise resolvers.
-     * This method is called automatically when the signal is used with a `using` declaration.
-     */
-    [Symbol.dispose](): void;
+    receive(): Promise<T>;
+    dispose(): void;
 }

package/build/signal.js

@@ -1,52 +1,43 @@
-import { CallableAsyncIterator } from "./callable.js";
-export class Signal extends CallableAsyncIterator {
-    abortSignal;
-    rx;
+import { Async } from "./async.js";
+export class Signal extends Async {
+    #rx;
     [Symbol.toStringTag] = 'Signal';
     static merge(target, ...signals) {
+        if (target.disposed) {
+            return;
+        }
         for (const source of signals){
-            queueMicrotask(async ()=>{
+            void (async ()=>{
                 try {
+                    const sink = target.sink;
                     for await (const value of source){
-                        if (target.aborted) break;
-                        target(value);
+                        if (!sink(value) && target.disposed) {
+                            return;
+                        }
                     }
                 } catch  {}
-            });
+            })();
         }
     }
     constructor(abortSignal){
-        super((value)=>{
-            if (this.rx) {
-                this.rx.resolve(value);
-                this.rx = undefined;
-                return true;
-            } else {
-                return false;
-            }
-        }), this.abortSignal = abortSignal;
-        this.abortSignal?.addEventListener('abort', ()=>{
-            this.rx?.reject(this.abortSignal.reason);
-            this.rx = undefined;
-        }, {
-            once: true
-        });
+        super(abortSignal);
     }
-    get aborted() {
-        return !!this.abortSignal?.aborted;
+    emit(value) {
+        if (!this.#rx) return false;
+        this.#rx.resolve(value);
+        this.#rx = undefined;
+        return true;
     }
-    next() {
-        if (this.abortSignal?.aborted) {
-            return Promise.reject(this.abortSignal.reason);
-        }
-        if (!this.rx) {
-            this.rx = Promise.withResolvers();
+    receive() {
+        if (this.disposed) {
+            return Promise.reject(new Error('Disposed'));
         }
-        return this.rx.promise;
+        this.#rx ??= Promise.withResolvers();
+        return this.#rx.promise;
     }
-    [Symbol.dispose]() {
-        this.rx?.reject(new Error('Disposed'));
-        this.rx = undefined;
+    dispose() {
+        this.#rx?.reject(new Error('Disposed'));
+        this.#rx = undefined;
     }
 }
 

package/build/signal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/signal.ts"],"sourcesContent":["import { CallableAsyncIterator } from './callable.js';\n\n/**\n * A signal is a broadcast async primitive for coordinating between producers and consumers.\n * When a value is sent, ALL waiting consumers receive the same value (broadcast pattern).\n * Signals can be reused - each call to next() creates a new promise for the next value.\n *\n * Key characteristics:\n * - Multiple consumers can wait simultaneously\n * - All waiting consumers receive the same value when sent\n * - Reusable - can send multiple values over time\n * - Supports async iteration for continuous value streaming\n *\n * @template T The type of value that this signal carries.\n *\n * ```typescript\n * // Create a signal for string values\n * const signal = new Signal<string>();\n *\n * // Multiple consumers wait for the same value\n * const promise1 = signal.next();\n * const promise2 = signal.next();\n *\n * // Send a value - both consumers receive it\n * signal('Hello World');\n *\n * const [value1, value2] = await Promise.all([promise1, promise2]);\n * console.log(value1 === value2); // true - both got 'Hello World'\n * ```\n */\nexport class Signal<T> extends CallableAsyncIterator<T, boolean> {\n  private rx?: PromiseWithResolvers<T>;\n\n  readonly [Symbol.toStringTag] = 'Signal';\n\n  /**\n   * Merges multiple source signals into a target signal.\n   * Values from any source signal are forwarded to the target signal.\n   * The merge continues until the target signal is aborted.\n   *\n   * @param target The signal that will receive values from all sources\n   * @param signals The source signals to merge from\n   *\n   * ```typescript\n   * // Create a target signal and source signals\n   * const target = new Signal<string>();\n   * const source1 = new Signal<string>();\n   * const source2 = new Signal<string>();\n   *\n   * // Merge sources into target\n   * Signal.merge(target, source1, source2);\n   *\n   * // Values from any source appear in target\n   * source1('Hello');\n   * const value = await target; // 'Hello'\n   * ```\n   */\n  static merge<T>(target: Signal<T>, ...signals: Signal<T>[]): void {\n    for (const source of signals) {\n      queueMicrotask(async () => {\n        try {\n          for await (const value of source) {\n            if (target.aborted) break;\n            target(value);\n          }\n        } catch {\n          // ignore aborted signal\n        }\n      });\n    }\n  }\n\n  /**\n   * Creates a new Signal instance.\n   *\n   * @param abortSignal An optional AbortSignal that can be used to cancel the signal operation.\n   *\n   * ```typescript\n   * // Create a signal with abort capability\n   * const controller = new AbortController();\n   * const signal = new Signal<number>(controller.signal);\n   *\n   * // Signal can be cancelled\n   * controller.abort('Operation cancelled');\n   * ```\n   */\n  constructor(private readonly abortSignal?: AbortSignal) {\n    super((value: T) => {\n      if (this.rx) {\n        this.rx.resolve(value);\n        this.rx = undefined;\n        return true;\n      } else {\n        return false;\n      }\n    });\n    this.abortSignal?.addEventListener(\n      'abort',\n      () => {\n        this.rx?.reject(this.abortSignal!.reason);\n        this.rx = undefined;\n      },\n      { once: true },\n    );\n  }\n\n  get aborted(): boolean {\n    return !!this.abortSignal?.aborted;\n  }\n\n  /**\n   * Waits for the next value to be sent to this signal. If the signal has been aborted,\n   * this method will reject with the abort reason.\n   *\n   * @returns A promise that resolves with the next value sent to the signal.\n   *\n   * ```typescript\n   * const signal = new Signal<string>();\n   *\n   * // Wait for a value\n   * const valuePromise = signal.next();\n   *\n   * // Send a value from elsewhere\n   * signal('Hello');\n   *\n   * const value = await valuePromise; // 'Hello'\n   * ```\n   */\n  next(): Promise<T> {\n    if (this.abortSignal?.aborted) {\n      return Promise.reject(this.abortSignal.reason);\n    }\n    if (!this.rx) {\n      this.rx = Promise.withResolvers<T>();\n    }\n    return this.rx.promise;\n  }\n\n  /**\n   * Disposes of the signal, cleaning up any pending promise resolvers.\n   * This method is called automatically when the signal is used with a `using` declaration.\n   */\n  [Symbol.dispose](): void {\n    this.rx?.reject(new Error('Disposed'));\n    this.rx = undefined;\n  }\n}\n"],"names":["CallableAsyncIterator","Signal","rx","Symbol","toStringTag","merge","target","signals","source","queueMicrotask","value","aborted","abortSignal","resolve","undefined","addEventListener","reject","reason","once","next","Promise","withResolvers","promise","dispose","Error"],"mappings":"AAAA,SAASA,qBAAqB,QAAQ,gBAAgB;AA8BtD,OAAO,MAAMC,eAAkBD;;IACrBE,GAA6B;IAE5B,CAACC,OAAOC,WAAW,CAAC,GAAG,SAAS;IAwBzC,OAAOC,MAASC,MAAiB,EAAE,GAAGC,OAAoB,EAAQ;QAChE,KAAK,MAAMC,UAAUD,QAAS;YAC5BE,eAAe;gBACb,IAAI;oBACF,WAAW,MAAMC,SAASF,OAAQ;wBAChC,IAAIF,OAAOK,OAAO,EAAE;wBACpBL,OAAOI;oBACT;gBACF,EAAE,OAAM,CAER;YACF;QACF;IACF;IAgBA,YAAY,AAAiBE,WAAyB,CAAE;QACtD,KAAK,CAAC,CAACF;YACL,IAAI,IAAI,CAACR,EAAE,EAAE;gBACX,IAAI,CAACA,EAAE,CAACW,OAAO,CAACH;gBAChB,IAAI,CAACR,EAAE,GAAGY;gBACV,OAAO;YACT,OAAO;gBACL,OAAO;YACT;QACF,SAT2BF,cAAAA;QAU3B,IAAI,CAACA,WAAW,EAAEG,iBAChB,SACA;YACE,IAAI,CAACb,EAAE,EAAEc,OAAO,IAAI,CAACJ,WAAW,CAAEK,MAAM;YACxC,IAAI,CAACf,EAAE,GAAGY;QACZ,GACA;YAAEI,MAAM;QAAK;IAEjB;IAEA,IAAIP,UAAmB;QACrB,OAAO,CAAC,CAAC,IAAI,CAACC,WAAW,EAAED;IAC7B;IAoBAQ,OAAmB;QACjB,IAAI,IAAI,CAACP,WAAW,EAAED,SAAS;YAC7B,OAAOS,QAAQJ,MAAM,CAAC,IAAI,CAACJ,WAAW,CAACK,MAAM;QAC/C;QACA,IAAI,CAAC,IAAI,CAACf,EAAE,EAAE;YACZ,IAAI,CAACA,EAAE,GAAGkB,QAAQC,aAAa;QACjC;QACA,OAAO,IAAI,CAACnB,EAAE,CAACoB,OAAO;IACxB;IAMA,CAACnB,OAAOoB,OAAO,CAAC,GAAS;QACvB,IAAI,CAACrB,EAAE,EAAEc,OAAO,IAAIQ,MAAM;QAC1B,IAAI,CAACtB,EAAE,GAAGY;IACZ;AACF"}
+{"version":3,"sources":["../src/signal.ts"],"sourcesContent":["import { Async } from './async.js';\n\n/**\n * Promise-based async coordination primitive.\n * `emit()` resolves the pending `receive()` promise (shared across callers).\n * Reusable - after each emission a new round of `receive()` calls can be made.\n * Disposable via `[Symbol.dispose]()` or an optional AbortSignal.\n *\n * @template T The type of value that this signal carries.\n *\n * @example\n * ```typescript\n * const signal = new Signal<string>();\n *\n * const promise = signal.receive();\n * signal.emit('hello');\n * await promise; // 'hello'\n * ```\n */\nexport class Signal<T> extends Async<T, boolean> {\n  #rx?: PromiseWithResolvers<T>;\n\n  readonly [Symbol.toStringTag] = 'Signal';\n\n  /**\n   * Merges multiple source signals into a target signal.\n   * Values from any source signal are emitted to the target signal.\n   * The merge continues until the target signal is disposed.\n   *\n   * Note: When the target is disposed, iteration stops after the next value\n   * from each source. For immediate cleanup, dispose source signals directly.\n   *\n   * @param target The signal that will receive values from all sources\n   * @param signals The source signals to merge from\n   *\n   * @example\n   * ```typescript\n   * // Create a target signal and source signals\n   * const target = new Signal<string>();\n   * const source1 = new Signal<string>();\n   * const source2 = new Signal<string>();\n   *\n   * // Merge sources into target\n   * Signal.merge(target, source1, source2);\n   *\n   * // Values from any source appear in target\n   * const promise = target.receive();\n   * source1.emit('Hello');\n   * const value = await promise; // 'Hello'\n   * ```\n   */\n  static merge<T>(target: Signal<T>, ...signals: Signal<T>[]): void {\n    if (target.disposed) {\n      return;\n    }\n    for (const source of signals) {\n      void (async () => {\n        try {\n          const sink = target.sink;\n          for await (const value of source) {\n            if (!sink(value) && target.disposed) {\n              return;\n            }\n          }\n        } catch {\n          // ignore disposed signal\n        }\n      })();\n    }\n  }\n\n  /**\n   * Creates a new Signal instance.\n   *\n   * @param abortSignal An optional AbortSignal that can be used to cancel the signal operation.\n   *\n   * @example\n   * ```typescript\n   * // Create a signal with abort capability\n   * const controller = new AbortController();\n   * const signal = new Signal<number>(controller.signal);\n   *\n   * // Signal can be cancelled\n   * controller.abort('Operation cancelled');\n   * ```\n   */\n  constructor(abortSignal?: AbortSignal) {\n    super(abortSignal);\n  }\n\n  /**\n   * Sends a value to the waiting receiver, if any.\n   *\n   * @param value - The value to send.\n   * @returns `true` if the value was emitted.\n   */\n  emit(value: T): boolean {\n    if (!this.#rx) return false;\n    this.#rx.resolve(value);\n    this.#rx = undefined;\n    return true;\n  }\n\n  /**\n   * Waits for the next value to be sent to this signal. If the signal has been aborted\n   * or disposed, this method rejects with Error('Disposed').\n   *\n   * @returns A promise that resolves with the next value sent to the signal.\n   *\n   * @example\n   * ```typescript\n   * const signal = new Signal<string>();\n   *\n   * // Wait for a value\n   * const valuePromise = signal.receive();\n   *\n   * // Send a value from elsewhere\n   * signal.emit('Hello');\n   *\n   * const value = await valuePromise; // 'Hello'\n   * ```\n   */\n  receive(): Promise<T> {\n    if (this.disposed) {\n      return Promise.reject(new Error('Disposed'));\n    }\n    this.#rx ??= Promise.withResolvers<T>();\n    return this.#rx.promise;\n  }\n\n  dispose(): void {\n    this.#rx?.reject(new Error('Disposed'));\n    this.#rx = undefined;\n  }\n}\n"],"names":["Async","Signal","Symbol","toStringTag","merge","target","signals","disposed","source","sink","value","abortSignal","emit","resolve","undefined","receive","Promise","reject","Error","withResolvers","promise","dispose"],"mappings":"AAAA,SAASA,KAAK,QAAQ,aAAa;AAmBnC,OAAO,MAAMC,eAAkBD;IAC7B,CAAA,EAAG,CAA2B;IAErB,CAACE,OAAOC,WAAW,CAAC,GAAG,SAAS;IA6BzC,OAAOC,MAASC,MAAiB,EAAE,GAAGC,OAAoB,EAAQ;QAChE,IAAID,OAAOE,QAAQ,EAAE;YACnB;QACF;QACA,KAAK,MAAMC,UAAUF,QAAS;YAC5B,KAAK,AAAC,CAAA;gBACJ,IAAI;oBACF,MAAMG,OAAOJ,OAAOI,IAAI;oBACxB,WAAW,MAAMC,SAASF,OAAQ;wBAChC,IAAI,CAACC,KAAKC,UAAUL,OAAOE,QAAQ,EAAE;4BACnC;wBACF;oBACF;gBACF,EAAE,OAAM,CAER;YACF,CAAA;QACF;IACF;IAiBA,YAAYI,WAAyB,CAAE;QACrC,KAAK,CAACA;IACR;IAQAC,KAAKF,KAAQ,EAAW;QACtB,IAAI,CAAC,IAAI,CAAC,CAAA,EAAG,EAAE,OAAO;QACtB,IAAI,CAAC,CAAA,EAAG,CAACG,OAAO,CAACH;QACjB,IAAI,CAAC,CAAA,EAAG,GAAGI;QACX,OAAO;IACT;IAqBAC,UAAsB;QACpB,IAAI,IAAI,CAACR,QAAQ,EAAE;YACjB,OAAOS,QAAQC,MAAM,CAAC,IAAIC,MAAM;QAClC;QACA,IAAI,CAAC,CAAA,EAAG,KAAKF,QAAQG,aAAa;QAClC,OAAO,IAAI,CAAC,CAAA,EAAG,CAACC,OAAO;IACzB;IAEAC,UAAgB;QACd,IAAI,CAAC,CAAA,EAAG,EAAEJ,OAAO,IAAIC,MAAM;QAC3B,IAAI,CAAC,CAAA,EAAG,GAAGJ;IACb;AACF"}

package/build/types.cjs

@@ -2,16 +2,5 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "HookType", {
-    enumerable: true,
-    get: function() {
-        return HookType;
-    }
-});
-var HookType = /*#__PURE__*/ function(HookType) {
-    HookType[HookType["Add"] = 0] = "Add";
-    HookType[HookType["Remove"] = 1] = "Remove";
-    return HookType;
-}({});
 
 //# sourceMappingURL=types.cjs.map

package/build/types.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["export interface Fn<A extends unknown[], R> {\n  (...args: A): R;\n}\n\nexport type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;\n\nexport type AnyIterable<T, TReturn, TNext> = Iterable<T, TReturn, TNext> | AsyncIterable<T, TReturn, TNext>;\n\nexport interface Callback<R = void> extends Fn<[], MaybePromise<R>> {}\n\nexport interface Listener<T, R = unknown> extends Fn<[T], MaybePromise<R | void>> {}\n\nexport enum HookType {\n  Add,\n  Remove,\n}\n\nexport interface HookListener<T, R> {\n  (listener: Listener<T, R> | undefined, type: HookType): void;\n}\n\nexport interface FilterIndexFunction<T> {\n  (value: T, index: number): boolean;\n}\n\nexport interface FilterFunction<T> {\n  (value: T): boolean;\n}\n\nexport interface AsyncFilterFunction<T> {\n  (value: T): MaybePromise<boolean>;\n}\n\nexport interface Predicate<T, P extends T> {\n  (value: T): value is P;\n}\n\nexport type Filter<T, P extends T> = Predicate<T, P> | FilterFunction<T> | AsyncFilterFunction<T>;\n\nexport interface Mapper<T, R> {\n  (value: T): MaybePromise<R>;\n}\n\nexport interface AsyncGenerable<T, R> {\n  (value: T): AsyncGenerator<R, void, unknown>;\n}\n\nexport interface Reducer<T, R> {\n  (result: R, value: T): MaybePromise<R>;\n}\n\nexport interface Expander<T, R> {\n  (value: T): MaybePromise<R>;\n}\n\nexport interface Promiseable<T> {\n  next(): Promise<T>;\n}\n"],"names":["HookType"],"mappings":";;;;+BAYYA;;;eAAAA;;;AAAL,IAAA,AAAKA,kCAAAA;;;WAAAA"}
+{"version":3,"sources":["../src/types.ts"],"names":[],"mappings":""}