@amqp-contract/worker 0.23.0 → 0.24.0

package/README.md

@@ -1,11 +1,11 @@
 # @amqp-contract/worker
 
-**Type-safe AMQP worker for consuming messages using amqp-contract with Future/Result error handling.**
+**Type-safe AMQP worker for consuming messages using amqp-contract with ResultAsync/Result error handling.**
 
 [![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/worker.svg?logo=npm)](https://www.npmjs.com/package/@amqp-contract/worker)
 [![npm downloads](https://img.shields.io/npm/dm/@amqp-contract/worker.svg)](https://www.npmjs.com/package/@amqp-contract/worker)
-[![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)
 
 📖 **[Full documentation →](https://btravers.github.io/amqp-contract/api/worker)**
@@ -31,7 +31,7 @@ pnpm add @amqp-contract/worker
 ```typescript
 import { TypedAmqpWorker, RetryableError } from "@amqp-contract/worker";
 import type { Logger } from "@amqp-contract/core";
-import { Future } from "@swan-io/boxed";
+import { ResultAsync } from "neverthrow";
 import { contract } from "./contract";
 
 // Optional: Create a logger implementation
@@ -43,21 +43,24 @@ const logger: Logger = {
 };
 
 // Create worker from contract with handlers (automatically connects and starts consuming)
-const worker = await TypedAmqpWorker.create({
-  contract,
-  handlers: {
-    processOrder: ({ payload }) => {
-      console.log("Processing order:", payload.orderId);
-
-      // Your business logic here
-      return Future.fromPromise(Promise.all([processPayment(payload), updateInventory(payload)]))
-        .mapOk(() => undefined)
-        .mapError((error) => new RetryableError("Order processing failed", error));
+const worker = (
+  await TypedAmqpWorker.create({
+    contract,
+    handlers: {
+      processOrder: ({ payload }) => {
+        console.log("Processing order:", payload.orderId);
+
+        // Your business logic here
+        return ResultAsync.fromPromise(
+          Promise.all([processPayment(payload), updateInventory(payload)]),
+          (error) => new RetryableError("Order processing failed", error),
+        ).map(() => undefined);
+      },
     },
-  },
-  urls: ["amqp://localhost"],
-  logger, // Optional: logs message consumption and errors
-});
+    urls: ["amqp://localhost"],
+    logger, // Optional: logs message consumption and errors
+  })
+)._unsafeUnwrap();
 
 // Worker is already consuming messages
 
@@ -96,19 +99,22 @@ Then use `RetryableError` in your handlers:
 
 ```typescript
 import { TypedAmqpWorker, RetryableError } from "@amqp-contract/worker";
-import { Future } from "@swan-io/boxed";
-
-const worker = await TypedAmqpWorker.create({
-  contract,
-  handlers: {
-    processOrder: ({ payload }) =>
-      // If this fails with RetryableError, message is automatically retried
-      Future.fromPromise(processPayment(payload))
-        .mapOk(() => undefined)
-        .mapError((error) => new RetryableError("Payment failed", error)),
-  },
-  urls: ["amqp://localhost"],
-});
+import { ResultAsync } from "neverthrow";
+
+const worker = (
+  await TypedAmqpWorker.create({
+    contract,
+    handlers: {
+      processOrder: ({ payload }) =>
+        // If this fails with RetryableError, message is automatically retried
+        ResultAsync.fromPromise(
+          processPayment(payload),
+          (error) => new RetryableError("Payment failed", error),
+        ).map(() => undefined),
+    },
+    urls: ["amqp://localhost"],
+  })
+)._unsafeUnwrap();
 ```
 
 See the [Error Handling and Retry](https://btravers.github.io/amqp-contract/guide/worker-usage#error-handling-and-retry) section in the guide for complete details.
@@ -119,23 +125,22 @@ You can define handlers outside of the worker creation using `defineHandler` and
 
 ## Error Handling
 
-Worker handlers return `Future<Result<void, HandlerError>>` for explicit error handling:
+Worker handlers return `ResultAsync<void, HandlerError>` for explicit error handling:
 
 ```typescript
 import { RetryableError, NonRetryableError } from "@amqp-contract/worker";
-import { Future, Result } from "@swan-io/boxed";
+import { errAsync, ResultAsync } from "neverthrow";
 
 handlers: {
   processOrder: ({ payload }) => {
     // Validation errors - non-retryable
     if (payload.amount <= 0) {
-      return Future.value(Result.Error(new NonRetryableError("Invalid amount")));
+      return errAsync(new NonRetryableError("Invalid amount"));
     }
 
     // Transient errors - retryable
-    return Future.fromPromise(process(payload))
-      .mapOk(() => undefined)
-      .mapError((error) => new RetryableError("Processing failed", error));
+    return ResultAsync.fromPromise(process(payload), (error) => new RetryableError("Processing failed", error))
+      .map(() => undefined);
   },
 }
 ```

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _amqp_contract_contract = require("@amqp-contract/contract");
 let _amqp_contract_core = require("@amqp-contract/core");
-let _swan_io_boxed = require("@swan-io/boxed");
+let neverthrow = require("neverthrow");
 let node_zlib = require("node:zlib");
 let node_util = require("node:util");
 //#region src/decompression.ts
@@ -22,17 +22,17 @@ function isSupportedEncoding(encoding) {
 *
 * @param buffer - The buffer to decompress
 * @param contentEncoding - The content-encoding header value (e.g., 'gzip', 'deflate')
-* @returns A Future with the decompressed buffer or a TechnicalError
+* @returns A ResultAsync resolving to the decompressed buffer or a TechnicalError
 *
 * @internal
 */
 function decompressBuffer(buffer, contentEncoding) {
-	if (!contentEncoding) return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(buffer));
+	if (!contentEncoding) return (0, neverthrow.okAsync)(buffer);
 	const normalizedEncoding = contentEncoding.toLowerCase();
-	if (!isSupportedEncoding(normalizedEncoding)) return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new _amqp_contract_core.TechnicalError(`Unsupported content-encoding: "${contentEncoding}". Supported encodings are: ${SUPPORTED_ENCODINGS.join(", ")}. Please check your publisher configuration.`)));
+	if (!isSupportedEncoding(normalizedEncoding)) return (0, neverthrow.errAsync)(new _amqp_contract_core.TechnicalError(`Unsupported content-encoding: "${contentEncoding}". Supported encodings are: ${SUPPORTED_ENCODINGS.join(", ")}. Please check your publisher configuration.`));
 	switch (normalizedEncoding) {
-		case "gzip": return _swan_io_boxed.Future.fromPromise(gunzipAsync(buffer)).mapError((error) => new _amqp_contract_core.TechnicalError("Failed to decompress gzip", error));
-		case "deflate": return _swan_io_boxed.Future.fromPromise(inflateAsync(buffer)).mapError((error) => new _amqp_contract_core.TechnicalError("Failed to decompress deflate", error));
+		case "gzip": return neverthrow.ResultAsync.fromPromise(gunzipAsync(buffer), (error) => new _amqp_contract_core.TechnicalError("Failed to decompress gzip", error));
+		case "deflate": return neverthrow.ResultAsync.fromPromise(inflateAsync(buffer), (error) => new _amqp_contract_core.TechnicalError("Failed to decompress deflate", error));
 	}
 }
 //#endregion
@@ -153,15 +153,16 @@ function isHandlerError(error) {
 * @example
 * ```typescript
 * import { retryable } from '@amqp-contract/worker';
-* import { Future, Result } from '@swan-io/boxed';
+* import { ResultAsync } from 'neverthrow';
 *
 * const handler = ({ payload }) =>
-*   Future.fromPromise(processPayment(payload))
-*     .mapOk(() => undefined)
-*     .mapError((e) => retryable('Payment service unavailable', e));
+*   ResultAsync.fromPromise(
+*     processPayment(payload),
+*     (e) => retryable('Payment service unavailable', e),
+*   ).map(() => undefined);
 *
 * // Equivalent to:
-* // .mapError((e) => new RetryableError('Payment service unavailable', e));
+* // ResultAsync.fromPromise(processPayment(payload), (e) => new RetryableError('...', e))
 * ```
 */
 function retryable(message, cause) {
@@ -180,17 +181,17 @@ function retryable(message, cause) {
 * @example
 * ```typescript
 * import { nonRetryable } from '@amqp-contract/worker';
-* import { Future, Result } from '@swan-io/boxed';
+* import { errAsync, okAsync } from 'neverthrow';
 *
 * const handler = ({ payload }) => {
 *   if (!isValidPayload(payload)) {
-*     return Future.value(Result.Error(nonRetryable('Invalid payload format')));
+*     return errAsync(nonRetryable('Invalid payload format'));
 *   }
-*   return Future.value(Result.Ok(undefined));
+*   return okAsync(undefined);
 * };
 *
 * // Equivalent to:
-* // return Future.value(Result.Error(new NonRetryableError('Invalid payload format')));
+* // return errAsync(new NonRetryableError('Invalid payload format'));
 * ```
 */
 function nonRetryable(message, cause) {
@@ -224,7 +225,7 @@ function handleError(ctx, error, msg, consumerName, consumer) {
 			error: error.message
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(void 0));
+		return (0, neverthrow.okAsync)(void 0);
 	}
 	const config = (0, _amqp_contract_contract.extractQueue)(consumer.queue).retry;
 	if (config.mode === "immediate-requeue") return handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, config);
@@ -234,7 +235,7 @@ function handleError(ctx, error, msg, consumerName, consumer) {
 		error: error.message
 	});
 	sendToDLQ(ctx, msg, consumer);
-	return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(void 0));
+	return (0, neverthrow.okAsync)(void 0);
 }
 /**
 * Handle error by requeuing immediately.
@@ -258,7 +259,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 			error: error.message
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(void 0));
+		return (0, neverthrow.okAsync)(void 0);
 	}
 	ctx.logger?.warn("Retrying message (immediate-requeue mode)", {
 		consumerName,
@@ -269,7 +270,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 	});
 	if (queue.type === "quorum") {
 		ctx.amqpClient.nack(msg, false, true);
-		return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(void 0));
+		return (0, neverthrow.okAsync)(void 0);
 	} else return publishForRetry(ctx, {
 		msg,
 		exchange: msg.fields.exchange,
@@ -310,7 +311,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			consumerName,
 			queueName: consumer.queue.name
 		});
-		return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new _amqp_contract_core.TechnicalError("Queue does not have TTL-backoff infrastructure")));
+		return (0, neverthrow.errAsync)(new _amqp_contract_core.TechnicalError("Queue does not have TTL-backoff infrastructure"));
 	}
 	const queueEntry = consumer.queue;
 	const queueName = (0, _amqp_contract_contract.extractQueue)(queueEntry).name;
@@ -324,7 +325,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			error: error.message
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(void 0));
+		return (0, neverthrow.okAsync)(void 0);
 	}
 	const delayMs = calculateRetryDelay(retryCount, config);
 	ctx.logger?.warn("Retrying message (ttl-backoff mode)", {
@@ -371,10 +372,10 @@ function parseMessageContentForRetry(ctx, msg, queueName) {
 	if (!(contentType === void 0 || contentType === "application/json" || contentType.startsWith("application/json;") || contentType.endsWith("+json"))) return msg.content;
 	try {
 		return JSON.parse(msg.content.toString());
-	} catch (err) {
+	} catch (parseErr) {
 		ctx.logger?.warn("Failed to parse JSON message for retry, using original buffer", {
 			queueName,
-			error: err
+			error: parseErr
 		});
 		return msg.content;
 	}
@@ -399,21 +400,21 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 				"x-retry-queue": queueName
 			} : {}
 		}
-	}).mapOkToResult((published) => {
+	}).andThen((published) => {
 		if (!published) {
 			ctx.logger?.error("Failed to publish message for retry (write buffer full)", {
 				queueName,
 				retryCount: newRetryCount,
 				...delayMs !== void 0 ? { delayMs } : {}
 			});
-			return _swan_io_boxed.Result.Error(new _amqp_contract_core.TechnicalError("Failed to publish message for retry (write buffer full)"));
+			return (0, neverthrow.err)(new _amqp_contract_core.TechnicalError("Failed to publish message for retry (write buffer full)"));
 		}
 		ctx.logger?.info("Message published for retry", {
 			queueName,
 			retryCount: newRetryCount,
 			...delayMs !== void 0 ? { delayMs } : {}
 		});
-		return _swan_io_boxed.Result.Ok(void 0);
+		return (0, neverthrow.ok)(void 0);
 	});
 }
 /**
@@ -450,6 +451,7 @@ function isHandlerTuple(entry) {
 * ```typescript
 * import { TypedAmqpWorker } from '@amqp-contract/worker';
 * import { defineQueue, defineMessage, defineContract, defineConsumer } from '@amqp-contract/contract';
+* import { okAsync } from 'neverthrow';
 * import { z } from 'zod';
 *
 * const orderQueue = defineQueue('order-processing');
@@ -464,19 +466,22 @@ function isHandlerTuple(entry) {
 *   }
 * });
 *
-* const worker = await TypedAmqpWorker.create({
+* const result = await TypedAmqpWorker.create({
 *   contract,
 *   handlers: {
-*     processOrder: async (message) => {
-*       console.log('Processing order', message.orderId);
-*       // Process the order...
-*     }
+*     processOrder: ({ payload }) => {
+*       console.log('Processing order', payload.orderId);
+*       return okAsync(undefined);
+*     },
 *   },
-*   urls: ['amqp://localhost']
-* }).resultToPromise();
+*   urls: ['amqp://localhost'],
+* });
+*
+* if (result.isErr()) throw result.error;
+* const worker = result.value;
 *
 * // Close when done
-* await worker.close().resultToPromise();
+* await worker.close();
 * ```
 */
 var TypedAmqpWorker = class TypedAmqpWorker {
@@ -552,18 +557,17 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* Connections are automatically shared across clients and workers with the same
 	* URLs and connection options, following RabbitMQ best practices.
 	*
-	* @param options - Configuration options for the worker
-	* @returns A Future that resolves to a Result containing the worker or an error
+	* @returns A ResultAsync that resolves to the worker or a TechnicalError.
 	*
 	* @example
 	* ```typescript
-	* const worker = await TypedAmqpWorker.create({
+	* const result = await TypedAmqpWorker.create({
 	*   contract: myContract,
 	*   handlers: {
-	*     processOrder: async ({ payload }) => console.log('Order:', payload.orderId)
+	*     processOrder: ({ payload }) => okAsync(undefined),
 	*   },
-	*   urls: ['amqp://localhost']
-	* }).resultToPromise();
+	*   urls: ['amqp://localhost'],
+	* });
 	* ```
 	*/
 	static create({ contract, handlers, urls, connectionOptions, defaultConsumerOptions, logger, telemetry, connectTimeoutMs }) {
@@ -572,12 +576,14 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 			connectionOptions,
 			connectTimeoutMs
 		}), handlers, defaultConsumerOptions ?? {}, logger, telemetry);
-		return worker.waitForConnectionReady().flatMapOk(() => worker.consumeAll()).flatMap((result) => result.match({
-			Ok: () => _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(worker)),
-			Error: (error) => worker.close().tapError((closeError) => {
-				logger?.warn("Failed to close worker after setup failure", { error: closeError });
-			}).map(() => _swan_io_boxed.Result.Error(error))
-		}));
+		const setup = worker.waitForConnectionReady().andThen(() => worker.consumeAll());
+		return new neverthrow.ResultAsync((async () => {
+			const setupResult = await setup;
+			if (setupResult.isOk()) return (0, neverthrow.ok)(worker);
+			const closeResult = await worker.close();
+			if (closeResult.isErr()) logger?.warn("Failed to close worker after setup failure", { error: closeResult.error });
+			return (0, neverthrow.err)(setupResult.error);
+		})());
 	}
 	/**
 	* Close the AMQP channel and connection.
@@ -585,26 +591,25 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* This gracefully closes the connection to the AMQP broker,
 	* stopping all message consumption and cleaning up resources.
 	*
-	* @returns A Future that resolves to a Result indicating success or failure
-	*
 	* @example
 	* ```typescript
-	* const closeResult = await worker.close().resultToPromise();
+	* const closeResult = await worker.close();
 	* if (closeResult.isOk()) {
 	*   console.log('Worker closed successfully');
 	* }
 	* ```
 	*/
 	close() {
-		return _swan_io_boxed.Future.all(Array.from(this.consumerTags).map((consumerTag) => this.amqpClient.cancel(consumerTag).mapErrorToResult((error) => {
+		const cancellations = Array.from(this.consumerTags).map((consumerTag) => this.amqpClient.cancel(consumerTag).orElse((error) => {
 			this.logger?.warn("Failed to cancel consumer during close", {
 				consumerTag,
 				error
 			});
-			return _swan_io_boxed.Result.Ok(void 0);
-		}))).map(_swan_io_boxed.Result.all).tapOk(() => {
+			return (0, neverthrow.ok)(void 0);
+		}));
+		return neverthrow.ResultAsync.combine(cancellations).andTee(() => {
 			this.consumerTags.clear();
-		}).flatMapOk(() => this.amqpClient.close()).mapOk(() => void 0);
+		}).andThen(() => this.amqpClient.close()).map(() => void 0);
 	}
 	/**
 	* Start consuming for every entry in `contract.consumers` and `contract.rpcs`.
@@ -613,7 +618,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		const consumerNames = Object.keys(this.contract.consumers ?? {});
 		const rpcNames = Object.keys(this.contract.rpcs ?? {});
 		const allNames = [...consumerNames, ...rpcNames];
-		return _swan_io_boxed.Future.all(allNames.map((name) => this.consume(name))).map(_swan_io_boxed.Result.all).mapOk(() => void 0);
+		return neverthrow.ResultAsync.combine(allNames.map((name) => this.consume(name))).map(() => void 0);
 	}
 	waitForConnectionReady() {
 		return this.amqpClient.waitForConnect();
@@ -634,9 +639,9 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	validateSchema(schema, data, context) {
 		const rawValidation = schema["~standard"].validate(data);
 		const validationPromise = rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);
-		return _swan_io_boxed.Future.fromPromise(validationPromise).mapError((error) => new _amqp_contract_core.TechnicalError(`Error validating ${context.field}`, error)).mapOkToResult((result) => {
-			if (result.issues) return _swan_io_boxed.Result.Error(new _amqp_contract_core.TechnicalError(`${context.field} validation failed`, new _amqp_contract_core.MessageValidationError(context.consumerName, result.issues)));
-			return _swan_io_boxed.Result.Ok(result.value);
+		return neverthrow.ResultAsync.fromPromise(validationPromise, (error) => new _amqp_contract_core.TechnicalError(`Error validating ${context.field}`, error)).andThen((result) => {
+			if (result.issues) return (0, neverthrow.err)(new _amqp_contract_core.TechnicalError(`${context.field} validation failed`, new _amqp_contract_core.MessageValidationError(context.consumerName, result.issues)));
+			return (0, neverthrow.ok)(result.value);
 		});
 	}
 	/**
@@ -648,18 +653,18 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	*/
 	parseAndValidateMessage(msg, consumer, consumerName) {
 		const context = { consumerName: String(consumerName) };
-		const parsePayload = decompressBuffer(msg.content, msg.properties.contentEncoding).mapErrorToResult((error) => _swan_io_boxed.Result.Error(new _amqp_contract_core.TechnicalError("Failed to decompress message", error))).mapOkToResult((buffer) => _swan_io_boxed.Result.fromExecution(() => JSON.parse(buffer.toString())).mapError((error) => new _amqp_contract_core.TechnicalError("Failed to parse JSON", error))).flatMapOk((parsed) => this.validateSchema(consumer.message.payload, parsed, {
+		const parsePayload = decompressBuffer(msg.content, msg.properties.contentEncoding).andThen((buffer) => neverthrow.Result.fromThrowable(() => JSON.parse(buffer.toString()), (error) => new _amqp_contract_core.TechnicalError("Failed to parse JSON", error))()).andThen((parsed) => this.validateSchema(consumer.message.payload, parsed, {
 			...context,
 			field: "payload"
 		}));
 		const parseHeaders = consumer.message.headers ? this.validateSchema(consumer.message.headers, msg.properties.headers ?? {}, {
 			...context,
 			field: "headers"
-		}) : _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(void 0));
-		return _swan_io_boxed.Future.allFromDict({
-			payload: parsePayload,
-			headers: parseHeaders
-		}).map(_swan_io_boxed.Result.allFromDict);
+		}) : (0, neverthrow.okAsync)(void 0);
+		return neverthrow.ResultAsync.combine([parsePayload, parseHeaders]).map(([payload, headers]) => ({
+			payload,
+			headers
+		}));
 	}
 	/**
 	* Validate an RPC handler's response and publish it back to the caller's reply
@@ -688,7 +693,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				rpcName: String(rpcName),
 				queueName
 			});
-			return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`)));
+			return (0, neverthrow.errAsync)(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`));
 		}
 		if (typeof correlationId !== "string" || correlationId.length === 0) {
 			this.logger?.error("RPC handler returned a response but the incoming message has no correlationId", {
@@ -696,22 +701,22 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				queueName,
 				replyTo
 			});
-			return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`)));
+			return (0, neverthrow.errAsync)(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`));
 		}
 		let rawValidation;
 		try {
 			rawValidation = responseSchema["~standard"].validate(response);
 		} catch (error) {
-			return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new NonRetryableError("RPC response schema validation threw", error)));
+			return (0, neverthrow.errAsync)(new NonRetryableError("RPC response schema validation threw", error));
 		}
 		const validationPromise = rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);
-		return _swan_io_boxed.Future.fromPromise(validationPromise).mapError((error) => new NonRetryableError("RPC response schema validation threw", error)).mapOkToResult((validation) => {
-			if (validation.issues) return _swan_io_boxed.Result.Error(new NonRetryableError(`RPC response for "${String(rpcName)}" failed schema validation`, new _amqp_contract_core.MessageValidationError(String(rpcName), validation.issues)));
-			return _swan_io_boxed.Result.Ok(validation.value);
-		}).flatMapOk((validatedResponse) => this.amqpClient.publish("", replyTo, validatedResponse, {
+		return neverthrow.ResultAsync.fromPromise(validationPromise, (error) => new NonRetryableError("RPC response schema validation threw", error)).andThen((validation) => {
+			if (validation.issues) return (0, neverthrow.err)(new NonRetryableError(`RPC response for "${String(rpcName)}" failed schema validation`, new _amqp_contract_core.MessageValidationError(String(rpcName), validation.issues)));
+			return (0, neverthrow.ok)(validation.value);
+		}).andThen((validatedResponse) => this.amqpClient.publish("", replyTo, validatedResponse, {
 			correlationId,
 			contentType: "application/json"
-		}).mapErrorToResult((error) => _swan_io_boxed.Result.Error(new NonRetryableError("Failed to publish RPC response", error))).mapOkToResult((published) => published ? _swan_io_boxed.Result.Ok(void 0) : _swan_io_boxed.Result.Error(new NonRetryableError("Failed to publish RPC response: channel buffer full"))));
+		}).mapErr((error) => new NonRetryableError("Failed to publish RPC response", error)).andThen((published) => published ? (0, neverthrow.ok)(void 0) : (0, neverthrow.err)(new NonRetryableError("Failed to publish RPC response: channel buffer full"))));
 	}
 	/**
 	* Process a single consumed message: validate, invoke handler, optionally
@@ -724,58 +729,56 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		const span = (0, _amqp_contract_core.startConsumeSpan)(this.telemetry, queueName, String(name), { "messaging.rabbitmq.message.delivery_tag": msg.fields.deliveryTag });
 		let messageHandled = false;
 		let firstError;
-		return this.parseAndValidateMessage(msg, consumer, name).flatMap((parseResult) => parseResult.match({
-			Ok: (validatedMessage) => handler(validatedMessage, msg).flatMapOk((handlerResponse) => {
-				if (isRpc && responseSchema) return this.publishRpcResponse(msg, queueName, name, responseSchema, handlerResponse).flatMapOk(() => {
-					this.logger?.info("Message consumed successfully", {
-						consumerName: String(name),
-						queueName
-					});
-					this.amqpClient.ack(msg);
-					messageHandled = true;
-					return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(void 0));
-				});
+		const inner = this.parseAndValidateMessage(msg, consumer, name).orElse((parseError) => {
+			firstError = parseError;
+			this.logger?.error("Failed to parse/validate message; sending to DLQ", {
+				consumerName: String(name),
+				queueName,
+				error: parseError
+			});
+			this.amqpClient.nack(msg, false, false);
+			return (0, neverthrow.errAsync)(parseError);
+		}).andThen((validatedMessage) => handler(validatedMessage, msg).andThen((handlerResponse) => {
+			if (isRpc && responseSchema) return this.publishRpcResponse(msg, queueName, name, responseSchema, handlerResponse).map(() => {
 				this.logger?.info("Message consumed successfully", {
 					consumerName: String(name),
 					queueName
 				});
 				this.amqpClient.ack(msg);
 				messageHandled = true;
-				return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Ok(void 0));
-			}).flatMapError((handlerError) => {
-				this.logger?.error("Error processing message", {
-					consumerName: String(name),
-					queueName,
-					errorType: handlerError.name,
-					error: handlerError.message
-				});
-				firstError = handlerError;
-				return handleError({
-					amqpClient: this.amqpClient,
-					logger: this.logger
-				}, handlerError, msg, String(name), consumer);
-			}),
-			Error: (parseError) => {
-				firstError = parseError;
-				this.logger?.error("Failed to parse/validate message; sending to DLQ", {
-					consumerName: String(name),
-					queueName,
-					error: parseError
-				});
-				this.amqpClient.nack(msg, false, false);
-				return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(parseError));
-			}
-		})).map((result) => {
+			});
+			this.logger?.info("Message consumed successfully", {
+				consumerName: String(name),
+				queueName
+			});
+			this.amqpClient.ack(msg);
+			messageHandled = true;
+			return (0, neverthrow.okAsync)(void 0);
+		}).orElse((handlerError) => {
+			this.logger?.error("Error processing message", {
+				consumerName: String(name),
+				queueName,
+				errorType: handlerError.name,
+				error: handlerError.message
+			});
+			firstError = handlerError;
+			return handleError({
+				amqpClient: this.amqpClient,
+				logger: this.logger
+			}, handlerError, msg, String(name), consumer);
+		}));
+		return new neverthrow.ResultAsync((async () => {
+			const result = await inner;
 			const durationMs = Date.now() - startTime;
 			if (messageHandled) {
 				(0, _amqp_contract_core.endSpanSuccess)(span);
 				(0, _amqp_contract_core.recordConsumeMetric)(this.telemetry, queueName, String(name), true, durationMs);
 			} else {
-				(0, _amqp_contract_core.endSpanError)(span, result.isError() ? result.error : firstError ?? /* @__PURE__ */ new Error("Unknown error"));
+				(0, _amqp_contract_core.endSpanError)(span, result.isErr() ? result.error : firstError ?? /* @__PURE__ */ new Error("Unknown error"));
 				(0, _amqp_contract_core.recordConsumeMetric)(this.telemetry, queueName, String(name), false, durationMs);
 			}
 			return result;
-		});
+		})());
 	}
 	/**
 	* Consume messages one at a time.
@@ -791,7 +794,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				return;
 			}
 			try {
-				await this.processMessage(msg, view, name, handler).toPromise();
+				await this.processMessage(msg, view, name, handler);
 			} catch (error) {
 				this.logger?.error("Uncaught error in consume callback; nacking message", {
 					consumerName: String(name),
@@ -800,9 +803,9 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				});
 				this.amqpClient.nack(msg, false, false);
 			}
-		}, this.consumerOptions[name]).tapOk((consumerTag) => {
+		}, this.consumerOptions[name]).andTee((consumerTag) => {
 			this.consumerTags.add(consumerTag);
-		}).mapError((error) => new _amqp_contract_core.TechnicalError(`Failed to start consuming for "${String(name)}"`, error)).mapOk(() => void 0);
+		}).map(() => void 0).mapErr((error) => new _amqp_contract_core.TechnicalError(`Failed to start consuming for "${String(name)}"`, error));
 	}
 };
 //#endregion
@@ -835,7 +838,7 @@ function defineHandler(contract, consumerName, handler, options) {
 /**
 * Define multiple type-safe handlers for consumers in a contract.
 *
-* **Recommended:** This function creates handlers that return `Future<Result<void, HandlerError>>`,
+* **Recommended:** This function creates handlers that return `ResultAsync<void, HandlerError>`,
 * providing explicit error handling and better control over retry behavior.
 *
 * @template TContract - The contract definition type
@@ -846,18 +849,20 @@ function defineHandler(contract, consumerName, handler, options) {
 * @example
 * ```typescript
 * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
-* import { Future } from '@swan-io/boxed';
+* import { ResultAsync } from 'neverthrow';
 * import { orderContract } from './contract';
 *
 * const handlers = defineHandlers(orderContract, {
 *   processOrder: ({ payload }) =>
-*     Future.fromPromise(processPayment(payload))
-*       .mapOk(() => undefined)
-*       .mapError((error) => new RetryableError('Payment failed', error)),
+*     ResultAsync.fromPromise(
+*       processPayment(payload),
+*       (error) => new RetryableError('Payment failed', error),
+*     ).map(() => undefined),
 *   notifyOrder: ({ payload }) =>
-*     Future.fromPromise(sendNotification(payload))
-*       .mapOk(() => undefined)
-*       .mapError((error) => new RetryableError('Notification failed', error)),
+*     ResultAsync.fromPromise(
+*       sendNotification(payload),
+*       (error) => new RetryableError('Notification failed', error),
+*     ).map(() => undefined),
 * });
 * ```
 */