evnty 5.0.0 → 5.1.0

package/build/ring-buffer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ring-buffer.ts"],"sourcesContent":["const DEFAULT_CAPACITY = 8;\n\n/**\n * @internal Fixed-size circular buffer that grows in powers of two when full.\n * Provides O(1) push/pop/shift/unshift and supports wrap-around iteration.\n */\nexport class RingBuffer<T> {\n  #buffer: Array<T | undefined>;\n  #head = 0;\n  #tail = 0;\n  #mask: number;\n  #length = 0;\n  #shiftCount = 0;\n\n  readonly [Symbol.toStringTag] = 'RingBuffer';\n\n  /**\n   * Creates a RingBuffer from an array of values.\n   * @param values - The values to initialize the buffer with\n   * @returns A new RingBuffer containing the values\n   */\n  static from<T>(values: T[]): RingBuffer<T> {\n    const n = values.length;\n    const ring = new RingBuffer<T>(n + 1);\n    for (let i = 0; i < n; i++) {\n      ring.#buffer[i] = values[i];\n    }\n    ring.#head = 0;\n    ring.#tail = n;\n    ring.#length = n;\n\n    return ring;\n  }\n\n  /**\n   * Creates a ring buffer with at least the requested capacity (rounded up to power of two).\n   */\n  constructor(capacity: number = DEFAULT_CAPACITY) {\n    const size = Math.max(1 << (32 - Math.clz32(capacity - 1)), DEFAULT_CAPACITY);\n    this.#buffer = new Array<T>(size);\n    this.#mask = size - 1;\n  }\n\n  /**\n   * The number of items currently in the buffer.\n   */\n  get length(): number {\n    return this.#length;\n  }\n\n  /**\n   * Logical position of the buffer's left edge (total items ever shifted).\n   * Monotonically increasing - useful for cursor-based consumers.\n   */\n  get left(): number {\n    return this.#shiftCount;\n  }\n\n  /**\n   * Logical position of the buffer's right edge (left + length).\n   * Represents the next logical index for push.\n   */\n  get right(): number {\n    return this.#shiftCount + this.#length;\n  }\n\n  /**\n   * Returns true if the buffer has wrapped around (head > tail).\n   */\n  isWrapped(): boolean {\n    return this.#head > this.#tail;\n  }\n\n  /**\n   * Returns true if the buffer contains no items.\n   */\n  isEmpty(): boolean {\n    return this.#tail === this.#head;\n  }\n\n  /**\n   * Ensures the underlying storage can hold at least `capacity` items.\n   * Preserves existing order when the buffer is wrapped.\n   */\n  grow(capacity: number = this.#mask + 1): void {\n    const buffer = this.#buffer;\n    const bufferLength = buffer.length;\n    if (bufferLength >= capacity + 1) {\n      return;\n    }\n    const size = 1 << (32 - Math.clz32(capacity));\n    this.#buffer.length = size;\n\n    const oldTail = this.#tail;\n    if (oldTail < this.#head) {\n      for (let i = 0; i < oldTail; i++) {\n        buffer[bufferLength + i] = buffer[i];\n        buffer[i] = undefined;\n      }\n      this.#tail = bufferLength + oldTail;\n    }\n\n    this.#mask = size - 1;\n  }\n\n  /**\n   * Appends a value at the tail, growing if full.\n   */\n  push(value: T) {\n    const nextTail = (this.#tail + 1) & this.#mask;\n    if (nextTail === this.#head) {\n      this.grow(this.#mask + 2);\n      this.#buffer[this.#tail] = value;\n      this.#tail = (this.#tail + 1) & this.#mask;\n    } else {\n      this.#buffer[this.#tail] = value;\n      this.#tail = nextTail;\n    }\n    this.#length++;\n    return this;\n  }\n\n  /**\n   * Inserts a value at the head, growing if full.\n   */\n  unshift(value: T): this {\n    const newHead = (this.#head - 1) & this.#mask;\n    if (newHead === this.#tail) {\n      this.grow(this.#mask + 2);\n      this.#head = (this.#head - 1) & this.#mask;\n    } else {\n      this.#head = newHead;\n    }\n    this.#buffer[this.#head] = value;\n    this.#length++;\n    return this;\n  }\n\n  /**\n   * Returns the value at the given index without removing it.\n   * Index 0 is the head, index length-1 is the tail.\n   */\n  peek(index: number): T | undefined {\n    if (index < 0 || index >= this.#length) {\n      return undefined;\n    }\n    return this.#buffer[(this.#head + index) & this.#mask];\n  }\n\n  /**\n   * Returns the value at the given logical index without removing it.\n   * Logical index is based on total push/shift history (cursor-friendly).\n   */\n  peekAt(logicalIndex: number): T | undefined {\n    return this.peek(logicalIndex - this.#shiftCount);\n  }\n\n  /**\n   * Removes and returns the value at the head, or undefined if empty.\n   */\n  shift(): T | undefined {\n    if (this.#head === this.#tail) {\n      return undefined;\n    }\n    const value = this.#buffer[this.#head];\n    this.#buffer[this.#head] = undefined;\n    this.#head = (this.#head + 1) & this.#mask;\n    this.#length--;\n    this.#shiftCount++;\n    return value;\n  }\n\n  /**\n   * Removes n values from the head.\n   */\n  shiftN(n: number): number {\n    const count = Math.min(n, this.#length);\n    for (let i = 0; i < count; i++) {\n      this.#buffer[this.#head] = undefined;\n      this.#head = (this.#head + 1) & this.#mask;\n    }\n    this.#length -= count;\n    this.#shiftCount += count;\n    return count;\n  }\n\n  /**\n   * Removes and returns the value at the tail, or undefined if empty.\n   */\n  pop(): T | undefined {\n    if (this.#head === this.#tail) {\n      return undefined;\n    }\n    this.#tail = (this.#tail - 1) & this.#mask;\n    const value = this.#buffer[this.#tail];\n    this.#buffer[this.#tail] = undefined;\n    this.#length--;\n    return value;\n  }\n\n  /**\n   * Clears all entries. Optionally keeps current capacity instead of resetting to default.\n   */\n  clear(preserveCapacity = false): this {\n    const capacity = preserveCapacity ? this.#buffer.length : DEFAULT_CAPACITY;\n    this.#buffer.length = 0;\n    this.#buffer.length = capacity;\n    this.#head = 0;\n    this.#tail = 0;\n    this.#length = 0;\n    this.#shiftCount = 0;\n    this.#mask = capacity - 1;\n    return this;\n  }\n\n  [Symbol.iterator](): Iterator<T, void, unknown> {\n    const buffer = this.#buffer;\n    const mask = this.#mask;\n    const length = this.#length;\n    let count = 0;\n    let idx = this.#head;\n    return {\n      next: (): IteratorResult<T> => {\n        if (count >= length) {\n          return { done: true, value: undefined };\n        }\n        const value = buffer[idx]!;\n        idx = (idx + 1) & mask;\n        count++;\n        return { done: false, value };\n      },\n    };\n  }\n}\n"],"names":["RingBuffer","DEFAULT_CAPACITY","Symbol","toStringTag","from","values","n","length","ring","i","capacity","size","Math","max","clz32","Array","left","right","isWrapped","isEmpty","grow","buffer","bufferLength","oldTail","undefined","push","value","nextTail","unshift","newHead","peek","index","peekAt","logicalIndex","shift","shiftN","count","min","pop","clear","preserveCapacity","iterator","mask","idx","next","done"],"mappings":"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"}

package/build/ring-buffer.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @internal Fixed-size circular buffer that grows in powers of two when full.
+ * Provides O(1) push/pop/shift/unshift and supports wrap-around iteration.
+ */
+export declare class RingBuffer<T> {
+    #private;
+    readonly [Symbol.toStringTag] = "RingBuffer";
+    /**
+     * Creates a RingBuffer from an array of values.
+     * @param values - The values to initialize the buffer with
+     * @returns A new RingBuffer containing the values
+     */
+    static from<T>(values: T[]): RingBuffer<T>;
+    /**
+     * Creates a ring buffer with at least the requested capacity (rounded up to power of two).
+     */
+    constructor(capacity?: number);
+    /**
+     * The number of items currently in the buffer.
+     */
+    get length(): number;
+    /**
+     * Logical position of the buffer's left edge (total items ever shifted).
+     * Monotonically increasing - useful for cursor-based consumers.
+     */
+    get left(): number;
+    /**
+     * Logical position of the buffer's right edge (left + length).
+     * Represents the next logical index for push.
+     */
+    get right(): number;
+    /**
+     * Returns true if the buffer has wrapped around (head > tail).
+     */
+    isWrapped(): boolean;
+    /**
+     * Returns true if the buffer contains no items.
+     */
+    isEmpty(): boolean;
+    /**
+     * Ensures the underlying storage can hold at least `capacity` items.
+     * Preserves existing order when the buffer is wrapped.
+     */
+    grow(capacity?: number): void;
+    /**
+     * Appends a value at the tail, growing if full.
+     */
+    push(value: T): this;
+    /**
+     * Inserts a value at the head, growing if full.
+     */
+    unshift(value: T): this;
+    /**
+     * Returns the value at the given index without removing it.
+     * Index 0 is the head, index length-1 is the tail.
+     */
+    peek(index: number): T | undefined;
+    /**
+     * Returns the value at the given logical index without removing it.
+     * Logical index is based on total push/shift history (cursor-friendly).
+     */
+    peekAt(logicalIndex: number): T | undefined;
+    /**
+     * Removes and returns the value at the head, or undefined if empty.
+     */
+    shift(): T | undefined;
+    /**
+     * Removes n values from the head.
+     */
+    shiftN(n: number): number;
+    /**
+     * Removes and returns the value at the tail, or undefined if empty.
+     */
+    pop(): T | undefined;
+    /**
+     * Clears all entries. Optionally keeps current capacity instead of resetting to default.
+     */
+    clear(preserveCapacity?: boolean): this;
+    [Symbol.iterator](): Iterator<T, void, unknown>;
+}

package/build/ring-buffer.js

@@ -0,0 +1,161 @@
+const DEFAULT_CAPACITY = 8;
+export class RingBuffer {
+    #buffer;
+    #head = 0;
+    #tail = 0;
+    #mask;
+    #length = 0;
+    #shiftCount = 0;
+    [Symbol.toStringTag] = 'RingBuffer';
+    static from(values) {
+        const n = values.length;
+        const ring = new RingBuffer(n + 1);
+        for(let i = 0; i < n; i++){
+            ring.#buffer[i] = values[i];
+        }
+        ring.#head = 0;
+        ring.#tail = n;
+        ring.#length = n;
+        return ring;
+    }
+    constructor(capacity = DEFAULT_CAPACITY){
+        const size = Math.max(1 << 32 - Math.clz32(capacity - 1), DEFAULT_CAPACITY);
+        this.#buffer = new Array(size);
+        this.#mask = size - 1;
+    }
+    get length() {
+        return this.#length;
+    }
+    get left() {
+        return this.#shiftCount;
+    }
+    get right() {
+        return this.#shiftCount + this.#length;
+    }
+    isWrapped() {
+        return this.#head > this.#tail;
+    }
+    isEmpty() {
+        return this.#tail === this.#head;
+    }
+    grow(capacity = this.#mask + 1) {
+        const buffer = this.#buffer;
+        const bufferLength = buffer.length;
+        if (bufferLength >= capacity + 1) {
+            return;
+        }
+        const size = 1 << 32 - Math.clz32(capacity);
+        this.#buffer.length = size;
+        const oldTail = this.#tail;
+        if (oldTail < this.#head) {
+            for(let i = 0; i < oldTail; i++){
+                buffer[bufferLength + i] = buffer[i];
+                buffer[i] = undefined;
+            }
+            this.#tail = bufferLength + oldTail;
+        }
+        this.#mask = size - 1;
+    }
+    push(value) {
+        const nextTail = this.#tail + 1 & this.#mask;
+        if (nextTail === this.#head) {
+            this.grow(this.#mask + 2);
+            this.#buffer[this.#tail] = value;
+            this.#tail = this.#tail + 1 & this.#mask;
+        } else {
+            this.#buffer[this.#tail] = value;
+            this.#tail = nextTail;
+        }
+        this.#length++;
+        return this;
+    }
+    unshift(value) {
+        const newHead = this.#head - 1 & this.#mask;
+        if (newHead === this.#tail) {
+            this.grow(this.#mask + 2);
+            this.#head = this.#head - 1 & this.#mask;
+        } else {
+            this.#head = newHead;
+        }
+        this.#buffer[this.#head] = value;
+        this.#length++;
+        return this;
+    }
+    peek(index) {
+        if (index < 0 || index >= this.#length) {
+            return undefined;
+        }
+        return this.#buffer[this.#head + index & this.#mask];
+    }
+    peekAt(logicalIndex) {
+        return this.peek(logicalIndex - this.#shiftCount);
+    }
+    shift() {
+        if (this.#head === this.#tail) {
+            return undefined;
+        }
+        const value = this.#buffer[this.#head];
+        this.#buffer[this.#head] = undefined;
+        this.#head = this.#head + 1 & this.#mask;
+        this.#length--;
+        this.#shiftCount++;
+        return value;
+    }
+    shiftN(n) {
+        const count = Math.min(n, this.#length);
+        for(let i = 0; i < count; i++){
+            this.#buffer[this.#head] = undefined;
+            this.#head = this.#head + 1 & this.#mask;
+        }
+        this.#length -= count;
+        this.#shiftCount += count;
+        return count;
+    }
+    pop() {
+        if (this.#head === this.#tail) {
+            return undefined;
+        }
+        this.#tail = this.#tail - 1 & this.#mask;
+        const value = this.#buffer[this.#tail];
+        this.#buffer[this.#tail] = undefined;
+        this.#length--;
+        return value;
+    }
+    clear(preserveCapacity = false) {
+        const capacity = preserveCapacity ? this.#buffer.length : DEFAULT_CAPACITY;
+        this.#buffer.length = 0;
+        this.#buffer.length = capacity;
+        this.#head = 0;
+        this.#tail = 0;
+        this.#length = 0;
+        this.#shiftCount = 0;
+        this.#mask = capacity - 1;
+        return this;
+    }
+    [Symbol.iterator]() {
+        const buffer = this.#buffer;
+        const mask = this.#mask;
+        const length = this.#length;
+        let count = 0;
+        let idx = this.#head;
+        return {
+            next: ()=>{
+                if (count >= length) {
+                    return {
+                        done: true,
+                        value: undefined
+                    };
+                }
+                const value = buffer[idx];
+                idx = idx + 1 & mask;
+                count++;
+                return {
+                    done: false,
+                    value
+                };
+            }
+        };
+    }
+}
+
+//# sourceMappingURL=ring-buffer.js.map

package/build/ring-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ring-buffer.ts"],"sourcesContent":["const DEFAULT_CAPACITY = 8;\n\n/**\n * @internal Fixed-size circular buffer that grows in powers of two when full.\n * Provides O(1) push/pop/shift/unshift and supports wrap-around iteration.\n */\nexport class RingBuffer<T> {\n  #buffer: Array<T | undefined>;\n  #head = 0;\n  #tail = 0;\n  #mask: number;\n  #length = 0;\n  #shiftCount = 0;\n\n  readonly [Symbol.toStringTag] = 'RingBuffer';\n\n  /**\n   * Creates a RingBuffer from an array of values.\n   * @param values - The values to initialize the buffer with\n   * @returns A new RingBuffer containing the values\n   */\n  static from<T>(values: T[]): RingBuffer<T> {\n    const n = values.length;\n    const ring = new RingBuffer<T>(n + 1);\n    for (let i = 0; i < n; i++) {\n      ring.#buffer[i] = values[i];\n    }\n    ring.#head = 0;\n    ring.#tail = n;\n    ring.#length = n;\n\n    return ring;\n  }\n\n  /**\n   * Creates a ring buffer with at least the requested capacity (rounded up to power of two).\n   */\n  constructor(capacity: number = DEFAULT_CAPACITY) {\n    const size = Math.max(1 << (32 - Math.clz32(capacity - 1)), DEFAULT_CAPACITY);\n    this.#buffer = new Array<T>(size);\n    this.#mask = size - 1;\n  }\n\n  /**\n   * The number of items currently in the buffer.\n   */\n  get length(): number {\n    return this.#length;\n  }\n\n  /**\n   * Logical position of the buffer's left edge (total items ever shifted).\n   * Monotonically increasing - useful for cursor-based consumers.\n   */\n  get left(): number {\n    return this.#shiftCount;\n  }\n\n  /**\n   * Logical position of the buffer's right edge (left + length).\n   * Represents the next logical index for push.\n   */\n  get right(): number {\n    return this.#shiftCount + this.#length;\n  }\n\n  /**\n   * Returns true if the buffer has wrapped around (head > tail).\n   */\n  isWrapped(): boolean {\n    return this.#head > this.#tail;\n  }\n\n  /**\n   * Returns true if the buffer contains no items.\n   */\n  isEmpty(): boolean {\n    return this.#tail === this.#head;\n  }\n\n  /**\n   * Ensures the underlying storage can hold at least `capacity` items.\n   * Preserves existing order when the buffer is wrapped.\n   */\n  grow(capacity: number = this.#mask + 1): void {\n    const buffer = this.#buffer;\n    const bufferLength = buffer.length;\n    if (bufferLength >= capacity + 1) {\n      return;\n    }\n    const size = 1 << (32 - Math.clz32(capacity));\n    this.#buffer.length = size;\n\n    const oldTail = this.#tail;\n    if (oldTail < this.#head) {\n      for (let i = 0; i < oldTail; i++) {\n        buffer[bufferLength + i] = buffer[i];\n        buffer[i] = undefined;\n      }\n      this.#tail = bufferLength + oldTail;\n    }\n\n    this.#mask = size - 1;\n  }\n\n  /**\n   * Appends a value at the tail, growing if full.\n   */\n  push(value: T) {\n    const nextTail = (this.#tail + 1) & this.#mask;\n    if (nextTail === this.#head) {\n      this.grow(this.#mask + 2);\n      this.#buffer[this.#tail] = value;\n      this.#tail = (this.#tail + 1) & this.#mask;\n    } else {\n      this.#buffer[this.#tail] = value;\n      this.#tail = nextTail;\n    }\n    this.#length++;\n    return this;\n  }\n\n  /**\n   * Inserts a value at the head, growing if full.\n   */\n  unshift(value: T): this {\n    const newHead = (this.#head - 1) & this.#mask;\n    if (newHead === this.#tail) {\n      this.grow(this.#mask + 2);\n      this.#head = (this.#head - 1) & this.#mask;\n    } else {\n      this.#head = newHead;\n    }\n    this.#buffer[this.#head] = value;\n    this.#length++;\n    return this;\n  }\n\n  /**\n   * Returns the value at the given index without removing it.\n   * Index 0 is the head, index length-1 is the tail.\n   */\n  peek(index: number): T | undefined {\n    if (index < 0 || index >= this.#length) {\n      return undefined;\n    }\n    return this.#buffer[(this.#head + index) & this.#mask];\n  }\n\n  /**\n   * Returns the value at the given logical index without removing it.\n   * Logical index is based on total push/shift history (cursor-friendly).\n   */\n  peekAt(logicalIndex: number): T | undefined {\n    return this.peek(logicalIndex - this.#shiftCount);\n  }\n\n  /**\n   * Removes and returns the value at the head, or undefined if empty.\n   */\n  shift(): T | undefined {\n    if (this.#head === this.#tail) {\n      return undefined;\n    }\n    const value = this.#buffer[this.#head];\n    this.#buffer[this.#head] = undefined;\n    this.#head = (this.#head + 1) & this.#mask;\n    this.#length--;\n    this.#shiftCount++;\n    return value;\n  }\n\n  /**\n   * Removes n values from the head.\n   */\n  shiftN(n: number): number {\n    const count = Math.min(n, this.#length);\n    for (let i = 0; i < count; i++) {\n      this.#buffer[this.#head] = undefined;\n      this.#head = (this.#head + 1) & this.#mask;\n    }\n    this.#length -= count;\n    this.#shiftCount += count;\n    return count;\n  }\n\n  /**\n   * Removes and returns the value at the tail, or undefined if empty.\n   */\n  pop(): T | undefined {\n    if (this.#head === this.#tail) {\n      return undefined;\n    }\n    this.#tail = (this.#tail - 1) & this.#mask;\n    const value = this.#buffer[this.#tail];\n    this.#buffer[this.#tail] = undefined;\n    this.#length--;\n    return value;\n  }\n\n  /**\n   * Clears all entries. Optionally keeps current capacity instead of resetting to default.\n   */\n  clear(preserveCapacity = false): this {\n    const capacity = preserveCapacity ? this.#buffer.length : DEFAULT_CAPACITY;\n    this.#buffer.length = 0;\n    this.#buffer.length = capacity;\n    this.#head = 0;\n    this.#tail = 0;\n    this.#length = 0;\n    this.#shiftCount = 0;\n    this.#mask = capacity - 1;\n    return this;\n  }\n\n  [Symbol.iterator](): Iterator<T, void, unknown> {\n    const buffer = this.#buffer;\n    const mask = this.#mask;\n    const length = this.#length;\n    let count = 0;\n    let idx = this.#head;\n    return {\n      next: (): IteratorResult<T> => {\n        if (count >= length) {\n          return { done: true, value: undefined };\n        }\n        const value = buffer[idx]!;\n        idx = (idx + 1) & mask;\n        count++;\n        return { done: false, value };\n      },\n    };\n  }\n}\n"],"names":["DEFAULT_CAPACITY","RingBuffer","Symbol","toStringTag","from","values","n","length","ring","i","capacity","size","Math","max","clz32","Array","left","right","isWrapped","isEmpty","grow","buffer","bufferLength","oldTail","undefined","push","value","nextTail","unshift","newHead","peek","index","peekAt","logicalIndex","shift","shiftN","count","min","pop","clear","preserveCapacity","iterator","mask","idx","next","done"],"mappings":"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"}

package/build/sequence.cjs

@@ -8,61 +8,60 @@ Object.defineProperty(exports, "Sequence", {
         return Sequence;
     }
 });
-const _fastds = require("fastds");
-const _callablecjs = require("./callable.cjs");
+const _asynccjs = require("./async.cjs");
 const _signalcjs = require("./signal.cjs");
-class Sequence extends _callablecjs.CallableAsyncIterator {
-    abortSignal;
-    queue;
-    nextSignal;
-    sendSignal;
+const _ringbuffercjs = require("./ring-buffer.cjs");
+class Sequence extends _asynccjs.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 _fastds.RingBuffer();
-        this.nextSignal = new _signalcjs.Signal(this.abortSignal);
-        this.sendSignal = new _signalcjs.Signal(this.abortSignal);
-        this.abortSignal?.addEventListener('abort', ()=>this.nextSignal(false), {
-            once: true
-        });
+        super(abortSignal);
+        this.#queue = new _ringbuffercjs.RingBuffer();
+        this.#nextSignal = new _signalcjs.Signal(abortSignal);
+        this.#sendSignal = new _signalcjs.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.cjs.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":["Sequence","CallableAsyncIterator","queue","nextSignal","sendSignal","Symbol","toStringTag","merge","target","sequences","source","queueMicrotask","value","abortSignal","aborted","push","RingBuffer","Signal","addEventListener","once","size","length","reserve","capacity","next","shift","dispose"],"mappings":";;;;+BAiCaA;;;eAAAA;;;wBAjCc;6BACW;2BACf;AA+BhB,MAAMA,iBAAoBC,kCAAqB;;IAC5CC,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,IAAIc,kBAAU;QAC3B,IAAI,CAACb,UAAU,GAAG,IAAIc,iBAAM,CAAC,IAAI,CAACJ,WAAW;QAC7C,IAAI,CAACT,UAAU,GAAG,IAAIa,iBAAM,CAAC,IAAI,CAACJ,WAAW;QAC7C,IAAI,CAACA,WAAW,EAAEK,iBAAiB,SAAS,IAAM,IAAI,CAACf,UAAU,CAAC,QAAQ;YAAEgB,MAAM;QAAK;IACzF;IAOA,IAAIC,OAAe;QACjB,OAAO,IAAI,CAAClB,KAAK,CAACmB,MAAM;IAC1B;IAkBA,MAAMC,QAAQC,QAAgB,EAAiB;QAC7C,MAAO,IAAI,CAACrB,KAAK,CAACmB,MAAM,GAAGE,SAAU;YACnC,MAAM,IAAI,CAACnB,UAAU;QACvB;IACF;IAsBA,MAAMoB,OAAmB;QACvB,MAAO,CAAC,IAAI,CAACtB,KAAK,CAACmB,MAAM,CAAE;YACzB,MAAM,IAAI,CAAClB,UAAU;QACvB;QACA,IAAI,CAACC,UAAU;QACf,OAAO,IAAI,CAACF,KAAK,CAACuB,KAAK;IACzB;IAMA,CAACpB,OAAOqB,OAAO,CAAC,GAAS;QACvB,IAAI,CAACvB,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":["Sequence","Async","Symbol","toStringTag","merge","target","sequences","source","queueMicrotask","disposed","sink","value","abortSignal","RingBuffer","Signal","size","length","reserve","capacity","emit","ok","push","receive","shift","dispose"],"mappings":";;;;+BAmCaA;;;eAAAA;;;0BAnCS;2BACC;+BACI;AAiCpB,MAAMA,iBAAoBC,eAAK;IACpC,CAAA,KAAM,CAAgB;IACtB,CAAA,UAAW,CAAe;IAC1B,CAAA,UAAW,CAAe;IAEjB,CAACC,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,IAAIC,yBAAU;QAC5B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIC,iBAAM,CAACF;QAC9B,IAAI,CAAC,CAAA,UAAW,GAAG,IAAIE,iBAAM,CAACF;IAChC;IAOA,IAAIG,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,KAAKR,KAAQ,EAAW;QACtB,MAAMS,KAAK,CAAC,IAAI,CAACX,QAAQ;QACzB,IAAIW,IAAI;YACN,IAAI,CAAC,CAAA,KAAM,CAACC,IAAI,CAACV;QACnB;QACA,IAAI,CAAC,CAAA,UAAW,CAACQ,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,CAACtB,OAAOsB,OAAO,CAAC;QAChC,IAAI,CAAC,CAAA,UAAW,CAACtB,OAAOsB,OAAO,CAAC;IAClC;AACF"}

package/build/sequence.d.ts

@@ -1,8 +1,9 @@
-import { CallableAsyncIterator } from './callable.js';
+import { Async } from './async.js';
 /**
  * A sequence is a FIFO (First-In-First-Out) queue for async consumption.
  * Designed for single consumer with multiple producers pattern.
  * Values are queued and consumed in order, with backpressure support.
+ * Respects an optional AbortSignal: emit() returns false when aborted; waits reject.
  *
  * Key characteristics:
  * - Single consumer - values are consumed once, in order
@@ -13,26 +14,24 @@ import { CallableAsyncIterator } from './callable.js';
  *
  * @template T The type of values in the sequence.
  *
+ * @example
  * ```typescript
  * // Create a sequence for processing tasks
  * const tasks = new Sequence<string>();
  *
  * // Producer: Add tasks to the queue
- * tasks('task1');
- * tasks('task2');
- * tasks('task3');
+ * tasks.emit('task1');
+ * tasks.emit('task2');
+ * tasks.emit('task3');
  *
  * // Consumer: Process tasks in order
- * const task1 = await tasks.next(); // 'task1'
- * const task2 = await tasks.next(); // 'task2'
- * const task3 = await tasks.next(); // 'task3'
+ * const task1 = await tasks.receive(); // 'task1'
+ * const task2 = await tasks.receive(); // 'task2'
+ * const task3 = await tasks.receive(); // 'task3'
  * ```
  */
-export declare class Sequence<T> extends CallableAsyncIterator<T, boolean> {
-    private readonly abortSignal?;
-    private queue;
-    private nextSignal;
-    private sendSignal;
+export declare class Sequence<T> extends Async<T, boolean> {
+    #private;
     readonly [Symbol.toStringTag] = "Sequence";
     /**
      * Merges multiple source sequences into a target sequence.
@@ -42,6 +41,7 @@ export declare class Sequence<T> extends CallableAsyncIterator<T, boolean> {
      * @param target The sequence that will receive values from all sources
      * @param sequences The source sequences to merge from
      *
+     * @example
      * ```typescript
      * // Create target and source sequences
      * const target = new Sequence<number>();
@@ -52,16 +52,20 @@ export declare class Sequence<T> extends CallableAsyncIterator<T, boolean> {
      * Sequence.merge(target, source1, source2);
      *
      * // Values from both sources appear in target
-     * source1(1);
-     * source2(2);
-     * source1(3);
+     * source1.emit(1);
+     * source2.emit(2);
+     * source1.emit(3);
      *
      * // Consumer gets values as they arrive
-     * await target.next(); // Could be 1, 2, or 3 depending on timing
+     * await target.receive(); // Could be 1, 2, or 3 depending on timing
      * ```
      */
     static merge<T>(target: Sequence<T>, ...sequences: Sequence<T>[]): void;
-    constructor(abortSignal?: AbortSignal | undefined);
+    /**
+     * Creates a new Sequence instance.
+     * @param abortSignal - Optional AbortSignal to cancel pending operations
+     */
+    constructor(abortSignal?: AbortSignal);
     /**
      * Returns the number of values currently queued.
      *
@@ -75,40 +79,50 @@ export declare class Sequence<T> extends CallableAsyncIterator<T, boolean> {
      * @param capacity The maximum queue size to wait for
      * @returns A promise that resolves when the queue size is at or below capacity
      *
+     * @example
      * ```typescript
      * // Producer with backpressure control
      * const sequence = new Sequence<string>();
      *
      * // Wait if queue has more than 10 items
      * await sequence.reserve(10);
-     * sequence('new item'); // Safe to add, queue has space
+     * sequence.emit('new item'); // Safe to add, queue has space
      * ```
      */
     reserve(capacity: number): Promise<void>;
+    /**
+     * Pushes a value onto the queue. Wakes any pending `receive()` waiter.
+     *
+     * @param value - The value to enqueue.
+     * @returns `true` if the sequence is still active.
+     */
+    emit(value: T): boolean;
     /**
      * Consumes and returns the next value from the queue.
      * If the queue is empty, waits for a value to be added.
      * Values are consumed in FIFO order.
+     * If the sequence has been aborted or disposed, this method rejects with Error('Disposed').
      *
      * @returns A promise that resolves with the next value
      *
+     * @example
      * ```typescript
      * const sequence = new Sequence<number>();
      *
      * // Consumer waits for values
-     * const valuePromise = sequence.next();
+     * const valuePromise = sequence.receive();
      *
      * // Producer adds value
-     * sequence(42);
+     * sequence.emit(42);
      *
      * // Consumer receives it
      * const value = await valuePromise; // 42
      * ```
      */
-    next(): Promise<T>;
+    receive(): Promise<T>;
     /**
-     * Disposes of the sequence, signaling any waiting consumers.
-     * Called automatically when used with `using` declaration.
+     * Disposes of the sequence, rejecting any pending `receive()` waiters.
+     * Called by `[Symbol.dispose]()` (inherited from Async) when using the `using` declaration.
      */
-    [Symbol.dispose](): void;
+    dispose(): void;
 }