@anabranch/queue 0.1.0

package/esm/queue/adapter.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Queue adapter interface for queue-agnostic operations.
+ *
+ * Implement this interface to create drivers for specific message brokers.
+ * The Queue class wraps adapters with Task/Stream semantics.
+ *
+ * For connection lifecycle management, use QueueConnector which produces adapters.
+ * The adapter's close() method releases the connection (e.g., back to a pool)
+ * rather than terminating it — termination is the connector's responsibility.
+ */
+export interface QueueMessage<T = unknown> {
+    /** Unique message identifier */
+    id: string;
+    /** Message payload */
+    data: T;
+    /** Number of times this message has been delivered */
+    attempt: number;
+    /** Timestamp when the message was first enqueued */
+    timestamp: number;
+    /** Optional metadata from the broker */
+    metadata?: Record<string, unknown>;
+}
+/** Options for sending a message with delay or scheduling. */
+export interface SendOptions {
+    /** Delay in milliseconds before the message becomes available */
+    delayMs?: number;
+    /** Explicit scheduled delivery time */
+    scheduledAt?: Date;
+    /** Override the default dead letter queue for this message */
+    deadLetterQueue?: string;
+    /** Message priority (higher = more important, if supported) */
+    priority?: number;
+}
+/** Options for negative acknowledgment. */
+export interface NackOptions {
+    /** Requeue the message instead of dead-letter routing */
+    requeue?: boolean;
+    /** Delay before the message is requeued */
+    delay?: number;
+    /** Explicit dead letter queue target */
+    deadLetter?: boolean;
+}
+/**
+ * Queue adapter interface for low-level queue operations.
+ */
+export interface QueueAdapter {
+    send<T>(queue: string, data: T, options?: SendOptions): Promise<string>;
+    receive<T>(queue: string, count?: number): Promise<QueueMessage<T>[]>;
+    ack(queue: string, ...ids: string[]): Promise<void>;
+    nack(queue: string, id: string, options?: NackOptions): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Extended adapter interface for broker-native streaming.
+ * Implement this if your broker has push-based message consumption
+ * (e.g., RabbitMQ channels, Kafka consumer groups, SQS long polling).
+ */
+export interface StreamAdapter extends QueueAdapter {
+    subscribe<T>(queue: string, options?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<QueueMessage<T>>;
+}
+/**
+ * Connector that produces connected QueueAdapter instances.
+ *
+ * Implement this to provide connection acquisition logic for your message broker.
+ * Handles pool checkout, connection creation, and termination on error.
+ */
+export interface QueueConnector {
+    /**
+     * Acquire a connected adapter.
+     * @param signal Optional AbortSignal for cancellation
+     * @throws QueueConnectionFailed if the connection cannot be established
+     */
+    connect(signal?: AbortSignal): Promise<QueueAdapter>;
+    /**
+     * Close all connections and clean up resources.
+     * After calling end(), the connector cannot be used to create new adapters.
+     */
+    end(): Promise<void>;
+}
+/** Queue configuration options. */
+export interface QueueOptions {
+    /** Maximum delivery attempts before routing to dead letter queue */
+    maxAttempts?: number;
+    /** Message visibility timeout (milliseconds) - time between delivery and ACK/NACK */
+    visibilityTimeout?: number;
+    /** Default dead letter queue for failed messages */
+    deadLetterQueue?: string;
+    /** Dead letter queue specific options */
+    deadLetterOptions?: {
+        /** DLQ's own max delivery attempts */
+        maxAttempts?: number;
+        /** Delay for DLQ messages */
+        delay?: number;
+    };
+}
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/queue/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACvC,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,sBAAsB;IACtB,IAAI,EAAE,CAAC,CAAC;IACR,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,8DAA8D;AAC9D,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uCAAuC;IACvC,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,8DAA8D;IAC9D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,2CAA2C;AAC3C,MAAM,WAAW,WAAW;IAC1B,yDAAyD;IACzD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wCAAwC;IACxC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,CAAC,EACJ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnB,OAAO,CAAC,CAAC,EACP,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAE9B,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,SAAS,CAAC,CAAC,EACT,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAErD;;;OAGG;IACH,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB;AAED,mCAAmC;AACnC,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oDAAoD;IACpD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yCAAyC;IACzC,iBAAiB,CAAC,EAAE;QAClB,sCAAsC;QACtC,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,6BAA6B;QAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;CACH"}

package/esm/queue/adapter.js

@@ -0,0 +1 @@
+export {};

package/esm/queue/errors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Error types for queue operations.
+ */
+/** Base error for all queue-related failures. */
+export declare class QueueError extends Error {
+    readonly queue?: string | undefined;
+    readonly messageId?: string | undefined;
+    constructor(message: string, queue?: string | undefined, messageId?: string | undefined);
+}
+/** Connection establishment failed. */
+export declare class QueueConnectionFailed extends QueueError {
+    readonly originalError?: unknown | undefined;
+    constructor(message: string, originalError?: unknown | undefined);
+}
+/** Message send operation failed. */
+export declare class QueueSendFailed extends QueueError {
+    readonly originalError?: unknown | undefined;
+    constructor(message: string, queue: string, originalError?: unknown | undefined);
+}
+/** Message receive operation failed. */
+export declare class QueueReceiveFailed extends QueueError {
+    readonly originalError?: unknown | undefined;
+    constructor(message: string, queue: string, originalError?: unknown | undefined);
+}
+/** Acknowledgment operation failed. */
+export declare class QueueAckFailed extends QueueError {
+    readonly originalError?: unknown | undefined;
+    constructor(message: string, queue: string, messageId: string, originalError?: unknown | undefined);
+}
+/** Consumer handler failed unexpectedly. */
+export declare class QueueConsumeFailed extends QueueError {
+    readonly originalError?: unknown | undefined;
+    constructor(message: string, queue: string, messageId: string, originalError?: unknown | undefined);
+}
+/** Message exceeded maximum delivery attempts. */
+export declare class QueueMaxAttemptsExceeded extends QueueError {
+    readonly attempts: number;
+    constructor(queue: string, messageId: string, attempts: number);
+}
+/** Connection close operation failed. */
+export declare class QueueCloseFailed extends QueueError {
+    readonly originalError?: unknown | undefined;
+    constructor(message: string, originalError?: unknown | undefined);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/queue/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/queue/errors.js

@@ -0,0 +1,113 @@
+/**
+ * Error types for queue operations.
+ */
+/** Base error for all queue-related failures. */
+export class QueueError extends Error {
+    constructor(message, queue, messageId) {
+        super(message);
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: queue
+        });
+        Object.defineProperty(this, "messageId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: messageId
+        });
+        this.name = "QueueError";
+    }
+}
+/** Connection establishment failed. */
+export class QueueConnectionFailed extends QueueError {
+    constructor(message, originalError) {
+        super(`Connection failed: ${message}`, undefined, undefined);
+        Object.defineProperty(this, "originalError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: originalError
+        });
+        this.name = "QueueConnectionFailed";
+    }
+}
+/** Message send operation failed. */
+export class QueueSendFailed extends QueueError {
+    constructor(message, queue, originalError) {
+        super(message, queue);
+        Object.defineProperty(this, "originalError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: originalError
+        });
+        this.name = "QueueSendFailed";
+    }
+}
+/** Message receive operation failed. */
+export class QueueReceiveFailed extends QueueError {
+    constructor(message, queue, originalError) {
+        super(message, queue);
+        Object.defineProperty(this, "originalError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: originalError
+        });
+        this.name = "QueueReceiveFailed";
+    }
+}
+/** Acknowledgment operation failed. */
+export class QueueAckFailed extends QueueError {
+    constructor(message, queue, messageId, originalError) {
+        super(message, queue, messageId);
+        Object.defineProperty(this, "originalError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: originalError
+        });
+        this.name = "QueueAckFailed";
+    }
+}
+/** Consumer handler failed unexpectedly. */
+export class QueueConsumeFailed extends QueueError {
+    constructor(message, queue, messageId, originalError) {
+        super(message, queue, messageId);
+        Object.defineProperty(this, "originalError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: originalError
+        });
+        this.name = "QueueConsumeFailed";
+    }
+}
+/** Message exceeded maximum delivery attempts. */
+export class QueueMaxAttemptsExceeded extends QueueError {
+    constructor(queue, messageId, attempts) {
+        super(`Message ${messageId} exceeded ${attempts} delivery attempts in queue ${queue}`, queue, messageId);
+        Object.defineProperty(this, "attempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: attempts
+        });
+        this.name = "QueueMaxAttemptsExceeded";
+    }
+}
+/** Connection close operation failed. */
+export class QueueCloseFailed extends QueueError {
+    constructor(message, originalError) {
+        super(message);
+        Object.defineProperty(this, "originalError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: originalError
+        });
+        this.name = "QueueCloseFailed";
+    }
+}

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

@@ -0,0 +1,61 @@
+import type { QueueAdapter, QueueConnector, QueueOptions } from "./adapter.js";
+/**
+ * Creates an in-memory queue connector using a simple message store.
+ *
+ * Messages are stored in memory only and will be lost on process restart.
+ * Uses bucketed priority queues for delayed message support.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { Queue, createInMemory } from "@anabranch/queue";
+ *
+ * const connector = createInMemory();
+ *
+ * // Send a message
+ * await Queue.withConnection(connector, (queue) =>
+ *   queue.send("notifications", { type: "welcome", userId: 123 })
+ * ).run();
+ *
+ * // Receive messages
+ * const { successes } = await Queue.withConnection(connector, (queue) =>
+ *   queue.stream("notifications", { count: 10 })
+ *     .map(async (msg) => await processNotification(msg.data))
+ *     .partition()
+ * ).run();
+ * ```
+ *
+ * @example With delayed messages
+ * ```ts
+ * await Queue.withConnection(connector, (queue) =>
+ *   queue.send("notifications", reminder, { delayMs: 30_000 })
+ * ).run();
+ * ```
+ *
+ * @example With dead letter queue
+ * ```ts
+ * const connector = createInMemory({
+ *   queues: {
+ *     orders: {
+ *       maxAttempts: 3,
+ *       deadLetterQueue: "orders-failed",
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export declare function createInMemory(options?: InMemoryOptions): InMemoryConnector;
+/** In-memory queue connector options. */
+export interface InMemoryOptions {
+    /** Maximum buffer size per queue (enforces backpressure) */
+    maxBufferSize?: number;
+    /** Callback when a message is dropped due to buffer overflow */
+    onDrop?: (value: unknown) => void;
+    /** Per-queue configuration */
+    queues?: Record<string, QueueOptions>;
+}
+/** In-memory queue connector. */
+export interface InMemoryConnector extends QueueConnector {
+    connect(): Promise<QueueAdapter>;
+    end(): Promise<void>;
+}
+//# sourceMappingURL=in-memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../../src/queue/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,YAAY,EACZ,cAAc,EAEd,YAAY,EAEb,MAAM,cAAc,CAAC;AA2BtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,iBAAiB,CAwS3E;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

@@ -0,0 +1,291 @@
+import { QueueReceiveFailed, QueueSendFailed } from "./errors.js";
+function generateId() {
+    return crypto.randomUUID();
+}
+/**
+ * Creates an in-memory queue connector using a simple message store.
+ *
+ * Messages are stored in memory only and will be lost on process restart.
+ * Uses bucketed priority queues for delayed message support.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { Queue, createInMemory } from "@anabranch/queue";
+ *
+ * const connector = createInMemory();
+ *
+ * // Send a message
+ * await Queue.withConnection(connector, (queue) =>
+ *   queue.send("notifications", { type: "welcome", userId: 123 })
+ * ).run();
+ *
+ * // Receive messages
+ * const { successes } = await Queue.withConnection(connector, (queue) =>
+ *   queue.stream("notifications", { count: 10 })
+ *     .map(async (msg) => await processNotification(msg.data))
+ *     .partition()
+ * ).run();
+ * ```
+ *
+ * @example With delayed messages
+ * ```ts
+ * await Queue.withConnection(connector, (queue) =>
+ *   queue.send("notifications", reminder, { delayMs: 30_000 })
+ * ).run();
+ * ```
+ *
+ * @example With dead letter queue
+ * ```ts
+ * const connector = createInMemory({
+ *   queues: {
+ *     orders: {
+ *       maxAttempts: 3,
+ *       deadLetterQueue: "orders-failed",
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export function createInMemory(options) {
+    const queues = new Map();
+    const timerIds = new Set();
+    let ended = false;
+    const defaultOptions = {
+        maxAttempts: 3,
+        visibilityTimeout: 30000,
+        deadLetterQueue: "",
+        deadLetterOptions: {
+            maxAttempts: 1,
+            delay: 0,
+        },
+    };
+    const queueConfigs = options?.queues ?? {};
+    const maxBufferSize = options?.maxBufferSize ?? Infinity;
+    const onDrop = options?.onDrop;
+    return {
+        connect() {
+            let adapterRef = undefined;
+            const routeToDlq = (queue, message) => {
+                const dlqName = queue.options.deadLetterQueue;
+                if (dlqName && adapterRef) {
+                    adapterRef.send(dlqName, {
+                        originalId: message.id,
+                        originalQueue: "source",
+                        data: message.data,
+                        attempt: message.attempt,
+                        timestamp: message.timestamp,
+                    }).catch((err) => {
+                        onDrop?.({ message, error: err });
+                    });
+                }
+            };
+            const findMessage = (queue, id) => {
+                return (queue.messages.find((m) => m.id === id) ??
+                    queue.inflight.get(id)?.msg ??
+                    Array.from(queue.delayed.values())
+                        .flat()
+                        .find((m) => m.id === id));
+            };
+            const handleNack = (queue, id, nackOptions) => {
+                const existing = findMessage(queue, id);
+                if (nackOptions?.deadLetter) {
+                    routeToDlq(queue, existing ??
+                        {
+                            id,
+                            data: null,
+                            attempt: 1,
+                            timestamp: Date.now(),
+                        });
+                    return Promise.resolve();
+                }
+                if (nackOptions?.requeue) {
+                    queue.inflight.delete(id);
+                    const attempt = existing ? existing.attempt + 1 : 2;
+                    if (attempt > queue.options.maxAttempts) {
+                        routeToDlq(queue, {
+                            id,
+                            data: existing?.data ?? null,
+                            attempt,
+                            timestamp: Date.now(),
+                        });
+                        return Promise.resolve();
+                    }
+                    const message = {
+                        id,
+                        data: (existing?.data ?? null),
+                        attempt,
+                        timestamp: Date.now(),
+                    };
+                    const delay = nackOptions.delay ?? 0;
+                    if (delay > 0) {
+                        const bucket = Math.ceil((Date.now() + delay) / 1000);
+                        if (!queue.delayed.has(bucket)) {
+                            queue.delayed.set(bucket, []);
+                        }
+                        queue.delayed.get(bucket).push(message);
+                        scheduleDelayedProcessingInner(queue);
+                    }
+                    else {
+                        queue.messages.push(message);
+                    }
+                    return Promise.resolve();
+                }
+                return Promise.resolve();
+            };
+            const adapter = {
+                send(queueName, data, sendOptions) {
+                    if (ended) {
+                        return Promise.reject(new QueueSendFailed("Connector ended", queueName));
+                    }
+                    let queue = queues.get(queueName);
+                    if (!queue) {
+                        const config = queueConfigs[queueName] ?? {};
+                        queue = {
+                            messages: [],
+                            delayed: new Map(),
+                            inflight: new Map(),
+                            options: {
+                                ...defaultOptions,
+                                ...config,
+                                deadLetterQueue: config.deadLetterQueue ?? "",
+                                deadLetterOptions: {
+                                    ...defaultOptions.deadLetterOptions,
+                                    ...config.deadLetterOptions,
+                                },
+                            },
+                        };
+                        queues.set(queueName, queue);
+                    }
+                    const id = generateId();
+                    const delayMs = sendOptions?.delayMs ??
+                        (sendOptions?.scheduledAt
+                            ? Math.max(0, sendOptions.scheduledAt.getTime() - Date.now())
+                            : 0);
+                    const message = {
+                        id,
+                        data,
+                        attempt: 1,
+                        timestamp: Date.now(),
+                    };
+                    if (delayMs > 0) {
+                        const bucket = Math.ceil((Date.now() + delayMs) / 1000);
+                        if (!queue.delayed.has(bucket)) {
+                            queue.delayed.set(bucket, []);
+                        }
+                        queue.delayed.get(bucket).push(message);
+                        scheduleDelayedProcessingInner(queue);
+                    }
+                    else {
+                        if (queue.messages.length >= maxBufferSize) {
+                            if (maxBufferSize !== Infinity) {
+                                onDrop?.(message);
+                            }
+                            return Promise.reject(new Error("Buffer full"));
+                        }
+                        queue.messages.push(message);
+                    }
+                    return Promise.resolve(id);
+                },
+                receive(queueName, count) {
+                    if (ended) {
+                        return Promise.reject(new QueueReceiveFailed("Connector ended", queueName));
+                    }
+                    const queue = queues.get(queueName);
+                    if (!queue) {
+                        return Promise.resolve([]);
+                    }
+                    promoteDelayedMessagesInner(queue);
+                    expireVisibleMessages(queue);
+                    const messages = [];
+                    const toReceive = count ?? 10;
+                    const now = Date.now();
+                    while (messages.length < toReceive && queue.messages.length > 0) {
+                        const msg = queue.messages.shift();
+                        if (msg) {
+                            messages.push(msg);
+                            queue.inflight.set(msg.id, { msg, deliveredAt: now });
+                        }
+                    }
+                    return Promise.resolve(messages);
+                },
+                ack(queueName, ...ids) {
+                    if (ended) {
+                        return Promise.reject(new QueueSendFailed("Connector ended", queueName));
+                    }
+                    const queue = queues.get(queueName);
+                    if (!queue)
+                        return Promise.resolve();
+                    for (const id of ids) {
+                        queue.inflight.delete(id);
+                    }
+                    queue.messages = queue.messages.filter((m) => !ids.includes(m.id));
+                    return Promise.resolve();
+                },
+                nack(queueName, id, nackOptions) {
+                    if (ended) {
+                        return Promise.reject(new QueueSendFailed("Connector ended", queueName));
+                    }
+                    const queue = queues.get(queueName);
+                    if (!queue)
+                        return Promise.resolve();
+                    return handleNack(queue, id, nackOptions);
+                },
+                close() {
+                    return Promise.resolve();
+                },
+            };
+            adapterRef = adapter;
+            const promoteDelayedMessagesInner = (queue) => {
+                const now = Math.ceil(Date.now() / 1000);
+                for (const [bucket, messages] of queue.delayed) {
+                    if (bucket <= now) {
+                        queue.messages.push(...messages);
+                        queue.delayed.delete(bucket);
+                    }
+                }
+            };
+            const scheduleDelayedProcessingInner = (queue) => {
+                if (queue.delayed.size === 0)
+                    return;
+                const nextBucket = Math.min(...queue.delayed.keys());
+                const delay = Math.max(0, nextBucket * 1000 - Date.now());
+                const timerId = setTimeout(() => {
+                    timerIds.delete(timerId);
+                    promoteDelayedMessagesInner(queue);
+                    if (queue.delayed.size > 0) {
+                        scheduleDelayedProcessingInner(queue);
+                    }
+                }, Math.max(delay, 10));
+                timerIds.add(timerId);
+            };
+            return Promise.resolve(adapter);
+        },
+        end() {
+            ended = true;
+            for (const timerId of timerIds) {
+                clearTimeout(timerId);
+            }
+            timerIds.clear();
+            for (const queue of queues.values()) {
+                queue.messages = [];
+                queue.delayed.clear();
+                queue.inflight.clear();
+            }
+            queues.clear();
+            return Promise.resolve();
+        },
+    };
+}
+const checkVisibilityTimeout = (queue) => {
+    const now = Date.now();
+    const timeout = queue.options.visibilityTimeout;
+    for (const [id, entry] of queue.inflight) {
+        if (entry.deliveredAt + timeout <= now) {
+            queue.inflight.delete(id);
+            queue.messages.push(entry.msg);
+        }
+    }
+};
+function expireVisibleMessages(queue) {
+    checkVisibilityTimeout(queue);
+}