@anabranch/queue 0.1.3 → 0.1.5

package/esm/{queue/adapter.d.ts → adapter.d.ts}

@@ -18,7 +18,10 @@ export interface QueueMessage<T = unknown> {
     /** Timestamp when the message was first enqueued */
     timestamp: number;
     /** Optional metadata from the broker */
-    metadata?: Record<string, unknown>;
+    metadata?: {
+        headers?: Record<string, string>;
+        [key: string]: unknown;
+    };
 }
 /** Options for sending a message with delay or scheduling. */
 export interface SendOptions {
@@ -30,6 +33,8 @@ export interface SendOptions {
     deadLetterQueue?: string;
     /** Message priority (higher = more important, if supported) */
     priority?: number;
+    /** Arbitrary key-value pairs to attach to the message */
+    headers?: Record<string, string>;
 }
 /** Options for negative acknowledgment. */
 export interface NackOptions {
@@ -58,6 +63,7 @@ export interface QueueAdapter {
 export interface StreamAdapter extends QueueAdapter {
     subscribe<T>(queue: string, options?: {
         signal?: AbortSignal;
+        prefetch?: number;
     }): AsyncIterable<QueueMessage<T>>;
 }
 /**

package/esm/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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"}

package/esm/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,iDAAiD;AACjD,qBAAa,UAAW,SAAQ,KAAK;aAGjB,KAAK,CAAC,EAAE,MAAM;aACd,SAAS,CAAC,EAAE,MAAM;gBAFlC,OAAO,EAAE,MAAM,EACC,KAAK,CAAC,EAAE,MAAM,YAAA,EACd,SAAS,CAAC,EAAE,MAAM,YAAA;CAKrC;AAED,uCAAuC;AACvC,qBAAa,qBAAsB,SAAQ,UAAU;aACN,aAAa,CAAC,EAAE,OAAO;gBAAxD,OAAO,EAAE,MAAM,EAAkB,aAAa,CAAC,EAAE,OAAO,YAAA;CAIrE;AAED,qCAAqC;AACrC,qBAAa,eAAgB,SAAQ,UAAU;aAI3B,aAAa,CAAC,EAAE,OAAO;gBAFvC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACG,aAAa,CAAC,EAAE,OAAO,YAAA;CAK1C;AAED,wCAAwC;AACxC,qBAAa,kBAAmB,SAAQ,UAAU;aAI9B,aAAa,CAAC,EAAE,OAAO;gBAFvC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACG,aAAa,CAAC,EAAE,OAAO,YAAA;CAK1C;AAED,uCAAuC;AACvC,qBAAa,cAAe,SAAQ,UAAU;aAK1B,aAAa,CAAC,EAAE,OAAO;gBAHvC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACD,aAAa,CAAC,EAAE,OAAO,YAAA;CAK1C;AAED,4CAA4C;AAC5C,qBAAa,kBAAmB,SAAQ,UAAU;aAK9B,aAAa,CAAC,EAAE,OAAO;gBAHvC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACD,aAAa,CAAC,EAAE,OAAO,YAAA;CAK1C;AAED,kDAAkD;AAClD,qBAAa,wBAAyB,SAAQ,UAAU;aAIpC,QAAQ,EAAE,MAAM;gBAFhC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACD,QAAQ,EAAE,MAAM;CASnC;AAED,yCAAyC;AACzC,qBAAa,gBAAiB,SAAQ,UAAU;aAG5B,aAAa,CAAC,EAAE,OAAO;gBADvC,OAAO,EAAE,MAAM,EACC,aAAa,CAAC,EAAE,OAAO,YAAA;CAK1C"}

package/esm/in-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../src/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,YAAY,EACZ,cAAc,EAEd,YAAY,EAEb,MAAM,cAAc,CAAC;AA2BtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,iBAAiB,CA+S3E;AAkBD,yCAAyC;AACzC,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAClC,8BAA8B;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACvC;AAED,iCAAiC;AACjC,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IACjC,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB"}

package/esm/{queue/in-memory.js → in-memory.js}

@@ -83,6 +83,10 @@ export function createInMemory(options) {
                         .flat()
                         .find((m) => m.id === id));
             };
+            /**
+             * Routes to DLQ when attempt > maxAttempts (not >=).
+             * A message with maxAttempts=2 will be delivered 2x before DLQ.
+             */
             const handleNack = (queue, id, nackOptions) => {
                 const existing = findMessage(queue, id);
                 if (nackOptions?.deadLetter) {
@@ -163,6 +167,9 @@ export function createInMemory(options) {
                         data,
                         attempt: 1,
                         timestamp: Date.now(),
+                        metadata: sendOptions?.headers
+                            ? { headers: sendOptions.headers }
+                            : undefined,
                     };
                     if (delayMs > 0) {
                         const bucket = Math.ceil((Date.now() + delayMs) / 1000);

package/esm/{queue/index.d.ts → index.d.ts}

@@ -85,10 +85,10 @@
  */
 export { Queue } from "./queue.js";
 export type { QueueMessage } from "./adapter.js";
-export type { NackOptions, QueueAdapter, QueueConnector, QueueOptions, SendOptions, } from "./adapter.js";
+export type { NackOptions, QueueAdapter, QueueConnector, QueueOptions, SendOptions, StreamAdapter, } from "./adapter.js";
 export * from "./errors.js";
 export { createInMemory } from "./in-memory.js";
 export type { InMemoryConnector } from "./in-memory.js";
-export { Task } from "../anabranch/index.js";
-export type { Source, Stream } from "../anabranch/index.js";
+export { Task } from "anabranch";
+export type { Source, Stream } from "anabranch";
 //# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,YAAY,EACV,WAAW,EACX,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,WAAW,EACX,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC"}

package/esm/{queue/index.js → index.js}

@@ -86,4 +86,4 @@
 export { Queue } from "./queue.js";
 export * from "./errors.js";
 export { createInMemory } from "./in-memory.js";
-export { Task } from "../anabranch/index.js";
+export { Task } from "anabranch";

package/esm/{queue/queue.d.ts → queue.d.ts}

@@ -1,4 +1,4 @@
-import { Source, Task } from "../anabranch/index.js";
+import { Source, Task } from "anabranch";
 import type { QueueAdapter, QueueConnector, QueueMessage, SendOptions } from "./adapter.js";
 import { QueueAckFailed, QueueCloseFailed, QueueConnectionFailed, QueueMaxAttemptsExceeded, QueueReceiveFailed, QueueSendFailed } from "./errors.js";
 /**
@@ -132,6 +132,7 @@ export declare class Queue {
     continuousStream<T>(queue: string, options?: {
         count?: number;
         signal?: AbortSignal;
+        prefetch?: number;
     }): Source<QueueMessage<T>, QueueReceiveFailed>;
     /**
      * Acknowledge one or more messages as successfully processed.

package/esm/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EACV,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,WAAW,EAEZ,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,eAAe,EAChB,MAAM,aAAa,CAAC;AAiBrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,KAAK;IACJ,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY;IAElD;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,CACZ,SAAS,EAAE,cAAc,GACxB,IAAI,CAAC,KAAK,EAAE,qBAAqB,CAAC;IAarC;;;;;;;OAOG;IACH,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAarC;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,EACJ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,WAAW,GACpB,IAAI,CAAC,MAAM,EAAE,eAAe,CAAC;IAchC;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,CAAC,EACT,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,EAAE,EACT,OAAO,CAAC,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7C,IAAI,CAAC,MAAM,EAAE,EAAE,eAAe,CAAC;IA0BlC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,CAAC,EACN,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GACjD,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC;IAqB9C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gBAAgB,CAAC,CAAC,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GACpE,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC;IAuD9C;;;;;;;OAOG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC;IAgBhE;;;;;;;;;;;;OAYG;IACH,IAAI,CACF,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,GACA,IAAI,CAAC,IAAI,EAAE,cAAc,GAAG,wBAAwB,CAAC;CAczD;AAED,6CAA6C;AAC7C,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}

package/esm/{queue/queue.js → queue.js}

@@ -1,4 +1,4 @@
-import { Source, Task } from "../anabranch/index.js";
+import { Source, Task } from "anabranch";
 import { QueueAckFailed, QueueCloseFailed, QueueConnectionFailed, QueueReceiveFailed, QueueSendFailed, } from "./errors.js";
 async function sleep(ms, signal) {
     if (signal?.aborted)
@@ -200,12 +200,16 @@ export class Queue {
     continuousStream(queue, options) {
         const count = options?.count ?? 10;
         const signal = options?.signal;
+        const prefetch = options?.prefetch;
         const adapter = this.adapter;
         const isStreamAdapter = "subscribe" in adapter;
         return Source.fromResults(async function* () {
             if (isStreamAdapter) {
                 const streamAdapter = adapter;
-                const iterable = streamAdapter.subscribe(queue, { signal });
+                const iterable = streamAdapter.subscribe(queue, {
+                    signal,
+                    prefetch,
+                });
                 for await (const msg of iterable) {
                     if (signal?.aborted)
                         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anabranch/queue",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Message queue with dead letter queue and visibility timeout support",
   "repository": {
     "type": "git",
@@ -10,10 +10,10 @@
   "bugs": {
     "url": "https://github.com/frodi-karlsson/anabranch/issues"
   },
-  "module": "./esm/queue/index.js",
+  "module": "./esm/index.js",
   "exports": {
     ".": {
-      "import": "./esm/queue/index.js"
+      "import": "./esm/index.js"
     }
   },
   "scripts": {},

package/esm/anabranch/index.d.ts

@@ -1,44 +0,0 @@
-/**
- * Anabranch is a TypeScript library for error-tolerant async streams.
- *
- * Instead of throwing on the first error, it collects errors alongside
- * successful values so you can process a stream to completion and deal with
- * failures at the end — or not at all.
- *
- * The entry point is {@link Source}. Once you have a stream, chain operations
- * like {@link Stream.map map}, {@link Stream.filter filter},
- * {@link Stream.flatMap flatMap}, and {@link Stream.fold fold} to transform it,
- * then consume it with {@link Stream.collect collect} or
- * {@link Stream.partition partition}.
- *
- * @example Fetch a list of URLs concurrently, collect results and failures separately
- * ```ts
- * import { Source } from "anabranch";
- *
- * const { successes, errors } = await Source.from<string, Error>(
- *   async function* () {
- *     yield "https://example.com/1";
- *     yield "https://example.com/2";
- *     yield "https://example.com/3";
- *   },
- * )
- *   .withConcurrency(3)
- *   .map(async (url) => {
- *     const res = await fetch(url);
- *     if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
- *     return res.json();
- *   })
- *   .partition();
- *
- * console.log(`${successes.length} succeeded, ${errors.length} failed`);
- * ```
- *
- * @module
- */
-export { Source } from "./streams/source.js";
-export { Task } from "./streams/task.js";
-export { Channel } from "./streams/channel.js";
-export type { Stream } from "./streams/stream.js";
-export { AggregateError } from "./streams/util.js";
-export type { ErrorResult, Promisable, Result, SuccessResult, } from "./streams/util.js";
-//# sourceMappingURL=index.d.ts.map

package/esm/anabranch/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/anabranch/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,YAAY,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,YAAY,EACV,WAAW,EACX,UAAU,EACV,MAAM,EACN,aAAa,GACd,MAAM,mBAAmB,CAAC"}

package/esm/anabranch/index.js

@@ -1,41 +0,0 @@
-/**
- * Anabranch is a TypeScript library for error-tolerant async streams.
- *
- * Instead of throwing on the first error, it collects errors alongside
- * successful values so you can process a stream to completion and deal with
- * failures at the end — or not at all.
- *
- * The entry point is {@link Source}. Once you have a stream, chain operations
- * like {@link Stream.map map}, {@link Stream.filter filter},
- * {@link Stream.flatMap flatMap}, and {@link Stream.fold fold} to transform it,
- * then consume it with {@link Stream.collect collect} or
- * {@link Stream.partition partition}.
- *
- * @example Fetch a list of URLs concurrently, collect results and failures separately
- * ```ts
- * import { Source } from "anabranch";
- *
- * const { successes, errors } = await Source.from<string, Error>(
- *   async function* () {
- *     yield "https://example.com/1";
- *     yield "https://example.com/2";
- *     yield "https://example.com/3";
- *   },
- * )
- *   .withConcurrency(3)
- *   .map(async (url) => {
- *     const res = await fetch(url);
- *     if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
- *     return res.json();
- *   })
- *   .partition();
- *
- * console.log(`${successes.length} succeeded, ${errors.length} failed`);
- * ```
- *
- * @module
- */
-export { Source } from "./streams/source.js";
-export { Task } from "./streams/task.js";
-export { Channel } from "./streams/channel.js";
-export { AggregateError } from "./streams/util.js";

package/esm/anabranch/streams/channel.d.ts

@@ -1,15 +0,0 @@
-import { _StreamImpl } from "./stream.js";
-interface ChannelOptions<T> {
-    bufferSize?: number;
-    onDrop?: (value: T) => void;
-    onClose?: () => void;
-}
-export declare class Channel<T, E = never> extends _StreamImpl<T, E> {
-    private sourceImpl;
-    constructor(options?: ChannelOptions<T>);
-    send(value: T): void;
-    fail(error: E): void;
-    close(): void;
-}
-export {};
-//# sourceMappingURL=channel.d.ts.map

package/esm/anabranch/streams/channel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../src/anabranch/streams/channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,UAAU,cAAc,CAAC,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAgFD,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,CAAE,SAAQ,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC;IAC1D,OAAO,CAAC,UAAU,CAAsB;gBAE5B,OAAO,GAAE,cAAc,CAAC,CAAC,CAAM;IAM3C,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAIpB,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAIpB,KAAK,IAAI,IAAI;CAGd"}

package/esm/anabranch/streams/channel.js

@@ -1,122 +0,0 @@
-import { _StreamImpl } from "./stream.js";
-class ChannelSource {
-    constructor(options = {}) {
-        Object.defineProperty(this, "queue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "closed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "consumers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "bufferSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "onDrop", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "onClose", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.bufferSize = Number.isFinite(options.bufferSize)
-            ? Math.max(1, options.bufferSize)
-            : Infinity;
-        this.onDrop = options.onDrop;
-        this.onClose = options.onClose;
-    }
-    send(value) {
-        if (this.closed) {
-            return;
-        }
-        if (this.queue.length >= this.bufferSize && this.bufferSize !== Infinity) {
-            this.onDrop?.(value);
-            return;
-        }
-        this.queue.push({ type: "success", value });
-        this.wake();
-    }
-    fail(error) {
-        if (this.closed) {
-            return;
-        }
-        this.queue.push({ type: "error", error });
-        this.wake();
-    }
-    close() {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        this.wake();
-    }
-    wake() {
-        while (this.consumers.length > 0) {
-            const consumer = this.consumers.shift();
-            if (consumer)
-                consumer();
-        }
-    }
-    async *generator() {
-        try {
-            while (true) {
-                while (this.queue.length > 0) {
-                    yield this.queue.shift();
-                }
-                if (this.closed && this.queue.length === 0) {
-                    return;
-                }
-                if (this.queue.length === 0) {
-                    await new Promise((resolve) => {
-                        this.consumers.push(resolve);
-                    });
-                    if (this.queue.length > 0)
-                        continue;
-                }
-            }
-        }
-        finally {
-            this.onClose?.();
-        }
-    }
-}
-export class Channel extends _StreamImpl {
-    constructor(options = {}) {
-        const sourceImpl = new ChannelSource(options);
-        super(() => sourceImpl.generator(), Infinity, Infinity);
-        Object.defineProperty(this, "sourceImpl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.sourceImpl = sourceImpl;
-    }
-    send(value) {
-        this.sourceImpl.send(value);
-    }
-    fail(error) {
-        this.sourceImpl.fail(error);
-    }
-    close() {
-        this.sourceImpl.close();
-    }
-}

package/esm/anabranch/streams/source.d.ts

@@ -1,75 +0,0 @@
-import { _StreamImpl } from "./stream.js";
-import type { Result } from "./util.js";
-/**
- * The entry point for creating a {@link Stream}. Wraps an async generator so
- * that yielded values become success results and any thrown error becomes a
- * single error result.
- *
- * Use {@link Source.from} to create a source from an existing `AsyncIterable`
- * or generator function. Use {@link Source.withConcurrency} and
- * {@link Source.withBufferSize} to configure parallel execution.
- *
- * @example
- * ```ts
- * import { Source } from "anabranch";
- *
- * const stream = Source.from<number, Error>(async function* () {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * });
- *
- * const results = await stream.collect();
- * ```
- */
-export declare class Source<T, E> extends _StreamImpl<T, E> {
-    private readonly resultSource;
-    /**
-     * @param source An async generator function. Each yielded value becomes a
-     * success result; any thrown error becomes an error result and terminates
-     * the source.
-     * @param concurrency Maximum number of concurrent operations. Defaults to `Infinity`.
-     * @param bufferSize Maximum number of buffered results before backpressure is applied. Defaults to `Infinity`.
-     */
-    private constructor();
-    /**
-     * Creates a {@link Source} from an existing `AsyncIterable` or async
-     * generator function. Each value emitted becomes a success result; any
-     * thrown error becomes an error result.
-     *
-     * @example
-     * ```ts
-     * import { Source } from "anabranch";
-     *
-     * // From a generator function
-     * const stream = Source.from<number, Error>(async function* () {
-     *   yield 1;
-     *   yield 2;
-     * });
-     *
-     * // From an AsyncIterable
-     * async function* generate() {
-     *   yield 1;
-     *   yield 2;
-     * }
-     * const stream2 = Source.from<number, Error>(generate());
-     * ```
-     */
-    static from<T, E>(source: AsyncIterable<T>): Source<T, E>;
-    static from<T, E>(fn: () => AsyncGenerator<T>): Source<T, E>;
-    /**
-     * Creates a {@link Source} from an async generator that yields {@link Result}
-     * values directly. This is useful when you want to yield both successes and
-     * errors from the source without terminating it on the first error.
-     */
-    static fromResults<T, E>(source: () => AsyncGenerator<Result<T, E>>): Source<T, E>;
-    /**
-     * Sets the maximum number of concurrent operations for the stream.
-     */
-    withConcurrency(n: number): Source<T, E>;
-    /**
-     * Sets the maximum number of buffered results before backpressure is applied to the stream. If the buffer is full, the stream will pause until there is space in the buffer for new results.
-     */
-    withBufferSize(n: number): Source<T, E>;
-}
-//# sourceMappingURL=source.d.ts.map

package/esm/anabranch/streams/source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../../src/anabranch/streams/source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,MAAM,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC;IAS/C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAR/B;;;;;;OAMG;IACH,OAAO;IAQP;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IACzD,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,cAAc,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IAoB5D;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,EACrB,MAAM,EAAE,MAAM,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GACzC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IAIf;;OAEG;IACH,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IAIxC;;OAEG;IACH,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;CAGxC"}

package/esm/anabranch/streams/source.js

@@ -1,77 +0,0 @@
-import { _StreamImpl } from "./stream.js";
-/**
- * The entry point for creating a {@link Stream}. Wraps an async generator so
- * that yielded values become success results and any thrown error becomes a
- * single error result.
- *
- * Use {@link Source.from} to create a source from an existing `AsyncIterable`
- * or generator function. Use {@link Source.withConcurrency} and
- * {@link Source.withBufferSize} to configure parallel execution.
- *
- * @example
- * ```ts
- * import { Source } from "anabranch";
- *
- * const stream = Source.from<number, Error>(async function* () {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * });
- *
- * const results = await stream.collect();
- * ```
- */
-export class Source extends _StreamImpl {
-    /**
-     * @param source An async generator function. Each yielded value becomes a
-     * success result; any thrown error becomes an error result and terminates
-     * the source.
-     * @param concurrency Maximum number of concurrent operations. Defaults to `Infinity`.
-     * @param bufferSize Maximum number of buffered results before backpressure is applied. Defaults to `Infinity`.
-     */
-    constructor(resultSource, concurrency = Infinity, bufferSize = Infinity) {
-        super(resultSource, concurrency, bufferSize);
-        Object.defineProperty(this, "resultSource", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: resultSource
-        });
-    }
-    static from(source) {
-        const fn = typeof source === "function" ? source : async function* () {
-            yield* source;
-        };
-        const resultSource = async function* () {
-            try {
-                for await (const value of fn()) {
-                    yield { type: "success", value };
-                }
-            }
-            catch (error) {
-                yield { type: "error", error: error };
-            }
-        };
-        return new Source(resultSource);
-    }
-    /**
-     * Creates a {@link Source} from an async generator that yields {@link Result}
-     * values directly. This is useful when you want to yield both successes and
-     * errors from the source without terminating it on the first error.
-     */
-    static fromResults(source) {
-        return new Source(source);
-    }
-    /**
-     * Sets the maximum number of concurrent operations for the stream.
-     */
-    withConcurrency(n) {
-        return new Source(this.resultSource, n, this.bufferSize);
-    }
-    /**
-     * Sets the maximum number of buffered results before backpressure is applied to the stream. If the buffer is full, the stream will pause until there is space in the buffer for new results.
-     */
-    withBufferSize(n) {
-        return new Source(this.resultSource, this.concurrency, n);
-    }
-}