@amqp-contract/worker 1.0.0 → 2.0.0

package/README.md

@@ -129,13 +129,13 @@ Worker handlers return `AsyncResult<void, HandlerError>` for explicit error hand
 
 ```typescript
 import { RetryableError, NonRetryableError } from "@amqp-contract/worker";
-import { err, fromPromise, type AsyncResult } from "unthrown";
+import { Err, fromPromise, type AsyncResult } from "unthrown";
 
 handlers: {
   processOrder: ({ payload }) => {
     // Validation errors - non-retryable
     if (payload.amount <= 0) {
-      return err(new NonRetryableError("Invalid amount")).toAsync();
+      return Err(new NonRetryableError("Invalid amount")).toAsync();
     }
 
     // Transient errors - retryable

package/dist/index.cjs

@@ -27,9 +27,9 @@ function isSupportedEncoding(encoding) {
 * @internal
 */
 function decompressBuffer(buffer, contentEncoding) {
-	if (!contentEncoding) return (0, unthrown.ok)(buffer).toAsync();
+	if (!contentEncoding) return (0, unthrown.Ok)(buffer).toAsync();
 	const normalizedEncoding = contentEncoding.toLowerCase();
-	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();
+	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 (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));
@@ -186,17 +186,17 @@ function retryable(message, cause) {
 * @example
 * ```typescript
 * import { nonRetryable } from '@amqp-contract/worker';
-* import { err, ok } from 'unthrown';
+* import { Err, Ok } from 'unthrown';
 *
 * const handler = ({ payload }) => {
 *   if (!isValidPayload(payload)) {
-*     return err(nonRetryable('Invalid payload format')).toAsync();
+*     return Err(nonRetryable('Invalid payload format')).toAsync();
 *   }
-*   return ok(undefined).toAsync();
+*   return Ok(undefined).toAsync();
 * };
 *
 * // Equivalent to:
-* // return err(new NonRetryableError('Invalid payload format')).toAsync();
+* // return Err(new NonRetryableError('Invalid payload format')).toAsync();
 * ```
 */
 function nonRetryable(message, cause) {
@@ -225,7 +225,7 @@ function nonRetryable(message, cause) {
 function handleError(ctx, error, msg, consumerName, consumer) {
 	if (error instanceof NonRetryableError) {
 		sendToDLQ(ctx, msg, consumer);
-		return (0, unthrown.ok)(void 0).toAsync();
+		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);
@@ -235,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, unthrown.ok)(void 0).toAsync();
+	return (0, unthrown.Ok)(void 0).toAsync();
 }
 /**
 * Handle error by requeuing immediately.
@@ -258,7 +258,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 			maxRetries: config.maxRetries
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return (0, unthrown.ok)(void 0).toAsync();
+		return (0, unthrown.Ok)(void 0).toAsync();
 	}
 	ctx.logger?.info("Retrying message (immediate-requeue mode)", {
 		consumerName,
@@ -268,7 +268,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 	});
 	if (queue.type === "quorum") {
 		ctx.amqpClient.nack(msg, false, true);
-		return (0, unthrown.ok)(void 0).toAsync();
+		return (0, unthrown.Ok)(void 0).toAsync();
 	} else return publishForRetry(ctx, {
 		msg,
 		exchange: msg.fields.exchange,
@@ -309,7 +309,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			consumerName,
 			queueName: consumer.queue.name
 		});
-		return (0, unthrown.err)(new _amqp_contract_core.TechnicalError("Queue does not have TTL-backoff infrastructure")).toAsync();
+		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;
@@ -322,7 +322,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			maxRetries: config.maxRetries
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return (0, unthrown.ok)(void 0).toAsync();
+		return (0, unthrown.Ok)(void 0).toAsync();
 	}
 	const delayMs = calculateRetryDelay(retryCount, config);
 	ctx.logger?.info("Retrying message (ttl-backoff mode)", {
@@ -402,7 +402,7 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 				retryCount: newRetryCount,
 				...delayMs !== void 0 ? { delayMs } : {}
 			});
-			return (0, unthrown.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", {
@@ -410,7 +410,7 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 			retryCount: newRetryCount,
 			...delayMs !== void 0 ? { delayMs } : {}
 		});
-		return (0, unthrown.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,
@@ -418,7 +418,7 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 			...delayMs !== void 0 ? { delayMs } : {},
 			error: publishError
 		});
-		return (0, unthrown.err)(publishError);
+		return (0, unthrown.Err)(publishError);
 	});
 }
 /**
@@ -455,7 +455,7 @@ function isHandlerTuple(entry) {
 * ```typescript
 * import { TypedAmqpWorker } from '@amqp-contract/worker';
 * import { defineQueue, defineMessage, defineContract, defineConsumer } from '@amqp-contract/contract';
-* import { ok } from 'unthrown';
+* import { Ok } from 'unthrown';
 * import { z } from 'zod';
 *
 * const orderQueue = defineQueue('order-processing');
@@ -475,7 +475,7 @@ function isHandlerTuple(entry) {
 *   handlers: {
 *     processOrder: ({ payload }) => {
 *       console.log('Processing order', payload.orderId);
-*       return ok(undefined).toAsync();
+*       return Ok(undefined).toAsync();
 *     },
 *   },
 *   urls: ['amqp://localhost'],
@@ -571,7 +571,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* const result = await TypedAmqpWorker.create({
 	*   contract: myContract,
 	*   handlers: {
-	*     processOrder: ({ payload }) => ok(undefined).toAsync(),
+	*     processOrder: ({ payload }) => Ok(undefined).toAsync(),
 	*   },
 	*   urls: ['amqp://localhost'],
 	* });
@@ -613,7 +613,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				consumerTag,
 				error
 			});
-			return (0, unthrown.ok)(void 0);
+			return (0, unthrown.Ok)(void 0);
 		}))).tap(() => {
 			this.consumerTags.clear();
 		}).flatMap(() => this.amqpClient.close()).map(() => void 0);
@@ -645,8 +645,8 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	validateSchema(schema, data, context) {
 		const rawValidation = schema["~standard"].validate(data);
 		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);
+			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);
 		});
 	}
 	/**
@@ -664,7 +664,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		})), consumer.message.headers ? this.validateSchema(consumer.message.headers, msg.properties.headers ?? {}, {
 			...context,
 			field: "headers"
-		}) : (0, unthrown.ok)(void 0).toAsync()]).map(([payload, headers]) => ({
+		}) : (0, unthrown.Ok)(void 0).toAsync()]).map(([payload, headers]) => ({
 			payload,
 			headers
 		}));
@@ -696,7 +696,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				rpcName: String(rpcName),
 				queueName
 			});
-			return (0, unthrown.err)(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`)).toAsync();
+			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", {
@@ -704,21 +704,21 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				queueName,
 				replyTo
 			});
-			return (0, unthrown.err)(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`)).toAsync();
+			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, unthrown.err)(new NonRetryableError("RPC response schema validation threw", error)).toAsync();
+			return (0, unthrown.Err)(new NonRetryableError("RPC response schema validation threw", error)).toAsync();
 		}
 		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);
+			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)).flatMap((published) => published ? (0, unthrown.ok)(void 0) : (0, unthrown.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, unthrown.err)(parseError).toAsync();
+			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 `ok(undefined).toAsync()`.
+	* resolves to `Ok(undefined).toAsync()`.
 	*/
 	publishReplyIfRpc(msg, view, name, handlerResponse) {
-		if (!view.isRpc || !view.responseSchema) return (0, unthrown.ok)(void 0).toAsync();
+		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
@@ -800,7 +800,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				logger: this.logger
 			}, handlerError, msg, String(name), consumer).tap(() => {
 				state.messageHandled = true;
-			}).flatMap(() => (0, unthrown.err)(new _amqp_contract_core.TechnicalError(`Handler "${String(name)}" failed: ${handlerError.message}`, handlerError)).toAsync());
+			}).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);
@@ -922,7 +922,7 @@ function defineHandler(contract, name, handler, options) {
 * @example
 * ```typescript
 * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
-* import { fromPromise, ok } from 'unthrown';
+* import { fromPromise, Ok } from 'unthrown';
 *
 * const handlers = defineHandlers(orderContract, {
 *   processOrder: ({ payload }) =>
@@ -930,7 +930,7 @@ function defineHandler(contract, name, handler, options) {
 *       processPayment(payload),
 *       (error) => new RetryableError('Payment failed', error),
 *     ).map(() => undefined),
-*   calculate: ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
+*   calculate: ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
 * });
 * ```
 */

package/dist/index.d.cts

@@ -333,17 +333,17 @@ declare function retryable(message: string, cause?: unknown): RetryableError;
  * @example
  * ```typescript
  * import { nonRetryable } from '@amqp-contract/worker';
- * import { err, ok } from 'unthrown';
+ * import { Err, Ok } from 'unthrown';
  *
  * const handler = ({ payload }) => {
  *   if (!isValidPayload(payload)) {
- *     return err(nonRetryable('Invalid payload format')).toAsync();
+ *     return Err(nonRetryable('Invalid payload format')).toAsync();
  *   }
- *   return ok(undefined).toAsync();
+ *   return Ok(undefined).toAsync();
  * };
  *
  * // Equivalent to:
- * // return err(new NonRetryableError('Invalid payload format')).toAsync();
+ * // return Err(new NonRetryableError('Invalid payload format')).toAsync();
  * ```
  */
 declare function nonRetryable(message: string, cause?: unknown): NonRetryableError;
@@ -412,7 +412,7 @@ type WorkerInferRpcResponse<TContract extends ContractDefinition, TName extends
  *   console.log(message.payload.orderId);  // Typed payload
  *   console.log(message.headers?.priority); // Typed headers (if defined)
  *   console.log(rawMessage.fields.deliveryTag); // Raw AMQP message
- *   return ok(undefined).toAsync();
+ *   return Ok(undefined).toAsync();
  * });
  * ```
  */
@@ -463,7 +463,7 @@ type WorkerInferRpcHandlerEntry<TContract extends ContractDefinition, TName exte
  *       processPayment(payload),
  *       (error) => new RetryableError('Payment failed', error),
  *     ).map(() => undefined),
- *   calculate: ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
+ *   calculate: ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
  * };
  * ```
  */
@@ -484,13 +484,13 @@ type ConsumerOptions = ConsumerOptions$1;
  *     // Simple handler
  *     processOrder: ({ payload }) => {
  *       console.log('Processing order:', payload.orderId);
- *       return ok(undefined).toAsync();
+ *       return Ok(undefined).toAsync();
  *     },
  *     // Handler with prefetch configuration
  *     processPayment: [
  *       ({ payload }) => {
  *         console.log('Processing payment:', payload.paymentId);
- *         return ok(undefined).toAsync();
+ *         return Ok(undefined).toAsync();
  *       },
  *       { prefetch: 10 }
  *     ]
@@ -538,7 +538,7 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
   defaultConsumerOptions?: ConsumerOptions | undefined;
   /**
    * Maximum time in ms to wait for the AMQP connection to become ready before
-   * `create()` resolves to an `err(TechnicalError)`. Defaults to 30s
+   * `create()` resolves to an `Err(TechnicalError)`. Defaults to 30s
    * (the {@link AmqpClient}'s `DEFAULT_CONNECT_TIMEOUT_MS`). Pass `null` to
    * disable the timeout and let amqp-connection-manager retry indefinitely.
    */
@@ -556,7 +556,7 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
  * ```typescript
  * import { TypedAmqpWorker } from '@amqp-contract/worker';
  * import { defineQueue, defineMessage, defineContract, defineConsumer } from '@amqp-contract/contract';
- * import { ok } from 'unthrown';
+ * import { Ok } from 'unthrown';
  * import { z } from 'zod';
  *
  * const orderQueue = defineQueue('order-processing');
@@ -576,7 +576,7 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
  *   handlers: {
  *     processOrder: ({ payload }) => {
  *       console.log('Processing order', payload.orderId);
- *       return ok(undefined).toAsync();
+ *       return Ok(undefined).toAsync();
  *     },
  *   },
  *   urls: ['amqp://localhost'],
@@ -630,7 +630,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    * const result = await TypedAmqpWorker.create({
    *   contract: myContract,
    *   handlers: {
-   *     processOrder: ({ payload }) => ok(undefined).toAsync(),
+   *     processOrder: ({ payload }) => Ok(undefined).toAsync(),
    *   },
    *   urls: ['amqp://localhost'],
    * });
@@ -721,7 +721,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
   /**
    * 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 `ok(undefined).toAsync()`.
+   * resolves to `Ok(undefined).toAsync()`.
    */
   private publishReplyIfRpc;
   /**
@@ -733,7 +733,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    * 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
@@ -774,7 +774,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
  * @example Consumer handler
  * ```typescript
  * import { defineHandler, RetryableError, NonRetryableError } from '@amqp-contract/worker';
- * import { fromPromise, ok } from 'unthrown';
+ * import { fromPromise, Ok } from 'unthrown';
  *
  * const processOrderHandler = defineHandler(
  *   orderContract,
@@ -792,7 +792,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
  * const calculateHandler = defineHandler(
  *   rpcContract,
  *   'calculate',
- *   ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
+ *   ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
  * );
  * ```
  */
@@ -819,7 +819,7 @@ declare function defineHandler<TContract extends ContractDefinition, TName exten
  * @example
  * ```typescript
  * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
- * import { fromPromise, ok } from 'unthrown';
+ * import { fromPromise, Ok } from 'unthrown';
  *
  * const handlers = defineHandlers(orderContract, {
  *   processOrder: ({ payload }) =>
@@ -827,7 +827,7 @@ declare function defineHandler<TContract extends ContractDefinition, TName exten
  *       processPayment(payload),
  *       (error) => new RetryableError('Payment failed', error),
  *     ).map(() => undefined),
- *   calculate: ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
+ *   calculate: ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
  * });
  * ```
  */

package/dist/index.d.mts

@@ -333,17 +333,17 @@ declare function retryable(message: string, cause?: unknown): RetryableError;
  * @example
  * ```typescript
  * import { nonRetryable } from '@amqp-contract/worker';
- * import { err, ok } from 'unthrown';
+ * import { Err, Ok } from 'unthrown';
  *
  * const handler = ({ payload }) => {
  *   if (!isValidPayload(payload)) {
- *     return err(nonRetryable('Invalid payload format')).toAsync();
+ *     return Err(nonRetryable('Invalid payload format')).toAsync();
  *   }
- *   return ok(undefined).toAsync();
+ *   return Ok(undefined).toAsync();
  * };
  *
  * // Equivalent to:
- * // return err(new NonRetryableError('Invalid payload format')).toAsync();
+ * // return Err(new NonRetryableError('Invalid payload format')).toAsync();
  * ```
  */
 declare function nonRetryable(message: string, cause?: unknown): NonRetryableError;
@@ -412,7 +412,7 @@ type WorkerInferRpcResponse<TContract extends ContractDefinition, TName extends
  *   console.log(message.payload.orderId);  // Typed payload
  *   console.log(message.headers?.priority); // Typed headers (if defined)
  *   console.log(rawMessage.fields.deliveryTag); // Raw AMQP message
- *   return ok(undefined).toAsync();
+ *   return Ok(undefined).toAsync();
  * });
  * ```
  */
@@ -463,7 +463,7 @@ type WorkerInferRpcHandlerEntry<TContract extends ContractDefinition, TName exte
  *       processPayment(payload),
  *       (error) => new RetryableError('Payment failed', error),
  *     ).map(() => undefined),
- *   calculate: ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
+ *   calculate: ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
  * };
  * ```
  */
@@ -484,13 +484,13 @@ type ConsumerOptions = ConsumerOptions$1;
  *     // Simple handler
  *     processOrder: ({ payload }) => {
  *       console.log('Processing order:', payload.orderId);
- *       return ok(undefined).toAsync();
+ *       return Ok(undefined).toAsync();
  *     },
  *     // Handler with prefetch configuration
  *     processPayment: [
  *       ({ payload }) => {
  *         console.log('Processing payment:', payload.paymentId);
- *         return ok(undefined).toAsync();
+ *         return Ok(undefined).toAsync();
  *       },
  *       { prefetch: 10 }
  *     ]
@@ -538,7 +538,7 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
   defaultConsumerOptions?: ConsumerOptions | undefined;
   /**
    * Maximum time in ms to wait for the AMQP connection to become ready before
-   * `create()` resolves to an `err(TechnicalError)`. Defaults to 30s
+   * `create()` resolves to an `Err(TechnicalError)`. Defaults to 30s
    * (the {@link AmqpClient}'s `DEFAULT_CONNECT_TIMEOUT_MS`). Pass `null` to
    * disable the timeout and let amqp-connection-manager retry indefinitely.
    */
@@ -556,7 +556,7 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
  * ```typescript
  * import { TypedAmqpWorker } from '@amqp-contract/worker';
  * import { defineQueue, defineMessage, defineContract, defineConsumer } from '@amqp-contract/contract';
- * import { ok } from 'unthrown';
+ * import { Ok } from 'unthrown';
  * import { z } from 'zod';
  *
  * const orderQueue = defineQueue('order-processing');
@@ -576,7 +576,7 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
  *   handlers: {
  *     processOrder: ({ payload }) => {
  *       console.log('Processing order', payload.orderId);
- *       return ok(undefined).toAsync();
+ *       return Ok(undefined).toAsync();
  *     },
  *   },
  *   urls: ['amqp://localhost'],
@@ -630,7 +630,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    * const result = await TypedAmqpWorker.create({
    *   contract: myContract,
    *   handlers: {
-   *     processOrder: ({ payload }) => ok(undefined).toAsync(),
+   *     processOrder: ({ payload }) => Ok(undefined).toAsync(),
    *   },
    *   urls: ['amqp://localhost'],
    * });
@@ -721,7 +721,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
   /**
    * 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 `ok(undefined).toAsync()`.
+   * resolves to `Ok(undefined).toAsync()`.
    */
   private publishReplyIfRpc;
   /**
@@ -733,7 +733,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    * 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
@@ -774,7 +774,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
  * @example Consumer handler
  * ```typescript
  * import { defineHandler, RetryableError, NonRetryableError } from '@amqp-contract/worker';
- * import { fromPromise, ok } from 'unthrown';
+ * import { fromPromise, Ok } from 'unthrown';
  *
  * const processOrderHandler = defineHandler(
  *   orderContract,
@@ -792,7 +792,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
  * const calculateHandler = defineHandler(
  *   rpcContract,
  *   'calculate',
- *   ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
+ *   ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
  * );
  * ```
  */
@@ -819,7 +819,7 @@ declare function defineHandler<TContract extends ContractDefinition, TName exten
  * @example
  * ```typescript
  * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
- * import { fromPromise, ok } from 'unthrown';
+ * import { fromPromise, Ok } from 'unthrown';
  *
  * const handlers = defineHandlers(orderContract, {
  *   processOrder: ({ payload }) =>
@@ -827,7 +827,7 @@ declare function defineHandler<TContract extends ContractDefinition, TName exten
  *       processPayment(payload),
  *       (error) => new RetryableError('Payment failed', error),
  *     ).map(() => undefined),
- *   calculate: ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
+ *   calculate: ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
  * });
  * ```
  */