@amqp-contract/worker 0.25.0 → 2.0.0

package/README.md

@@ -1,14 +1,14 @@
 # @amqp-contract/worker
 
-**Type-safe AMQP worker for consuming messages using amqp-contract with ResultAsync/Result error handling.**
+**Type-safe AMQP worker for consuming messages using amqp-contract with AsyncResult/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)
+[![CI](https://github.com/btravstack/amqp-contract/actions/workflows/ci.yml/badge.svg)](https://github.com/btravstack/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-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)**
+📖 **[Full documentation →](https://btravstack.github.io/amqp-contract/api/worker)**
 
 ## Installation
 
@@ -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 { ResultAsync } from "neverthrow";
+import { fromPromise, type AsyncResult } from "unthrown";
 import { contract } from "./contract";
 
 // Optional: Create a logger implementation
@@ -51,7 +51,7 @@ const worker = (
         console.log("Processing order:", payload.orderId);
 
         // Your business logic here
-        return ResultAsync.fromPromise(
+        return fromPromise(
           Promise.all([processPayment(payload), updateInventory(payload)]),
           (error) => new RetryableError("Order processing failed", error),
         ).map(() => undefined);
@@ -60,7 +60,7 @@ const worker = (
     urls: ["amqp://localhost"],
     logger, // Optional: logs message consumption and errors
   })
-)._unsafeUnwrap();
+).unwrap();
 
 // Worker is already consuming messages
 
@@ -70,7 +70,7 @@ const worker = (
 
 ### Advanced Features
 
-For advanced features like prefetch configuration and **automatic retry**, see the [Worker Usage Guide](https://btravers.github.io/amqp-contract/guide/worker-usage).
+For advanced features like prefetch configuration and **automatic retry**, see the [Worker Usage Guide](https://btravstack.github.io/amqp-contract/guide/worker-usage).
 
 #### Retry configuration
 
@@ -99,7 +99,7 @@ Then use `RetryableError` in your handlers:
 
 ```typescript
 import { TypedAmqpWorker, RetryableError } from "@amqp-contract/worker";
-import { ResultAsync } from "neverthrow";
+import { fromPromise, type AsyncResult } from "unthrown";
 
 const worker = (
   await TypedAmqpWorker.create({
@@ -107,39 +107,39 @@ const worker = (
     handlers: {
       processOrder: ({ payload }) =>
         // If this fails with RetryableError, message is automatically retried
-        ResultAsync.fromPromise(
+        fromPromise(
           processPayment(payload),
           (error) => new RetryableError("Payment failed", error),
         ).map(() => undefined),
     },
     urls: ["amqp://localhost"],
   })
-)._unsafeUnwrap();
+).unwrap();
 ```
 
-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.
+See the [Error Handling and Retry](https://btravstack.github.io/amqp-contract/guide/worker-usage#error-handling-and-retry) section in the guide for complete details.
 
 ## Defining Handlers Externally
 
-You can define handlers outside of the worker creation using `defineHandler` and `defineHandlers` for better code organization. See the [Worker API documentation](https://btravers.github.io/amqp-contract/api/worker) for details.
+You can define handlers outside of the worker creation using `defineHandler` and `defineHandlers` for better code organization. See the [Worker API documentation](https://btravstack.github.io/amqp-contract/api/worker) for details.
 
 ## Error Handling
 
-Worker handlers return `ResultAsync<void, HandlerError>` for explicit error handling:
+Worker handlers return `AsyncResult<void, HandlerError>` for explicit error handling:
 
 ```typescript
 import { RetryableError, NonRetryableError } from "@amqp-contract/worker";
-import { errAsync, ResultAsync } from "neverthrow";
+import { Err, fromPromise, type AsyncResult } from "unthrown";
 
 handlers: {
   processOrder: ({ payload }) => {
     // Validation errors - non-retryable
     if (payload.amount <= 0) {
-      return errAsync(new NonRetryableError("Invalid amount"));
+      return Err(new NonRetryableError("Invalid amount")).toAsync();
     }
 
     // Transient errors - retryable
-    return ResultAsync.fromPromise(process(payload), (error) => new RetryableError("Processing failed", error))
+    return fromPromise(process(payload), (error) => new RetryableError("Processing failed", error))
       .map(() => undefined);
   },
 }
@@ -156,11 +156,11 @@ Worker defines error classes:
 
 ## API
 
-For complete API documentation, see the [Worker API Reference](https://btravers.github.io/amqp-contract/api/worker).
+For complete API documentation, see the [Worker API Reference](https://btravstack.github.io/amqp-contract/api/worker).
 
 ## Documentation
 
-📖 **[Read the full documentation →](https://btravers.github.io/amqp-contract)**
+📖 **[Read the full documentation →](https://btravstack.github.io/amqp-contract)**
 
 ## License
 

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 neverthrow = require("neverthrow");
+let unthrown = require("unthrown");
 let node_zlib = require("node:zlib");
 let node_util = require("node:util");
 //#region src/decompression.ts
@@ -22,55 +22,57 @@ function isSupportedEncoding(encoding) {
 *
 * @param buffer - The buffer to decompress
 * @param contentEncoding - The content-encoding header value (e.g., 'gzip', 'deflate')
-* @returns A ResultAsync resolving to the decompressed buffer or a TechnicalError
+* @returns An AsyncResult resolving to the decompressed buffer or a TechnicalError
 *
 * @internal
 */
 function decompressBuffer(buffer, contentEncoding) {
-	if (!contentEncoding) return (0, neverthrow.okAsync)(buffer);
+	if (!contentEncoding) return (0, unthrown.Ok)(buffer).toAsync();
 	const normalizedEncoding = contentEncoding.toLowerCase();
-	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.`));
+	if (!isSupportedEncoding(normalizedEncoding)) return (0, unthrown.Err)(new _amqp_contract_core.TechnicalError(`Unsupported content-encoding: "${contentEncoding}". Supported encodings are: ${SUPPORTED_ENCODINGS.join(", ")}. Please check your publisher configuration.`)).toAsync();
 	switch (normalizedEncoding) {
-		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));
+		case "gzip": return (0, unthrown.fromPromise)(gunzipAsync(buffer), (error) => new _amqp_contract_core.TechnicalError("Failed to decompress gzip", error));
+		case "deflate": return (0, unthrown.fromPromise)(inflateAsync(buffer), (error) => new _amqp_contract_core.TechnicalError("Failed to decompress deflate", error));
 	}
 }
 //#endregion
 //#region src/errors.ts
 /**
-* Abstract base class for all handler-signalled errors.
-*
-* Concrete subclasses (`RetryableError`, `NonRetryableError`) discriminate on
-* the `name` property so exhaustive narrowing in user code keeps working.
-* `error instanceof HandlerError` is true for any handler error.
-*/
-var HandlerError = class extends Error {
-	constructor(message, cause) {
-		super(message);
-		this.cause = cause;
-		const ErrorConstructor = Error;
-		if (typeof ErrorConstructor.captureStackTrace === "function") ErrorConstructor.captureStackTrace(this, this.constructor);
-	}
-};
-/**
 * Retryable errors - transient failures that may succeed on retry
 * Examples: network timeouts, rate limiting, temporary service unavailability
 *
 * Use this error type when the operation might succeed if retried.
 * The worker will apply exponential backoff and retry the message.
+*
+* Built on unthrown's {@link TaggedError}, so it carries a namespaced `_tag` of
+* `"@amqp-contract/RetryableError"` (to avoid colliding with other libraries'
+* tags in a shared `matchTags`) for exhaustive dispatch; the `Error.name` is
+* kept bare (`"RetryableError"`).
 */
-var RetryableError = class extends HandlerError {
-	name = "RetryableError";
+var RetryableError = class extends (0, unthrown.TaggedError)("@amqp-contract/RetryableError", { name: "RetryableError" }) {
+	constructor(message, cause) {
+		super({
+			message,
+			cause
+		});
+	}
 };
 /**
 * Non-retryable errors - permanent failures that should not be retried
 * Examples: invalid data, business rule violations, permanent external failures
 *
 * Use this error type when retrying would not help - the message will be
-* immediately sent to the dead letter queue (DLQ) if configured.
+* immediately sent to the dead letter queue (DLQ) if configured. Carries a
+* namespaced `_tag` of `"@amqp-contract/NonRetryableError"`; the `Error.name` is
+* kept bare (`"NonRetryableError"`).
 */
-var NonRetryableError = class extends HandlerError {
-	name = "NonRetryableError";
+var NonRetryableError = class extends (0, unthrown.TaggedError)("@amqp-contract/NonRetryableError", { name: "NonRetryableError" }) {
+	constructor(message, cause) {
+		super({
+			message,
+			cause
+		});
+	}
 };
 /**
 * Type guard to check if an error is a RetryableError.
@@ -141,7 +143,7 @@ function isNonRetryableError(error) {
 * ```
 */
 function isHandlerError(error) {
-	return error instanceof HandlerError;
+	return error instanceof RetryableError || error instanceof NonRetryableError;
 }
 /**
 * Create a RetryableError with less verbosity.
@@ -156,16 +158,16 @@ function isHandlerError(error) {
 * @example
 * ```typescript
 * import { retryable } from '@amqp-contract/worker';
-* import { ResultAsync } from 'neverthrow';
+* import { fromPromise } from 'unthrown';
 *
 * const handler = ({ payload }) =>
-*   ResultAsync.fromPromise(
+*   fromPromise(
 *     processPayment(payload),
 *     (e) => retryable('Payment service unavailable', e),
 *   ).map(() => undefined);
 *
 * // Equivalent to:
-* // ResultAsync.fromPromise(processPayment(payload), (e) => new RetryableError('...', e))
+* // fromPromise(processPayment(payload), (e) => new RetryableError('...', e))
 * ```
 */
 function retryable(message, cause) {
@@ -184,17 +186,17 @@ function retryable(message, cause) {
 * @example
 * ```typescript
 * import { nonRetryable } from '@amqp-contract/worker';
-* import { errAsync, okAsync } from 'neverthrow';
+* import { Err, Ok } from 'unthrown';
 *
 * const handler = ({ payload }) => {
 *   if (!isValidPayload(payload)) {
-*     return errAsync(nonRetryable('Invalid payload format'));
+*     return Err(nonRetryable('Invalid payload format')).toAsync();
 *   }
-*   return okAsync(undefined);
+*   return Ok(undefined).toAsync();
 * };
 *
 * // Equivalent to:
-* // return errAsync(new NonRetryableError('Invalid payload format'));
+* // return Err(new NonRetryableError('Invalid payload format')).toAsync();
 * ```
 */
 function nonRetryable(message, cause) {
@@ -223,7 +225,7 @@ function nonRetryable(message, cause) {
 function handleError(ctx, error, msg, consumerName, consumer) {
 	if (error instanceof NonRetryableError) {
 		sendToDLQ(ctx, msg, consumer);
-		return (0, neverthrow.okAsync)(void 0);
+		return (0, unthrown.Ok)(void 0).toAsync();
 	}
 	const config = (0, _amqp_contract_contract.extractQueue)(consumer.queue).retry;
 	if (config.mode === "immediate-requeue") return handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, config);
@@ -233,7 +235,7 @@ function handleError(ctx, error, msg, consumerName, consumer) {
 		queueName: (0, _amqp_contract_contract.extractQueue)(consumer.queue).name
 	});
 	sendToDLQ(ctx, msg, consumer);
-	return (0, neverthrow.okAsync)(void 0);
+	return (0, unthrown.Ok)(void 0).toAsync();
 }
 /**
 * Handle error by requeuing immediately.
@@ -256,7 +258,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 			maxRetries: config.maxRetries
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return (0, neverthrow.okAsync)(void 0);
+		return (0, unthrown.Ok)(void 0).toAsync();
 	}
 	ctx.logger?.info("Retrying message (immediate-requeue mode)", {
 		consumerName,
@@ -266,7 +268,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 	});
 	if (queue.type === "quorum") {
 		ctx.amqpClient.nack(msg, false, true);
-		return (0, neverthrow.okAsync)(void 0);
+		return (0, unthrown.Ok)(void 0).toAsync();
 	} else return publishForRetry(ctx, {
 		msg,
 		exchange: msg.fields.exchange,
@@ -307,7 +309,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			consumerName,
 			queueName: consumer.queue.name
 		});
-		return (0, neverthrow.errAsync)(new _amqp_contract_core.TechnicalError("Queue does not have TTL-backoff infrastructure"));
+		return (0, unthrown.Err)(new _amqp_contract_core.TechnicalError("Queue does not have TTL-backoff infrastructure")).toAsync();
 	}
 	const queueEntry = consumer.queue;
 	const queueName = (0, _amqp_contract_contract.extractQueue)(queueEntry).name;
@@ -320,7 +322,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			maxRetries: config.maxRetries
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return (0, neverthrow.okAsync)(void 0);
+		return (0, unthrown.Ok)(void 0).toAsync();
 	}
 	const delayMs = calculateRetryDelay(retryCount, config);
 	ctx.logger?.info("Retrying message (ttl-backoff mode)", {
@@ -393,14 +395,14 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 				"x-retry-queue": queueName
 			} : {}
 		}
-	}).andThen((published) => {
+	}).flatMap((published) => {
 		if (!published) {
 			ctx.logger?.error("Failed to publish message for retry (write buffer full)", {
 				queueName,
 				retryCount: newRetryCount,
 				...delayMs !== void 0 ? { delayMs } : {}
 			});
-			return (0, neverthrow.err)(new _amqp_contract_core.TechnicalError("Failed to publish message for retry (write buffer full)"));
+			return (0, unthrown.Err)(new _amqp_contract_core.TechnicalError("Failed to publish message for retry (write buffer full)"));
 		}
 		ctx.amqpClient.ack(msg);
 		ctx.logger?.info("Message published for retry", {
@@ -408,7 +410,7 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 			retryCount: newRetryCount,
 			...delayMs !== void 0 ? { delayMs } : {}
 		});
-		return (0, neverthrow.ok)(void 0);
+		return (0, unthrown.Ok)(void 0);
 	}).orElse((publishError) => {
 		ctx.logger?.error("Publish for retry failed; leaving original un-ack'd for redelivery", {
 			queueName,
@@ -416,7 +418,7 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 			...delayMs !== void 0 ? { delayMs } : {},
 			error: publishError
 		});
-		return (0, neverthrow.err)(publishError);
+		return (0, unthrown.Err)(publishError);
 	});
 }
 /**
@@ -453,7 +455,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 { Ok } from 'unthrown';
 * import { z } from 'zod';
 *
 * const orderQueue = defineQueue('order-processing');
@@ -473,20 +475,23 @@ function isHandlerTuple(entry) {
 *   handlers: {
 *     processOrder: ({ payload }) => {
 *       console.log('Processing order', payload.orderId);
-*       return okAsync(undefined);
+*       return Ok(undefined).toAsync();
 *     },
 *   },
 *   urls: ['amqp://localhost'],
 * });
 *
-* if (result.isErr()) throw result.error;
-* const worker = result.value;
+* const worker = result.unwrap();
 *
 * // Close when done
 * await worker.close();
 * ```
 */
 var TypedAmqpWorker = class TypedAmqpWorker {
+	contract;
+	amqpClient;
+	defaultConsumerOptions;
+	logger;
 	/**
 	* Internal handler storage. Keyed by handler name (consumer or RPC); the
 	* stored function signature is widened so the dispatch loop can call it
@@ -559,14 +564,14 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* Connections are automatically shared across clients and workers with the same
 	* URLs and connection options, following RabbitMQ best practices.
 	*
-	* @returns A ResultAsync that resolves to the worker or a TechnicalError.
+	* @returns A AsyncResult that resolves to the worker or a TechnicalError.
 	*
 	* @example
 	* ```typescript
 	* const result = await TypedAmqpWorker.create({
 	*   contract: myContract,
 	*   handlers: {
-	*     processOrder: ({ payload }) => okAsync(undefined),
+	*     processOrder: ({ payload }) => Ok(undefined).toAsync(),
 	*   },
 	*   urls: ['amqp://localhost'],
 	* });
@@ -578,14 +583,15 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 			connectionOptions,
 			connectTimeoutMs
 		}), handlers, defaultConsumerOptions ?? {}, logger, telemetry);
-		const setup = worker.waitForConnectionReady().andThen(() => worker.consumeAll());
-		return new neverthrow.ResultAsync((async () => {
+		const setup = worker.waitForConnectionReady().flatMap(() => worker.consumeAll());
+		return (0, unthrown.fromSafePromise)((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);
-		})());
+			if (!setupResult.isOk()) {
+				const closeResult = await worker.close();
+				if (closeResult.isErr()) logger?.warn("Failed to close worker after setup failure", { error: closeResult.error });
+			}
+			return setupResult.map(() => worker);
+		})()).flatMap((result) => result);
 	}
 	/**
 	* Close the AMQP channel and connection.
@@ -602,16 +608,15 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* ```
 	*/
 	close() {
-		const cancellations = Array.from(this.consumerTags).map((consumerTag) => this.amqpClient.cancel(consumerTag).orElse((error) => {
+		return (0, unthrown.allAsync)(Array.from(this.consumerTags).map((consumerTag) => this.amqpClient.cancel(consumerTag).orElse((error) => {
 			this.logger?.warn("Failed to cancel consumer during close", {
 				consumerTag,
 				error
 			});
-			return (0, neverthrow.ok)(void 0);
-		}));
-		return neverthrow.ResultAsync.combine(cancellations).andTee(() => {
+			return (0, unthrown.Ok)(void 0);
+		}))).tap(() => {
 			this.consumerTags.clear();
-		}).andThen(() => this.amqpClient.close()).map(() => void 0);
+		}).flatMap(() => this.amqpClient.close()).map(() => void 0);
 	}
 	/**
 	* Start consuming for every entry in `contract.consumers` and `contract.rpcs`.
@@ -619,8 +624,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	consumeAll() {
 		const consumerNames = Object.keys(this.contract.consumers ?? {});
 		const rpcNames = Object.keys(this.contract.rpcs ?? {});
-		const allNames = [...consumerNames, ...rpcNames];
-		return neverthrow.ResultAsync.combine(allNames.map((name) => this.consume(name))).map(() => void 0);
+		return (0, unthrown.allAsync)([...consumerNames, ...rpcNames].map((name) => this.consume(name))).map(() => void 0);
 	}
 	waitForConnectionReady() {
 		return this.amqpClient.waitForConnect();
@@ -640,10 +644,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 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);
+		return (0, unthrown.fromPromise)(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation), (error) => new _amqp_contract_core.TechnicalError(`Error validating ${context.field}`, error)).flatMap((result) => {
+			if (result.issues) return (0, unthrown.Err)(new _amqp_contract_core.TechnicalError(`${context.field} validation failed`, new _amqp_contract_core.MessageValidationError(context.consumerName, result.issues)));
+			return (0, unthrown.Ok)(result.value);
 		});
 	}
 	/**
@@ -655,15 +658,13 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	*/
 	parseAndValidateMessage(msg, consumer, consumerName) {
 		const context = { consumerName: String(consumerName) };
-		const parsePayload = decompressBuffer(msg.content, msg.properties.contentEncoding).andThen((buffer) => (0, _amqp_contract_core.safeJsonParse)(buffer, (error) => new _amqp_contract_core.TechnicalError("Failed to parse JSON", error))).andThen((parsed) => this.validateSchema(consumer.message.payload, parsed, {
+		return (0, unthrown.allAsync)([decompressBuffer(msg.content, msg.properties.contentEncoding).flatMap((buffer) => (0, _amqp_contract_core.safeJsonParse)(buffer, (error) => new _amqp_contract_core.TechnicalError("Failed to parse JSON", error))).flatMap((parsed) => this.validateSchema(consumer.message.payload, parsed, {
 			...context,
 			field: "payload"
-		}));
-		const parseHeaders = consumer.message.headers ? this.validateSchema(consumer.message.headers, msg.properties.headers ?? {}, {
+		})), consumer.message.headers ? this.validateSchema(consumer.message.headers, msg.properties.headers ?? {}, {
 			...context,
 			field: "headers"
-		}) : (0, neverthrow.okAsync)(void 0);
-		return neverthrow.ResultAsync.combine([parsePayload, parseHeaders]).map(([payload, headers]) => ({
+		}) : (0, unthrown.Ok)(void 0).toAsync()]).map(([payload, headers]) => ({
 			payload,
 			headers
 		}));
@@ -695,7 +696,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				rpcName: String(rpcName),
 				queueName
 			});
-			return (0, neverthrow.errAsync)(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`));
+			return (0, unthrown.Err)(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`)).toAsync();
 		}
 		if (typeof correlationId !== "string" || correlationId.length === 0) {
 			this.logger?.error("RPC handler returned a response but the incoming message has no correlationId", {
@@ -703,22 +704,21 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				queueName,
 				replyTo
 			});
-			return (0, neverthrow.errAsync)(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`));
+			return (0, unthrown.Err)(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`)).toAsync();
 		}
 		let rawValidation;
 		try {
 			rawValidation = responseSchema["~standard"].validate(response);
 		} catch (error) {
-			return (0, neverthrow.errAsync)(new NonRetryableError("RPC response schema validation threw", error));
+			return (0, unthrown.Err)(new NonRetryableError("RPC response schema validation threw", error)).toAsync();
 		}
-		const validationPromise = rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);
-		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, {
+		return (0, unthrown.fromPromise)(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation), (error) => new NonRetryableError("RPC response schema validation threw", error)).flatMap((validation) => {
+			if (validation.issues) return (0, unthrown.Err)(new NonRetryableError(`RPC response for "${String(rpcName)}" failed schema validation`, new _amqp_contract_core.MessageValidationError(String(rpcName), validation.issues)));
+			return (0, unthrown.Ok)(validation.value);
+		}).flatMap((validatedResponse) => this.amqpClient.publish("", replyTo, validatedResponse, {
 			correlationId,
 			contentType: "application/json"
-		}).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"))));
+		}).mapErr((error) => new NonRetryableError("Failed to publish RPC response", error)).flatMap((published) => published ? (0, unthrown.Ok)(void 0) : (0, unthrown.Err)(new NonRetryableError("Failed to publish RPC response: channel buffer full"))));
 	}
 	/**
 	* Parse and validate the message; on failure, nack(requeue=false) so the
@@ -729,7 +729,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	parseAndValidateOrNack(msg, consumer, name) {
 		return this.parseAndValidateMessage(msg, consumer, name).orElse((parseError) => {
 			this.amqpClient.nack(msg, false, false);
-			return (0, neverthrow.errAsync)(parseError);
+			return (0, unthrown.Err)(parseError).toAsync();
 		});
 	}
 	/**
@@ -744,10 +744,10 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	/**
 	* For RPC handlers, validate and publish the reply on the caller's
 	* `replyTo` / `correlationId`. For non-RPC consumers, this is a no-op that
-	* resolves to `okAsync(undefined)`.
+	* resolves to `Ok(undefined).toAsync()`.
 	*/
 	publishReplyIfRpc(msg, view, name, handlerResponse) {
-		if (!view.isRpc || !view.responseSchema) return (0, neverthrow.okAsync)(void 0);
+		if (!view.isRpc || !view.responseSchema) return (0, unthrown.Ok)(void 0).toAsync();
 		const queueName = (0, _amqp_contract_contract.extractQueue)(view.consumer.queue).name;
 		return this.publishRpcResponse(msg, queueName, name, view.responseSchema, handlerResponse);
 	}
@@ -760,7 +760,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* is still needed (see {@link consumeSingle}).
 	*
 	* Success-vs-failure telemetry is data-driven: the chain resolves to
-	* `ok(undefined)` only on handler success (and reply-publish success for
+	* `Ok(undefined)` only on handler success (and reply-publish success for
 	* RPC). Handler failures — even when {@link handleError} routes them
 	* successfully to retry/DLQ — are classified as failures for metrics by
 	* re-failing the chain with a `TechnicalError` whose `cause` is the
@@ -773,14 +773,14 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		const queueName = (0, _amqp_contract_contract.extractQueue)(consumer.queue).name;
 		const startTime = Date.now();
 		const span = (0, _amqp_contract_core.startConsumeSpan)(this.telemetry, queueName, String(name), { "messaging.rabbitmq.message.delivery_tag": msg.fields.deliveryTag });
-		return this.parseAndValidateOrNack(msg, consumer, name).orTee((parseError) => {
+		return this.parseAndValidateOrNack(msg, consumer, name).tapErr((parseError) => {
 			this.logger?.error("Failed to parse/validate message; sending to DLQ", {
 				consumerName: String(name),
 				queueName,
 				error: parseError
 			});
 			state.messageHandled = true;
-		}).andThen((validatedMessage) => this.runHandler(handler, validatedMessage, msg).andThen((handlerResponse) => this.publishReplyIfRpc(msg, view, name, handlerResponse).andTee(() => {
+		}).flatMap((validatedMessage) => this.runHandler(handler, validatedMessage, msg).flatMap((handlerResponse) => this.publishReplyIfRpc(msg, view, name, handlerResponse).tap(() => {
 			this.logger?.info("Message consumed successfully", {
 				consumerName: String(name),
 				queueName
@@ -798,10 +798,10 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 			return handleError({
 				amqpClient: this.amqpClient,
 				logger: this.logger
-			}, handlerError, msg, String(name), consumer).andTee(() => {
+			}, handlerError, msg, String(name), consumer).tap(() => {
 				state.messageHandled = true;
-			}).andThen(() => (0, neverthrow.errAsync)(new _amqp_contract_core.TechnicalError(`Handler "${String(name)}" failed: ${handlerError.message}`, handlerError)));
-		})).andTee(() => {
+			}).flatMap(() => (0, unthrown.Err)(new _amqp_contract_core.TechnicalError(`Handler "${String(name)}" failed: ${handlerError.message}`, handlerError)).toAsync());
+		})).tap(() => {
 			try {
 				(0, _amqp_contract_core.endSpanSuccess)(span);
 				(0, _amqp_contract_core.recordConsumeMetric)(this.telemetry, queueName, String(name), true, Date.now() - startTime);
@@ -812,7 +812,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 					error: telemetryError
 				});
 			}
-		}).orTee((error) => {
+		}).tapErr((error) => {
 			const reportedError = error.cause instanceof Error ? error.cause : error;
 			try {
 				(0, _amqp_contract_core.endSpanError)(span, reportedError);
@@ -858,7 +858,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				});
 				this.amqpClient.nack(msg, false, false);
 			}
-		}, this.consumerOptions[name]).andTee((consumerTag) => {
+		}, this.consumerOptions[name]).tap((consumerTag) => {
 			this.consumerTags.add(consumerTag);
 		}).map(() => void 0).mapErr((error) => new _amqp_contract_core.TechnicalError(`Failed to start consuming for "${String(name)}"`, error));
 	}
@@ -884,7 +884,9 @@ function formatAvailable(names) {
 function validateHandlerTargetExists(contract, name) {
 	const consumers = contract.consumers;
 	const rpcs = contract.rpcs;
-	if (!(!!consumers && Object.hasOwn(consumers, name)) && !(!!rpcs && Object.hasOwn(rpcs, name))) {
+	const isConsumer = !!consumers && Object.hasOwn(consumers, name);
+	const isRpc = !!rpcs && Object.hasOwn(rpcs, name);
+	if (!isConsumer && !isRpc) {
 		const available = formatAvailable(availableHandlerNames(contract));
 		throw new Error(`Handler target "${name}" not found in contract. Available consumers and RPCs: ${available}`);
 	}
@@ -905,8 +907,8 @@ function defineHandler(contract, name, handler, options) {
 * Define multiple type-safe handlers for consumers and RPCs in a contract.
 *
 * **Recommended:** This function creates handlers that return
-* `ResultAsync<void, HandlerError>` (consumers) or
-* `ResultAsync<TResponse, HandlerError>` (RPCs), providing explicit error
+* `AsyncResult<void, HandlerError>` (consumers) or
+* `AsyncResult<TResponse, HandlerError>` (RPCs), providing explicit error
 * handling and better control over retry behavior.
 *
 * The handlers object must contain exactly one entry per `consumers` and
@@ -920,15 +922,15 @@ function defineHandler(contract, name, handler, options) {
 * @example
 * ```typescript
 * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
-* import { okAsync, ResultAsync } from 'neverthrow';
+* import { fromPromise, Ok } from 'unthrown';
 *
 * const handlers = defineHandlers(orderContract, {
 *   processOrder: ({ payload }) =>
-*     ResultAsync.fromPromise(
+*     fromPromise(
 *       processPayment(payload),
 *       (error) => new RetryableError('Payment failed', error),
 *     ).map(() => undefined),
-*   calculate: ({ payload }) => okAsync({ sum: payload.a + payload.b }),
+*   calculate: ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
 * });
 * ```
 */
@@ -937,7 +939,6 @@ function defineHandlers(contract, handlers) {
 	return handlers;
 }
 //#endregion
-exports.HandlerError = HandlerError;
 Object.defineProperty(exports, "MessageValidationError", {
 	enumerable: true,
 	get: function() {