@amqp-contract/core 0.23.1 → 0.24.0

package/README.md

@@ -5,7 +5,7 @@
 [![CI](https://github.com/btravers/amqp-contract/actions/workflows/ci.yml/badge.svg)](https://github.com/btravers/amqp-contract/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/@amqp-contract/core.svg?logo=npm)](https://www.npmjs.com/package/@amqp-contract/core)
 [![npm downloads](https://img.shields.io/npm/dm/@amqp-contract/core.svg)](https://www.npmjs.com/package/@amqp-contract/core)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-6.0-blue?logo=typescript)](https://www.typescriptlang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 This package provides centralized functionality for establishing AMQP topology (exchanges, queues, and bindings) from contract definitions, and defines the `Logger` interface used across amqp-contract packages.
@@ -87,11 +87,13 @@ const logger: Logger = {
 // Pass the logger to client or worker
 import { TypedAmqpClient } from "@amqp-contract/client";
 
-const client = await TypedAmqpClient.create({
-  contract,
-  urls: ["amqp://localhost"],
-  logger, // Optional: logs published messages
-});
+const client = (
+  await TypedAmqpClient.create({
+    contract,
+    urls: ["amqp://localhost"],
+    logger, // Optional: logs published messages
+  })
+)._unsafeUnwrap();
 ```
 
 ## API

package/dist/index.cjs

@@ -21,7 +21,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let _swan_io_boxed = require("@swan-io/boxed");
+let neverthrow = require("neverthrow");
 let amqp_connection_manager = require("amqp-connection-manager");
 amqp_connection_manager = __toESM(amqp_connection_manager, 1);
 let _amqp_contract_contract = require("@amqp-contract/contract");
@@ -321,7 +321,7 @@ function callSetupFunc(setup, channel) {
 * Default time `waitForConnect` will wait for the broker before erroring out.
 * Defaulting to a finite value (rather than waiting forever) means a fail-fast
 * developer experience: a misconfigured URL, a down broker, or wrong
-* credentials surface as a Result.Error within 30 seconds. Pass `null`
+* credentials surface as an `err` within 30 seconds. Pass `null`
 * explicitly to disable the timeout — `Infinity` and other non-finite values
 * are also coerced to "no timeout" because Node's `setTimeout` clamps large
 * delays to ~24.8 days and silently fires near-immediately on `Infinity`.
@@ -348,7 +348,7 @@ function resolveConnectTimeoutMs(input) {
 * - Automatic AMQP topology setup (exchanges, queues, bindings) from contract
 * - Channel creation with JSON serialization enabled by default
 *
-* All operations return `Future<Result<T, TechnicalError>>` for consistent error handling.
+* All operations return `ResultAsync<T, TechnicalError>` for consistent error handling.
 *
 * @example
 * ```typescript
@@ -357,14 +357,14 @@ function resolveConnectTimeoutMs(input) {
 *   connectionOptions: { heartbeatIntervalInSeconds: 30 }
 * });
 *
-* // Wait for connection
-* await client.waitForConnect().resultToPromise();
+* // Wait for connection (ResultAsync is thenable)
+* await client.waitForConnect();
 *
 * // Publish a message
-* const result = await client.publish('exchange', 'routingKey', { data: 'value' }).resultToPromise();
+* const result = await client.publish('exchange', 'routingKey', { data: 'value' });
 *
 * // Close when done
-* await client.close().resultToPromise();
+* await client.close();
 * ```
 */
 var AmqpClient = class {
@@ -422,7 +422,7 @@ var AmqpClient = class {
 	* Wait for the channel to be connected and ready.
 	*
 	* If `connectTimeoutMs` was provided in the constructor options, the returned
-	* Future resolves to `Result.Error<TechnicalError>` once the timeout elapses.
+	* ResultAsync resolves to `err(TechnicalError)` once the timeout elapses.
 	* Without a timeout, this waits forever — amqp-connection-manager retries
 	* connections indefinitely and never errors on its own.
 	*
@@ -431,9 +431,6 @@ var AmqpClient = class {
 	* 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() {
 		const connectPromise = this.channelWrapper.waitForConnect();
@@ -450,50 +447,37 @@ var AmqpClient = class {
 				reject(error);
 			});
 		});
-		return _swan_io_boxed.Future.fromPromise(racedPromise).mapError((error) => new TechnicalError("Failed to connect to AMQP broker", error));
+		return neverthrow.ResultAsync.fromPromise(racedPromise, (error) => new TechnicalError("Failed to connect to AMQP broker", error));
 	}
 	/**
 	* Publish a message to an exchange.
 	*
-	* @param exchange - The exchange name
-	* @param routingKey - The routing key
-	* @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
+	* @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
 	*/
 	publish(exchange, routingKey, content, options) {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.publish(exchange, routingKey, content, options)).mapError((error) => new TechnicalError("Failed to publish message", error));
+		return neverthrow.ResultAsync.fromPromise(this.channelWrapper.publish(exchange, routingKey, content, options), (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
+	* @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
 	*/
 	sendToQueue(queue, content, options) {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.sendToQueue(queue, content, options)).mapError((error) => new TechnicalError("Failed to publish message to queue", error));
+		return neverthrow.ResultAsync.fromPromise(this.channelWrapper.sendToQueue(queue, content, options), (error) => new TechnicalError("Failed to publish message to queue", error));
 	}
 	/**
 	* Start consuming messages from a queue.
 	*
-	* @param queue - The queue name
-	* @param callback - The callback to invoke for each message
-	* @param options - Optional consume options
-	* @returns A Future with `Result<string>` - the consumer tag
+	* @returns ResultAsync resolving to the consumer tag.
 	*/
 	consume(queue, callback, options) {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.consume(queue, callback, options)).mapError((error) => new TechnicalError("Failed to start consuming messages", error)).mapOk((reply) => reply.consumerTag);
+		return neverthrow.ResultAsync.fromPromise(this.channelWrapper.consume(queue, callback, options), (error) => new TechnicalError("Failed to start consuming messages", error)).map((reply) => reply.consumerTag);
 	}
 	/**
 	* Cancel a consumer by its consumer tag.
-	*
-	* @param consumerTag - The consumer tag to cancel
-	* @returns A Future that resolves when the consumer is cancelled
 	*/
 	cancel(consumerTag) {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.cancel(consumerTag)).mapError((error) => new TechnicalError("Failed to cancel consumer", error)).mapOk(() => void 0);
+		return neverthrow.ResultAsync.fromPromise(this.channelWrapper.cancel(consumerTag), (error) => new TechnicalError("Failed to cancel consumer", error)).map(() => void 0);
 	}
 	/**
 	* Acknowledge a message.
@@ -546,13 +530,18 @@ var AmqpClient = class {
 	* - Decrease the reference count on the shared connection
 	* - Close the connection if this was the last client using it
 	*
-	* @returns A Future that resolves when the channel and connection are closed
+	* Both steps run regardless of each other's outcome; if both fail, the
+	* errors are wrapped in an AggregateError.
 	*/
 	close() {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.close()).mapError((error) => new TechnicalError("Failed to close channel", error)).flatMap((channelResult) => _swan_io_boxed.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 _swan_io_boxed.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;
-		}));
+		return new neverthrow.ResultAsync((async () => {
+			const channelResult = await neverthrow.ResultAsync.fromPromise(this.channelWrapper.close(), (error) => new TechnicalError("Failed to close channel", error));
+			const releaseResult = await neverthrow.ResultAsync.fromPromise(ConnectionManagerSingleton.getInstance().releaseConnection(this.urls, this.connectionOptions), (error) => new TechnicalError("Failed to release connection", error));
+			if (channelResult.isErr() && releaseResult.isErr()) return (0, neverthrow.err)(new TechnicalError("Failed to close channel and release connection", new AggregateError([channelResult.error, releaseResult.error], "Failed to close channel and release connection")));
+			if (channelResult.isErr()) return channelResult;
+			if (releaseResult.isErr()) return releaseResult;
+			return (0, neverthrow.ok)(void 0);
+		})());
 	}
 	/**
 	* Reset connection singleton cache (for testing only)

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { ContractDefinition } from "@amqp-contract/contract";
-import { Future, Result } from "@swan-io/boxed";
 import { AmqpConnectionManager, AmqpConnectionManagerOptions, ConnectionUrl, CreateChannelOpts } from "amqp-connection-manager";
 import { Channel, ConsumeMessage, Options } from "amqplib";
+import { ResultAsync } from "neverthrow";
 import { Attributes, Counter, Histogram, Span, Tracer } from "@opentelemetry/api";
 
 //#region src/errors.d.ts
@@ -35,7 +35,7 @@ declare class MessageValidationError extends Error {
  * Default time `waitForConnect` will wait for the broker before erroring out.
  * Defaulting to a finite value (rather than waiting forever) means a fail-fast
  * developer experience: a misconfigured URL, a down broker, or wrong
- * credentials surface as a Result.Error within 30 seconds. Pass `null`
+ * credentials surface as an `err` within 30 seconds. Pass `null`
  * explicitly to disable the timeout — `Infinity` and other non-finite values
  * are also coerced to "no timeout" because Node's `setTimeout` clamps large
  * delays to ~24.8 days and silently fires near-immediately on `Infinity`.
@@ -83,7 +83,7 @@ type ConsumerOptions = Options.Consume & {
  * - Automatic AMQP topology setup (exchanges, queues, bindings) from contract
  * - Channel creation with JSON serialization enabled by default
  *
- * All operations return `Future<Result<T, TechnicalError>>` for consistent error handling.
+ * All operations return `ResultAsync<T, TechnicalError>` for consistent error handling.
  *
  * @example
  * ```typescript
@@ -92,14 +92,14 @@ type ConsumerOptions = Options.Consume & {
  *   connectionOptions: { heartbeatIntervalInSeconds: 30 }
  * });
  *
- * // Wait for connection
- * await client.waitForConnect().resultToPromise();
+ * // Wait for connection (ResultAsync is thenable)
+ * await client.waitForConnect();
  *
  * // Publish a message
- * const result = await client.publish('exchange', 'routingKey', { data: 'value' }).resultToPromise();
+ * const result = await client.publish('exchange', 'routingKey', { data: 'value' });
  *
  * // Close when done
- * await client.close().resultToPromise();
+ * await client.close();
  * ```
  */
 declare class AmqpClient {
@@ -136,7 +136,7 @@ declare class AmqpClient {
    * Wait for the channel to be connected and ready.
    *
    * If `connectTimeoutMs` was provided in the constructor options, the returned
-   * Future resolves to `Result.Error<TechnicalError>` once the timeout elapses.
+   * ResultAsync resolves to `err(TechnicalError)` once the timeout elapses.
    * Without a timeout, this waits forever — amqp-connection-manager retries
    * connections indefinitely and never errors on its own.
    *
@@ -145,46 +145,30 @@ declare class AmqpClient {
    * 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>>;
+  waitForConnect(): ResultAsync<void, TechnicalError>;
   /**
    * Publish a message to an exchange.
    *
-   * @param exchange - The exchange name
-   * @param routingKey - The routing key
-   * @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
+   * @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
    */
-  publish(exchange: string, routingKey: string, content: Buffer | unknown, options?: PublishOptions): Future<Result<boolean, TechnicalError>>;
+  publish(exchange: string, routingKey: string, content: Buffer | unknown, options?: PublishOptions): ResultAsync<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
+   * @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
    */
-  sendToQueue(queue: string, content: Buffer | unknown, options?: PublishOptions): Future<Result<boolean, TechnicalError>>;
+  sendToQueue(queue: string, content: Buffer | unknown, options?: PublishOptions): ResultAsync<boolean, TechnicalError>;
   /**
    * Start consuming messages from a queue.
    *
-   * @param queue - The queue name
-   * @param callback - The callback to invoke for each message
-   * @param options - Optional consume options
-   * @returns A Future with `Result<string>` - the consumer tag
+   * @returns ResultAsync resolving to the consumer tag.
    */
-  consume(queue: string, callback: ConsumeCallback, options?: ConsumerOptions): Future<Result<string, TechnicalError>>;
+  consume(queue: string, callback: ConsumeCallback, options?: ConsumerOptions): ResultAsync<string, TechnicalError>;
   /**
    * Cancel a consumer by its consumer tag.
-   *
-   * @param consumerTag - The consumer tag to cancel
-   * @returns A Future that resolves when the consumer is cancelled
    */
-  cancel(consumerTag: string): Future<Result<void, TechnicalError>>;
+  cancel(consumerTag: string): ResultAsync<void, TechnicalError>;
   /**
    * Acknowledge a message.
    *
@@ -228,9 +212,10 @@ declare class AmqpClient {
    * - Decrease the reference count on the shared connection
    * - Close the connection if this was the last client using it
    *
-   * @returns A Future that resolves when the channel and connection are closed
+   * Both steps run regardless of each other's outcome; if both fail, the
+   * errors are wrapped in an AggregateError.
    */
-  close(): Future<Result<void, TechnicalError>>;
+  close(): ResultAsync<void, TechnicalError>;
   /**
    * Reset connection singleton cache (for testing only)
    * @internal

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","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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"}
+{"version":3,"file":"index.d.cts","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.d.mts

@@ -1,4 +1,4 @@
-import { Future, Result } from "@swan-io/boxed";
+import { ResultAsync } from "neverthrow";
 import { AmqpConnectionManager, AmqpConnectionManagerOptions, ConnectionUrl, CreateChannelOpts } from "amqp-connection-manager";
 import { ContractDefinition } from "@amqp-contract/contract";
 import { Attributes, Counter, Histogram, Span, Tracer } from "@opentelemetry/api";
@@ -35,7 +35,7 @@ declare class MessageValidationError extends Error {
  * Default time `waitForConnect` will wait for the broker before erroring out.
  * Defaulting to a finite value (rather than waiting forever) means a fail-fast
  * developer experience: a misconfigured URL, a down broker, or wrong
- * credentials surface as a Result.Error within 30 seconds. Pass `null`
+ * credentials surface as an `err` within 30 seconds. Pass `null`
  * explicitly to disable the timeout — `Infinity` and other non-finite values
  * are also coerced to "no timeout" because Node's `setTimeout` clamps large
  * delays to ~24.8 days and silently fires near-immediately on `Infinity`.
@@ -83,7 +83,7 @@ type ConsumerOptions = Options.Consume & {
  * - Automatic AMQP topology setup (exchanges, queues, bindings) from contract
  * - Channel creation with JSON serialization enabled by default
  *
- * All operations return `Future<Result<T, TechnicalError>>` for consistent error handling.
+ * All operations return `ResultAsync<T, TechnicalError>` for consistent error handling.
  *
  * @example
  * ```typescript
@@ -92,14 +92,14 @@ type ConsumerOptions = Options.Consume & {
  *   connectionOptions: { heartbeatIntervalInSeconds: 30 }
  * });
  *
- * // Wait for connection
- * await client.waitForConnect().resultToPromise();
+ * // Wait for connection (ResultAsync is thenable)
+ * await client.waitForConnect();
  *
  * // Publish a message
- * const result = await client.publish('exchange', 'routingKey', { data: 'value' }).resultToPromise();
+ * const result = await client.publish('exchange', 'routingKey', { data: 'value' });
  *
  * // Close when done
- * await client.close().resultToPromise();
+ * await client.close();
  * ```
  */
 declare class AmqpClient {
@@ -136,7 +136,7 @@ declare class AmqpClient {
    * Wait for the channel to be connected and ready.
    *
    * If `connectTimeoutMs` was provided in the constructor options, the returned
-   * Future resolves to `Result.Error<TechnicalError>` once the timeout elapses.
+   * ResultAsync resolves to `err(TechnicalError)` once the timeout elapses.
    * Without a timeout, this waits forever — amqp-connection-manager retries
    * connections indefinitely and never errors on its own.
    *
@@ -145,46 +145,30 @@ declare class AmqpClient {
    * 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>>;
+  waitForConnect(): ResultAsync<void, TechnicalError>;
   /**
    * Publish a message to an exchange.
    *
-   * @param exchange - The exchange name
-   * @param routingKey - The routing key
-   * @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
+   * @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
    */
-  publish(exchange: string, routingKey: string, content: Buffer | unknown, options?: PublishOptions): Future<Result<boolean, TechnicalError>>;
+  publish(exchange: string, routingKey: string, content: Buffer | unknown, options?: PublishOptions): ResultAsync<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
+   * @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
    */
-  sendToQueue(queue: string, content: Buffer | unknown, options?: PublishOptions): Future<Result<boolean, TechnicalError>>;
+  sendToQueue(queue: string, content: Buffer | unknown, options?: PublishOptions): ResultAsync<boolean, TechnicalError>;
   /**
    * Start consuming messages from a queue.
    *
-   * @param queue - The queue name
-   * @param callback - The callback to invoke for each message
-   * @param options - Optional consume options
-   * @returns A Future with `Result<string>` - the consumer tag
+   * @returns ResultAsync resolving to the consumer tag.
    */
-  consume(queue: string, callback: ConsumeCallback, options?: ConsumerOptions): Future<Result<string, TechnicalError>>;
+  consume(queue: string, callback: ConsumeCallback, options?: ConsumerOptions): ResultAsync<string, TechnicalError>;
   /**
    * Cancel a consumer by its consumer tag.
-   *
-   * @param consumerTag - The consumer tag to cancel
-   * @returns A Future that resolves when the consumer is cancelled
    */
-  cancel(consumerTag: string): Future<Result<void, TechnicalError>>;
+  cancel(consumerTag: string): ResultAsync<void, TechnicalError>;
   /**
    * Acknowledge a message.
    *
@@ -228,9 +212,10 @@ declare class AmqpClient {
    * - Decrease the reference count on the shared connection
    * - Close the connection if this was the last client using it
    *
-   * @returns A Future that resolves when the channel and connection are closed
+   * Both steps run regardless of each other's outcome; if both fail, the
+   * errors are wrapped in an AggregateError.
    */
-  close(): Future<Result<void, TechnicalError>>;
+  close(): ResultAsync<void, TechnicalError>;
   /**
    * Reset connection singleton cache (for testing only)
    * @internal

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"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":";;;;;;;;;;;;;cAMa,cAAA,SAAuB,KAAA;EAAA,SAGP,KAAA;cADzB,OAAA,UACyB,KAAA;AAAA;;;;;;;;;AAuB7B;cAAa,sBAAA,SAA+B,KAAA;EAAA,SAExB,MAAA;EAAA,SACA,MAAA;cADA,MAAA,UACA,MAAA;AAAA;;;;;AA7BpB;;;;;;;cCwCa,0BAAA;;;;ADdb;;;;;;;;KCwCY,iBAAA;EACV,IAAA,EAAM,aAAA;EACN,iBAAA,GAAoB,4BAAA;EACpB,cAAA,GAAiB,OAAA,CAAQ,iBAAA;EACzB,gBAAA;AAAA;;AA9BF;;KAoCY,eAAA,IAAmB,GAAA,EAAK,cAAA,mBAAiC,OAAA;;;AAVrE;KAeY,cAAA,GAAiB,OAAA,CAAQ,OAAA;kDAEnC,OAAA;AAAA;;;;KAMU,eAAA,GAAkB,OAAA,CAAQ,OAAA;EAtBpC,qCAwBA,QAAA;AAAA;;;;;;;;AAfF;;;;;;;;;AAKA;;;;;;;;;AAQA;;;cAiCa,UAAA;EAAA,iBAoBQ,QAAA;EAAA,iBAnBF,UAAA;EAAA,iBACA,cAAA;EAAA,iBACA,IAAA;EAAA,iBACA,iBAAA;EAJN;EAAA,iBAMM,gBAAA;;;;;;;;;;;;cAcE,QAAA,EAAU,kBAAA,EAC3B,OAAA,EAAS,iBAAA;EAoIA;;;;;;;;;EA/EX,aAAA,CAAA,GAAiB,qBAAA;EA+GgC;;;;;;;;;;;;;;;;;EA1FjD,cAAA,CAAA,GAAkB,MAAA,CAAO,MAAA,OAAa,cAAA;EAzFrB;;;;;;;;;EA8HjB,OAAA,CACE,QAAA,UACA,UAAA,UACA,OAAA,EAAS,MAAA,YACT,OAAA,GAAU,cAAA,GACT,MAAA,CAAO,MAAA,UAAgB,cAAA;EA1CD;;;;;;;;EAwDzB,WAAA,CACE,KAAA,UACA,OAAA,EAAS,MAAA,YACT,OAAA,GAAU,cAAA,GACT,MAAA,CAAO,MAAA,UAAgB,cAAA;EAlBvB;;;;;;;;EAgCH,OAAA,CACE,KAAA,UACA,QAAA,EAAU,eAAA,EACV,OAAA,GAAU,eAAA,GACT,MAAA,CAAO,MAAA,SAAe,cAAA;EAlBtB;;;;;;EA8BH,MAAA,CAAO,WAAA,WAAsB,MAAA,CAAO,MAAA,OAAa,cAAA;EAbrC;;;;;;EAyBZ,GAAA,CAAI,GAAA,EAAK,cAAA,EAAgB,OAAA;EAZI;;;;;;;EAuB7B,IAAA,CAAK,GAAA,EAAK,cAAA,EAAgB,OAAA,YAAiB,OAAA;EAAjC;;;;;;;EAWV,QAAA,CAAS,KAAA,GAAQ,OAAA,EAAS,OAAA,YAAmB,OAAA;EAApC;;;;;;;;;;;EAeT,EAAA,CAAG,KAAA,UAAe,QAAA,MAAc,IAAA;EA+CuB;;;;AC1NzD;;;;;AASA;EDgLE,KAAA,CAAA,GAAS,MAAA,CAAO,MAAA,OAAa,cAAA;;;;;SAiChB,+BAAA,CAAA,GAAmC,OAAA;AAAA;;;;;;;;;;;iBC1NlC,6BAAA,CAAA;;;;;;iBASA,2BAAA,CAAA,GAA+B,OAAA;;;;;;;;;;AFlM/C;KGEY,aAAA,GAAgB,MAAA;EAC1B,KAAA;AAAA;;;;;;;;AHuBF;;;;;;;;;;KGHY,MAAA;EHMuB;;;;ACWnC;EEXE,KAAA,CAAM,OAAA,UAAiB,OAAA,GAAU,aAAA;;;;AFqCnC;;EE9BE,IAAA,CAAK,OAAA,UAAiB,OAAA,GAAU,aAAA;EF+B1B;;;;;EExBN,IAAA,CAAK,OAAA,UAAiB,OAAA,GAAU,aAAA;EFwBhC;;;;;EEjBA,KAAA,CAAM,OAAA,UAAiB,OAAA,GAAU,aAAA;AAAA;;;;;;;;AHlDnC;;;;;;;;;;;AA0BA;;;;iBIPsB,iBAAA,CACpB,OAAA,EAAS,OAAA,EACT,QAAA,EAAU,kBAAA,GACT,OAAA;;;;;;;cCHU,4BAAA;EAAA;;;;;;;;;;;;;;;;;;;KA4BD,iBAAA;ELnBQ;;;;EKwBlB,SAAA,QAAiB,MAAA;;;AJZnB;;EIkBE,iBAAA,QAAyB,OAAA;EJlBY;;AA0BvC;;EIFE,iBAAA,QAAyB,OAAA;EJGnB;;;;EIGN,0BAAA,QAAkC,SAAA;EJDV;;;;EIOxB,0BAAA,QAAkC,SAAA;EJPlC;;;;;EIcA,sBAAA,QAA8B,OAAA;AAAA;;;;cA2InB,wBAAA,EAA0B,iBAAA;;;;;iBAavB,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;;;;iBA2Ba,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;AJzNF;;;AAAA,iBI+OgB,mBAAA,CACd,QAAA,EAAU,iBAAA,EACV,SAAA,UACA,YAAA,UACA,OAAA,WACA,UAAA;;;;;;;;;iBAyBc,kBAAA,CACd,QAAA,EAAU,iBAAA,EACV,MAAA;;;;;;iBAkBc,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,5 +1,5 @@
 import { createRequire } from "node:module";
-import { Future, Result } from "@swan-io/boxed";
+import { ResultAsync, err, ok } from "neverthrow";
 import amqp from "amqp-connection-manager";
 import { extractQueue } from "@amqp-contract/contract";
 //#region \0rolldown/runtime.js
@@ -300,7 +300,7 @@ function callSetupFunc(setup, channel) {
 * Default time `waitForConnect` will wait for the broker before erroring out.
 * Defaulting to a finite value (rather than waiting forever) means a fail-fast
 * developer experience: a misconfigured URL, a down broker, or wrong
-* credentials surface as a Result.Error within 30 seconds. Pass `null`
+* credentials surface as an `err` within 30 seconds. Pass `null`
 * explicitly to disable the timeout — `Infinity` and other non-finite values
 * are also coerced to "no timeout" because Node's `setTimeout` clamps large
 * delays to ~24.8 days and silently fires near-immediately on `Infinity`.
@@ -327,7 +327,7 @@ function resolveConnectTimeoutMs(input) {
 * - Automatic AMQP topology setup (exchanges, queues, bindings) from contract
 * - Channel creation with JSON serialization enabled by default
 *
-* All operations return `Future<Result<T, TechnicalError>>` for consistent error handling.
+* All operations return `ResultAsync<T, TechnicalError>` for consistent error handling.
 *
 * @example
 * ```typescript
@@ -336,14 +336,14 @@ function resolveConnectTimeoutMs(input) {
 *   connectionOptions: { heartbeatIntervalInSeconds: 30 }
 * });
 *
-* // Wait for connection
-* await client.waitForConnect().resultToPromise();
+* // Wait for connection (ResultAsync is thenable)
+* await client.waitForConnect();
 *
 * // Publish a message
-* const result = await client.publish('exchange', 'routingKey', { data: 'value' }).resultToPromise();
+* const result = await client.publish('exchange', 'routingKey', { data: 'value' });
 *
 * // Close when done
-* await client.close().resultToPromise();
+* await client.close();
 * ```
 */
 var AmqpClient = class {
@@ -401,7 +401,7 @@ var AmqpClient = class {
 	* Wait for the channel to be connected and ready.
 	*
 	* If `connectTimeoutMs` was provided in the constructor options, the returned
-	* Future resolves to `Result.Error<TechnicalError>` once the timeout elapses.
+	* ResultAsync resolves to `err(TechnicalError)` once the timeout elapses.
 	* Without a timeout, this waits forever — amqp-connection-manager retries
 	* connections indefinitely and never errors on its own.
 	*
@@ -410,9 +410,6 @@ var AmqpClient = class {
 	* 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() {
 		const connectPromise = this.channelWrapper.waitForConnect();
@@ -429,50 +426,37 @@ var AmqpClient = class {
 				reject(error);
 			});
 		});
-		return Future.fromPromise(racedPromise).mapError((error) => new TechnicalError("Failed to connect to AMQP broker", error));
+		return ResultAsync.fromPromise(racedPromise, (error) => new TechnicalError("Failed to connect to AMQP broker", error));
 	}
 	/**
 	* Publish a message to an exchange.
 	*
-	* @param exchange - The exchange name
-	* @param routingKey - The routing key
-	* @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
+	* @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
 	*/
 	publish(exchange, routingKey, content, options) {
-		return Future.fromPromise(this.channelWrapper.publish(exchange, routingKey, content, options)).mapError((error) => new TechnicalError("Failed to publish message", error));
+		return ResultAsync.fromPromise(this.channelWrapper.publish(exchange, routingKey, content, options), (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
+	* @returns ResultAsync resolving to `true` if the message was sent, `false` if the 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));
+		return ResultAsync.fromPromise(this.channelWrapper.sendToQueue(queue, content, options), (error) => new TechnicalError("Failed to publish message to queue", error));
 	}
 	/**
 	* Start consuming messages from a queue.
 	*
-	* @param queue - The queue name
-	* @param callback - The callback to invoke for each message
-	* @param options - Optional consume options
-	* @returns A Future with `Result<string>` - the consumer tag
+	* @returns ResultAsync resolving to the consumer tag.
 	*/
 	consume(queue, callback, options) {
-		return Future.fromPromise(this.channelWrapper.consume(queue, callback, options)).mapError((error) => new TechnicalError("Failed to start consuming messages", error)).mapOk((reply) => reply.consumerTag);
+		return ResultAsync.fromPromise(this.channelWrapper.consume(queue, callback, options), (error) => new TechnicalError("Failed to start consuming messages", error)).map((reply) => reply.consumerTag);
 	}
 	/**
 	* Cancel a consumer by its consumer tag.
-	*
-	* @param consumerTag - The consumer tag to cancel
-	* @returns A Future that resolves when the consumer is cancelled
 	*/
 	cancel(consumerTag) {
-		return Future.fromPromise(this.channelWrapper.cancel(consumerTag)).mapError((error) => new TechnicalError("Failed to cancel consumer", error)).mapOk(() => void 0);
+		return ResultAsync.fromPromise(this.channelWrapper.cancel(consumerTag), (error) => new TechnicalError("Failed to cancel consumer", error)).map(() => void 0);
 	}
 	/**
 	* Acknowledge a message.
@@ -525,13 +509,18 @@ var AmqpClient = class {
 	* - Decrease the reference count on the shared connection
 	* - Close the connection if this was the last client using it
 	*
-	* @returns A Future that resolves when the channel and connection are closed
+	* Both steps run regardless of each other's outcome; if both fail, the
+	* errors are wrapped in an AggregateError.
 	*/
 	close() {
-		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;
-		}));
+		return new ResultAsync((async () => {
+			const channelResult = await ResultAsync.fromPromise(this.channelWrapper.close(), (error) => new TechnicalError("Failed to close channel", error));
+			const releaseResult = await ResultAsync.fromPromise(ConnectionManagerSingleton.getInstance().releaseConnection(this.urls, this.connectionOptions), (error) => new TechnicalError("Failed to release connection", error));
+			if (channelResult.isErr() && releaseResult.isErr()) return err(new TechnicalError("Failed to close channel and release connection", new AggregateError([channelResult.error, releaseResult.error], "Failed to close channel and release connection")));
+			if (channelResult.isErr()) return channelResult;
+			if (releaseResult.isErr()) return releaseResult;
+			return ok(void 0);
+		})());
 	}
 	/**
 	* Reset connection singleton cache (for testing only)