@znight/messaging 0.0.0-stage → 0.1.1

package/dist/memory.d.mts

@@ -0,0 +1,124 @@
+import { c as SubscribeOptions, f as OutboundMessage, i as DriverContext, l as Subscription, n as DeliveryHandler, o as MessagingDriver, r as DriverCapabilities, u as DeadLetterReason } from "./driver-ZxLqy_Ap.mjs";
+/** Options of {@link memory}. */
+export interface MemoryDriverOptions {
+  /** Longest retry delay waited in-process. Default: 1000 ms. */
+  readonly maxInProcessDelayMs?: number;
+  /** Whether longer delays are scheduled by the driver (timers). Default: `true`. */
+  readonly nativeDelay?: boolean;
+  /** Longest native delay. Default: unlimited. */
+  readonly maxNativeDelayMs?: number;
+  /** Longest `publish(..., { delay })`. Default: unlimited. */
+  readonly maxPublishDelayMs?: number;
+  /** Dead-letter naming. Default: `${queue}.dlq`. */
+  readonly deadLetterName?: (queue: string) => string;
+}
+/** A message stored by the memory broker. */
+export interface MemoryMessage {
+  readonly queue: string;
+  readonly id: string;
+  readonly type: string | undefined;
+  readonly key: string | undefined;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly body: Uint8Array | string;
+  readonly contentType: string | undefined;
+  readonly timestamp: number;
+  /** Deliveries made so far (the next delivery is attempt `deliveries + 1`). */
+  readonly deliveries: number;
+  /** The body decoded with the JSON codec (`undefined` when it cannot be decoded). */
+  readonly payload: unknown;
+}
+/** A settlement performed by a consumer, in order. */
+export interface MemorySettlement {
+  readonly queue: string;
+  readonly id: string;
+  readonly attempt: number;
+  readonly action: "ack" | "retry" | "release" | "dead-letter" | "reject";
+  /** Retry delay requested (native delays only; in-process delays happen before a `retry` with delay 0). */
+  readonly delayMs?: number;
+  readonly reason?: DeadLetterReason;
+  readonly error?: unknown;
+}
+/** A dead-lettered message. */
+export interface MemoryDeadLetter {
+  /** Dead-letter queue (`undefined` when dead-lettering was disabled: the message was discarded). */
+  readonly queue: string | undefined;
+  readonly originalQueue: string;
+  readonly message: MemoryMessage;
+  readonly reason: DeadLetterReason;
+  readonly error: unknown;
+  readonly attempt: number;
+}
+/** A message injected with {@link MemoryDriver.send}, as an external producer would. */
+export interface MemorySendOptions {
+  /** Payload encoded with the JSON codec (ignored when `body` is given). */
+  readonly payload?: unknown;
+  /** Raw body (e.g. malformed JSON). */
+  readonly body?: Uint8Array | string;
+  readonly contentType?: string;
+  readonly type?: string;
+  readonly key?: string;
+  readonly id?: string;
+  readonly headers?: Readonly<Record<string, string>>;
+  /** Deliveries already made (simulates a redelivered message). Default: 0. */
+  readonly deliveries?: number;
+}
+/** Operations whose failure can be injected with {@link MemoryDriver.fail}. */
+export type MemoryOperation = "connect" | "subscribe" | "publish" | "ack" | "retry" | "dead-letter" | "release";
+/** Options of {@link MemoryDriver.fail}. */
+export interface MemoryFailureOptions {
+  /** Only for this queue (the destination queue for `publish`, the consumed queue otherwise). */
+  readonly queue?: string;
+  /** Number of failures before the operation works again. Default: unlimited. */
+  readonly times?: number;
+  /** Thrown error. Default: an `Error` naming the operation. */
+  readonly error?: unknown;
+}
+/** Creates a {@link MemoryDriver}. */
+export declare function memory(options?: MemoryDriverOptions): MemoryDriver;
+/** In-memory {@link MessagingDriver}. See the module documentation. */
+export declare class MemoryDriver implements MessagingDriver {
+  #private;
+  readonly name = "memory";
+  readonly capabilities: DriverCapabilities;
+  constructor(options?: MemoryDriverOptions);
+  /** Whether `connect()` was called and `close()` was not. */
+  get connected(): boolean;
+  connect(_context: DriverContext): Promise<void>;
+  close(): Promise<void>;
+  deadLetterName(queue: string): string;
+  publish(queue: string, message: OutboundMessage): Promise<void>;
+  subscribe(queue: string, handler: DeliveryHandler, options: SubscribeOptions): Promise<Subscription>;
+  /**
+   * Injects a message into `queue` as an external producer would (no codec involved when `body` is
+   * given). Returns the message id.
+   */
+  send(queue: string, options?: MemorySendOptions): string;
+  /** Messages published through `publish()` (the `MessageBroker`), optionally for one queue. */
+  published(queue?: string): MemoryMessage[];
+  /** Messages waiting in `queue` (not delivered yet, delayed messages excluded). */
+  pending(queue: string): MemoryMessage[];
+  /** Settlements performed by consumers, in order, optionally for one consumed queue. */
+  settlements(queue?: string): MemorySettlement[];
+  /** Dead-lettered (or discarded) messages, optionally for one consumed queue. */
+  deadLetters(queue?: string): MemoryDeadLetter[];
+  /** Deliveries currently handed to consumers and not finished. */
+  get inFlight(): number;
+  /** Whether nothing is in flight, scheduled or deliverable. */
+  isIdle(): boolean;
+  /**
+   * Resolves once nothing is in flight, scheduled (delayed messages, retries) or deliverable to an
+   * active subscriber. Rejects after `timeoutMs` (default 5 s).
+   */
+  idle(timeoutMs?: number): Promise<void>;
+  /** Polls `predicate` until it returns `true`; rejects after `timeoutMs` (default 5 s). */
+  waitFor(predicate: () => boolean, timeoutMs?: number): Promise<void>;
+  /**
+   * Makes an operation fail (for tests): `publish` (also dead-letter publications, by destination
+   * queue), `ack`, `retry`, `dead-letter`, `release` (by consumed queue), `subscribe`, `connect`.
+   * Returns a function removing the failure.
+   */
+  fail(operation: MemoryOperation, options?: MemoryFailureOptions): () => void;
+  /** Forgets every message, settlement and failure (subscriptions are kept). */
+  reset(): void;
+}
+//# sourceMappingURL=memory.d.mts.map

package/dist/memory.mjs

@@ -0,0 +1,429 @@
+import { g as brokerUnavailableError, l as headerRecord, t as MAX_TIMER_DELAY_MS } from "./async-CFh_bvex.mjs";
+import { o as jsonCodec } from "./codec-Dku-NXXU.mjs";
+import { n as deadLetterHeaders, r as durationOption } from "./shared-BJBpLS8V.mjs";
+import { randomUUID } from "node:crypto";
+// src/drivers/memory.ts
+const DEFAULT_IN_PROCESS_DELAY_MS = 1e3;
+const DEFAULT_IDLE_TIMEOUT_MS = 5e3;
+/** Creates a {@link MemoryDriver}. */
+function memory(options = {}) {
+	return new MemoryDriver(options);
+}
+/** In-memory {@link MessagingDriver}. See the module documentation. */
+var MemoryDriver = class {
+	name = "memory";
+	capabilities;
+	#deadLetterName;
+	#queues = /* @__PURE__ */ new Map();
+	#published = [];
+	#settlements = [];
+	#deadLetters = [];
+	#timers = /* @__PURE__ */ new Set();
+	#failures = [];
+	#idleWaiters = /* @__PURE__ */ new Set();
+	#inflight = 0;
+	#connected = false;
+	#closed = false;
+	#idleCheckScheduled = false;
+	constructor(options = {}) {
+		const nativeDelay = options.nativeDelay ?? true;
+		this.capabilities = Object.freeze({
+			nativeDelay,
+			maxNativeDelayMs: nativeDelay ? durationOption(options.maxNativeDelayMs, Number.POSITIVE_INFINITY, "maxNativeDelayMs") : 0,
+			maxInProcessDelayMs: durationOption(options.maxInProcessDelayMs, DEFAULT_IN_PROCESS_DELAY_MS, "maxInProcessDelayMs"),
+			deliveryCount: "native",
+			maxPublishDelayMs: durationOption(options.maxPublishDelayMs, Number.POSITIVE_INFINITY, "maxPublishDelayMs")
+		});
+		this.#deadLetterName = options.deadLetterName ?? ((queue) => `${queue}.dlq`);
+	}
+	/** Whether `connect()` was called and `close()` was not. */
+	get connected() {
+		return this.#connected && !this.#closed;
+	}
+	async connect(_context) {
+		await Promise.resolve();
+		this.#maybeFail("connect", void 0);
+		this.#connected = true;
+		this.#closed = false;
+	}
+	async close() {
+		await Promise.resolve();
+		this.#closed = true;
+		for (const timer of this.#timers) clearTimeout(timer);
+		this.#timers.clear();
+		for (const state of this.#queues.values()) {
+			for (const subscriber of state.subscribers) subscriber.active = false;
+			state.subscribers.length = 0;
+		}
+		this.#checkIdle();
+	}
+	deadLetterName(queue) {
+		return this.#deadLetterName(queue);
+	}
+	async publish(queue, message) {
+		await Promise.resolve();
+		this.#assertOpen(`publish to "${queue}"`);
+		this.#maybeFail("publish", queue);
+		const stored = {
+			queue,
+			id: message.id,
+			type: message.type,
+			key: message.key,
+			headers: { ...message.headers },
+			body: message.body,
+			contentType: message.contentType,
+			timestamp: message.timestamp,
+			deliveries: 0
+		};
+		this.#published.push(snapshot(stored));
+		if (message.delayMs > 0) this.#schedule(() => this.#enqueue(stored, "tail"), message.delayMs);
+		else this.#enqueue(stored, "tail");
+	}
+	async subscribe(queue, handler, options) {
+		await Promise.resolve();
+		this.#assertOpen(`subscribe to "${queue}"`);
+		this.#maybeFail("subscribe", queue);
+		const state = this.#queue(queue);
+		const subscriber = {
+			queue,
+			handler,
+			concurrency: options.concurrency,
+			options,
+			inflight: 0,
+			active: true
+		};
+		state.subscribers.push(subscriber);
+		this.#pump(queue);
+		return {
+			cancel: async () => {
+				await Promise.resolve();
+				subscriber.active = false;
+				this.#checkIdle();
+			},
+			close: async () => {
+				await Promise.resolve();
+				subscriber.active = false;
+				const index = state.subscribers.indexOf(subscriber);
+				if (index !== -1) state.subscribers.splice(index, 1);
+				this.#checkIdle();
+			}
+		};
+	}
+	/**
+	* Injects a message into `queue` as an external producer would (no codec involved when `body` is
+	* given). Returns the message id.
+	*/
+	send(queue, options = {}) {
+		this.#assertOpen(`send to "${queue}"`);
+		const encoded = options.body === void 0 ? jsonCodec.encode(options.payload, options.contentType) : {
+			body: options.body,
+			contentType: options.contentType
+		};
+		const stored = {
+			queue,
+			id: options.id ?? randomUUID(),
+			type: options.type,
+			key: options.key,
+			headers: { ...options.headers ?? {} },
+			body: encoded.body,
+			contentType: encoded.contentType,
+			timestamp: Date.now(),
+			deliveries: options.deliveries ?? 0
+		};
+		this.#enqueue(stored, "tail");
+		return stored.id;
+	}
+	/** Messages published through `publish()` (the `MessageBroker`), optionally for one queue. */
+	published(queue) {
+		return this.#published.filter((message) => queue === void 0 || message.queue === queue);
+	}
+	/** Messages waiting in `queue` (not delivered yet, delayed messages excluded). */
+	pending(queue) {
+		return (this.#queues.get(queue)?.ready ?? []).map(snapshot);
+	}
+	/** Settlements performed by consumers, in order, optionally for one consumed queue. */
+	settlements(queue) {
+		return this.#settlements.filter((settlement) => queue === void 0 || settlement.queue === queue);
+	}
+	/** Dead-lettered (or discarded) messages, optionally for one consumed queue. */
+	deadLetters(queue) {
+		return this.#deadLetters.filter((entry) => queue === void 0 || entry.originalQueue === queue);
+	}
+	/** Deliveries currently handed to consumers and not finished. */
+	get inFlight() {
+		return this.#inflight;
+	}
+	/** Whether nothing is in flight, scheduled or deliverable. */
+	isIdle() {
+		if (this.#inflight > 0 || this.#timers.size > 0) return false;
+		for (const state of this.#queues.values()) {
+			if (state.scheduled) return false;
+			if (state.ready.length > 0 && state.subscribers.some((s) => s.active && s.inflight < s.concurrency)) return false;
+		}
+		return true;
+	}
+	/**
+	* Resolves once nothing is in flight, scheduled (delayed messages, retries) or deliverable to an
+	* active subscriber. Rejects after `timeoutMs` (default 5 s).
+	*/
+	idle(timeoutMs = DEFAULT_IDLE_TIMEOUT_MS) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#idleWaiters.delete(done);
+				reject(/* @__PURE__ */ new Error(`[znight] MemoryDriver.idle(): still busy after ${timeoutMs} ms (${this.#inflight} in flight)`));
+			}, timeoutMs);
+			const done = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			this.#idleWaiters.add(done);
+			this.#checkIdle();
+		});
+	}
+	/** Polls `predicate` until it returns `true`; rejects after `timeoutMs` (default 5 s). */
+	async waitFor(predicate, timeoutMs = DEFAULT_IDLE_TIMEOUT_MS) {
+		const deadline = Date.now() + timeoutMs;
+		while (!predicate()) {
+			if (Date.now() > deadline) throw new Error(`[znight] MemoryDriver.waitFor(): condition not met after ${timeoutMs} ms`);
+			await new Promise((resolve) => setTimeout(resolve, 1));
+		}
+	}
+	/**
+	* Makes an operation fail (for tests): `publish` (also dead-letter publications, by destination
+	* queue), `ack`, `retry`, `dead-letter`, `release` (by consumed queue), `subscribe`, `connect`.
+	* Returns a function removing the failure.
+	*/
+	fail(operation, options = {}) {
+		const failure = {
+			operation,
+			queue: options.queue,
+			remaining: options.times ?? Number.POSITIVE_INFINITY,
+			error: options.error ?? /* @__PURE__ */ new Error(`[memory] injected ${operation} failure`)
+		};
+		this.#failures.push(failure);
+		return () => {
+			const index = this.#failures.indexOf(failure);
+			if (index !== -1) this.#failures.splice(index, 1);
+		};
+	}
+	/** Forgets every message, settlement and failure (subscriptions are kept). */
+	reset() {
+		for (const timer of this.#timers) clearTimeout(timer);
+		this.#timers.clear();
+		for (const state of this.#queues.values()) state.ready.length = 0;
+		this.#published.length = 0;
+		this.#settlements.length = 0;
+		this.#deadLetters.length = 0;
+		this.#failures.length = 0;
+		this.#checkIdle();
+	}
+	#queue(name) {
+		let state = this.#queues.get(name);
+		if (state === void 0) {
+			state = {
+				ready: [],
+				subscribers: [],
+				next: 0,
+				scheduled: false
+			};
+			this.#queues.set(name, state);
+		}
+		return state;
+	}
+	#enqueue(message, position) {
+		const state = this.#queue(message.queue);
+		if (position === "head") state.ready.unshift(message);
+		else state.ready.push(message);
+		this.#pump(message.queue);
+	}
+	/** Runs `fn` after `delayMs` (any duration: a timer waits at most 2^31 - 1 ms, longer delays re-arm). */
+	#schedule(fn, delayMs) {
+		const wait = Math.min(delayMs, MAX_TIMER_DELAY_MS);
+		const timer = setTimeout(() => {
+			this.#timers.delete(timer);
+			if (delayMs > wait) return this.#schedule(fn, delayMs - wait);
+			fn();
+			this.#checkIdle();
+		}, wait);
+		this.#timers.add(timer);
+	}
+	#pump(queue) {
+		const state = this.#queue(queue);
+		if (state.scheduled) return;
+		state.scheduled = true;
+		queueMicrotask(() => {
+			state.scheduled = false;
+			this.#dispatch(state);
+			this.#checkIdle();
+		});
+	}
+	#dispatch(state) {
+		while (state.ready.length > 0) {
+			const subscriber = this.#nextSubscriber(state);
+			if (subscriber === void 0) return;
+			const message = state.ready.shift();
+			this.#deliver(subscriber, message);
+		}
+	}
+	#nextSubscriber(state) {
+		const count = state.subscribers.length;
+		for (let offset = 0; offset < count; offset++) {
+			const index = (state.next + offset) % count;
+			const subscriber = state.subscribers[index];
+			if (subscriber.active && subscriber.inflight < subscriber.concurrency) {
+				state.next = (index + 1) % count;
+				return subscriber;
+			}
+		}
+	}
+	#deliver(subscriber, message) {
+		message.deliveries++;
+		subscriber.inflight++;
+		this.#inflight++;
+		const attempt = message.deliveries;
+		let settled = false;
+		/** Validates a settlement before any side effect (already settled, closed driver, injected failure). */
+		const check = (action) => {
+			if (settled) throw new Error(`[memory] message ${message.id} was already settled (${action})`);
+			this.#assertOpen(`${action} message ${message.id}`);
+			this.#maybeFail(action, message.queue);
+		};
+		const record = (settlement) => {
+			this.#settlements.push({
+				queue: message.queue,
+				id: message.id,
+				attempt,
+				...settlement
+			});
+		};
+		const delivery = {
+			id: message.id,
+			body: message.body,
+			contentType: message.contentType,
+			headers: message.headers,
+			type: message.type,
+			key: message.key,
+			attempt,
+			redelivered: attempt > 1,
+			timestamp: message.timestamp,
+			raw: snapshot(message),
+			ack: async () => {
+				await Promise.resolve();
+				check("ack");
+				settled = true;
+				record({ action: "ack" });
+			},
+			retry: async (request) => {
+				await Promise.resolve();
+				check("retry");
+				settled = true;
+				record({
+					action: "retry",
+					delayMs: request.delayMs,
+					error: request.error
+				});
+				if (request.delayMs > 0) this.#schedule(() => this.#enqueue(message, "tail"), request.delayMs);
+				else this.#enqueue(message, "tail");
+			},
+			deadLetter: async (request) => {
+				await Promise.resolve();
+				check("dead-letter");
+				const queue = request.queue;
+				if (queue !== void 0) {
+					this.#maybeFail("publish", queue);
+					const copy = {
+						...message,
+						queue,
+						headers: deadLetterHeaders(message.headers, request, message.queue),
+						deliveries: 0
+					};
+					this.#enqueue(copy, "tail");
+				}
+				settled = true;
+				record({
+					action: queue === void 0 ? "reject" : "dead-letter",
+					reason: request.reason,
+					error: request.error
+				});
+				this.#deadLetters.push({
+					queue,
+					originalQueue: message.queue,
+					message: snapshot(message),
+					reason: request.reason,
+					error: request.error,
+					attempt: request.attempt
+				});
+			},
+			release: async () => {
+				await Promise.resolve();
+				check("release");
+				settled = true;
+				record({ action: "release" });
+				this.#enqueue(message, "head");
+			}
+		};
+		const finish = () => {
+			subscriber.inflight--;
+			this.#inflight--;
+			if (!settled && !this.#closed) {
+				settled = true;
+				record({ action: "release" });
+				this.#enqueue(message, "head");
+			}
+			this.#pump(message.queue);
+			this.#checkIdle();
+		};
+		let result;
+		try {
+			result = subscriber.handler(delivery);
+		} catch (error) {
+			result = Promise.reject(error);
+		}
+		Promise.resolve(result).then(finish, finish);
+	}
+	#maybeFail(operation, queue) {
+		for (const failure of this.#failures) {
+			if (failure.operation !== operation || failure.remaining <= 0) continue;
+			if (failure.queue !== void 0 && failure.queue !== queue) continue;
+			failure.remaining--;
+			throw failure.error;
+		}
+	}
+	#assertOpen(action) {
+		if (this.#closed) throw brokerUnavailableError(`[memory] Cannot ${action}: the driver is closed`);
+	}
+	#checkIdle() {
+		if (this.#idleWaiters.size === 0 || this.#idleCheckScheduled) return;
+		this.#idleCheckScheduled = true;
+		queueMicrotask(() => {
+			this.#idleCheckScheduled = false;
+			if (!this.isIdle()) return;
+			const waiters = [...this.#idleWaiters];
+			this.#idleWaiters.clear();
+			for (const waiter of waiters) waiter();
+		});
+	}
+};
+function snapshot(message) {
+	let payload;
+	try {
+		payload = jsonCodec.decode(message.body, message.contentType);
+	} catch {
+		payload = void 0;
+	}
+	return {
+		queue: message.queue,
+		id: message.id,
+		type: message.type,
+		key: message.key,
+		headers: Object.assign(headerRecord(), message.headers),
+		body: message.body,
+		contentType: message.contentType,
+		timestamp: message.timestamp,
+		deliveries: message.deliveries,
+		payload
+	};
+}
+export { MemoryDriver, memory };
+
+//# sourceMappingURL=memory.mjs.map

package/dist/memory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.mjs","names":[],"sources":["../src/drivers/memory.ts"],"sourcesContent":["/**\n * `@znight/messaging/memory`: an in-process broker for tests and local development. Deterministic\n * (FIFO queues, round-robin between competing subscribers, microtask dispatch, timers only for\n * delays), full featured (delays, native delivery counts, dead-letter queues, competing consumers)\n * and inspectable (published messages, settlements, dead letters, `idle()`, failure injection).\n *\n * ```ts\n * const driver = memory()\n * const app = await Application.create({ metadata, plugins: [MessagingPlugin.configure({ driver })] })\n * await app.start()\n * await app.get(MessageBroker).publish('orders', { id: 1 }, { type: 'order.created' })\n * await driver.idle()\n * expect(driver.settlements('orders')).toMatchObject([{ action: 'ack' }])\n * ```\n */\nimport type {\n  DeadLetterRequest,\n  DeliveryHandler,\n  DriverCapabilities,\n  DriverContext,\n  DriverDelivery,\n  MessagingDriver,\n  RetryRequest,\n  SubscribeOptions,\n  Subscription,\n} from '../driver.ts'\nimport type { DeadLetterReason, OutboundMessage } from '../message.ts'\n\nimport { randomUUID } from 'node:crypto'\n\nimport { jsonCodec } from '../codec.ts'\nimport { brokerUnavailableError } from '../errors.ts'\nimport { headerRecord } from '../headers.ts'\nimport { MAX_TIMER_DELAY_MS } from '../internal/async.ts'\nimport { deadLetterHeaders, durationOption } from './shared.ts'\n\n/** Options of {@link memory}. */\nexport interface MemoryDriverOptions {\n  /** Longest retry delay waited in-process. Default: 1000 ms. */\n  readonly maxInProcessDelayMs?: number\n  /** Whether longer delays are scheduled by the driver (timers). Default: `true`. */\n  readonly nativeDelay?: boolean\n  /** Longest native delay. Default: unlimited. */\n  readonly maxNativeDelayMs?: number\n  /** Longest `publish(..., { delay })`. Default: unlimited. */\n  readonly maxPublishDelayMs?: number\n  /** Dead-letter naming. Default: `${queue}.dlq`. */\n  readonly deadLetterName?: (queue: string) => string\n}\n\n/** A message stored by the memory broker. */\nexport interface MemoryMessage {\n  readonly queue: string\n  readonly id: string\n  readonly type: string | undefined\n  readonly key: string | undefined\n  readonly headers: Readonly<Record<string, string>>\n  readonly body: Uint8Array | string\n  readonly contentType: string | undefined\n  readonly timestamp: number\n  /** Deliveries made so far (the next delivery is attempt `deliveries + 1`). */\n  readonly deliveries: number\n  /** The body decoded with the JSON codec (`undefined` when it cannot be decoded). */\n  readonly payload: unknown\n}\n\n/** A settlement performed by a consumer, in order. */\nexport interface MemorySettlement {\n  readonly queue: string\n  readonly id: string\n  readonly attempt: number\n  readonly action: 'ack' | 'retry' | 'release' | 'dead-letter' | 'reject'\n  /** Retry delay requested (native delays only; in-process delays happen before a `retry` with delay 0). */\n  readonly delayMs?: number\n  readonly reason?: DeadLetterReason\n  readonly error?: unknown\n}\n\n/** A dead-lettered message. */\nexport interface MemoryDeadLetter {\n  /** Dead-letter queue (`undefined` when dead-lettering was disabled: the message was discarded). */\n  readonly queue: string | undefined\n  readonly originalQueue: string\n  readonly message: MemoryMessage\n  readonly reason: DeadLetterReason\n  readonly error: unknown\n  readonly attempt: number\n}\n\n/** A message injected with {@link MemoryDriver.send}, as an external producer would. */\nexport interface MemorySendOptions {\n  /** Payload encoded with the JSON codec (ignored when `body` is given). */\n  readonly payload?: unknown\n  /** Raw body (e.g. malformed JSON). */\n  readonly body?: Uint8Array | string\n  readonly contentType?: string\n  readonly type?: string\n  readonly key?: string\n  readonly id?: string\n  readonly headers?: Readonly<Record<string, string>>\n  /** Deliveries already made (simulates a redelivered message). Default: 0. */\n  readonly deliveries?: number\n}\n\n/** Operations whose failure can be injected with {@link MemoryDriver.fail}. */\nexport type MemoryOperation = 'connect' | 'subscribe' | 'publish' | 'ack' | 'retry' | 'dead-letter' | 'release'\n\n/** Options of {@link MemoryDriver.fail}. */\nexport interface MemoryFailureOptions {\n  /** Only for this queue (the destination queue for `publish`, the consumed queue otherwise). */\n  readonly queue?: string\n  /** Number of failures before the operation works again. Default: unlimited. */\n  readonly times?: number\n  /** Thrown error. Default: an `Error` naming the operation. */\n  readonly error?: unknown\n}\n\ninterface StoredMessage {\n  readonly queue: string\n  readonly id: string\n  readonly type: string | undefined\n  readonly key: string | undefined\n  readonly headers: Readonly<Record<string, string>>\n  readonly body: Uint8Array | string\n  readonly contentType: string | undefined\n  readonly timestamp: number\n  deliveries: number\n}\n\ninterface Subscriber {\n  readonly queue: string\n  readonly handler: DeliveryHandler\n  readonly concurrency: number\n  readonly options: SubscribeOptions\n  inflight: number\n  active: boolean\n}\n\ninterface QueueState {\n  readonly ready: StoredMessage[]\n  readonly subscribers: Subscriber[]\n  next: number\n  scheduled: boolean\n}\n\ninterface Failure {\n  readonly operation: MemoryOperation\n  readonly queue: string | undefined\n  remaining: number\n  readonly error: unknown\n}\n\nconst DEFAULT_IN_PROCESS_DELAY_MS = 1000\nconst DEFAULT_IDLE_TIMEOUT_MS = 5000\n\n/** Creates a {@link MemoryDriver}. */\nexport function memory(options: MemoryDriverOptions = {}): MemoryDriver {\n  return new MemoryDriver(options)\n}\n\n/** In-memory {@link MessagingDriver}. See the module documentation. */\nexport class MemoryDriver implements MessagingDriver {\n  readonly name = 'memory'\n  readonly capabilities: DriverCapabilities\n  readonly #deadLetterName: (queue: string) => string\n  readonly #queues = new Map<string, QueueState>()\n  readonly #published: MemoryMessage[] = []\n  readonly #settlements: MemorySettlement[] = []\n  readonly #deadLetters: MemoryDeadLetter[] = []\n  readonly #timers = new Set<ReturnType<typeof setTimeout>>()\n  readonly #failures: Failure[] = []\n  readonly #idleWaiters = new Set<() => void>()\n  #inflight = 0\n  #connected = false\n  #closed = false\n  #idleCheckScheduled = false\n\n  constructor(options: MemoryDriverOptions = {}) {\n    const nativeDelay = options.nativeDelay ?? true\n    this.capabilities = Object.freeze({\n      nativeDelay,\n      maxNativeDelayMs: nativeDelay\n        ? durationOption(options.maxNativeDelayMs, Number.POSITIVE_INFINITY, 'maxNativeDelayMs')\n        : 0,\n      maxInProcessDelayMs: durationOption(\n        options.maxInProcessDelayMs,\n        DEFAULT_IN_PROCESS_DELAY_MS,\n        'maxInProcessDelayMs',\n      ),\n      deliveryCount: 'native',\n      maxPublishDelayMs: durationOption(options.maxPublishDelayMs, Number.POSITIVE_INFINITY, 'maxPublishDelayMs'),\n    })\n    this.#deadLetterName = options.deadLetterName ?? (queue => `${queue}.dlq`)\n  }\n\n  /** Whether `connect()` was called and `close()` was not. */\n  get connected(): boolean {\n    return this.#connected && !this.#closed\n  }\n\n  // -----------------------------------------------------------------------------------------------\n  // MessagingDriver\n  // -----------------------------------------------------------------------------------------------\n\n  async connect(_context: DriverContext): Promise<void> {\n    await Promise.resolve()\n    this.#maybeFail('connect', undefined)\n    this.#connected = true\n    this.#closed = false\n  }\n\n  async close(): Promise<void> {\n    await Promise.resolve()\n    this.#closed = true\n    for (const timer of this.#timers) clearTimeout(timer)\n    this.#timers.clear()\n    for (const state of this.#queues.values()) {\n      for (const subscriber of state.subscribers) subscriber.active = false\n      state.subscribers.length = 0\n    }\n    this.#checkIdle()\n  }\n\n  deadLetterName(queue: string): string {\n    return this.#deadLetterName(queue)\n  }\n\n  async publish(queue: string, message: OutboundMessage): Promise<void> {\n    await Promise.resolve()\n    this.#assertOpen(`publish to \"${queue}\"`)\n    this.#maybeFail('publish', queue)\n    const stored: StoredMessage = {\n      queue,\n      id: message.id,\n      type: message.type,\n      key: message.key,\n      headers: { ...message.headers },\n      body: message.body,\n      contentType: message.contentType,\n      timestamp: message.timestamp,\n      deliveries: 0,\n    }\n    this.#published.push(snapshot(stored))\n    if (message.delayMs > 0) this.#schedule(() => this.#enqueue(stored, 'tail'), message.delayMs)\n    else this.#enqueue(stored, 'tail')\n  }\n\n  async subscribe(queue: string, handler: DeliveryHandler, options: SubscribeOptions): Promise<Subscription> {\n    await Promise.resolve()\n    this.#assertOpen(`subscribe to \"${queue}\"`)\n    this.#maybeFail('subscribe', queue)\n    const state = this.#queue(queue)\n    const subscriber: Subscriber = {\n      queue,\n      handler,\n      concurrency: options.concurrency,\n      options,\n      inflight: 0,\n      active: true,\n    }\n    state.subscribers.push(subscriber)\n    this.#pump(queue)\n    return {\n      cancel: async (): Promise<void> => {\n        await Promise.resolve()\n        subscriber.active = false\n        this.#checkIdle()\n      },\n      close: async (): Promise<void> => {\n        await Promise.resolve()\n        subscriber.active = false\n        const index = state.subscribers.indexOf(subscriber)\n        if (index !== -1) state.subscribers.splice(index, 1)\n        this.#checkIdle()\n      },\n    }\n  }\n\n  // -----------------------------------------------------------------------------------------------\n  // Test helpers\n  // -----------------------------------------------------------------------------------------------\n\n  /**\n   * Injects a message into `queue` as an external producer would (no codec involved when `body` is\n   * given). Returns the message id.\n   */\n  send(queue: string, options: MemorySendOptions = {}): string {\n    this.#assertOpen(`send to \"${queue}\"`)\n    const encoded =\n      options.body === undefined\n        ? jsonCodec.encode(options.payload, options.contentType)\n        : { body: options.body, contentType: options.contentType }\n    const stored: StoredMessage = {\n      queue,\n      id: options.id ?? randomUUID(),\n      type: options.type,\n      key: options.key,\n      headers: { ...(options.headers ?? {}) },\n      body: encoded.body,\n      contentType: encoded.contentType,\n      timestamp: Date.now(),\n      deliveries: options.deliveries ?? 0,\n    }\n    this.#enqueue(stored, 'tail')\n    return stored.id\n  }\n\n  /** Messages published through `publish()` (the `MessageBroker`), optionally for one queue. */\n  published(queue?: string): MemoryMessage[] {\n    return this.#published.filter(message => queue === undefined || message.queue === queue)\n  }\n\n  /** Messages waiting in `queue` (not delivered yet, delayed messages excluded). */\n  pending(queue: string): MemoryMessage[] {\n    return (this.#queues.get(queue)?.ready ?? []).map(snapshot)\n  }\n\n  /** Settlements performed by consumers, in order, optionally for one consumed queue. */\n  settlements(queue?: string): MemorySettlement[] {\n    return this.#settlements.filter(settlement => queue === undefined || settlement.queue === queue)\n  }\n\n  /** Dead-lettered (or discarded) messages, optionally for one consumed queue. */\n  deadLetters(queue?: string): MemoryDeadLetter[] {\n    return this.#deadLetters.filter(entry => queue === undefined || entry.originalQueue === queue)\n  }\n\n  /** Deliveries currently handed to consumers and not finished. */\n  get inFlight(): number {\n    return this.#inflight\n  }\n\n  /** Whether nothing is in flight, scheduled or deliverable. */\n  isIdle(): boolean {\n    if (this.#inflight > 0 || this.#timers.size > 0) return false\n    for (const state of this.#queues.values()) {\n      if (state.scheduled) return false\n      if (state.ready.length > 0 && state.subscribers.some(s => s.active && s.inflight < s.concurrency)) return false\n    }\n    return true\n  }\n\n  /**\n   * Resolves once nothing is in flight, scheduled (delayed messages, retries) or deliverable to an\n   * active subscriber. Rejects after `timeoutMs` (default 5 s).\n   */\n  idle(timeoutMs: number = DEFAULT_IDLE_TIMEOUT_MS): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const timer = setTimeout(() => {\n        this.#idleWaiters.delete(done)\n        reject(\n          new Error(`[znight] MemoryDriver.idle(): still busy after ${timeoutMs} ms (${this.#inflight} in flight)`),\n        )\n      }, timeoutMs)\n      const done = (): void => {\n        clearTimeout(timer)\n        resolve()\n      }\n      this.#idleWaiters.add(done)\n      this.#checkIdle()\n    })\n  }\n\n  /** Polls `predicate` until it returns `true`; rejects after `timeoutMs` (default 5 s). */\n  async waitFor(predicate: () => boolean, timeoutMs: number = DEFAULT_IDLE_TIMEOUT_MS): Promise<void> {\n    const deadline = Date.now() + timeoutMs\n    while (!predicate()) {\n      if (Date.now() > deadline)\n        throw new Error(`[znight] MemoryDriver.waitFor(): condition not met after ${timeoutMs} ms`)\n      await new Promise(resolve => setTimeout(resolve, 1))\n    }\n  }\n\n  /**\n   * Makes an operation fail (for tests): `publish` (also dead-letter publications, by destination\n   * queue), `ack`, `retry`, `dead-letter`, `release` (by consumed queue), `subscribe`, `connect`.\n   * Returns a function removing the failure.\n   */\n  fail(operation: MemoryOperation, options: MemoryFailureOptions = {}): () => void {\n    const failure: Failure = {\n      operation,\n      queue: options.queue,\n      remaining: options.times ?? Number.POSITIVE_INFINITY,\n      error: options.error ?? new Error(`[memory] injected ${operation} failure`),\n    }\n    this.#failures.push(failure)\n    return () => {\n      const index = this.#failures.indexOf(failure)\n      if (index !== -1) this.#failures.splice(index, 1)\n    }\n  }\n\n  /** Forgets every message, settlement and failure (subscriptions are kept). */\n  reset(): void {\n    for (const timer of this.#timers) clearTimeout(timer)\n    this.#timers.clear()\n    for (const state of this.#queues.values()) state.ready.length = 0\n    this.#published.length = 0\n    this.#settlements.length = 0\n    this.#deadLetters.length = 0\n    this.#failures.length = 0\n    this.#checkIdle()\n  }\n\n  // -----------------------------------------------------------------------------------------------\n  // Internals\n  // -----------------------------------------------------------------------------------------------\n\n  #queue(name: string): QueueState {\n    let state = this.#queues.get(name)\n    if (state === undefined) {\n      state = { ready: [], subscribers: [], next: 0, scheduled: false }\n      this.#queues.set(name, state)\n    }\n    return state\n  }\n\n  #enqueue(message: StoredMessage, position: 'head' | 'tail'): void {\n    const state = this.#queue(message.queue)\n    if (position === 'head') state.ready.unshift(message)\n    else state.ready.push(message)\n    this.#pump(message.queue)\n  }\n\n  /** Runs `fn` after `delayMs` (any duration: a timer waits at most 2^31 - 1 ms, longer delays re-arm). */\n  #schedule(fn: () => void, delayMs: number): void {\n    const wait = Math.min(delayMs, MAX_TIMER_DELAY_MS)\n    const timer = setTimeout(() => {\n      this.#timers.delete(timer)\n      if (delayMs > wait) return this.#schedule(fn, delayMs - wait)\n      fn()\n      this.#checkIdle()\n    }, wait)\n    this.#timers.add(timer)\n  }\n\n  #pump(queue: string): void {\n    const state = this.#queue(queue)\n    if (state.scheduled) return\n    state.scheduled = true\n    queueMicrotask(() => {\n      state.scheduled = false\n      this.#dispatch(state)\n      this.#checkIdle()\n    })\n  }\n\n  #dispatch(state: QueueState): void {\n    while (state.ready.length > 0) {\n      const subscriber = this.#nextSubscriber(state)\n      if (subscriber === undefined) return\n      const message = state.ready.shift() as StoredMessage\n      this.#deliver(subscriber, message)\n    }\n  }\n\n  #nextSubscriber(state: QueueState): Subscriber | undefined {\n    const count = state.subscribers.length\n    for (let offset = 0; offset < count; offset++) {\n      const index = (state.next + offset) % count\n      const subscriber = state.subscribers[index] as Subscriber\n      if (subscriber.active && subscriber.inflight < subscriber.concurrency) {\n        state.next = (index + 1) % count\n        return subscriber\n      }\n    }\n    return undefined\n  }\n\n  #deliver(subscriber: Subscriber, message: StoredMessage): void {\n    message.deliveries++\n    subscriber.inflight++\n    this.#inflight++\n    const attempt = message.deliveries\n    let settled = false\n    /** Validates a settlement before any side effect (already settled, closed driver, injected failure). */\n    const check = (action: MemoryOperation): void => {\n      if (settled) throw new Error(`[memory] message ${message.id} was already settled (${action})`)\n      this.#assertOpen(`${action} message ${message.id}`)\n      this.#maybeFail(action, message.queue)\n    }\n    const record = (settlement: Omit<MemorySettlement, 'queue' | 'id' | 'attempt'>): void => {\n      this.#settlements.push({ queue: message.queue, id: message.id, attempt, ...settlement })\n    }\n    const delivery: DriverDelivery = {\n      id: message.id,\n      body: message.body,\n      contentType: message.contentType,\n      headers: message.headers,\n      type: message.type,\n      key: message.key,\n      attempt,\n      redelivered: attempt > 1,\n      timestamp: message.timestamp,\n      raw: snapshot(message),\n      ack: async (): Promise<void> => {\n        await Promise.resolve()\n        check('ack')\n        settled = true\n        record({ action: 'ack' })\n      },\n      retry: async (request: RetryRequest): Promise<void> => {\n        await Promise.resolve()\n        check('retry')\n        settled = true\n        record({ action: 'retry', delayMs: request.delayMs, error: request.error })\n        if (request.delayMs > 0) this.#schedule(() => this.#enqueue(message, 'tail'), request.delayMs)\n        else this.#enqueue(message, 'tail')\n      },\n      deadLetter: async (request: DeadLetterRequest): Promise<void> => {\n        await Promise.resolve()\n        check('dead-letter')\n        const queue = request.queue\n        if (queue !== undefined) {\n          this.#maybeFail('publish', queue)\n          const copy: StoredMessage = {\n            ...message,\n            queue,\n            headers: deadLetterHeaders(message.headers, request, message.queue),\n            deliveries: 0,\n          }\n          this.#enqueue(copy, 'tail')\n        }\n        settled = true\n        record({ action: queue === undefined ? 'reject' : 'dead-letter', reason: request.reason, error: request.error })\n        this.#deadLetters.push({\n          queue,\n          originalQueue: message.queue,\n          message: snapshot(message),\n          reason: request.reason,\n          error: request.error,\n          attempt: request.attempt,\n        })\n      },\n      release: async (): Promise<void> => {\n        await Promise.resolve()\n        check('release')\n        settled = true\n        record({ action: 'release' })\n        this.#enqueue(message, 'head')\n      },\n    }\n    const finish = (): void => {\n      subscriber.inflight--\n      this.#inflight--\n      if (!settled && !this.#closed) {\n        // the consumer returned without settling: give the message back, like a broker would\n        settled = true\n        record({ action: 'release' })\n        this.#enqueue(message, 'head')\n      }\n      this.#pump(message.queue)\n      this.#checkIdle()\n    }\n    let result: Promise<void>\n    try {\n      result = subscriber.handler(delivery)\n    } catch (error) {\n      result = Promise.reject(error)\n    }\n    Promise.resolve(result).then(finish, finish)\n  }\n\n  #maybeFail(operation: MemoryOperation, queue: string | undefined): void {\n    for (const failure of this.#failures) {\n      if (failure.operation !== operation || failure.remaining <= 0) continue\n      if (failure.queue !== undefined && failure.queue !== queue) continue\n      failure.remaining--\n      throw failure.error\n    }\n  }\n\n  #assertOpen(action: string): void {\n    if (this.#closed) throw brokerUnavailableError(`[memory] Cannot ${action}: the driver is closed`)\n  }\n\n  #checkIdle(): void {\n    if (this.#idleWaiters.size === 0 || this.#idleCheckScheduled) return\n    this.#idleCheckScheduled = true\n    queueMicrotask(() => {\n      this.#idleCheckScheduled = false\n      if (!this.isIdle()) return\n      const waiters = [...this.#idleWaiters]\n      this.#idleWaiters.clear()\n      for (const waiter of waiters) waiter()\n    })\n  }\n}\n\nfunction snapshot(message: StoredMessage): MemoryMessage {\n  let payload: unknown\n  try {\n    payload = jsonCodec.decode(message.body, message.contentType)\n  } catch {\n    payload = undefined\n  }\n  return {\n    queue: message.queue,\n    id: message.id,\n    type: message.type,\n    key: message.key,\n    headers: Object.assign(headerRecord(), message.headers),\n    body: message.body,\n    contentType: message.contentType,\n    timestamp: message.timestamp,\n    deliveries: message.deliveries,\n    payload,\n  }\n}\n"],"mappings":"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"}