@amqp-contract/client 0.25.0 → 2.0.0

package/README.md

@@ -2,13 +2,13 @@
 
 **Type-safe AMQP client for publishing messages using amqp-contract with explicit error handling via `Result` types.**
 
-[![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/client.svg?logo=npm)](https://www.npmjs.com/package/@amqp-contract/client)
 [![npm downloads](https://img.shields.io/npm/dm/@amqp-contract/client.svg)](https://www.npmjs.com/package/@amqp-contract/client)
 [![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/client)**
+📖 **[Full documentation →](https://btravstack.github.io/amqp-contract/api/client)**
 
 ## Installation
 
@@ -28,17 +28,20 @@ const client = (
     contract,
     urls: ["amqp://localhost"],
   })
-)._unsafeUnwrap();
+).unwrap();
 
 // Publish message with explicit error handling
 const result = await client.publish("orderCreated", {
   orderId: "ORD-123",
   amount: 99.99,
 });
-result.match(
-  () => console.log("Published successfully"),
-  (error) => console.error("Publish failed:", error),
-);
+result.match({
+  ok: () => console.log("Published successfully"),
+  err: (error) => console.error("Publish failed:", error),
+  defect: (cause) => {
+    throw cause;
+  },
+});
 
 // Clean up
 await client.close();
@@ -46,7 +49,7 @@ await client.close();
 
 ## Error Handling
 
-The client uses `Result` types from [neverthrow](https://github.com/supermacro/neverthrow) for explicit error handling. Runtime errors are part of the type signature:
+The client uses `Result` types from [unthrown](https://github.com/btravstack/unthrown) for explicit error handling. Runtime errors are part of the type signature:
 
 ```typescript
 publish(): Result<boolean, TechnicalError | MessageValidationError>
@@ -61,11 +64,11 @@ publish(): Result<boolean, TechnicalError | MessageValidationError>
 
 ## API
 
-For complete API documentation, see the [Client API Reference](https://btravers.github.io/amqp-contract/api/client).
+For complete API documentation, see the [Client API Reference](https://btravstack.github.io/amqp-contract/api/client).
 
 ## 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_crypto = require("node:crypto");
 let node_zlib = require("node:zlib");
 let node_util = require("node:util");
@@ -14,50 +14,47 @@ const deflateAsync = (0, node_util.promisify)(node_zlib.deflate);
 *
 * @param buffer - The buffer to compress
 * @param algorithm - The compression algorithm to use
-* @returns A ResultAsync resolving to the compressed buffer or a TechnicalError
+* @returns An AsyncResult resolving to the compressed buffer or a TechnicalError
 *
 * @internal
 */
 function compressBuffer(buffer, algorithm) {
-	return (0, ts_pattern.match)(algorithm).with("gzip", () => neverthrow.ResultAsync.fromPromise(gzipAsync(buffer), (error) => new _amqp_contract_core.TechnicalError("Failed to compress with gzip", error))).with("deflate", () => neverthrow.ResultAsync.fromPromise(deflateAsync(buffer), (error) => new _amqp_contract_core.TechnicalError("Failed to compress with deflate", error))).exhaustive();
+	return (0, ts_pattern.match)(algorithm).with("gzip", () => (0, unthrown.fromPromise)(gzipAsync(buffer), (error) => new _amqp_contract_core.TechnicalError("Failed to compress with gzip", error))).with("deflate", () => (0, unthrown.fromPromise)(deflateAsync(buffer), (error) => new _amqp_contract_core.TechnicalError("Failed to compress with deflate", error))).exhaustive();
 }
 //#endregion
 //#region src/errors.ts
 /**
-* Captured `Error.captureStackTrace` shim — only present on Node.js.
-*/
-function captureStack(target, ctor) {
-	const ErrorConstructor = Error;
-	if (typeof ErrorConstructor.captureStackTrace === "function") ErrorConstructor.captureStackTrace(target, ctor);
-}
-/**
 * Returned from `TypedAmqpClient.call()` when the configured `timeoutMs` elapses
 * before the RPC server publishes a reply with the matching `correlationId`.
 *
 * The pending call is removed from the in-memory correlation map; if a reply
 * arrives after the timeout it is dropped (and a debug log is emitted by the
-* client if a logger is configured).
+* client if a logger is configured). Carries a namespaced `_tag` of
+* `"@amqp-contract/RpcTimeoutError"`; the `Error.name` is kept bare
+* (`"RpcTimeoutError"`).
 */
-var RpcTimeoutError = class extends Error {
+var RpcTimeoutError = class extends (0, unthrown.TaggedError)("@amqp-contract/RpcTimeoutError", { name: "RpcTimeoutError" }) {
 	constructor(rpcName, timeoutMs) {
-		super(`RPC call to "${rpcName}" timed out after ${timeoutMs}ms with no reply received`);
-		this.rpcName = rpcName;
-		this.timeoutMs = timeoutMs;
-		this.name = "RpcTimeoutError";
-		captureStack(this, this.constructor);
+		super({
+			message: `RPC call to "${rpcName}" timed out after ${timeoutMs}ms with no reply received`,
+			rpcName,
+			timeoutMs
+		});
 	}
 };
 /**
 * Returned from any in-flight RPC call when the client is closed before the
 * reply is received. The correlation map is cleared on close and every pending
-* caller's promise resolves with `err(RpcCancelledError)`.
+* caller's promise resolves with `Err(RpcCancelledError)`. Carries a namespaced
+* `_tag` of `"@amqp-contract/RpcCancelledError"`; the `Error.name` is kept bare
+* (`"RpcCancelledError"`).
 */
-var RpcCancelledError = class extends Error {
+var RpcCancelledError = class extends (0, unthrown.TaggedError)("@amqp-contract/RpcCancelledError", { name: "RpcCancelledError" }) {
 	constructor(rpcName) {
-		super(`RPC call to "${rpcName}" was cancelled because the client was closed`);
-		this.rpcName = rpcName;
-		this.name = "RpcCancelledError";
-		captureStack(this, this.constructor);
+		super({
+			message: `RPC call to "${rpcName}" was cancelled because the client was closed`,
+			rpcName
+		});
 	}
 };
 //#endregion
@@ -75,6 +72,11 @@ const DIRECT_REPLY_TO = "amq.rabbitmq.reply-to";
 * Type-safe AMQP client for publishing messages
 */
 var TypedAmqpClient = class TypedAmqpClient {
+	contract;
+	amqpClient;
+	defaultPublishOptions;
+	logger;
+	telemetry;
 	/**
 	* In-flight RPC calls keyed by `correlationId`. Cleared when a reply is
 	* received, when the call times out, or when the client is closed.
@@ -111,14 +113,15 @@ var TypedAmqpClient = class TypedAmqpClient {
 			persistent: true,
 			...defaultPublishOptions
 		}, logger, telemetry ?? _amqp_contract_core.defaultTelemetryProvider);
-		const setup = client.waitForConnectionReady().andThen(() => client.setupReplyConsumerIfNeeded());
-		return new neverthrow.ResultAsync((async () => {
+		const setup = client.waitForConnectionReady().flatMap(() => client.setupReplyConsumerIfNeeded());
+		return (0, unthrown.fromSafePromise)((async () => {
 			const setupResult = await setup;
-			if (setupResult.isOk()) return (0, neverthrow.ok)(client);
-			const closeResult = await client.close();
-			if (closeResult.isErr()) logger?.warn("Failed to close client after connection failure", { error: closeResult.error });
-			return (0, neverthrow.err)(setupResult.error);
-		})());
+			if (!setupResult.isOk()) {
+				const closeResult = await client.close();
+				if (closeResult.isErr()) logger?.warn("Failed to close client after connection failure", { error: closeResult.error });
+			}
+			return setupResult.map(() => client);
+		})()).flatMap((result) => result);
 	}
 	/**
 	* If the contract has any RPC entry, subscribe to `amq.rabbitmq.reply-to`
@@ -127,8 +130,8 @@ var TypedAmqpClient = class TypedAmqpClient {
 	*/
 	setupReplyConsumerIfNeeded() {
 		const rpcs = this.contract.rpcs ?? {};
-		if (Object.keys(rpcs).length === 0) return (0, neverthrow.okAsync)(void 0);
-		return this.amqpClient.consume(DIRECT_REPLY_TO, (msg) => this.handleRpcReply(msg), { noAck: true }).andTee((tag) => {
+		if (Object.keys(rpcs).length === 0) return (0, unthrown.Ok)(void 0).toAsync();
+		return this.amqpClient.consume(DIRECT_REPLY_TO, (msg) => this.handleRpcReply(msg), { noAck: true }).tap((tag) => {
 			this.replyConsumerTag = tag;
 		}).map(() => void 0);
 	}
@@ -158,8 +161,8 @@ var TypedAmqpClient = class TypedAmqpClient {
 		this.pendingCalls.delete(correlationId);
 		clearTimeout(pending.timer);
 		const parseResult = (0, _amqp_contract_core.safeJsonParse)(msg.content, (error) => new _amqp_contract_core.TechnicalError(`Failed to parse RPC reply JSON for "${pending.rpcName}"`, error));
-		if (parseResult.isErr()) {
-			pending.resolve((0, neverthrow.err)(parseResult.error));
+		if (!parseResult.isOk()) {
+			pending.resolve((0, unthrown.Err)(parseResult.isErr() ? parseResult.error : new _amqp_contract_core.TechnicalError(`Failed to parse RPC reply JSON for "${pending.rpcName}"`, parseResult.cause)));
 			return;
 		}
 		const parsed = parseResult.value;
@@ -167,17 +170,17 @@ var TypedAmqpClient = class TypedAmqpClient {
 		try {
 			rawValidation = pending.responseSchema["~standard"].validate(parsed);
 		} catch (error) {
-			pending.resolve((0, neverthrow.err)(new _amqp_contract_core.TechnicalError(`RPC reply validation threw for "${pending.rpcName}"`, error)));
+			pending.resolve((0, unthrown.Err)(new _amqp_contract_core.TechnicalError(`RPC reply validation threw for "${pending.rpcName}"`, error)));
 			return;
 		}
 		(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation)).then((validation) => {
 			if (validation.issues) {
-				pending.resolve((0, neverthrow.err)(new _amqp_contract_core.MessageValidationError(pending.rpcName, validation.issues)));
+				pending.resolve((0, unthrown.Err)(new _amqp_contract_core.MessageValidationError(pending.rpcName, validation.issues)));
 				return;
 			}
-			pending.resolve((0, neverthrow.ok)(validation.value));
+			pending.resolve((0, unthrown.Ok)(validation.value));
 		}, (error) => {
-			pending.resolve((0, neverthrow.err)(new _amqp_contract_core.TechnicalError(`RPC reply validation threw for "${pending.rpcName}"`, error)));
+			pending.resolve((0, unthrown.Err)(new _amqp_contract_core.TechnicalError(`RPC reply validation threw for "${pending.rpcName}"`, error)));
 		});
 	}
 	/**
@@ -199,10 +202,9 @@ var TypedAmqpClient = class TypedAmqpClient {
 		const span = (0, _amqp_contract_core.startPublishSpan)(this.telemetry, exchange.name, routingKey, { [_amqp_contract_core.MessagingSemanticConventions.AMQP_PUBLISHER_NAME]: String(publisherName) });
 		const validateMessage = () => {
 			const validationResult = publisher.message.payload["~standard"].validate(message);
-			const promise = validationResult instanceof Promise ? validationResult : Promise.resolve(validationResult);
-			return neverthrow.ResultAsync.fromPromise(promise, (error) => new _amqp_contract_core.TechnicalError("Validation failed", error)).andThen((validation) => {
-				if (validation.issues) return (0, neverthrow.err)(new _amqp_contract_core.MessageValidationError(String(publisherName), validation.issues));
-				return (0, neverthrow.ok)(validation.value);
+			return (0, unthrown.fromPromise)(validationResult instanceof Promise ? validationResult : Promise.resolve(validationResult), (error) => new _amqp_contract_core.TechnicalError("Validation failed", error)).flatMap((validation) => {
+				if (validation.issues) return (0, unthrown.Err)(new _amqp_contract_core.MessageValidationError(String(publisherName), validation.issues));
+				return (0, unthrown.Ok)(validation.value);
 			});
 		};
 		const publishMessage = (validatedMessage) => {
@@ -217,24 +219,24 @@ var TypedAmqpClient = class TypedAmqpClient {
 					publishOptions.contentEncoding = compression;
 					return compressBuffer(messageBuffer, compression);
 				}
-				return (0, neverthrow.okAsync)(validatedMessage);
+				return (0, unthrown.Ok)(validatedMessage).toAsync();
 			};
-			return preparePayload().andThen((payload) => this.amqpClient.publish(publisher.exchange.name, publisher.routingKey ?? "", payload, publishOptions).andThen((published) => {
-				if (!published) return (0, neverthrow.err)(new _amqp_contract_core.TechnicalError(`Failed to publish message for publisher "${String(publisherName)}": Channel rejected the message (buffer full or other channel issue)`));
+			return preparePayload().flatMap((payload) => this.amqpClient.publish(publisher.exchange.name, publisher.routingKey ?? "", payload, publishOptions).flatMap((published) => {
+				if (!published) return (0, unthrown.Err)(new _amqp_contract_core.TechnicalError(`Failed to publish message for publisher "${String(publisherName)}": Channel rejected the message (buffer full or other channel issue)`));
 				this.logger?.info("Message published successfully", {
 					publisherName: String(publisherName),
 					exchange: publisher.exchange.name,
 					routingKey: publisher.routingKey,
 					compressed: !!compression
 				});
-				return (0, neverthrow.ok)(void 0);
+				return (0, unthrown.Ok)(void 0);
 			}));
 		};
-		return validateMessage().andThen((validatedMessage) => publishMessage(validatedMessage)).andTee(() => {
+		return validateMessage().flatMap((validatedMessage) => publishMessage(validatedMessage)).tap(() => {
 			const durationMs = Date.now() - startTime;
 			(0, _amqp_contract_core.endSpanSuccess)(span);
 			(0, _amqp_contract_core.recordPublishMetric)(this.telemetry, exchange.name, routingKey, true, durationMs);
-		}).orTee((error) => {
+		}).tapErr((error) => {
 			const durationMs = Date.now() - startTime;
 			(0, _amqp_contract_core.endSpanError)(span, error);
 			(0, _amqp_contract_core.recordPublishMetric)(this.telemetry, exchange.name, routingKey, false, durationMs);
@@ -246,19 +248,23 @@ var TypedAmqpClient = class TypedAmqpClient {
 	* The request payload is validated against the RPC's request schema, then
 	* published to the AMQP default exchange with the server's queue name as
 	* routing key, `replyTo` set to `amq.rabbitmq.reply-to`, and a fresh UUID
-	* `correlationId`. The returned ResultAsync resolves once a matching reply
+	* `correlationId`. The returned AsyncResult resolves once a matching reply
 	* arrives and validates against the response schema, or once `timeoutMs`
 	* elapses (whichever comes first).
 	*
 	* @example
 	* ```typescript
 	* const result = await client.call('calculate', { a: 1, b: 2 }, { timeoutMs: 5_000 });
-	* if (result.isOk()) console.log(result.value.sum); // 3
+	* result.match({
+	*   ok: (value) => console.log(value.sum), // 3
+	*   err: (error) => console.error(error),
+	*   defect: (cause) => console.error(cause),
+	* });
 	* ```
 	*/
 	call(rpcName, request, options) {
 		const TIMEOUT_MAX_MS = 2147483647;
-		if (typeof options.timeoutMs !== "number" || !Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0 || options.timeoutMs > TIMEOUT_MAX_MS) return (0, neverthrow.errAsync)(new _amqp_contract_core.TechnicalError(`Invalid timeoutMs for RPC call to "${String(rpcName)}": expected a finite positive number ≤ ${TIMEOUT_MAX_MS}, got ${String(options.timeoutMs)}`));
+		if (typeof options.timeoutMs !== "number" || !Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0 || options.timeoutMs > TIMEOUT_MAX_MS) return (0, unthrown.Err)(new _amqp_contract_core.TechnicalError(`Invalid timeoutMs for RPC call to "${String(rpcName)}": expected a finite positive number ≤ ${TIMEOUT_MAX_MS}, got ${String(options.timeoutMs)}`)).toAsync();
 		const startTime = Date.now();
 		const rpc = this.contract.rpcs[rpcName];
 		const requestSchema = rpc.request.payload;
@@ -267,13 +273,13 @@ var TypedAmqpClient = class TypedAmqpClient {
 		const span = (0, _amqp_contract_core.startPublishSpan)(this.telemetry, "", queueName, { [_amqp_contract_core.MessagingSemanticConventions.AMQP_PUBLISHER_NAME]: String(rpcName) });
 		const correlationId = (0, node_crypto.randomUUID)();
 		let resolveCall;
-		const callResultAsync = new neverthrow.ResultAsync(new Promise((res) => {
+		const callResultAsync = (0, unthrown.fromSafePromise)(new Promise((res) => {
 			resolveCall = res;
-		}));
+		})).flatMap((result) => result);
 		const timer = setTimeout(() => {
 			if (!this.pendingCalls.has(correlationId)) return;
 			this.pendingCalls.delete(correlationId);
-			resolveCall((0, neverthrow.err)(new RpcTimeoutError(String(rpcName), options.timeoutMs)));
+			resolveCall((0, unthrown.Err)(new RpcTimeoutError(String(rpcName), options.timeoutMs)));
 		}, options.timeoutMs);
 		this.pendingCalls.set(correlationId, {
 			rpcName: String(rpcName),
@@ -286,10 +292,9 @@ var TypedAmqpClient = class TypedAmqpClient {
 			try {
 				rawValidation = requestSchema["~standard"].validate(request);
 			} catch (error) {
-				return (0, neverthrow.errAsync)(new _amqp_contract_core.TechnicalError("RPC request validation threw", error));
+				return (0, unthrown.Err)(new _amqp_contract_core.TechnicalError("RPC request validation threw", error)).toAsync();
 			}
-			const validationPromise = rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);
-			return neverthrow.ResultAsync.fromPromise(validationPromise, (error) => new _amqp_contract_core.TechnicalError("RPC request validation threw", error)).andThen((validation) => validation.issues ? (0, neverthrow.err)(new _amqp_contract_core.MessageValidationError(String(rpcName), validation.issues)) : (0, neverthrow.ok)(validation.value));
+			return (0, unthrown.fromPromise)(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation), (error) => new _amqp_contract_core.TechnicalError("RPC request validation threw", error)).flatMap((validation) => validation.issues ? (0, unthrown.Err)(new _amqp_contract_core.MessageValidationError(String(rpcName), validation.issues)) : (0, unthrown.Ok)(validation.value));
 		};
 		const publishRequest = (validatedRequest) => {
 			const { compression: _ignoredCompression, ...defaultsWithoutCompression } = this.defaultPublishOptions;
@@ -300,19 +305,19 @@ var TypedAmqpClient = class TypedAmqpClient {
 				correlationId,
 				contentType: "application/json"
 			};
-			return this.amqpClient.publish("", queueName, validatedRequest, publishOptions).andThen((published) => published ? (0, neverthrow.ok)(void 0) : (0, neverthrow.err)(new _amqp_contract_core.TechnicalError(`Failed to publish RPC request for "${String(rpcName)}": channel buffer full`)));
+			return this.amqpClient.publish("", queueName, validatedRequest, publishOptions).flatMap((published) => published ? (0, unthrown.Ok)(void 0) : (0, unthrown.Err)(new _amqp_contract_core.TechnicalError(`Failed to publish RPC request for "${String(rpcName)}": channel buffer full`)));
 		};
-		return validateRequest().andThen((validated) => publishRequest(validated)).andThen(() => callResultAsync).orElse((error) => {
+		return validateRequest().flatMap((validated) => publishRequest(validated)).flatMap(() => callResultAsync).orElse((error) => {
 			if (this.pendingCalls.has(correlationId)) {
 				clearTimeout(timer);
 				this.pendingCalls.delete(correlationId);
 			}
-			return (0, neverthrow.errAsync)(error);
-		}).andTee(() => {
+			return (0, unthrown.Err)(error).toAsync();
+		}).tap(() => {
 			const durationMs = Date.now() - startTime;
 			(0, _amqp_contract_core.endSpanSuccess)(span);
 			(0, _amqp_contract_core.recordPublishMetric)(this.telemetry, "", queueName, true, durationMs);
-		}).orTee((error) => {
+		}).tapErr((error) => {
 			const durationMs = Date.now() - startTime;
 			(0, _amqp_contract_core.endSpanError)(span, error);
 			(0, _amqp_contract_core.recordPublishMetric)(this.telemetry, "", queueName, false, durationMs);
@@ -325,13 +330,13 @@ var TypedAmqpClient = class TypedAmqpClient {
 	close() {
 		for (const [, pending] of this.pendingCalls) {
 			clearTimeout(pending.timer);
-			pending.resolve((0, neverthrow.err)(new RpcCancelledError(pending.rpcName)));
+			pending.resolve((0, unthrown.Err)(new RpcCancelledError(pending.rpcName)));
 		}
 		this.pendingCalls.clear();
 		return (this.replyConsumerTag ? this.amqpClient.cancel(this.replyConsumerTag).orElse((error) => {
 			this.logger?.warn("Failed to cancel RPC reply consumer during close", { error });
-			return (0, neverthrow.ok)(void 0);
-		}) : (0, neverthrow.okAsync)(void 0)).andThen(() => this.amqpClient.close());
+			return (0, unthrown.Ok)(void 0);
+		}) : (0, unthrown.Ok)(void 0).toAsync()).flatMap(() => this.amqpClient.close());
 	}
 	waitForConnectionReady() {
 		return this.amqpClient.waitForConnect();

package/dist/index.d.cts

@@ -1,13 +1,92 @@
 import { CompressionAlgorithm, ContractDefinition, InferPublisherNames, InferRpcNames, MessageDefinition, PublisherEntry, RpcDefinition } from "@amqp-contract/contract";
 import { Logger, MessageValidationError, PublishOptions as PublishOptions$1, TechnicalError, TelemetryProvider } from "@amqp-contract/core";
-import * as amqp from "amqplib";
-import { TcpSocketConnectOpts } from "net";
 import { ConnectionOptions } from "tls";
-import { ResultAsync } from "neverthrow";
+import { TcpSocketConnectOpts } from "net";
+import { AsyncResult } from "unthrown";
 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;
+  }
+}
+//#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;
 };
@@ -48,26 +127,36 @@ interface AmqpConnectionManagerOptions {
 }
 //#endregion
 //#region src/errors.d.ts
+declare const RpcTimeoutError_base: import("unthrown").TaggedErrorConstructor<"@amqp-contract/RpcTimeoutError">;
 /**
  * Returned from `TypedAmqpClient.call()` when the configured `timeoutMs` elapses
  * before the RPC server publishes a reply with the matching `correlationId`.
  *
  * The pending call is removed from the in-memory correlation map; if a reply
  * arrives after the timeout it is dropped (and a debug log is emitted by the
- * client if a logger is configured).
+ * client if a logger is configured). Carries a namespaced `_tag` of
+ * `"@amqp-contract/RpcTimeoutError"`; the `Error.name` is kept bare
+ * (`"RpcTimeoutError"`).
  */
-declare class RpcTimeoutError extends Error {
-  readonly rpcName: string;
-  readonly timeoutMs: number;
+declare class RpcTimeoutError extends RpcTimeoutError_base<{
+  message: string;
+  rpcName: string;
+  timeoutMs: number;
+}> {
   constructor(rpcName: string, timeoutMs: number);
 }
+declare const RpcCancelledError_base: import("unthrown").TaggedErrorConstructor<"@amqp-contract/RpcCancelledError">;
 /**
  * Returned from any in-flight RPC call when the client is closed before the
  * reply is received. The correlation map is cleared on close and every pending
- * caller's promise resolves with `err(RpcCancelledError)`.
+ * caller's promise resolves with `Err(RpcCancelledError)`. Carries a namespaced
+ * `_tag` of `"@amqp-contract/RpcCancelledError"`; the `Error.name` is kept bare
+ * (`"RpcCancelledError"`).
  */
-declare class RpcCancelledError extends Error {
-  readonly rpcName: string;
+declare class RpcCancelledError extends RpcCancelledError_base<{
+  message: string;
+  rpcName: string;
+}> {
   constructor(rpcName: string);
 }
 //#endregion
@@ -141,7 +230,7 @@ type CreateClientOptions<TContract extends ContractDefinition> = {
   defaultPublishOptions?: PublishOptions | 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.
    */
@@ -153,7 +242,7 @@ type CreateClientOptions<TContract extends ContractDefinition> = {
 type CallOptions = {
   /**
    * Maximum time in ms to wait for an RPC reply. If exceeded, the call resolves
-   * to `err(RpcTimeoutError)` and the in-memory correlation entry is cleared.
+   * to `Err(RpcTimeoutError)` and the in-memory correlation entry is cleared.
    * A late reply arriving after the timeout is silently dropped.
    *
    * Required: RPC without a timeout is a footgun.
@@ -203,7 +292,7 @@ declare class TypedAmqpClient<TContract extends ContractDefinition> {
     logger,
     telemetry,
     connectTimeoutMs
-  }: CreateClientOptions<TContract>): ResultAsync<TypedAmqpClient<TContract>, TechnicalError>;
+  }: CreateClientOptions<TContract>): AsyncResult<TypedAmqpClient<TContract>, TechnicalError>;
   /**
    * If the contract has any RPC entry, subscribe to `amq.rabbitmq.reply-to`
    * once. Replies for every in-flight call arrive on this single consumer and
@@ -232,29 +321,33 @@ declare class TypedAmqpClient<TContract extends ContractDefinition> {
    * and the `contentEncoding` property will be set automatically. Any `contentEncoding`
    * value already in options will be overwritten by the compression algorithm.
    */
-  publish<TName extends InferPublisherNames<TContract>>(publisherName: TName, message: ClientInferPublisherInput<TContract, TName>, options?: PublishOptions): ResultAsync<void, TechnicalError | MessageValidationError>;
+  publish<TName extends InferPublisherNames<TContract>>(publisherName: TName, message: ClientInferPublisherInput<TContract, TName>, options?: PublishOptions): AsyncResult<void, TechnicalError | MessageValidationError>;
   /**
    * Invoke an RPC defined via `defineRpc` and await the typed response.
    *
    * The request payload is validated against the RPC's request schema, then
    * published to the AMQP default exchange with the server's queue name as
    * routing key, `replyTo` set to `amq.rabbitmq.reply-to`, and a fresh UUID
-   * `correlationId`. The returned ResultAsync resolves once a matching reply
+   * `correlationId`. The returned AsyncResult resolves once a matching reply
    * arrives and validates against the response schema, or once `timeoutMs`
    * elapses (whichever comes first).
    *
    * @example
    * ```typescript
    * const result = await client.call('calculate', { a: 1, b: 2 }, { timeoutMs: 5_000 });
-   * if (result.isOk()) console.log(result.value.sum); // 3
+   * result.match({
+   *   ok: (value) => console.log(value.sum), // 3
+   *   err: (error) => console.error(error),
+   *   defect: (cause) => console.error(cause),
+   * });
    * ```
    */
-  call<TName extends InferRpcNames<TContract>>(rpcName: TName, request: ClientInferRpcRequestInput<TContract, TName>, options: CallOptions): ResultAsync<ClientInferRpcResponseOutput<TContract, TName>, TechnicalError | MessageValidationError | RpcTimeoutError | RpcCancelledError>;
+  call<TName extends InferRpcNames<TContract>>(rpcName: TName, request: ClientInferRpcRequestInput<TContract, TName>, options: CallOptions): AsyncResult<ClientInferRpcResponseOutput<TContract, TName>, TechnicalError | MessageValidationError | RpcTimeoutError | RpcCancelledError>;
   /**
    * Close the channel and connection. Cancels the reply consumer (if any) and
    * rejects every in-flight RPC call with `RpcCancelledError`.
    */
-  close(): ResultAsync<void, TechnicalError>;
+  close(): AsyncResult<void, TechnicalError>;
   private waitForConnectionReady;
 }
 //#endregion

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","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/client.ts"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"index.d.cts","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/client.ts"],"x_google_ignoreList":[0,1],"mappings":"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"}