@amqp-contract/core 0.20.0 → 0.22.0

package/dist/index.d.mts

@@ -4,62 +4,6 @@ import { ContractDefinition } from "@amqp-contract/contract";
 import { Attributes, Counter, Histogram, Span, Tracer } from "@opentelemetry/api";
 import { Channel, ConsumeMessage, Options } from "amqplib";
 
-//#region src/logger.d.ts
-/**
- * Context object for logger methods.
- *
- * This type includes reserved keys that provide consistent naming
- * for common logging context properties.
- *
- * @property error - Error object or error details
- */
-type LoggerContext = Record<string, unknown> & {
-  error?: unknown;
-};
-/**
- * Logger interface for amqp-contract packages.
- *
- * Provides a simple logging abstraction that can be implemented by users
- * to integrate with their preferred logging framework.
- *
- * @example
- * ```typescript
- * // Simple console logger implementation
- * const logger: Logger = {
- *   debug: (message, context) => console.debug(message, context),
- *   info: (message, context) => console.info(message, context),
- *   warn: (message, context) => console.warn(message, context),
- *   error: (message, context) => console.error(message, context),
- * };
- * ```
- */
-type Logger = {
-  /**
-   * Log debug level messages
-   * @param message - The log message
-   * @param context - Optional context to include with the log
-   */
-  debug(message: string, context?: LoggerContext): void;
-  /**
-   * Log info level messages
-   * @param message - The log message
-   * @param context - Optional context to include with the log
-   */
-  info(message: string, context?: LoggerContext): void;
-  /**
-   * Log warning level messages
-   * @param message - The log message
-   * @param context - Optional context to include with the log
-   */
-  warn(message: string, context?: LoggerContext): void;
-  /**
-   * Log error level messages
-   * @param message - The log message
-   * @param context - Optional context to include with the log
-   */
-  error(message: string, context?: LoggerContext): void;
-};
-//#endregion
 //#region src/errors.d.ts
 /**
  * Error for technical/runtime failures that cannot be prevented by TypeScript.
@@ -93,16 +37,31 @@ declare class MessageValidationError extends Error {
  * @property urls - AMQP broker URL(s). Multiple URLs provide failover support.
  * @property connectionOptions - Optional connection configuration (heartbeat, reconnect settings, etc.).
  * @property channelOptions - Optional channel configuration options.
+ * @property connectTimeoutMs - Maximum time in ms to wait for the channel to become ready
+ *   in `waitForConnect`. If unset, waits forever (amqp-connection-manager retries indefinitely).
  */
 type AmqpClientOptions = {
   urls: ConnectionUrl[];
   connectionOptions?: AmqpConnectionManagerOptions | undefined;
   channelOptions?: Partial<CreateChannelOpts> | undefined;
+  connectTimeoutMs?: number | undefined;
 };
 /**
  * Callback type for consuming messages.
  */
 type ConsumeCallback = (msg: ConsumeMessage | null) => void | Promise<void>;
+/**
+ * Publish options that extend amqplib's Options.Publish with optional timeout support.
+ */
+type PublishOptions = Options.Publish & {
+  /** Message will be rejected after timeout ms */timeout?: number;
+};
+/**
+ * Consume options that extend amqplib's Options.Consume with optional prefetch support.
+ */
+type ConsumerOptions = Options.Consume & {
+  /** Number of messages to prefetch */prefetch?: number;
+};
 /**
  * AMQP client that manages connections and channels with automatic topology setup.
  *
@@ -137,6 +96,7 @@ declare class AmqpClient {
   private readonly channelWrapper;
   private readonly urls;
   private readonly connectionOptions?;
+  private readonly connectTimeoutMs?;
   /**
    * Create a new AMQP client instance.
    *
@@ -162,7 +122,19 @@ declare class AmqpClient {
   /**
    * Wait for the channel to be connected and ready.
    *
-   * @returns A Future that resolves when the channel is connected
+   * If `connectTimeoutMs` was provided in the constructor options, the returned
+   * Future resolves to `Result.Error<TechnicalError>` once the timeout elapses.
+   * Without a timeout, this waits forever — amqp-connection-manager retries
+   * connections indefinitely and never errors on its own.
+   *
+   * NOTE: When using `AmqpClient` directly (not via `TypedAmqpClient` /
+   * `TypedAmqpWorker`), the constructor has already incremented the pooled
+   * connection's reference count. Callers must invoke `close()` on the error
+   * path to release the connection — `waitForConnect` does not do this
+   * automatically. The typed factories handle this cleanup for you.
+   *
+   * @returns A Future resolving to `Result.Ok(void)` on connect, or
+   *   `Result.Error(TechnicalError)` on timeout / connection failure.
    */
   waitForConnect(): Future<Result<void, TechnicalError>>;
   /**
@@ -174,7 +146,16 @@ declare class AmqpClient {
    * @param options - Optional publish options
    * @returns A Future with `Result<boolean>` - true if message was sent, false if channel buffer is full
    */
-  publish(exchange: string, routingKey: string, content: Buffer | unknown, options?: Options.Publish): Future<Result<boolean, TechnicalError>>;
+  publish(exchange: string, routingKey: string, content: Buffer | unknown, options?: PublishOptions): Future<Result<boolean, TechnicalError>>;
+  /**
+   * Publish a message directly to a queue.
+   *
+   * @param queue - The queue name
+   * @param content - The message content (will be JSON serialized if json: true)
+   * @param options - Optional publish options
+   * @returns A Future with `Result<boolean>` - true if message was sent, false if channel buffer is full
+   */
+  sendToQueue(queue: string, content: Buffer | unknown, options?: PublishOptions): Future<Result<boolean, TechnicalError>>;
   /**
    * Start consuming messages from a queue.
    *
@@ -183,7 +164,7 @@ declare class AmqpClient {
    * @param options - Optional consume options
    * @returns A Future with `Result<string>` - the consumer tag
    */
-  consume(queue: string, callback: ConsumeCallback, options?: Options.Consume): Future<Result<string, TechnicalError>>;
+  consume(queue: string, callback: ConsumeCallback, options?: ConsumerOptions): Future<Result<string, TechnicalError>>;
   /**
    * Cancel a consumer by its consumer tag.
    *
@@ -319,6 +300,12 @@ declare class ConnectionManagerSingleton {
    * @returns The value with all object keys sorted alphabetically
    */
   private deepSort;
+  /**
+   * Get the number of active pooled connections.
+   *
+   * @internal
+   */
+  _getConnectionCountForTesting(): number;
   /**
    * Reset all cached connections (for testing purposes)
    * @internal
@@ -326,6 +313,62 @@ declare class ConnectionManagerSingleton {
   _resetForTesting(): Promise<void>;
 }
 //#endregion
+//#region src/logger.d.ts
+/**
+ * Context object for logger methods.
+ *
+ * This type includes reserved keys that provide consistent naming
+ * for common logging context properties.
+ *
+ * @property error - Error object or error details
+ */
+type LoggerContext = Record<string, unknown> & {
+  error?: unknown;
+};
+/**
+ * Logger interface for amqp-contract packages.
+ *
+ * Provides a simple logging abstraction that can be implemented by users
+ * to integrate with their preferred logging framework.
+ *
+ * @example
+ * ```typescript
+ * // Simple console logger implementation
+ * const logger: Logger = {
+ *   debug: (message, context) => console.debug(message, context),
+ *   info: (message, context) => console.info(message, context),
+ *   warn: (message, context) => console.warn(message, context),
+ *   error: (message, context) => console.error(message, context),
+ * };
+ * ```
+ */
+type Logger = {
+  /**
+   * Log debug level messages
+   * @param message - The log message
+   * @param context - Optional context to include with the log
+   */
+  debug(message: string, context?: LoggerContext): void;
+  /**
+   * Log info level messages
+   * @param message - The log message
+   * @param context - Optional context to include with the log
+   */
+  info(message: string, context?: LoggerContext): void;
+  /**
+   * Log warning level messages
+   * @param message - The log message
+   * @param context - Optional context to include with the log
+   */
+  warn(message: string, context?: LoggerContext): void;
+  /**
+   * Log error level messages
+   * @param message - The log message
+   * @param context - Optional context to include with the log
+   */
+  error(message: string, context?: LoggerContext): void;
+};
+//#endregion
 //#region src/setup.d.ts
 /**
  * Setup AMQP topology (exchanges, queues, and bindings) from a contract definition.
@@ -438,5 +481,5 @@ declare function recordConsumeMetric(provider: TelemetryProvider, queueName: str
  */
 declare function _resetTelemetryCacheForTesting(): void;
 //#endregion
-export { AmqpClient, type AmqpClientOptions, ConnectionManagerSingleton, type ConsumeCallback, type Logger, type LoggerContext, MessageValidationError, MessagingSemanticConventions, TechnicalError, type TelemetryProvider, _resetTelemetryCacheForTesting, defaultTelemetryProvider, endSpanError, endSpanSuccess, recordConsumeMetric, recordPublishMetric, setupAmqpTopology, startConsumeSpan, startPublishSpan };
+export { AmqpClient, type AmqpClientOptions, ConnectionManagerSingleton, type ConsumeCallback, type ConsumerOptions, type Logger, type LoggerContext, MessageValidationError, MessagingSemanticConventions, type PublishOptions, TechnicalError, type TelemetryProvider, _resetTelemetryCacheForTesting, defaultTelemetryProvider, endSpanError, endSpanSuccess, recordConsumeMetric, recordPublishMetric, setupAmqpTopology, startConsumeSpan, startPublishSpan };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/logger.ts","../src/errors.ts","../src/amqp-client.ts","../src/connection-manager.ts","../src/setup.ts","../src/telemetry.ts"],"mappings":";;;;;;;;;;;;;;AAQA;KAAY,aAAA,GAAgB,MAAA;EAC1B,KAAA;AAAA;;AAoBF;;;;;;;;;;;;;;;;KAAY,MAAA;EAoBV;;;;;EAdA,KAAA,CAAM,OAAA,UAAiB,OAAA,GAAU,aAAA;EAqBA;;;;;EAdjC,IAAA,CAAK,OAAA,UAAiB,OAAA,GAAU,aAAA;;ACpClC;;;;ED2CE,IAAA,CAAK,OAAA,UAAiB,OAAA,GAAU,aAAA;ECxCL;;;;;ED+C3B,KAAA,CAAM,OAAA,UAAiB,OAAA,GAAU,aAAA;AAAA;;;;;;;;;cClDtB,cAAA,SAAuB,KAAA;EAAA,SAGP,KAAA;cADzB,OAAA,UACyB,KAAA;AAAA;;;ADoB7B;;;;;;;cCGa,sBAAA,SAA+B,KAAA;EAAA,SAExB,MAAA;EAAA,SACA,MAAA;cADA,MAAA,UACA,MAAA;AAAA;;;;;AD3BpB;;;;;KEoCY,iBAAA;EACV,IAAA,EAAM,aAAA;EACN,iBAAA,GAAoB,4BAAA;EACpB,cAAA,GAAiB,OAAA,CAAQ,iBAAA;AAAA;;;;KAMf,eAAA,IAAmB,GAAA,EAAK,cAAA,mBAAiC,OAAA;;;;;;;;;;;;;;;;;;;;;;AD/CrE;;;;;;;cC6Ea,UAAA;EAAA,iBAkBQ,QAAA;EAAA,iBAjBF,UAAA;EAAA,iBACA,cAAA;EAAA,iBACA,IAAA;EAAA,iBACA,iBAAA;;;;;;;;;;;;cAcE,QAAA,EAAU,kBAAA,EAC3B,OAAA,EAAS,iBAAA;;AA1Db;;;;;;;;EAuGE,aAAA,CAAA,GAAiB,qBAAA;EAtGjB;;;;;EA+GA,cAAA,CAAA,GAAkB,MAAA,CAAO,MAAA,OAAa,cAAA;EA7Gb;;;AAM3B;;;;;;EAsHE,OAAA,CACE,QAAA,UACA,UAAA,UACA,OAAA,EAAS,MAAA,YACT,OAAA,GAAU,OAAA,CAAQ,OAAA,GACjB,MAAA,CAAO,MAAA,UAAgB,cAAA;EA3HgD;;AA8B5E;;;;;;EA2GE,OAAA,CACE,KAAA,UACA,QAAA,EAAU,eAAA,EACV,OAAA,GAAU,OAAA,CAAQ,OAAA,GACjB,MAAA,CAAO,MAAA,SAAe,cAAA;EAtCA;;;;;;EAkDzB,MAAA,CAAO,WAAA,WAAsB,MAAA,CAAO,MAAA,OAAa,cAAA;EAdrC;;;;;;EA0BZ,GAAA,CAAI,GAAA,EAAK,cAAA,EAAgB,OAAA;EAZI;;;;;;;EAuB7B,IAAA,CAAK,GAAA,EAAK,cAAA,EAAgB,OAAA,YAAiB,OAAA;EA0DK;;;;;;;EA/ChD,QAAA,CAAS,KAAA,GAAQ,OAAA,EAAS,OAAA,YAAmB,OAAA;;;;;;;;;;;;EAe7C,EAAA,CAAG,KAAA,UAAe,QAAA,MAAc,IAAA;EAnF9B;;;;;;;;;;EAiGF,KAAA,CAAA,GAAS,MAAA,CAAO,MAAA,OAAa,cAAA;EA9E3B;;;;EAAA,OAgGW,+BAAA,CAAA,GAAmC,OAAA;AAAA;;;;;;;;;AFvRlD;;;;;AAqBA;;;;;cGPa,0BAAA;EAAA,eACI,QAAA;EAAA,QACP,WAAA;EAAA,QACA,SAAA;EAAA,QAED,WAAA,CAAA;EHQD;;;;;EAAA,OGDC,WAAA,CAAA,GAAe,0BAAA;EHQA;;;;;;;;;;EGStB,aAAA,CACE,IAAA,EAAM,aAAA,IACN,iBAAA,GAAoB,4BAAA,GACnB,qBAAA;;;;AFhDL;;;;;;;EE0EQ,iBAAA,CACJ,IAAA,EAAM,aAAA,IACN,iBAAA,GAAoB,4BAAA,GACnB,OAAA;EF1EwB;;;AAuB7B;;;;;;;EAvB6B,QEsGnB,mBAAA;EF7EU;;;;;;EAAA,QE+FV,gBAAA;EDrFE;;;;;;EAAA,QCiGF,QAAA;ED9FgB;;;;ECsHlB,gBAAA,CAAA,GAAoB,OAAA;AAAA;;;;;;;;AH7J5B;;;;;AAqBA;;;;;;;;;;iBIJsB,iBAAA,CACpB,OAAA,EAAS,OAAA,EACT,QAAA,EAAU,kBAAA,GACT,OAAA;;;;;;;cCJU,4BAAA;EAAA;;;;;;;;;;;;;;;;;;;KA4BD,iBAAA;ELVL;;;;EKeL,SAAA,QAAiB,MAAA;ELRe;;;;EKchC,iBAAA,QAAyB,OAAA;ELPF;;;;EKavB,iBAAA,QAAyB,OAAA;;AJ/D3B;;;EIqEE,0BAAA,QAAkC,SAAA;EJrEA;;;;EI2ElC,0BAAA,QAAkC,SAAA;AAAA;;AJjDpC;;cIiKa,wBAAA,EAA0B,iBAAA;;;;;iBAYvB,gBAAA,CACd,QAAA,EAAU,iBAAA,EACV,YAAA,UACA,UAAA,sBACA,UAAA,GAAa,UAAA,GACZ,IAAA;;;;;iBA8Ba,gBAAA,CACd,QAAA,EAAU,iBAAA,EACV,SAAA,UACA,YAAA,UACA,UAAA,GAAa,UAAA,GACZ,IAAA;;;AHzMH;iBGoOgB,cAAA,CAAe,IAAA,EAAM,IAAA;;;;iBAerB,YAAA,CAAa,IAAA,EAAM,IAAA,cAAkB,KAAA,EAAO,KAAA;;;;iBAiB5C,mBAAA,CACd,QAAA,EAAU,iBAAA,EACV,YAAA,UACA,UAAA,sBACA,OAAA,WACA,UAAA;;;;iBAsBc,mBAAA,CACd,QAAA,EAAU,iBAAA,EACV,SAAA,UACA,YAAA,UACA,OAAA,WACA,UAAA;;;;;AH3RF;iBGiTgB,8BAAA,CAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts","../src/amqp-client.ts","../src/connection-manager.ts","../src/logger.ts","../src/setup.ts","../src/telemetry.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -1,11 +1,9 @@
 import { createRequire } from "node:module";
-import { Future } from "@swan-io/boxed";
+import { Future, Result } from "@swan-io/boxed";
 import amqp from "amqp-connection-manager";
 import { extractQueue } from "@amqp-contract/contract";
-
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
 //#endregion
 //#region src/connection-manager.ts
 /**
@@ -121,6 +119,14 @@ var ConnectionManagerSingleton = class ConnectionManagerSingleton {
 		return value;
 	}
 	/**
+	* Get the number of active pooled connections.
+	*
+	* @internal
+	*/
+	_getConnectionCountForTesting() {
+		return this.connections.size;
+	}
+	/**
 	* Reset all cached connections (for testing purposes)
 	* @internal
 	*/
@@ -131,7 +137,6 @@ var ConnectionManagerSingleton = class ConnectionManagerSingleton {
 		this.refCounts.clear();
 	}
 };
-
 //#endregion
 //#region src/errors.ts
 /**
@@ -168,7 +173,6 @@ var MessageValidationError = class extends Error {
 		if (typeof ErrorConstructor.captureStackTrace === "function") ErrorConstructor.captureStackTrace(this, this.constructor);
 	}
 };
-
 //#endregion
 //#region src/setup.ts
 /**
@@ -192,13 +196,20 @@ var MessageValidationError = class extends Error {
 * ```
 */
 async function setupAmqpTopology(channel, contract) {
-	const exchangeErrors = (await Promise.allSettled(Object.values(contract.exchanges ?? {}).map((exchange) => channel.assertExchange(exchange.name, exchange.type, {
+	const exchanges = Object.values(contract.exchanges ?? {}).filter((e) => e.name !== "");
+	const exchangeErrors = (await Promise.allSettled(exchanges.map((exchange) => channel.assertExchange(exchange.name, exchange.type, {
 		durable: exchange.durable,
 		autoDelete: exchange.autoDelete,
 		internal: exchange.internal,
 		arguments: exchange.arguments
-	})))).filter((result) => result.status === "rejected");
-	if (exchangeErrors.length > 0) throw new AggregateError(exchangeErrors.map(({ reason }) => reason), "Failed to setup exchanges");
+	})))).map((result, i) => ({
+		result,
+		name: exchanges[i].name
+	})).filter((entry) => entry.result.status === "rejected");
+	if (exchangeErrors.length > 0) {
+		const names = exchangeErrors.map((e) => e.name).join(", ");
+		throw new AggregateError(exchangeErrors.map(({ result }) => result.reason), `Failed to setup exchanges: ${names}`);
+	}
 	for (const queueEntry of Object.values(contract.queues ?? {})) {
 		const queue = extractQueue(queueEntry);
 		if (queue.deadLetter) {
@@ -206,7 +217,8 @@ async function setupAmqpTopology(channel, contract) {
 			if (!Object.values(contract.exchanges ?? {}).some((exchange) => exchange.name === dlxName)) throw new TechnicalError(`Queue "${queue.name}" references dead letter exchange "${dlxName}" which is not declared in the contract. Add the exchange to contract.exchanges to ensure it is created before the queue.`);
 		}
 	}
-	const queueErrors = (await Promise.allSettled(Object.values(contract.queues ?? {}).map((queueEntry) => {
+	const queueEntries = Object.values(contract.queues ?? {});
+	const queueErrors = (await Promise.allSettled(queueEntries.map((queueEntry) => {
 		const queue = extractQueue(queueEntry);
 		const queueArguments = { ...queue.arguments };
 		queueArguments["x-queue-type"] = queue.type;
@@ -214,29 +226,41 @@ async function setupAmqpTopology(channel, contract) {
 			queueArguments["x-dead-letter-exchange"] = queue.deadLetter.exchange.name;
 			if (queue.deadLetter.routingKey) queueArguments["x-dead-letter-routing-key"] = queue.deadLetter.routingKey;
 		}
-		if (queue.type === "quorum") {
-			if (queue.deliveryLimit !== void 0) queueArguments["x-delivery-limit"] = queue.deliveryLimit;
-			return channel.assertQueue(queue.name, {
-				durable: true,
-				autoDelete: queue.autoDelete,
-				arguments: queueArguments
-			});
-		}
+		if (queue.type === "quorum") return channel.assertQueue(queue.name, {
+			durable: true,
+			arguments: queueArguments
+		});
+		if (queue.maxPriority !== void 0) queueArguments["x-max-priority"] = queue.maxPriority;
 		return channel.assertQueue(queue.name, {
 			durable: queue.durable,
 			exclusive: queue.exclusive,
 			autoDelete: queue.autoDelete,
 			arguments: queueArguments
 		});
-	}))).filter((result) => result.status === "rejected");
-	if (queueErrors.length > 0) throw new AggregateError(queueErrors.map(({ reason }) => reason), "Failed to setup queues");
-	const bindingErrors = (await Promise.allSettled(Object.values(contract.bindings ?? {}).map((binding) => {
+	}))).map((result, i) => ({
+		result,
+		name: extractQueue(queueEntries[i]).name
+	})).filter((entry) => entry.result.status === "rejected");
+	if (queueErrors.length > 0) {
+		const names = queueErrors.map((e) => e.name).join(", ");
+		throw new AggregateError(queueErrors.map(({ result }) => result.reason), `Failed to setup queues: ${names}`);
+	}
+	const bindings = Object.values(contract.bindings ?? {});
+	const bindingErrors = (await Promise.allSettled(bindings.map((binding) => {
 		if (binding.type === "queue") return channel.bindQueue(binding.queue.name, binding.exchange.name, binding.routingKey ?? "", binding.arguments);
 		return channel.bindExchange(binding.destination.name, binding.source.name, binding.routingKey ?? "", binding.arguments);
-	}))).filter((result) => result.status === "rejected");
-	if (bindingErrors.length > 0) throw new AggregateError(bindingErrors.map(({ reason }) => reason), "Failed to setup bindings");
+	}))).map((result, i) => {
+		const binding = bindings[i];
+		return {
+			result,
+			name: binding.type === "queue" ? `${binding.exchange.name} -> ${binding.queue.name}` : `${binding.source.name} -> ${binding.destination.name}`
+		};
+	}).filter((entry) => entry.result.status === "rejected");
+	if (bindingErrors.length > 0) {
+		const names = bindingErrors.map((e) => e.name).join(", ");
+		throw new AggregateError(bindingErrors.map(({ result }) => result.reason), `Failed to setup bindings: ${names}`);
+	}
 }
-
 //#endregion
 //#region src/amqp-client.ts
 /**
@@ -286,6 +310,7 @@ var AmqpClient = class {
 	channelWrapper;
 	urls;
 	connectionOptions;
+	connectTimeoutMs;
 	/**
 	* Create a new AMQP client instance.
 	*
@@ -301,10 +326,13 @@ var AmqpClient = class {
 		this.contract = contract;
 		this.urls = options.urls;
 		if (options.connectionOptions !== void 0) this.connectionOptions = options.connectionOptions;
-		this.connection = ConnectionManagerSingleton.getInstance().getConnection(options.urls, options.connectionOptions);
+		if (options.connectTimeoutMs !== void 0) this.connectTimeoutMs = options.connectTimeoutMs;
+		const singleton = ConnectionManagerSingleton.getInstance();
+		this.connection = singleton.getConnection(options.urls, options.connectionOptions);
 		const defaultSetup = (channel) => setupAmqpTopology(channel, this.contract);
 		const { setup: userSetup, ...otherChannelOptions } = options.channelOptions ?? {};
 		const channelOpts = {
+			confirm: true,
 			json: true,
 			setup: defaultSetup,
 			...otherChannelOptions
@@ -330,10 +358,36 @@ var AmqpClient = class {
 	/**
 	* Wait for the channel to be connected and ready.
 	*
-	* @returns A Future that resolves when the channel is connected
+	* If `connectTimeoutMs` was provided in the constructor options, the returned
+	* Future resolves to `Result.Error<TechnicalError>` once the timeout elapses.
+	* Without a timeout, this waits forever — amqp-connection-manager retries
+	* connections indefinitely and never errors on its own.
+	*
+	* NOTE: When using `AmqpClient` directly (not via `TypedAmqpClient` /
+	* `TypedAmqpWorker`), the constructor has already incremented the pooled
+	* connection's reference count. Callers must invoke `close()` on the error
+	* path to release the connection — `waitForConnect` does not do this
+	* automatically. The typed factories handle this cleanup for you.
+	*
+	* @returns A Future resolving to `Result.Ok(void)` on connect, or
+	*   `Result.Error(TechnicalError)` on timeout / connection failure.
 	*/
 	waitForConnect() {
-		return Future.fromPromise(this.channelWrapper.waitForConnect()).mapError((error) => new TechnicalError("Failed to connect to AMQP broker", error));
+		const connectPromise = this.channelWrapper.waitForConnect();
+		const racedPromise = this.connectTimeoutMs === void 0 ? connectPromise : new Promise((resolve, reject) => {
+			const timeoutMs = this.connectTimeoutMs;
+			const handle = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`Timed out waiting for AMQP connection after ${timeoutMs}ms`));
+			}, timeoutMs);
+			connectPromise.then(() => {
+				clearTimeout(handle);
+				resolve();
+			}, (error) => {
+				clearTimeout(handle);
+				reject(error);
+			});
+		});
+		return Future.fromPromise(racedPromise).mapError((error) => new TechnicalError("Failed to connect to AMQP broker", error));
 	}
 	/**
 	* Publish a message to an exchange.
@@ -348,6 +402,17 @@ var AmqpClient = class {
 		return Future.fromPromise(this.channelWrapper.publish(exchange, routingKey, content, options)).mapError((error) => new TechnicalError("Failed to publish message", error));
 	}
 	/**
+	* Publish a message directly to a queue.
+	*
+	* @param queue - The queue name
+	* @param content - The message content (will be JSON serialized if json: true)
+	* @param options - Optional publish options
+	* @returns A Future with `Result<boolean>` - true if message was sent, false if channel buffer is full
+	*/
+	sendToQueue(queue, content, options) {
+		return Future.fromPromise(this.channelWrapper.sendToQueue(queue, content, options)).mapError((error) => new TechnicalError("Failed to publish message to queue", error));
+	}
+	/**
 	* Start consuming messages from a queue.
 	*
 	* @param queue - The queue name
@@ -421,7 +486,10 @@ var AmqpClient = class {
 	* @returns A Future that resolves when the channel and connection are closed
 	*/
 	close() {
-		return Future.fromPromise(this.channelWrapper.close()).mapError((error) => new TechnicalError("Failed to close channel", error)).flatMapOk(() => Future.fromPromise(ConnectionManagerSingleton.getInstance().releaseConnection(this.urls, this.connectionOptions)).mapError((error) => new TechnicalError("Failed to release connection", error))).mapOk(() => void 0);
+		return Future.fromPromise(this.channelWrapper.close()).mapError((error) => new TechnicalError("Failed to close channel", error)).flatMap((channelResult) => Future.fromPromise(ConnectionManagerSingleton.getInstance().releaseConnection(this.urls, this.connectionOptions)).mapError((error) => new TechnicalError("Failed to release connection", error)).map((releaseResult) => {
+			if (channelResult.isError() && releaseResult.isError()) return Result.Error(new TechnicalError("Failed to close channel and release connection", new AggregateError([channelResult.error, releaseResult.error], "Failed to close channel and release connection")));
+			return channelResult.isError() ? channelResult : releaseResult;
+		}));
 	}
 	/**
 	* Reset connection singleton cache (for testing only)
@@ -431,7 +499,6 @@ var AmqpClient = class {
 		await ConnectionManagerSingleton.getInstance()._resetForTesting();
 	}
 };
-
 //#endregion
 //#region src/telemetry.ts
 /**
@@ -440,7 +507,9 @@ var AmqpClient = class {
 * @see https://opentelemetry.io/docs/specs/otel/trace/api/#spankind
 */
 const SpanKind = {
+	/** Producer span represents a message producer */
 	PRODUCER: 3,
+	/** Consumer span represents a message consumer */
 	CONSUMER: 4
 };
 /**
@@ -655,7 +724,7 @@ function _resetTelemetryCacheForTesting() {
 	cachedPublishLatencyHistogram = void 0;
 	cachedConsumeLatencyHistogram = void 0;
 }
-
 //#endregion
 export { AmqpClient, ConnectionManagerSingleton, MessageValidationError, MessagingSemanticConventions, TechnicalError, _resetTelemetryCacheForTesting, defaultTelemetryProvider, endSpanError, endSpanSuccess, recordConsumeMetric, recordPublishMetric, setupAmqpTopology, startConsumeSpan, startPublishSpan };
+
 //# sourceMappingURL=index.mjs.map