@amqp-contract/worker 0.24.0 → 1.0.0

package/dist/index.d.mts

@@ -1,14 +1,148 @@
 import { ConsumerDefinition, ConsumerEntry, ContractDefinition, InferConsumerNames, InferRpcNames, MessageDefinition, RpcDefinition } from "@amqp-contract/contract";
 import { ConsumerOptions as ConsumerOptions$1, Logger, MessageValidationError, TechnicalError, TelemetryProvider } from "@amqp-contract/core";
-import { ResultAsync } from "neverthrow";
-import * as amqp from "amqplib";
-import { ConsumeMessage } from "amqplib";
-import { TcpSocketConnectOpts } from "net";
+import { AsyncResult } from "unthrown";
 import { ConnectionOptions } from "tls";
+import { TcpSocketConnectOpts } from "net";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region ../../node_modules/.pnpm/amqp-connection-manager@5.0.0_amqplib@0.10.9/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts
-type ConnectionUrl = string | amqp.Options.Connect | {
+//#region ../../node_modules/.pnpm/amqplib@2.0.1/node_modules/amqplib/lib/properties.d.ts
+declare namespace Options {
+  interface Connect {
+    protocol?: string;
+    hostname?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    locale?: string;
+    frameMax?: number;
+    heartbeat?: number;
+    vhost?: string;
+    channelMax?: number;
+    credentials?: {
+      mechanism: string;
+      response(): Buffer;
+      username?: string;
+      password?: string;
+    };
+  }
+  interface AssertQueue {
+    exclusive?: boolean;
+    durable?: boolean;
+    autoDelete?: boolean;
+    arguments?: any;
+    messageTtl?: number;
+    expires?: number;
+    deadLetterExchange?: string;
+    deadLetterRoutingKey?: string;
+    maxLength?: number;
+    maxPriority?: number;
+    overflow?: string;
+    queueMode?: string;
+  }
+  interface DeleteQueue {
+    ifUnused?: boolean;
+    ifEmpty?: boolean;
+  }
+  interface AssertExchange {
+    durable?: boolean;
+    internal?: boolean;
+    autoDelete?: boolean;
+    alternateExchange?: string;
+    arguments?: any;
+  }
+  interface DeleteExchange {
+    ifUnused?: boolean;
+  }
+  interface Publish {
+    expiration?: string | number;
+    userId?: string;
+    CC?: string | string[];
+    mandatory?: boolean;
+    persistent?: boolean;
+    deliveryMode?: boolean | number;
+    BCC?: string | string[];
+    contentType?: string;
+    contentEncoding?: string;
+    headers?: any;
+    priority?: number;
+    correlationId?: string;
+    replyTo?: string;
+    messageId?: string;
+    timestamp?: number;
+    type?: string;
+    appId?: string;
+  }
+  interface Consume {
+    consumerTag?: string;
+    noLocal?: boolean;
+    noAck?: boolean;
+    exclusive?: boolean;
+    priority?: number;
+    arguments?: any;
+  }
+  interface Get {
+    noAck?: boolean;
+  }
+}
+interface Message {
+  content: Buffer;
+  fields: MessageFields;
+  properties: MessageProperties;
+}
+interface ConsumeMessage extends Message {
+  fields: ConsumeMessageFields;
+}
+interface CommonMessageFields {
+  deliveryTag: number;
+  redelivered: boolean;
+  exchange: string;
+  routingKey: string;
+}
+interface MessageFields extends CommonMessageFields {
+  messageCount?: number;
+  consumerTag?: string;
+}
+interface ConsumeMessageFields extends CommonMessageFields {
+  consumerTag: string;
+}
+interface MessageProperties {
+  contentType: any | undefined;
+  contentEncoding: any | undefined;
+  headers: MessagePropertyHeaders | undefined;
+  deliveryMode: any | undefined;
+  priority: any | undefined;
+  correlationId: any | undefined;
+  replyTo: any | undefined;
+  expiration: any | undefined;
+  messageId: any | undefined;
+  timestamp: any | undefined;
+  type: any | undefined;
+  userId: any | undefined;
+  appId: any | undefined;
+  clusterId: any | undefined;
+}
+interface MessagePropertyHeaders {
+  'x-first-death-exchange'?: string;
+  'x-first-death-queue'?: string;
+  'x-first-death-reason'?: string;
+  'x-death'?: XDeath[];
+  [key: string]: any;
+}
+interface XDeath {
+  count: number;
+  reason: 'rejected' | 'expired' | 'maxlen';
+  queue: string;
+  time: {
+    '!': 'timestamp';
+    value: number;
+  };
+  exchange: string;
+  'original-expiration'?: any;
+  'routing-keys': string[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/amqp-connection-manager@5.0.0_amqplib@2.0.1/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts
+type ConnectionUrl = string | Options.Connect | {
   url: string;
   connectionOptions?: AmqpConnectionOptions;
 };
@@ -49,31 +183,50 @@ interface AmqpConnectionManagerOptions {
 }
 //#endregion
 //#region src/errors.d.ts
+declare const RetryableError_base: import("unthrown").TaggedErrorConstructor<"@amqp-contract/RetryableError">;
 /**
  * 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"`).
  */
-declare class RetryableError extends Error {
-  readonly cause?: unknown | undefined;
-  constructor(message: string, cause?: unknown | undefined);
+declare class RetryableError extends RetryableError_base<{
+  message: string;
+  cause?: unknown;
+}> {
+  constructor(message: string, cause?: unknown);
 }
+declare const NonRetryableError_base: import("unthrown").TaggedErrorConstructor<"@amqp-contract/NonRetryableError">;
 /**
  * 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"`).
  */
-declare class NonRetryableError extends Error {
-  readonly cause?: unknown | undefined;
-  constructor(message: string, cause?: unknown | undefined);
+declare class NonRetryableError extends NonRetryableError_base<{
+  message: string;
+  cause?: unknown;
+}> {
+  constructor(message: string, cause?: unknown);
 }
 /**
- * Union type representing all handler errors.
- * Use this type when defining handlers that explicitly signal error outcomes.
+ * Any handler-signalled error — the union a handler may put in the `Err`
+ * channel of its `AsyncResult`. Discriminate on `_tag`
+ * (`"@amqp-contract/RetryableError"` / `"@amqp-contract/NonRetryableError"`),
+ * e.g. with `matchTags`.
+ *
+ * Previously an abstract base class; now a tagged union, because unthrown's
+ * `TaggedError` mints a distinct base class per tag. Use {@link isHandlerError}
+ * for runtime narrowing instead of `instanceof HandlerError`.
  */
 type HandlerError = RetryableError | NonRetryableError;
 /**
@@ -154,16 +307,16 @@ declare function isHandlerError(error: unknown): error is HandlerError;
  * @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))
  * ```
  */
 declare function retryable(message: string, cause?: unknown): RetryableError;
@@ -180,17 +333,17 @@ declare function retryable(message: string, cause?: unknown): RetryableError;
  * @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();
  * ```
  */
 declare function nonRetryable(message: string, cause?: unknown): NonRetryableError;
@@ -241,7 +394,7 @@ type WorkerInferRpcRequest<TContract extends ContractDefinition, TName extends I
 type WorkerInferRpcHeaders<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpc<TContract, TName> extends RpcDefinition<infer TRequest, MessageDefinition> ? TRequest extends MessageDefinition<infer _TPayload, infer THeaders> ? THeaders extends StandardSchemaV1<Record<string, unknown>> ? InferSchemaOutput<THeaders> : undefined : undefined : undefined;
 /**
  * Infer the response payload type for an RPC. The handler must return a
- * `ResultAsync<TResponse, HandlerError>` matching this shape.
+ * `AsyncResult<TResponse, HandlerError>` matching this shape.
  */
 type WorkerInferRpcResponse<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpc<TContract, TName> extends RpcDefinition<MessageDefinition, infer TResponse> ? TResponse extends MessageDefinition ? InferSchemaOutput<TResponse["payload"]> : never : never;
 /**
@@ -259,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 okAsync(undefined);
+ *   return ok(undefined).toAsync();
  * });
  * ```
  */
@@ -278,17 +431,17 @@ type WorkerInferConsumedMessage<TContract extends ContractDefinition, TName exte
 type WorkerInferRpcConsumedMessage<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = WorkerConsumedMessage<WorkerInferRpcRequest<TContract, TName>, WorkerInferRpcHeaders<TContract, TName>>;
 /**
  * Handler signature for a regular consumer (event/command). Returns
- * `ResultAsync<void, HandlerError>` — there is no response message.
+ * `AsyncResult<void, HandlerError>` — there is no response message.
  */
-type WorkerInferConsumerHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = (message: WorkerInferConsumedMessage<TContract, TName>, rawMessage: ConsumeMessage) => ResultAsync<void, HandlerError>;
+type WorkerInferConsumerHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = (message: WorkerInferConsumedMessage<TContract, TName>, rawMessage: ConsumeMessage) => AsyncResult<void, HandlerError>;
 /**
  * Handler signature for an RPC. Returns
- * `ResultAsync<TResponse, HandlerError>` where `TResponse` is the inferred
+ * `AsyncResult<TResponse, HandlerError>` where `TResponse` is the inferred
  * response payload. The worker validates the response against the RPC's
  * response schema and publishes it back to `msg.properties.replyTo` with the
  * same `correlationId`.
  */
-type WorkerInferRpcHandler<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = (message: WorkerInferRpcConsumedMessage<TContract, TName>, rawMessage: ConsumeMessage) => ResultAsync<WorkerInferRpcResponse<TContract, TName>, HandlerError>;
+type WorkerInferRpcHandler<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = (message: WorkerInferRpcConsumedMessage<TContract, TName>, rawMessage: ConsumeMessage) => AsyncResult<WorkerInferRpcResponse<TContract, TName>, HandlerError>;
 /**
  * Handler entry for a regular consumer — function or `[handler, options]`.
  */
@@ -306,19 +459,15 @@ type WorkerInferRpcHandlerEntry<TContract extends ContractDefinition, TName exte
  * ```typescript
  * const handlers: WorkerInferHandlers<typeof contract> = {
  *   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(),
  * };
  * ```
  */
 type WorkerInferHandlers<TContract extends ContractDefinition> = ([InferConsumerNames<TContract>] extends [never] ? {} : { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandlerEntry<TContract, K> }) & ([InferRpcNames<TContract>] extends [never] ? {} : { [K in InferRpcNames<TContract>]: WorkerInferRpcHandlerEntry<TContract, K> });
-/**
- * @deprecated Use `WorkerInferHandlers` — handlers now span consumers ∪ rpcs.
- */
-type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = WorkerInferHandlers<TContract>;
 //#endregion
 //#region src/worker.d.ts
 type ConsumerOptions = ConsumerOptions$1;
@@ -335,13 +484,13 @@ type ConsumerOptions = ConsumerOptions$1;
  *     // Simple handler
  *     processOrder: ({ payload }) => {
  *       console.log('Processing order:', payload.orderId);
- *       return okAsync(undefined);
+ *       return ok(undefined).toAsync();
  *     },
  *     // Handler with prefetch configuration
  *     processPayment: [
  *       ({ payload }) => {
  *         console.log('Processing payment:', payload.paymentId);
- *         return okAsync(undefined);
+ *         return ok(undefined).toAsync();
  *       },
  *       { prefetch: 10 }
  *     ]
@@ -365,8 +514,8 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
   /**
    * Handlers for each `consumers` and `rpcs` entry in the contract.
    *
-   * - Regular consumers return `ResultAsync<void, HandlerError>`.
-   * - RPC handlers return `ResultAsync<TResponse, HandlerError>` where
+   * - Regular consumers return `AsyncResult<void, HandlerError>`.
+   * - RPC handlers return `AsyncResult<TResponse, HandlerError>` where
    *   `TResponse` is inferred from the RPC's response message schema.
    *
    * Use `defineHandler` / `defineHandlers` to create handlers with full type
@@ -407,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 { okAsync } from 'neverthrow';
+ * import { ok } from 'unthrown';
  * import { z } from 'zod';
  *
  * const orderQueue = defineQueue('order-processing');
@@ -427,14 +576,13 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
  *   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();
@@ -475,14 +623,14 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    * 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'],
    * });
@@ -497,7 +645,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
     logger,
     telemetry,
     connectTimeoutMs
-  }: CreateWorkerOptions<TContract>): ResultAsync<TypedAmqpWorker<TContract>, TechnicalError>;
+  }: CreateWorkerOptions<TContract>): AsyncResult<TypedAmqpWorker<TContract>, TechnicalError>;
   /**
    * Close the AMQP channel and connection.
    *
@@ -512,7 +660,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    * }
    * ```
    */
-  close(): ResultAsync<void, TechnicalError>;
+  close(): AsyncResult<void, TechnicalError>;
   /**
    * Start consuming for every entry in `contract.consumers` and `contract.rpcs`.
    */
@@ -556,9 +704,42 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    *   inbox.
    */
   private publishRpcResponse;
+  /**
+   * Parse and validate the message; on failure, nack(requeue=false) so the
+   * queue's DLX (if configured) receives the poison message and bypass the
+   * retry pipeline — a malformed payload is deterministic and retrying it
+   * would burn the queue's retry budget on a guaranteed failure.
+   */
+  private parseAndValidateOrNack;
+  /**
+   * Invoke the handler and ack the message on success. Returns the handler's
+   * response (RPC) or `undefined` (regular consumer). Errors propagate as
+   * `HandlerError` for downstream RPC reply publishing or routing via
+   * {@link handleError}.
+   */
+  private runHandler;
+  /**
+   * 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()`.
+   */
+  private publishReplyIfRpc;
   /**
    * Process a single consumed message: validate, invoke handler, optionally
-   * publish the RPC response, record telemetry, and handle errors.
+   * publish the RPC response, record telemetry, and route errors.
+   *
+   * The caller-supplied `state` is mutated as the message is ack'd/nack'd so
+   * the consume callback's catch-all guard can tell whether a defensive nack
+   * 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
+   * 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
+   * original `HandlerError`. The terminal `orTee` unwraps the cause before
+   * recording the span exception so traces keep the original
+   * `RetryableError` / `NonRetryableError` class as the exception type.
    */
   private processMessage;
   /**
@@ -569,88 +750,88 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
 //#endregion
 //#region src/handlers.d.ts
 /**
- * Define a type-safe handler for a specific consumer in a contract.
+ * Define a type-safe handler for a specific consumer or RPC in a contract.
  *
- * **Recommended:** This function creates handlers that return `ResultAsync<void, HandlerError>`,
- * providing explicit error handling and better control over retry behavior.
+ * **Recommended:** This function creates handlers that return
+ * `AsyncResult<void, HandlerError>` (consumers) or
+ * `AsyncResult<TResponse, HandlerError>` (RPCs), providing explicit error
+ * handling and better control over retry behavior.
  *
  * Supports two patterns:
  * 1. Simple handler: just the function
- * 2. Handler with options: [handler, { prefetch: 10 }]
+ * 2. Handler with options: `[handler, { prefetch: 10 }]`
  *
  * @template TContract - The contract definition type
- * @template TName - The consumer name from the contract
- * @param contract - The contract definition containing the consumer
- * @param consumerName - The name of the consumer from the contract
- * @param handler - The handler function that returns `ResultAsync<void, HandlerError>`
+ * @template TName - The consumer or RPC name from the contract
+ * @param contract - The contract definition containing the consumer or RPC
+ * @param name - The name of the consumer or RPC from the contract
+ * @param handler - The handler function — for consumers, returns
+ *   `AsyncResult<void, HandlerError>`; for RPCs, returns
+ *   `AsyncResult<TResponse, HandlerError>`.
  * @param options - Optional consumer options (prefetch)
  * @returns A type-safe handler that can be used with TypedAmqpWorker
  *
- * @example
+ * @example Consumer handler
  * ```typescript
  * import { defineHandler, RetryableError, NonRetryableError } from '@amqp-contract/worker';
- * import { errAsync, okAsync, ResultAsync } from 'neverthrow';
- * import { orderContract } from './contract';
+ * import { fromPromise, ok } from 'unthrown';
  *
- * // Simple handler with explicit error handling
  * const processOrderHandler = defineHandler(
  *   orderContract,
  *   'processOrder',
  *   ({ payload }) =>
- *     ResultAsync.fromPromise(
+ *     fromPromise(
  *       processPayment(payload),
  *       (error) => new RetryableError('Payment failed', error),
  *     ).map(() => undefined),
  * );
+ * ```
  *
- * // Handler with validation (non-retryable error)
- * const validateOrderHandler = defineHandler(
- *   orderContract,
- *   'validateOrder',
- *   ({ payload }) => {
- *     if (payload.amount < 1) {
- *       // Won't be retried - goes directly to DLQ
- *       return errAsync(new NonRetryableError('Invalid order amount'));
- *     }
- *     return okAsync(undefined);
- *   },
+ * @example RPC handler
+ * ```typescript
+ * const calculateHandler = defineHandler(
+ *   rpcContract,
+ *   'calculate',
+ *   ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
  * );
  * ```
  */
-declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>): WorkerInferConsumerHandlerEntry<TContract, TName>;
-declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>, options: ConsumerOptions): WorkerInferConsumerHandlerEntry<TContract, TName>;
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, name: TName, handler: WorkerInferConsumerHandler<TContract, TName>): WorkerInferConsumerHandlerEntry<TContract, TName>;
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, name: TName, handler: WorkerInferConsumerHandler<TContract, TName>, options: ConsumerOptions): WorkerInferConsumerHandlerEntry<TContract, TName>;
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>>(contract: TContract, name: TName, handler: WorkerInferRpcHandler<TContract, TName>): WorkerInferRpcHandlerEntry<TContract, TName>;
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>>(contract: TContract, name: TName, handler: WorkerInferRpcHandler<TContract, TName>, options: ConsumerOptions): WorkerInferRpcHandlerEntry<TContract, TName>;
 /**
- * Define multiple type-safe handlers for consumers in a contract.
+ * Define multiple type-safe handlers for consumers and RPCs in a contract.
+ *
+ * **Recommended:** This function creates handlers that return
+ * `AsyncResult<void, HandlerError>` (consumers) or
+ * `AsyncResult<TResponse, HandlerError>` (RPCs), providing explicit error
+ * handling and better control over retry behavior.
  *
- * **Recommended:** This function creates handlers that return `ResultAsync<void, HandlerError>`,
- * providing explicit error handling and better control over retry behavior.
+ * The handlers object must contain exactly one entry per `consumers` and
+ * `rpcs` key in the contract — see {@link WorkerInferHandlers}.
  *
  * @template TContract - The contract definition type
- * @param contract - The contract definition containing the consumers
- * @param handlers - An object with handler functions for each consumer
+ * @param contract - The contract definition containing the consumers and RPCs
+ * @param handlers - An object with handler functions for each consumer and RPC
  * @returns A type-safe handlers object that can be used with TypedAmqpWorker
  *
  * @example
  * ```typescript
  * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
- * import { ResultAsync } from 'neverthrow';
- * import { orderContract } from './contract';
+ * import { fromPromise, ok } from 'unthrown';
  *
  * const handlers = defineHandlers(orderContract, {
  *   processOrder: ({ payload }) =>
- *     ResultAsync.fromPromise(
+ *     fromPromise(
  *       processPayment(payload),
  *       (error) => new RetryableError('Payment failed', error),
  *     ).map(() => undefined),
- *   notifyOrder: ({ payload }) =>
- *     ResultAsync.fromPromise(
- *       sendNotification(payload),
- *       (error) => new RetryableError('Notification failed', error),
- *     ).map(() => undefined),
+ *   calculate: ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
  * });
  * ```
  */
-declare function defineHandlers<TContract extends ContractDefinition>(contract: TContract, handlers: WorkerInferConsumerHandlers<TContract>): WorkerInferConsumerHandlers<TContract>;
+declare function defineHandlers<TContract extends ContractDefinition>(contract: TContract, handlers: WorkerInferHandlers<TContract>): WorkerInferHandlers<TContract>;
 //#endregion
-export { type ConsumerOptions, type CreateWorkerOptions, type HandlerError, MessageValidationError, NonRetryableError, RetryableError, TypedAmqpWorker, type WorkerConsumedMessage, type WorkerInferConsumedMessage, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlerEntry, type WorkerInferConsumerHandlers, type WorkerInferConsumerHeaders, defineHandler, defineHandlers, isHandlerError, isNonRetryableError, isRetryableError, nonRetryable, retryable };
+export { type ConsumerOptions, type CreateWorkerOptions, type HandlerError, MessageValidationError, NonRetryableError, RetryableError, TypedAmqpWorker, type WorkerConsumedMessage, type WorkerInferConsumedMessage, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlerEntry, type WorkerInferConsumerHeaders, type WorkerInferHandlers, type WorkerInferRpcConsumedMessage, type WorkerInferRpcHandler, type WorkerInferRpcHandlerEntry, type WorkerInferRpcHeaders, type WorkerInferRpcRequest, type WorkerInferRpcResponse, defineHandler, defineHandlers, isHandlerError, isNonRetryableError, isRetryableError, nonRetryable, retryable };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":["amqp","EventEmitter","TcpSocketConnectOpts","ConnectionOptions","ChannelWrapper","CreateChannelOpts","ConnectionUrl","Options","Connect","AmqpConnectionOptions","url","connectionOptions","ConnectListener","Connection","connection","arg","ConnectFailedListener","Error","err","Buffer","noDelay","timeout","keepAlive","keepAliveDelay","clientProperties","credentials","mechanism","username","password","response","AmqpConnectionManagerOptions","Promise","heartbeatIntervalInSeconds","reconnectTimeInSeconds","findServers","urls","callback","IAmqpConnectionManager","Function","ChannelModel","addListener","event","args","listener","reason","listeners","eventName","on","once","prependListener","prependOnceListener","removeListener","connect","options","reconnect","createChannel","close","isConnected","channelCount","AmqpConnectionManager","_channels","_currentUrl","_closed","_cancelRetriesHandler","_connectPromise","_currentConnection","_findServers","_urls","constructor","_connect","default"],"sources":["../../../node_modules/.pnpm/amqp-connection-manager@5.0.0_amqplib@0.10.9/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts","../src/errors.ts","../src/types.ts","../src/worker.ts","../src/handlers.ts"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":["Empty","AssertQueue","queue","messageCount","consumerCount","PurgeQueue","DeleteQueue","AssertExchange","exchange","Consume","consumerTag","Connect","protocol","hostname","port","username","password","locale","frameMax","heartbeat","vhost","channelMax","credentials","mechanism","response","Buffer","exclusive","durable","autoDelete","arguments","messageTtl","expires","deadLetterExchange","deadLetterRoutingKey","maxLength","maxPriority","overflow","queueMode","ifUnused","ifEmpty","internal","alternateExchange","DeleteExchange","Publish","expiration","userId","CC","mandatory","persistent","deliveryMode","BCC","contentType","contentEncoding","headers","priority","correlationId","replyTo","messageId","timestamp","type","appId","noLocal","noAck","Get","tls","ConnectionOptions","noDelay","timeout","keepAlive","keepAliveDelay","clientProperties","Record","highWaterMark","content","fields","MessageFields","properties","MessageProperties","Message","GetMessageFields","ConsumeMessageFields","deliveryTag","redelivered","routingKey","CommonMessageFields","MessagePropertyHeaders","clusterId","XDeath","key","count","reason","time","value","host","product","version","platform","copyright","information","amqp","Options","Connect","url","connectionOptions","AmqpConnectionOptions","connection","Connection","arg","err","Error","ConnectionOptions","TcpSocketConnectOpts","noDelay","timeout","keepAlive","keepAliveDelay","clientProperties","credentials","mechanism","username","password","response","Buffer","heartbeatIntervalInSeconds","reconnectTimeInSeconds","findServers","ConnectionUrl","urls","callback","Promise","EventEmitter","addListener","event","args","listener","ConnectListener","ConnectFailedListener","reason","listeners","eventName","Function","on","once","prependListener","prependOnceListener","removeListener","connect","options","reconnect","createChannel","CreateChannelOpts","ChannelWrapper","close","isConnected","ChannelModel","channelCount","IAmqpConnectionManager","_channels","_currentUrl","_closed","_cancelRetriesHandler","_connectPromise","_currentConnection","_findServers","_urls","constructor","AmqpConnectionManagerOptions","_connect"],"sources":["../../../node_modules/.pnpm/amqplib@2.0.1/node_modules/amqplib/lib/properties.d.ts","../../../node_modules/.pnpm/amqp-connection-manager@5.0.0_amqplib@2.0.1/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts","../src/errors.ts","../src/types.ts","../src/worker.ts","../src/handlers.ts"],"x_google_ignoreList":[0,1],"mappings":"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"}