@anabranch/queue 0.1.0

package/esm/queue/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @anabranch/queue
+ *
+ * Queue primitives with Task/Stream semantics for error-tolerant message processing.
+ * Integrates with anabranch's {@linkcode Task}, {@linkcode Stream}, {@linkcode Source}, and
+ * {@linkcode Channel} types for composable error handling and concurrent processing.
+ *
+ * ## Adapters vs Connectors
+ *
+ * A **QueueConnector** produces connected **QueueAdapter** instances. Use connectors for
+ * production code to properly manage connection lifecycles:
+ *
+ * - **Connector**: Manages connection pool/lifecycle, produces adapters
+ * - **Adapter**: Low-level send/receive/ack/nack interface
+ * - **Queue**: Wrapper providing Task/Stream methods over an adapter
+ *
+ * ## Core Types
+ *
+ * - {@link QueueConnector} - Interface for connection factories
+ * - {@link QueueAdapter} - Low-level queue operations interface
+ * - {@link Queue} - High-level wrapper with Task/Stream methods
+ * - {@link QueueMessage} - Message envelope with id, data, attempt count
+ *
+ * ## Error Types
+ *
+ * All errors are typed for catchable handling:
+ * - {@link QueueConnectionFailed} - Connection establishment failed
+ * - {@link QueueSendFailed} - Send operation failed
+ * - {@link QueueReceiveFailed} - Receive operation failed
+ * - {@link QueueAckFailed} - Acknowledgment failed
+ *
+ * @example Basic send with Task semantics
+ * ```ts
+ * import { Queue, createInMemory } from "@anabranch/queue";
+ *
+ * const messageId = await Queue.withConnection(createInMemory(), (queue) =>
+ *   queue.send("notifications", { userId: 123, type: "welcome" })
+ * ).run();
+ * ```
+ *
+ * @example Stream messages with concurrent processing and error collection
+ * ```ts
+ * const { successes, errors } = await Queue.withConnection(createInMemory(), (queue) =>
+ *   queue.stream("notifications")
+ *     .withConcurrency(5)
+ *     .map(async (msg) => await sendEmail(msg.data))
+ *     .tapErr((err) => logError(err))
+ *     .partition()
+ * ).run();
+ * ```
+ *
+ * @example Delayed messages with retry handling
+ * ```ts
+ * import { Queue, createInMemory } from "@anabranch/queue";
+ *
+ * await Queue.withConnection(createInMemory(), (queue) =>
+ *   queue.send("notifications", reminder, { delayMs: 30_000 })
+ * ).run();
+ *
+ * const processed = await Queue.withConnection(createInMemory(), (queue) =>
+ *   queue.stream("notifications")
+ *     .map(async (msg) => await processWithRetry(msg.data))
+ *     .filter((r) => r.type === "success")
+ *     .map((r) => r.value)
+ *     .collect()
+ * ).run();
+ * ```
+ *
+ * @module
+ */
+export { Queue } from "./queue.js";
+export type { QueueMessage } from "./adapter.js";
+export type { NackOptions, QueueAdapter, QueueConnector, QueueOptions, SendOptions, } 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";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/queue/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;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,GACZ,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,uBAAuB,CAAC;AAC7C,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC"}

package/esm/queue/index.js

@@ -0,0 +1,74 @@
+/**
+ * @anabranch/queue
+ *
+ * Queue primitives with Task/Stream semantics for error-tolerant message processing.
+ * Integrates with anabranch's {@linkcode Task}, {@linkcode Stream}, {@linkcode Source}, and
+ * {@linkcode Channel} types for composable error handling and concurrent processing.
+ *
+ * ## Adapters vs Connectors
+ *
+ * A **QueueConnector** produces connected **QueueAdapter** instances. Use connectors for
+ * production code to properly manage connection lifecycles:
+ *
+ * - **Connector**: Manages connection pool/lifecycle, produces adapters
+ * - **Adapter**: Low-level send/receive/ack/nack interface
+ * - **Queue**: Wrapper providing Task/Stream methods over an adapter
+ *
+ * ## Core Types
+ *
+ * - {@link QueueConnector} - Interface for connection factories
+ * - {@link QueueAdapter} - Low-level queue operations interface
+ * - {@link Queue} - High-level wrapper with Task/Stream methods
+ * - {@link QueueMessage} - Message envelope with id, data, attempt count
+ *
+ * ## Error Types
+ *
+ * All errors are typed for catchable handling:
+ * - {@link QueueConnectionFailed} - Connection establishment failed
+ * - {@link QueueSendFailed} - Send operation failed
+ * - {@link QueueReceiveFailed} - Receive operation failed
+ * - {@link QueueAckFailed} - Acknowledgment failed
+ *
+ * @example Basic send with Task semantics
+ * ```ts
+ * import { Queue, createInMemory } from "@anabranch/queue";
+ *
+ * const messageId = await Queue.withConnection(createInMemory(), (queue) =>
+ *   queue.send("notifications", { userId: 123, type: "welcome" })
+ * ).run();
+ * ```
+ *
+ * @example Stream messages with concurrent processing and error collection
+ * ```ts
+ * const { successes, errors } = await Queue.withConnection(createInMemory(), (queue) =>
+ *   queue.stream("notifications")
+ *     .withConcurrency(5)
+ *     .map(async (msg) => await sendEmail(msg.data))
+ *     .tapErr((err) => logError(err))
+ *     .partition()
+ * ).run();
+ * ```
+ *
+ * @example Delayed messages with retry handling
+ * ```ts
+ * import { Queue, createInMemory } from "@anabranch/queue";
+ *
+ * await Queue.withConnection(createInMemory(), (queue) =>
+ *   queue.send("notifications", reminder, { delayMs: 30_000 })
+ * ).run();
+ *
+ * const processed = await Queue.withConnection(createInMemory(), (queue) =>
+ *   queue.stream("notifications")
+ *     .map(async (msg) => await processWithRetry(msg.data))
+ *     .filter((r) => r.type === "success")
+ *     .map((r) => r.value)
+ *     .collect()
+ * ).run();
+ * ```
+ *
+ * @module
+ */
+export { Queue } from "./queue.js";
+export * from "./errors.js";
+export { createInMemory } from "./in-memory.js";
+export { Task } from "../anabranch/index.js";

package/esm/queue/queue.d.ts

@@ -0,0 +1,166 @@
+import { Source, Task } from "../anabranch/index.js";
+import type { QueueAdapter, QueueConnector, QueueMessage, SendOptions } from "./adapter.js";
+import { QueueAckFailed, QueueCloseFailed, QueueConnectionFailed, QueueMaxAttemptsExceeded, QueueReceiveFailed, QueueSendFailed } from "./errors.js";
+/**
+ * Queue wrapper with Task/Stream semantics for error-tolerant message processing.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { Queue, createInMemory } from "@anabranch/queue";
+ *
+ * const connector = createInMemory();
+ * const queue = await Queue.connect(connector).run();
+ *
+ * await queue.send("notifications", { userId: 123 }).run();
+ * await queue.ack("notifications", msg.id).run();
+ *
+ * await queue.close().run();
+ * ```
+ *
+ * @example Stream with concurrent processing
+ * ```ts
+ * const { successes, errors } = await queue.stream("notifications")
+ *   .withConcurrency(5)
+ *   .map(async (msg) => await sendEmail(msg.data))
+ *   .tapErr((err) => logError(err))
+ *   .partition();
+ * ```
+ *
+ * @example Continuous streaming
+ * ```ts
+ * const ac = new AbortController();
+ *
+ * queue.continuousStream("notifications", { signal: ac.signal })
+ *   .withConcurrency(5)
+ *   .tap(async (msg) => await processMessage(msg))
+ *   .collect();
+ *
+ * ac.abort();
+ * ```
+ */
+export declare class Queue {
+    private readonly adapter;
+    constructor(adapter: QueueAdapter);
+    /**
+     * Connect to a queue via a connector.
+     *
+     * @example
+     * ```ts
+     * const queue = await Queue.connect(createInMemory()).run();
+     * ```
+     */
+    static connect(connector: QueueConnector): Task<Queue, QueueConnectionFailed>;
+    /**
+     * Release the connection back to its source (e.g., pool).
+     *
+     * @example
+     * ```ts
+     * await queue.close().run();
+     * ```
+     */
+    close(): Task<void, QueueCloseFailed>;
+    /**
+     * Send a message to a queue.
+     *
+     * @example Send with delay
+     * ```ts
+     * const id = await queue.send("notifications", payload, { delayMs: 30_000 }).run();
+     * ```
+     */
+    send<T>(queue: string, data: T, options?: SendOptions): Task<string, QueueSendFailed>;
+    /**
+     * Send multiple messages to a queue in batch.
+     *
+     * @example Batch send
+     * ```ts
+     * const ids = await queue.sendBatch("notifications", [
+     *   { to: "user1@example.com", subject: "Welcome!" },
+     *   { to: "user2@example.com", subject: "Welcome!" },
+     * ]).run();
+     * ```
+     *
+     * @example Parallel batch send (for adapters that support it)
+     * ```ts
+     * const ids = await queue.sendBatch("notifications", items, { parallel: true }).run();
+     * ```
+     */
+    sendBatch<T>(queue: string, data: T[], options?: SendOptions & {
+        parallel?: boolean;
+    }): Task<string[], QueueSendFailed>;
+    /**
+     * Stream messages from a queue for memory-efficient concurrent processing.
+     *
+     * Messages are delivered one at a time but can be processed concurrently
+     * using `withConcurrency()`. Errors are collected alongside successes,
+     * allowing the stream to continue processing while you decide how to handle
+     * failures later.
+     *
+     * @example
+     * ```ts
+     * const { successes, errors } = await queue.stream("notifications")
+     *   .withConcurrency(10)
+     *   .map(async (msg) => await sendNotification(msg.data))
+     *   .tapErr((err) => console.error("Failed:", err))
+     *   .partition();
+     * ```
+     */
+    stream<T>(queue: string, options?: {
+        count?: number;
+        concurrency?: number;
+    }): Source<QueueMessage<T>, QueueReceiveFailed>;
+    /**
+     * Continuous stream that polls for messages until stopped.
+     *
+     * Uses broker-native subscribe if available (StreamAdapter), otherwise
+     * falls back to polling-based implementation. Errors from the adapter
+     * are emitted as error results, allowing pipeline-style error handling
+     * with .recover(), .tapErr(), etc. Use an AbortSignal to stop.
+     *
+     * @example
+     * ```ts
+     * const ac = new AbortController();
+     *
+     * queue.continuousStream("notifications", { signal: ac.signal, count: 5 })
+     *   .withConcurrency(10)
+     *   .tap(async (msg) => await processMessage(msg))
+     *   .tapErr((err) => console.error("Receive failed:", err.message))
+     *   .collect();
+     *
+     * ac.abort();
+     * ```
+     */
+    continuousStream<T>(queue: string, options?: {
+        count?: number;
+        signal?: AbortSignal;
+    }): Source<QueueMessage<T>, QueueReceiveFailed>;
+    /**
+     * Acknowledge one or more messages as successfully processed.
+     *
+     * @example
+     * ```ts
+     * await queue.ack("notifications", msg1.id, msg2.id, msg3.id).run();
+     * ```
+     */
+    ack(queue: string, ...ids: string[]): Task<void, QueueAckFailed>;
+    /**
+     * Negative acknowledgment - indicates processing failure.
+     *
+     * @example Requeue with delay
+     * ```ts
+     * await queue.nack("notifications", msg.id, { requeue: true, delay: 5_000 }).run();
+     * ```
+     *
+     * @example Route to dead letter queue
+     * ```ts
+     * await queue.nack("notifications", msg.id, { deadLetter: true }).run();
+     * ```
+     */
+    nack(queue: string, id: string, options?: {
+        requeue?: boolean;
+        delay?: number;
+        deadLetter?: boolean;
+    }): Task<void, QueueAckFailed | QueueMaxAttemptsExceeded>;
+}
+/** Re-export QueueMessage for convenience */
+export type { QueueMessage } from "./adapter.js";
+//# sourceMappingURL=queue.d.ts.map

package/esm/queue/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../src/queue/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACrD,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,CAAA;KAAE,GACjD,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC;IAmD9C;;;;;;;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

@@ -0,0 +1,284 @@
+import { Source, Task } from "../anabranch/index.js";
+import { QueueAckFailed, QueueCloseFailed, QueueConnectionFailed, QueueReceiveFailed, QueueSendFailed, } from "./errors.js";
+async function sleep(ms, signal) {
+    if (signal?.aborted)
+        return;
+    await new Promise((resolve) => {
+        const timerId = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timerId);
+            resolve();
+        }, { once: true });
+    });
+}
+/**
+ * Queue wrapper with Task/Stream semantics for error-tolerant message processing.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { Queue, createInMemory } from "@anabranch/queue";
+ *
+ * const connector = createInMemory();
+ * const queue = await Queue.connect(connector).run();
+ *
+ * await queue.send("notifications", { userId: 123 }).run();
+ * await queue.ack("notifications", msg.id).run();
+ *
+ * await queue.close().run();
+ * ```
+ *
+ * @example Stream with concurrent processing
+ * ```ts
+ * const { successes, errors } = await queue.stream("notifications")
+ *   .withConcurrency(5)
+ *   .map(async (msg) => await sendEmail(msg.data))
+ *   .tapErr((err) => logError(err))
+ *   .partition();
+ * ```
+ *
+ * @example Continuous streaming
+ * ```ts
+ * const ac = new AbortController();
+ *
+ * queue.continuousStream("notifications", { signal: ac.signal })
+ *   .withConcurrency(5)
+ *   .tap(async (msg) => await processMessage(msg))
+ *   .collect();
+ *
+ * ac.abort();
+ * ```
+ */
+export class Queue {
+    constructor(adapter) {
+        Object.defineProperty(this, "adapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: adapter
+        });
+    }
+    /**
+     * Connect to a queue via a connector.
+     *
+     * @example
+     * ```ts
+     * const queue = await Queue.connect(createInMemory()).run();
+     * ```
+     */
+    static connect(connector) {
+        return Task.of(async () => {
+            try {
+                return new Queue(await connector.connect());
+            }
+            catch (error) {
+                throw new QueueConnectionFailed(error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * Release the connection back to its source (e.g., pool).
+     *
+     * @example
+     * ```ts
+     * await queue.close().run();
+     * ```
+     */
+    close() {
+        return Task.of(async () => {
+            try {
+                await this.adapter.close();
+            }
+            catch (error) {
+                throw new QueueCloseFailed(error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * Send a message to a queue.
+     *
+     * @example Send with delay
+     * ```ts
+     * const id = await queue.send("notifications", payload, { delayMs: 30_000 }).run();
+     * ```
+     */
+    send(queue, data, options) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.send(queue, data, options);
+            }
+            catch (error) {
+                throw new QueueSendFailed(error instanceof Error ? error.message : String(error), queue, error);
+            }
+        });
+    }
+    /**
+     * Send multiple messages to a queue in batch.
+     *
+     * @example Batch send
+     * ```ts
+     * const ids = await queue.sendBatch("notifications", [
+     *   { to: "user1@example.com", subject: "Welcome!" },
+     *   { to: "user2@example.com", subject: "Welcome!" },
+     * ]).run();
+     * ```
+     *
+     * @example Parallel batch send (for adapters that support it)
+     * ```ts
+     * const ids = await queue.sendBatch("notifications", items, { parallel: true }).run();
+     * ```
+     */
+    sendBatch(queue, data, options) {
+        return Task.of(async () => {
+            const ids = [];
+            if (options?.parallel) {
+                const promises = data.map((item) => this.adapter.send(queue, item, options).catch((e) => {
+                    throw new QueueSendFailed(e instanceof Error ? e.message : String(e), queue, e);
+                }));
+                const results = await Promise.all(promises);
+                return results;
+            }
+            for (const item of data) {
+                const id = await this.adapter.send(queue, item, options);
+                ids.push(id);
+            }
+            return ids;
+        });
+    }
+    /**
+     * Stream messages from a queue for memory-efficient concurrent processing.
+     *
+     * Messages are delivered one at a time but can be processed concurrently
+     * using `withConcurrency()`. Errors are collected alongside successes,
+     * allowing the stream to continue processing while you decide how to handle
+     * failures later.
+     *
+     * @example
+     * ```ts
+     * const { successes, errors } = await queue.stream("notifications")
+     *   .withConcurrency(10)
+     *   .map(async (msg) => await sendNotification(msg.data))
+     *   .tapErr((err) => console.error("Failed:", err))
+     *   .partition();
+     * ```
+     */
+    stream(queue, options) {
+        const adapter = this.adapter;
+        const count = options?.count ?? 10;
+        return Source.from(async function* () {
+            try {
+                const messages = await adapter.receive(queue, count);
+                for (const msg of messages) {
+                    yield msg;
+                }
+            }
+            catch (error) {
+                throw new QueueReceiveFailed(error instanceof Error ? error.message : String(error), queue, error);
+            }
+        }).withConcurrency(options?.concurrency ?? Infinity);
+    }
+    /**
+     * Continuous stream that polls for messages until stopped.
+     *
+     * Uses broker-native subscribe if available (StreamAdapter), otherwise
+     * falls back to polling-based implementation. Errors from the adapter
+     * are emitted as error results, allowing pipeline-style error handling
+     * with .recover(), .tapErr(), etc. Use an AbortSignal to stop.
+     *
+     * @example
+     * ```ts
+     * const ac = new AbortController();
+     *
+     * queue.continuousStream("notifications", { signal: ac.signal, count: 5 })
+     *   .withConcurrency(10)
+     *   .tap(async (msg) => await processMessage(msg))
+     *   .tapErr((err) => console.error("Receive failed:", err.message))
+     *   .collect();
+     *
+     * ac.abort();
+     * ```
+     */
+    continuousStream(queue, options) {
+        const count = options?.count ?? 10;
+        const signal = options?.signal;
+        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 });
+                for await (const msg of iterable) {
+                    if (signal?.aborted)
+                        return;
+                    yield { type: "success", value: msg };
+                }
+                return;
+            }
+            const baseDelay = 50;
+            let currentDelay = baseDelay;
+            while (!signal?.aborted) {
+                try {
+                    const messages = await adapter.receive(queue, count);
+                    currentDelay = baseDelay;
+                    for (const msg of messages) {
+                        if (signal?.aborted)
+                            return;
+                        yield { type: "success", value: msg };
+                    }
+                    if (!signal?.aborted && messages.length === 0) {
+                        await sleep(currentDelay, signal);
+                        currentDelay = Math.min(currentDelay * 2, 5000);
+                    }
+                }
+                catch (error) {
+                    if (signal?.aborted)
+                        return;
+                    const queueError = new QueueReceiveFailed(error instanceof Error ? error.message : String(error), queue, error);
+                    yield { type: "error", error: queueError };
+                }
+            }
+        });
+    }
+    /**
+     * Acknowledge one or more messages as successfully processed.
+     *
+     * @example
+     * ```ts
+     * await queue.ack("notifications", msg1.id, msg2.id, msg3.id).run();
+     * ```
+     */
+    ack(queue, ...ids) {
+        return Task.of(async () => {
+            if (ids.length === 0)
+                return;
+            try {
+                await this.adapter.ack(queue, ...ids);
+            }
+            catch (error) {
+                throw new QueueAckFailed(error instanceof Error ? error.message : String(error), queue, ids[0], error);
+            }
+        });
+    }
+    /**
+     * Negative acknowledgment - indicates processing failure.
+     *
+     * @example Requeue with delay
+     * ```ts
+     * await queue.nack("notifications", msg.id, { requeue: true, delay: 5_000 }).run();
+     * ```
+     *
+     * @example Route to dead letter queue
+     * ```ts
+     * await queue.nack("notifications", msg.id, { deadLetter: true }).run();
+     * ```
+     */
+    nack(queue, id, options) {
+        return Task.of(async () => {
+            try {
+                await this.adapter.nack(queue, id, options);
+            }
+            catch (error) {
+                throw new QueueAckFailed(error instanceof Error ? error.message : String(error), queue, id, error);
+            }
+        });
+    }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@anabranch/queue",
+  "version": "0.1.0",
+  "description": "Message queue with dead letter queue and visibility timeout support",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frodi-karlsson/anabranch.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/frodi-karlsson/anabranch/issues"
+  },
+  "module": "./esm/queue/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/queue/index.js"
+    }
+  },
+  "scripts": {},
+  "dependencies": {
+    "anabranch": "^0"
+  },
+  "_generatedBy": "dnt@dev"
+}