@amqp-contract/client 0.21.0 → 0.22.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
+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 { Future, Result } from "@swan-io/boxed";
-import { CompressionAlgorithm, ContractDefinition, InferPublisherNames, PublisherEntry } from "@amqp-contract/contract";
 import * as amqp from "amqplib";
 import { TcpSocketConnectOpts } from "net";
 import { ConnectionOptions } from "tls";
@@ -47,11 +47,39 @@ interface AmqpConnectionManagerOptions {
   connectionOptions?: AmqpConnectionOptions;
 }
 //#endregion
+//#region src/errors.d.ts
+/**
+ * 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).
+ */
+declare class RpcTimeoutError extends Error {
+  readonly rpcName: string;
+  readonly timeoutMs: number;
+  constructor(rpcName: string, timeoutMs: number);
+}
+/**
+ * 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 `Result.Error(RpcCancelledError)`.
+ */
+declare class RpcCancelledError extends Error {
+  readonly rpcName: string;
+  constructor(rpcName: string);
+}
+//#endregion
 //#region src/types.d.ts
 /**
- * Infer the TypeScript type from a schema
+ * Infer the TypeScript type from a schema (input side, used for publish payloads).
  */
 type InferSchemaInput<TSchema extends StandardSchemaV1> = TSchema extends StandardSchemaV1<infer TInput> ? TInput : never;
+/**
+ * Infer the TypeScript type from a schema (output side, used for validated responses).
+ */
+type InferSchemaOutput<TSchema extends StandardSchemaV1> = TSchema extends StandardSchemaV1<infer _TInput, infer TOutput> ? TOutput : never;
 /**
  * Infer publisher message input type.
  * Works with both PublisherDefinition and EventPublisherConfig since both have
@@ -62,18 +90,22 @@ type PublisherInferInput<TPublisher extends PublisherEntry> = TPublisher extends
     payload: StandardSchemaV1;
   };
 } ? InferSchemaInput<TPublisher["message"]["payload"]> : never;
+type InferPublishers<TContract extends ContractDefinition> = NonNullable<TContract["publishers"]>;
+type InferPublisher<TContract extends ContractDefinition, TName extends InferPublisherNames<TContract>> = InferPublishers<TContract>[TName];
 /**
- * Infer all publishers from contract
+ * Input type accepted by `client.publish(name, ...)` for a specific publisher.
  */
-type InferPublishers<TContract extends ContractDefinition> = NonNullable<TContract["publishers"]>;
+type ClientInferPublisherInput<TContract extends ContractDefinition, TName extends InferPublisherNames<TContract>> = PublisherInferInput<InferPublisher<TContract, TName>>;
+type InferRpcs<TContract extends ContractDefinition> = NonNullable<TContract["rpcs"]>;
+type InferRpc<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpcs<TContract>[TName];
 /**
- * Get specific publisher definition from contract
+ * Input type accepted by `client.call(name, request, ...)`.
  */
-type InferPublisher<TContract extends ContractDefinition, TName extends InferPublisherNames<TContract>> = InferPublishers<TContract>[TName];
+type ClientInferRpcRequestInput<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpc<TContract, TName> extends RpcDefinition<infer TRequest, MessageDefinition> ? TRequest extends MessageDefinition ? InferSchemaInput<TRequest["payload"]> : never : never;
 /**
- * Infer publisher input type (message payload) for a specific publisher in a contract
+ * Output (validated) response type returned by `client.call(name, ...)`.
  */
-type ClientInferPublisherInput<TContract extends ContractDefinition, TName extends InferPublisherNames<TContract>> = PublisherInferInput<InferPublisher<TContract, TName>>;
+type ClientInferRpcResponseOutput<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpc<TContract, TName> extends RpcDefinition<MessageDefinition, infer TResponse> ? TResponse extends MessageDefinition ? InferSchemaOutput<TResponse["payload"]> : never : never;
 //#endregion
 //#region src/client.d.ts
 /**
@@ -107,6 +139,31 @@ type CreateClientOptions<TContract extends ContractDefinition> = {
    * By default, persistent is set to true for message durability.
    */
   defaultPublishOptions?: PublishOptions | undefined;
+  /**
+   * Maximum time in ms to wait for the AMQP connection to become ready before
+   * `create()` resolves to `Result.Error<TechnicalError>`. Without this option,
+   * `create()` waits forever — the underlying amqp-connection-manager retries
+   * indefinitely.
+   */
+  connectTimeoutMs?: number | undefined;
+};
+/**
+ * Per-call options for `client.call()`.
+ */
+type CallOptions = {
+  /**
+   * Maximum time in ms to wait for an RPC reply. If exceeded, the call resolves
+   * to `Result.Error<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.
+   */
+  timeoutMs: number;
+  /**
+   * Optional AMQP message properties to merge into the request. `replyTo` and
+   * `correlationId` are managed by the client and cannot be overridden.
+   */
+  publishOptions?: Omit<PublishOptions$1, "replyTo" | "correlationId">;
 };
 /**
  * Type-safe AMQP client for publishing messages
@@ -117,6 +174,16 @@ declare class TypedAmqpClient<TContract extends ContractDefinition> {
   private readonly defaultPublishOptions;
   private readonly logger?;
   private readonly 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.
+   */
+  private readonly pendingCalls;
+  /**
+   * Consumer tag of the reply consumer subscribed on `amq.rabbitmq.reply-to`.
+   * Set when the contract has at least one entry in `rpcs`; undefined otherwise.
+   */
+  private replyConsumerTag?;
   private constructor();
   /**
    * Create a type-safe AMQP client from a contract.
@@ -134,8 +201,22 @@ declare class TypedAmqpClient<TContract extends ContractDefinition> {
     connectionOptions,
     defaultPublishOptions,
     logger,
-    telemetry
+    telemetry,
+    connectTimeoutMs
   }: CreateClientOptions<TContract>): Future<Result<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
+   * are demultiplexed by `correlationId`.
+   */
+  private setupReplyConsumerIfNeeded;
+  /**
+   * Demultiplex an RPC reply by `correlationId`, validate the body against the
+   * call's response schema, and resolve the awaiting caller. Replies with no
+   * matching pending call (e.g. arriving after the call timed out) are dropped
+   * with a debug log.
+   */
+  private handleRpcReply;
   /**
    * Publish a message using a defined publisher
    *
@@ -156,11 +237,39 @@ declare class TypedAmqpClient<TContract extends ContractDefinition> {
    */
   publish<TName extends InferPublisherNames<TContract>>(publisherName: TName, message: ClientInferPublisherInput<TContract, TName>, options?: PublishOptions): Future<Result<void, TechnicalError | MessageValidationError>>;
   /**
-   * Close the channel and connection
+   * 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 Future resolves once a matching reply
+   * arrives and validates against the response schema, or once `timeoutMs`
+   * elapses (whichever comes first).
+   *
+   * @typeParam TName - An RPC name from `contract.rpcs`.
+   * @param rpcName - The RPC name from the contract.
+   * @param request - The request payload, validated against the request schema.
+   * @param options - Per-call options. `timeoutMs` is required.
+   *
+   * @returns `Result.Ok(response)` on a successful round-trip; `Result.Error`
+   *   on validation, transport, timeout, or cancel.
+   *
+   * @example
+   * ```typescript
+   * const result = await client
+   *   .call('calculate', { a: 1, b: 2 }, { timeoutMs: 5_000 })
+   *   .toPromise();
+   * if (result.isOk()) console.log(result.value.sum); // 3
+   * ```
+   */
+  call<TName extends InferRpcNames<TContract>>(rpcName: TName, request: ClientInferRpcRequestInput<TContract, TName>, options: CallOptions): Future<Result<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(): Future<Result<void, TechnicalError>>;
   private waitForConnectionReady;
 }
 //#endregion
-export { type ClientInferPublisherInput, type CreateClientOptions, MessageValidationError, type PublishOptions, TypedAmqpClient };
+export { type CallOptions, type ClientInferPublisherInput, type ClientInferRpcRequestInput, type ClientInferRpcResponseOutput, type CreateClientOptions, MessageValidationError, type PublishOptions, RpcCancelledError, RpcTimeoutError, TypedAmqpClient };
 //# 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@1.0.3/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts","../src/types.ts","../src/client.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;KAKYM,aAAAA,YAAyBN,IAAAA,CAAKO,OAAAA,CAAQC,OAAAA;EAC9CE,GAAAA;EACAC,iBAAAA,GAAoBF,qBAAAA;AAAAA;AAAAA,KAcZA,qBAAAA,IAAyBN,iBAAAA,GAAoBD,oBAAAA;EACrDkB,OAAAA;EACAC,OAAAA;EACAC,SAAAA;EACAC,cAAAA;EACAC,gBAAAA;EACAC,WAAAA;IACIC,SAAAA;IACAC,QAAAA;IACAC,QAAAA;IACAC,QAAAA,QAAgBV,MAAAA;EAAAA;IAEhBO,SAAAA;IACAG,QAAAA,QAAgBV,MAAAA;EAAAA;AAAAA;AAAAA,UAGPW,4BAAAA;EATTJ;EAWJM,0BAAAA;EATIJ;;;;EAcJK,sBAAAA;EAVoBd;;;AAGxB;;;;EAeIe,WAAAA,KAAgBE,QAAAA,GAAWD,IAAAA,EAAM7B,aAAAA,GAAgBA,aAAAA,+BAA4CyB,OAAAA,CAAQzB,aAAAA,GAAgBA,aAAAA;EAAhBA;EAErGK,iBAAAA,GAAoBF,qBAAAA;AAAAA;;;;;;KC5CnB,gBAAA,iBAAiC,gBAAA,IACpC,OAAA,SAAgB,gBAAA,iBAAiC,MAAA;;;;ADNnD;;KCaK,mBAAA,oBAAuC,cAAA,IAAkB,UAAA;EAC5D,OAAA;IAAW,OAAA,EAAS,gBAAA;EAAA;AAAA,IAElB,gBAAA,CAAiB,UAAA;;;;KAMhB,eAAA,mBAAkC,kBAAA,IAAsB,WAAA,CAAY,SAAA;;ADNzE;;KCWK,cAAA,mBACe,kBAAA,gBACJ,mBAAA,CAAoB,SAAA,KAChC,eAAA,CAAgB,SAAA,EAAW,KAAA;;;;KAKnB,yBAAA,mBACQ,kBAAA,gBACJ,mBAAA,CAAoB,SAAA,KAChC,mBAAA,CAAoB,cAAA,CAAe,SAAA,EAAW,KAAA;;;;;;KChBtC,cAAA,GAAiB,gBAAA;EFtBJ;;;;;EE4BvB,WAAA,GAAc,oBAAA;AAAA;;;;KAMJ,mBAAA,mBAAsC,kBAAA;EAChD,QAAA,EAAU,SAAA;EACV,IAAA,EAAM,aAAA;EACN,iBAAA,GAAoB,4BAAA;EACpB,MAAA,GAAS,MAAA;EFtB8CP;;;;;EE4BvD,SAAA,GAAY,iBAAA;EF5B2CA;;;;;EEkCvD,qBAAA,GAAwB,cAAA;AAAA;;;;cAMb,eAAA,mBAAkC,kBAAA;EAAA,iBAE1B,QAAA;EAAA,iBACA,UAAA;EAAA,iBACA,qBAAA;EAAA,iBACA,MAAA;EAAA,iBACA,SAAA;EAAA,QALZ,WAAA,CAAA;EFzBQ4B;;;;;;;;;;EAAAA,OE2CR,MAAA,mBAAyB,kBAAA,CAAA,CAAA;IAC9B,QAAA;IACA,IAAA;IACA,iBAAA;IACA,qBAAA;IACA,MAAA;IACA;EAAA,GACC,mBAAA,CAAoB,SAAA,IAAa,MAAA,CAAO,MAAA,CAAO,eAAA,CAAgB,SAAA,GAAY,cAAA;EFhD5EE;;;;;;;;;;;;;;;;;AClC0D;ECgH5D,OAAA,eAAsB,mBAAA,CAAoB,SAAA,EAAA,CACxC,aAAA,EAAe,KAAA,EACf,OAAA,EAAS,yBAAA,CAA0B,SAAA,EAAW,KAAA,GAC9C,OAAA,GAAU,cAAA,GACT,MAAA,CAAO,MAAA,OAAa,cAAA,GAAiB,sBAAA;ED/GrB;;;EC4MnB,KAAA,CAAA,GAAS,MAAA,CAAO,MAAA,OAAa,cAAA;EAAA,QAIrB,sBAAA;AAAA"}
+{"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@1.0.3/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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"}

package/dist/index.mjs

@@ -1,5 +1,7 @@
+import { extractQueue } from "@amqp-contract/contract";
 import { AmqpClient, MessageValidationError, MessagingSemanticConventions, TechnicalError, defaultTelemetryProvider, endSpanError, endSpanSuccess, recordPublishMetric, startPublishSpan } from "@amqp-contract/core";
 import { Future, Result } from "@swan-io/boxed";
+import { randomUUID } from "node:crypto";
 import { deflate, gzip } from "node:zlib";
 import { match } from "ts-pattern";
 import { promisify } from "node:util";
@@ -19,11 +21,69 @@ function compressBuffer(buffer, algorithm) {
 	return match(algorithm).with("gzip", () => Future.fromPromise(gzipAsync(buffer)).mapError((error) => new TechnicalError("Failed to compress with gzip", error))).with("deflate", () => Future.fromPromise(deflateAsync(buffer)).mapError((error) => new 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).
+*/
+var RpcTimeoutError = class extends Error {
+	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);
+	}
+};
+/**
+* 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 `Result.Error(RpcCancelledError)`.
+*/
+var RpcCancelledError = class extends Error {
+	constructor(rpcName) {
+		super(`RPC call to "${rpcName}" was cancelled because the client was closed`);
+		this.rpcName = rpcName;
+		this.name = "RpcCancelledError";
+		captureStack(this, this.constructor);
+	}
+};
+//#endregion
 //#region src/client.ts
 /**
+* The RabbitMQ direct-reply-to pseudo-queue. Publishing with `replyTo` set to
+* this value tells the server to deliver the response back to the consumer
+* subscribed on this queue on the same channel — no real queue is created and
+* no setup is required beyond consuming from it once with `noAck: true`.
+*
+* @see https://www.rabbitmq.com/docs/direct-reply-to
+*/
+const DIRECT_REPLY_TO = "amq.rabbitmq.reply-to";
+/**
 * Type-safe AMQP client for publishing messages
 */
 var TypedAmqpClient = class TypedAmqpClient {
+	/**
+	* In-flight RPC calls keyed by `correlationId`. Cleared when a reply is
+	* received, when the call times out, or when the client is closed.
+	*/
+	pendingCalls = /* @__PURE__ */ new Map();
+	/**
+	* Consumer tag of the reply consumer subscribed on `amq.rabbitmq.reply-to`.
+	* Set when the contract has at least one entry in `rpcs`; undefined otherwise.
+	*/
+	replyConsumerTag;
 	constructor(contract, amqpClient, defaultPublishOptions, logger, telemetry = defaultTelemetryProvider) {
 		this.contract = contract;
 		this.amqpClient = amqpClient;
@@ -41,15 +101,77 @@ var TypedAmqpClient = class TypedAmqpClient {
 	* Connections are automatically shared across clients with the same URLs and
 	* connection options, following RabbitMQ best practices.
 	*/
-	static create({ contract, urls, connectionOptions, defaultPublishOptions, logger, telemetry }) {
+	static create({ contract, urls, connectionOptions, defaultPublishOptions, logger, telemetry, connectTimeoutMs }) {
 		const client = new TypedAmqpClient(contract, new AmqpClient(contract, {
 			urls,
-			connectionOptions
+			connectionOptions,
+			connectTimeoutMs
 		}), {
 			persistent: true,
 			...defaultPublishOptions
 		}, logger, telemetry ?? defaultTelemetryProvider);
-		return client.waitForConnectionReady().mapOk(() => client);
+		return client.waitForConnectionReady().flatMapOk(() => client.setupReplyConsumerIfNeeded()).flatMap((result) => result.match({
+			Ok: () => Future.value(Result.Ok(client)),
+			Error: (error) => client.close().tapError((closeError) => {
+				logger?.warn("Failed to close client after connection failure", { error: closeError });
+			}).map(() => Result.Error(error))
+		}));
+	}
+	/**
+	* 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
+	* are demultiplexed by `correlationId`.
+	*/
+	setupReplyConsumerIfNeeded() {
+		const rpcs = this.contract.rpcs ?? {};
+		if (Object.keys(rpcs).length === 0) return Future.value(Result.Ok(void 0));
+		return this.amqpClient.consume(DIRECT_REPLY_TO, (msg) => this.handleRpcReply(msg), { noAck: true }).tapOk((tag) => {
+			this.replyConsumerTag = tag;
+		}).mapOk(() => void 0);
+	}
+	/**
+	* Demultiplex an RPC reply by `correlationId`, validate the body against the
+	* call's response schema, and resolve the awaiting caller. Replies with no
+	* matching pending call (e.g. arriving after the call timed out) are dropped
+	* with a debug log.
+	*/
+	handleRpcReply(msg) {
+		if (!msg) return;
+		const correlationId = msg.properties.correlationId;
+		if (typeof correlationId !== "string") {
+			this.logger?.warn("Received RPC reply without correlationId; dropping", { deliveryTag: msg.fields.deliveryTag });
+			return;
+		}
+		const pending = this.pendingCalls.get(correlationId);
+		if (!pending) {
+			this.logger?.debug("Received RPC reply for unknown correlationId", { correlationId });
+			return;
+		}
+		this.pendingCalls.delete(correlationId);
+		clearTimeout(pending.timer);
+		let parsed;
+		try {
+			parsed = JSON.parse(msg.content.toString());
+		} catch (error) {
+			pending.resolve(Result.Error(new TechnicalError(`Failed to parse RPC reply JSON for "${pending.rpcName}"`, error)));
+			return;
+		}
+		let rawValidation;
+		try {
+			rawValidation = pending.responseSchema["~standard"].validate(parsed);
+		} catch (error) {
+			pending.resolve(Result.Error(new TechnicalError(`RPC reply validation threw for "${pending.rpcName}"`, error)));
+			return;
+		}
+		(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation)).then((validation) => {
+			if (validation.issues) {
+				pending.resolve(Result.Error(new MessageValidationError(pending.rpcName, validation.issues)));
+				return;
+			}
+			pending.resolve(Result.Ok(validation.value));
+		}, (error) => {
+			pending.resolve(Result.Error(new TechnicalError(`RPC reply validation threw for "${pending.rpcName}"`, error)));
+		});
 	}
 	/**
 	* Publish a message using a defined publisher
@@ -117,16 +239,114 @@ var TypedAmqpClient = class TypedAmqpClient {
 		});
 	}
 	/**
-	* Close the channel and connection
+	* 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 Future resolves once a matching reply
+	* arrives and validates against the response schema, or once `timeoutMs`
+	* elapses (whichever comes first).
+	*
+	* @typeParam TName - An RPC name from `contract.rpcs`.
+	* @param rpcName - The RPC name from the contract.
+	* @param request - The request payload, validated against the request schema.
+	* @param options - Per-call options. `timeoutMs` is required.
+	*
+	* @returns `Result.Ok(response)` on a successful round-trip; `Result.Error`
+	*   on validation, transport, timeout, or cancel.
+	*
+	* @example
+	* ```typescript
+	* const result = await client
+	*   .call('calculate', { a: 1, b: 2 }, { timeoutMs: 5_000 })
+	*   .toPromise();
+	* if (result.isOk()) console.log(result.value.sum); // 3
+	* ```
+	*/
+	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 Future.value(Result.Error(new TechnicalError(`Invalid timeoutMs for RPC call to "${String(rpcName)}": expected a finite positive number ≤ ${TIMEOUT_MAX_MS}, got ${String(options.timeoutMs)}`)));
+		const startTime = Date.now();
+		const rpc = this.contract.rpcs[rpcName];
+		const requestSchema = rpc.request.payload;
+		const responseSchema = rpc.response.payload;
+		const queueName = extractQueue(rpc.queue).name;
+		const span = startPublishSpan(this.telemetry, "", queueName, { [MessagingSemanticConventions.AMQP_PUBLISHER_NAME]: String(rpcName) });
+		const correlationId = randomUUID();
+		const callFuture = Future.make((resolve) => {
+			const timer = setTimeout(() => {
+				if (!this.pendingCalls.get(correlationId)) return;
+				this.pendingCalls.delete(correlationId);
+				resolve(Result.Error(new RpcTimeoutError(String(rpcName), options.timeoutMs)));
+			}, options.timeoutMs);
+			this.pendingCalls.set(correlationId, {
+				rpcName: String(rpcName),
+				responseSchema,
+				resolve,
+				timer
+			});
+		});
+		const validateRequest = () => {
+			let rawValidation;
+			try {
+				rawValidation = requestSchema["~standard"].validate(request);
+			} catch (error) {
+				return Future.value(Result.Error(new TechnicalError("RPC request validation threw", error)));
+			}
+			const validationPromise = rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);
+			return Future.fromPromise(validationPromise).mapError((error) => new TechnicalError("RPC request validation threw", error)).mapOkToResult((validation) => validation.issues ? Result.Error(new MessageValidationError(String(rpcName), validation.issues)) : Result.Ok(validation.value));
+		};
+		const publishRequest = (validatedRequest) => {
+			const { compression: _ignoredCompression, ...defaultsWithoutCompression } = this.defaultPublishOptions;
+			const publishOptions = {
+				...defaultsWithoutCompression,
+				...options.publishOptions,
+				replyTo: DIRECT_REPLY_TO,
+				correlationId,
+				contentType: "application/json"
+			};
+			return this.amqpClient.publish("", queueName, validatedRequest, publishOptions).mapOkToResult((published) => published ? Result.Ok(void 0) : Result.Error(new TechnicalError(`Failed to publish RPC request for "${String(rpcName)}": channel buffer full`)));
+		};
+		return validateRequest().flatMapOk((validated) => publishRequest(validated)).flatMap((preflight) => {
+			if (preflight.isError()) {
+				const pending = this.pendingCalls.get(correlationId);
+				if (pending) {
+					clearTimeout(pending.timer);
+					this.pendingCalls.delete(correlationId);
+				}
+				return Future.value(Result.Error(preflight.error));
+			}
+			return callFuture;
+		}).tapOk(() => {
+			const durationMs = Date.now() - startTime;
+			endSpanSuccess(span);
+			recordPublishMetric(this.telemetry, "", queueName, true, durationMs);
+		}).tapError((error) => {
+			const durationMs = Date.now() - startTime;
+			endSpanError(span, error);
+			recordPublishMetric(this.telemetry, "", queueName, false, durationMs);
+		});
+	}
+	/**
+	* Close the channel and connection. Cancels the reply consumer (if any) and
+	* rejects every in-flight RPC call with `RpcCancelledError`.
 	*/
 	close() {
-		return this.amqpClient.close().mapOk(() => void 0);
+		for (const [, pending] of this.pendingCalls) {
+			clearTimeout(pending.timer);
+			pending.resolve(Result.Error(new RpcCancelledError(pending.rpcName)));
+		}
+		this.pendingCalls.clear();
+		return (this.replyConsumerTag ? this.amqpClient.cancel(this.replyConsumerTag).tapError((error) => {
+			this.logger?.warn("Failed to cancel RPC reply consumer during close", { error });
+		}) : Future.value(Result.Ok(void 0))).flatMap(() => this.amqpClient.close()).mapOk(() => void 0);
 	}
 	waitForConnectionReady() {
 		return this.amqpClient.waitForConnect();
 	}
 };
 //#endregion
-export { MessageValidationError, TypedAmqpClient };
+export { MessageValidationError, RpcCancelledError, RpcTimeoutError, TypedAmqpClient };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/compression.ts","../src/client.ts"],"sourcesContent":["import { Future, Result } from \"@swan-io/boxed\";\nimport { deflate, gzip } from \"node:zlib\";\nimport type { CompressionAlgorithm } from \"@amqp-contract/contract\";\nimport { TechnicalError } from \"@amqp-contract/core\";\nimport { match } from \"ts-pattern\";\nimport { promisify } from \"node:util\";\n\nconst gzipAsync = promisify(gzip);\nconst deflateAsync = promisify(deflate);\n\n/**\n * Compress a buffer using the specified compression algorithm.\n *\n * @param buffer - The buffer to compress\n * @param algorithm - The compression algorithm to use\n * @returns A Future with the compressed buffer or a TechnicalError\n *\n * @internal\n */\nexport function compressBuffer(\n  buffer: Buffer,\n  algorithm: CompressionAlgorithm,\n): Future<Result<Buffer, TechnicalError>> {\n  return match(algorithm)\n    .with(\"gzip\", () =>\n      Future.fromPromise(gzipAsync(buffer)).mapError(\n        (error) => new TechnicalError(\"Failed to compress with gzip\", error),\n      ),\n    )\n    .with(\"deflate\", () =>\n      Future.fromPromise(deflateAsync(buffer)).mapError(\n        (error) => new TechnicalError(\"Failed to compress with deflate\", error),\n      ),\n    )\n    .exhaustive();\n}\n","import type {\n  CompressionAlgorithm,\n  ContractDefinition,\n  InferPublisherNames,\n} from \"@amqp-contract/contract\";\nimport {\n  AmqpClient,\n  PublishOptions as AmqpClientPublishOptions,\n  type Logger,\n  MessagingSemanticConventions,\n  TechnicalError,\n  type TelemetryProvider,\n  defaultTelemetryProvider,\n  endSpanError,\n  endSpanSuccess,\n  recordPublishMetric,\n  startPublishSpan,\n} from \"@amqp-contract/core\";\nimport { Future, Result } from \"@swan-io/boxed\";\nimport type { AmqpConnectionManagerOptions, ConnectionUrl } from \"amqp-connection-manager\";\nimport { compressBuffer } from \"./compression.js\";\nimport { MessageValidationError } from \"./errors.js\";\nimport type { ClientInferPublisherInput } from \"./types.js\";\n\n/**\n * Publish options that extend amqp-client's PublishOptions with optional compression support.\n */\nexport type PublishOptions = AmqpClientPublishOptions & {\n  /**\n   * Optional compression algorithm to use for the message payload.\n   * When specified, the message will be compressed using the chosen algorithm\n   * and the contentEncoding header will be set automatically.\n   */\n  compression?: CompressionAlgorithm | undefined;\n};\n\n/**\n * Options for creating a client\n */\nexport type CreateClientOptions<TContract extends ContractDefinition> = {\n  contract: TContract;\n  urls: ConnectionUrl[];\n  connectionOptions?: AmqpConnectionManagerOptions | undefined;\n  logger?: Logger | undefined;\n  /**\n   * Optional telemetry provider for tracing and metrics.\n   * If not provided, uses the default provider which attempts to load OpenTelemetry.\n   * OpenTelemetry instrumentation is automatically enabled if @opentelemetry/api is installed.\n   */\n  telemetry?: TelemetryProvider | undefined;\n  /**\n   * Default publish options that will be applied to all publish operations.\n   * These can be overridden by options passed to the publish method.\n   * By default, persistent is set to true for message durability.\n   */\n  defaultPublishOptions?: PublishOptions | undefined;\n};\n\n/**\n * Type-safe AMQP client for publishing messages\n */\nexport class TypedAmqpClient<TContract extends ContractDefinition> {\n  private constructor(\n    private readonly contract: TContract,\n    private readonly amqpClient: AmqpClient,\n    private readonly defaultPublishOptions: PublishOptions,\n    private readonly logger?: Logger,\n    private readonly telemetry: TelemetryProvider = defaultTelemetryProvider,\n  ) {}\n\n  /**\n   * Create a type-safe AMQP client from a contract.\n   *\n   * Connection management (including automatic reconnection) is handled internally\n   * by amqp-connection-manager via the {@link AmqpClient}. The client establishes\n   * infrastructure asynchronously in the background once the connection is ready.\n   *\n   * Connections are automatically shared across clients with the same URLs and\n   * connection options, following RabbitMQ best practices.\n   */\n  static create<TContract extends ContractDefinition>({\n    contract,\n    urls,\n    connectionOptions,\n    defaultPublishOptions,\n    logger,\n    telemetry,\n  }: CreateClientOptions<TContract>): Future<Result<TypedAmqpClient<TContract>, TechnicalError>> {\n    const client = new TypedAmqpClient(\n      contract,\n      new AmqpClient(contract, { urls, connectionOptions }),\n      { persistent: true, ...defaultPublishOptions },\n      logger,\n      telemetry ?? defaultTelemetryProvider,\n    );\n\n    return client.waitForConnectionReady().mapOk(() => client);\n  }\n\n  /**\n   * Publish a message using a defined publisher\n   *\n   * @param publisherName - The name of the publisher to use\n   * @param message - The message to publish\n   * @param options - Optional publish options including compression, headers, priority, etc.\n   *\n   * @remarks\n   * If `options.compression` is specified, the message will be compressed before publishing\n   * and the `contentEncoding` property will be set automatically. Any `contentEncoding`\n   * value already in options will be overwritten by the compression algorithm.\n   *\n   * @returns Result.Ok(void) on success, or Result.Error with specific error on failure\n   */\n  /**\n   * Publish a message using a defined publisher.\n   * TypeScript guarantees publisher exists for valid publisher names.\n   */\n  publish<TName extends InferPublisherNames<TContract>>(\n    publisherName: TName,\n    message: ClientInferPublisherInput<TContract, TName>,\n    options?: PublishOptions,\n  ): Future<Result<void, TechnicalError | MessageValidationError>> {\n    const startTime = Date.now();\n    // Non-null assertions safe: TypeScript guarantees these exist for valid TName\n    const publisher = this.contract.publishers![publisherName as string]!;\n    const { exchange, routingKey } = publisher;\n\n    // Start telemetry span\n    const span = startPublishSpan(this.telemetry, exchange.name, routingKey, {\n      [MessagingSemanticConventions.AMQP_PUBLISHER_NAME]: String(publisherName),\n    });\n\n    const validateMessage = () => {\n      const validationResult = publisher.message.payload[\"~standard\"].validate(message);\n      return Future.fromPromise(\n        validationResult instanceof Promise ? validationResult : Promise.resolve(validationResult),\n      )\n        .mapError((error) => new TechnicalError(`Validation failed`, error))\n        .mapOkToResult((validation) => {\n          if (validation.issues) {\n            return Result.Error(\n              new MessageValidationError(String(publisherName), validation.issues),\n            );\n          }\n\n          return Result.Ok(validation.value);\n        });\n    };\n\n    const publishMessage = (validatedMessage: unknown): Future<Result<void, TechnicalError>> => {\n      // Merge default options with provided options\n      const mergedOptions = { ...this.defaultPublishOptions, ...options };\n\n      // Extract compression from merged options and create publish options without it\n      const { compression, ...restOptions } = mergedOptions;\n      const publishOptions: AmqpClientPublishOptions = { ...restOptions };\n\n      // Prepare payload and options based on compression configuration\n      const preparePayload = (): Future<Result<Buffer | unknown, TechnicalError>> => {\n        if (compression) {\n          // Compress the message payload\n          const messageBuffer = Buffer.from(JSON.stringify(validatedMessage));\n          publishOptions.contentEncoding = compression;\n\n          return compressBuffer(messageBuffer, compression);\n        }\n\n        // No compression: use the channel's built-in JSON serialization\n        return Future.value(Result.Ok(validatedMessage));\n      };\n\n      // Publish the prepared payload\n      return preparePayload().flatMapOk((payload) =>\n        this.amqpClient\n          .publish(publisher.exchange.name, publisher.routingKey ?? \"\", payload, publishOptions)\n          .mapOkToResult((published) => {\n            if (!published) {\n              return Result.Error(\n                new TechnicalError(\n                  `Failed to publish message for publisher \"${String(publisherName)}\": Channel rejected the message (buffer full or other channel issue)`,\n                ),\n              );\n            }\n\n            this.logger?.info(\"Message published successfully\", {\n              publisherName: String(publisherName),\n              exchange: publisher.exchange.name,\n              routingKey: publisher.routingKey,\n              compressed: !!compression,\n            });\n\n            return Result.Ok(undefined);\n          }),\n      );\n    };\n\n    // Validate message using schema\n    return validateMessage()\n      .flatMapOk((validatedMessage) => publishMessage(validatedMessage))\n      .tapOk(() => {\n        const durationMs = Date.now() - startTime;\n        endSpanSuccess(span);\n        recordPublishMetric(this.telemetry, exchange.name, routingKey, true, durationMs);\n      })\n      .tapError((error) => {\n        const durationMs = Date.now() - startTime;\n        endSpanError(span, error);\n        recordPublishMetric(this.telemetry, exchange.name, routingKey, false, durationMs);\n      });\n  }\n\n  /**\n   * Close the channel and connection\n   */\n  close(): Future<Result<void, TechnicalError>> {\n    return this.amqpClient.close().mapOk(() => undefined);\n  }\n\n  private waitForConnectionReady(): Future<Result<void, TechnicalError>> {\n    return this.amqpClient.waitForConnect();\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/compression.ts","../src/errors.ts","../src/client.ts"],"sourcesContent":["import { Future, Result } from \"@swan-io/boxed\";\nimport { deflate, gzip } from \"node:zlib\";\nimport type { CompressionAlgorithm } from \"@amqp-contract/contract\";\nimport { TechnicalError } from \"@amqp-contract/core\";\nimport { match } from \"ts-pattern\";\nimport { promisify } from \"node:util\";\n\nconst gzipAsync = promisify(gzip);\nconst deflateAsync = promisify(deflate);\n\n/**\n * Compress a buffer using the specified compression algorithm.\n *\n * @param buffer - The buffer to compress\n * @param algorithm - The compression algorithm to use\n * @returns A Future with the compressed buffer or a TechnicalError\n *\n * @internal\n */\nexport function compressBuffer(\n  buffer: Buffer,\n  algorithm: CompressionAlgorithm,\n): Future<Result<Buffer, TechnicalError>> {\n  return match(algorithm)\n    .with(\"gzip\", () =>\n      Future.fromPromise(gzipAsync(buffer)).mapError(\n        (error) => new TechnicalError(\"Failed to compress with gzip\", error),\n      ),\n    )\n    .with(\"deflate\", () =>\n      Future.fromPromise(deflateAsync(buffer)).mapError(\n        (error) => new TechnicalError(\"Failed to compress with deflate\", error),\n      ),\n    )\n    .exhaustive();\n}\n","export { MessageValidationError } from \"@amqp-contract/core\";\n\n/**\n * Captured `Error.captureStackTrace` shim — only present on Node.js.\n */\nfunction captureStack(target: object, ctor: Function): void {\n  const ErrorConstructor = Error as unknown as {\n    captureStackTrace?: (target: object, constructor: Function) => void;\n  };\n  if (typeof ErrorConstructor.captureStackTrace === \"function\") {\n    ErrorConstructor.captureStackTrace(target, ctor);\n  }\n}\n\n/**\n * Returned from `TypedAmqpClient.call()` when the configured `timeoutMs` elapses\n * before the RPC server publishes a reply with the matching `correlationId`.\n *\n * The pending call is removed from the in-memory correlation map; if a reply\n * arrives after the timeout it is dropped (and a debug log is emitted by the\n * client if a logger is configured).\n */\nexport class RpcTimeoutError extends Error {\n  constructor(\n    public readonly rpcName: string,\n    public readonly timeoutMs: number,\n  ) {\n    super(`RPC call to \"${rpcName}\" timed out after ${timeoutMs}ms with no reply received`);\n    this.name = \"RpcTimeoutError\";\n    captureStack(this, this.constructor);\n  }\n}\n\n/**\n * Returned from any in-flight RPC call when the client is closed before the\n * reply is received. The correlation map is cleared on close and every pending\n * caller's promise resolves with `Result.Error(RpcCancelledError)`.\n */\nexport class RpcCancelledError extends Error {\n  constructor(public readonly rpcName: string) {\n    super(`RPC call to \"${rpcName}\" was cancelled because the client was closed`);\n    this.name = \"RpcCancelledError\";\n    captureStack(this, this.constructor);\n  }\n}\n","import {\n  extractQueue,\n  type CompressionAlgorithm,\n  type ContractDefinition,\n  type InferPublisherNames,\n  type InferRpcNames,\n} from \"@amqp-contract/contract\";\nimport {\n  AmqpClient,\n  PublishOptions as AmqpClientPublishOptions,\n  type Logger,\n  MessagingSemanticConventions,\n  TechnicalError,\n  type TelemetryProvider,\n  defaultTelemetryProvider,\n  endSpanError,\n  endSpanSuccess,\n  recordPublishMetric,\n  startPublishSpan,\n} from \"@amqp-contract/core\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { Future, Result } from \"@swan-io/boxed\";\nimport type { AmqpConnectionManagerOptions, ConnectionUrl } from \"amqp-connection-manager\";\nimport { randomUUID } from \"node:crypto\";\nimport { compressBuffer } from \"./compression.js\";\nimport { MessageValidationError, RpcCancelledError, RpcTimeoutError } from \"./errors.js\";\nimport type {\n  ClientInferPublisherInput,\n  ClientInferRpcRequestInput,\n  ClientInferRpcResponseOutput,\n} from \"./types.js\";\n\n/**\n * The RabbitMQ direct-reply-to pseudo-queue. Publishing with `replyTo` set to\n * this value tells the server to deliver the response back to the consumer\n * subscribed on this queue on the same channel — no real queue is created and\n * no setup is required beyond consuming from it once with `noAck: true`.\n *\n * @see https://www.rabbitmq.com/docs/direct-reply-to\n */\nconst DIRECT_REPLY_TO = \"amq.rabbitmq.reply-to\";\n\n/**\n * In-flight RPC call tracked by `TypedAmqpClient`. The reply consumer\n * looks up entries by `correlationId` when responses arrive.\n */\ntype PendingCall = {\n  rpcName: string;\n  responseSchema: StandardSchemaV1;\n  resolve: (\n    result: Result<\n      unknown,\n      TechnicalError | MessageValidationError | RpcTimeoutError | RpcCancelledError\n    >,\n  ) => void;\n  timer: ReturnType<typeof setTimeout>;\n};\n\n/**\n * Publish options that extend amqp-client's PublishOptions with optional compression support.\n */\nexport type PublishOptions = AmqpClientPublishOptions & {\n  /**\n   * Optional compression algorithm to use for the message payload.\n   * When specified, the message will be compressed using the chosen algorithm\n   * and the contentEncoding header will be set automatically.\n   */\n  compression?: CompressionAlgorithm | undefined;\n};\n\n/**\n * Options for creating a client\n */\nexport type CreateClientOptions<TContract extends ContractDefinition> = {\n  contract: TContract;\n  urls: ConnectionUrl[];\n  connectionOptions?: AmqpConnectionManagerOptions | undefined;\n  logger?: Logger | undefined;\n  /**\n   * Optional telemetry provider for tracing and metrics.\n   * If not provided, uses the default provider which attempts to load OpenTelemetry.\n   * OpenTelemetry instrumentation is automatically enabled if @opentelemetry/api is installed.\n   */\n  telemetry?: TelemetryProvider | undefined;\n  /**\n   * Default publish options that will be applied to all publish operations.\n   * These can be overridden by options passed to the publish method.\n   * By default, persistent is set to true for message durability.\n   */\n  defaultPublishOptions?: PublishOptions | undefined;\n  /**\n   * Maximum time in ms to wait for the AMQP connection to become ready before\n   * `create()` resolves to `Result.Error<TechnicalError>`. Without this option,\n   * `create()` waits forever — the underlying amqp-connection-manager retries\n   * indefinitely.\n   */\n  connectTimeoutMs?: number | undefined;\n};\n\n/**\n * Per-call options for `client.call()`.\n */\nexport type CallOptions = {\n  /**\n   * Maximum time in ms to wait for an RPC reply. If exceeded, the call resolves\n   * to `Result.Error<RpcTimeoutError>` and the in-memory correlation entry is\n   * cleared. A late reply arriving after the timeout is silently dropped.\n   *\n   * Required: RPC without a timeout is a footgun.\n   */\n  timeoutMs: number;\n\n  /**\n   * Optional AMQP message properties to merge into the request. `replyTo` and\n   * `correlationId` are managed by the client and cannot be overridden.\n   */\n  publishOptions?: Omit<AmqpClientPublishOptions, \"replyTo\" | \"correlationId\">;\n};\n\n/**\n * Type-safe AMQP client for publishing messages\n */\nexport class TypedAmqpClient<TContract extends ContractDefinition> {\n  /**\n   * In-flight RPC calls keyed by `correlationId`. Cleared when a reply is\n   * received, when the call times out, or when the client is closed.\n   */\n  private readonly pendingCalls = new Map<string, PendingCall>();\n\n  /**\n   * Consumer tag of the reply consumer subscribed on `amq.rabbitmq.reply-to`.\n   * Set when the contract has at least one entry in `rpcs`; undefined otherwise.\n   */\n  private replyConsumerTag?: string;\n\n  private constructor(\n    private readonly contract: TContract,\n    private readonly amqpClient: AmqpClient,\n    private readonly defaultPublishOptions: PublishOptions,\n    private readonly logger?: Logger,\n    private readonly telemetry: TelemetryProvider = defaultTelemetryProvider,\n  ) {}\n\n  /**\n   * Create a type-safe AMQP client from a contract.\n   *\n   * Connection management (including automatic reconnection) is handled internally\n   * by amqp-connection-manager via the {@link AmqpClient}. The client establishes\n   * infrastructure asynchronously in the background once the connection is ready.\n   *\n   * Connections are automatically shared across clients with the same URLs and\n   * connection options, following RabbitMQ best practices.\n   */\n  static create<TContract extends ContractDefinition>({\n    contract,\n    urls,\n    connectionOptions,\n    defaultPublishOptions,\n    logger,\n    telemetry,\n    connectTimeoutMs,\n  }: CreateClientOptions<TContract>): Future<Result<TypedAmqpClient<TContract>, TechnicalError>> {\n    const client = new TypedAmqpClient(\n      contract,\n      new AmqpClient(contract, { urls, connectionOptions, connectTimeoutMs }),\n      { persistent: true, ...defaultPublishOptions },\n      logger,\n      telemetry ?? defaultTelemetryProvider,\n    );\n\n    return client\n      .waitForConnectionReady()\n      .flatMapOk(() => client.setupReplyConsumerIfNeeded())\n      .flatMap((result) =>\n        result.match({\n          Ok: () => Future.value(Result.Ok<TypedAmqpClient<TContract>, TechnicalError>(client)),\n          // Release the AmqpClient's connection ref-count so a failed create() does not leak.\n          Error: (error) =>\n            client\n              .close()\n              .tapError((closeError) => {\n                logger?.warn(\"Failed to close client after connection failure\", {\n                  error: closeError,\n                });\n              })\n              .map(() => Result.Error<TypedAmqpClient<TContract>, TechnicalError>(error)),\n        }),\n      );\n  }\n\n  /**\n   * If the contract has any RPC entry, subscribe to `amq.rabbitmq.reply-to`\n   * once. Replies for every in-flight call arrive on this single consumer and\n   * are demultiplexed by `correlationId`.\n   */\n  private setupReplyConsumerIfNeeded(): Future<Result<void, TechnicalError>> {\n    const rpcs = this.contract.rpcs ?? {};\n    if (Object.keys(rpcs).length === 0) {\n      return Future.value(Result.Ok(undefined));\n    }\n\n    return this.amqpClient\n      .consume(DIRECT_REPLY_TO, (msg) => this.handleRpcReply(msg), { noAck: true })\n      .tapOk((tag) => {\n        this.replyConsumerTag = tag;\n      })\n      .mapOk(() => undefined);\n  }\n\n  /**\n   * Demultiplex an RPC reply by `correlationId`, validate the body against the\n   * call's response schema, and resolve the awaiting caller. Replies with no\n   * matching pending call (e.g. arriving after the call timed out) are dropped\n   * with a debug log.\n   */\n  private handleRpcReply(msg: Parameters<Parameters<AmqpClient[\"consume\"]>[1]>[0]): void {\n    if (!msg) return;\n    const correlationId = msg.properties.correlationId;\n    if (typeof correlationId !== \"string\") {\n      this.logger?.warn(\"Received RPC reply without correlationId; dropping\", {\n        deliveryTag: msg.fields.deliveryTag,\n      });\n      return;\n    }\n    const pending = this.pendingCalls.get(correlationId);\n    if (!pending) {\n      this.logger?.debug(\"Received RPC reply for unknown correlationId\", { correlationId });\n      return;\n    }\n    this.pendingCalls.delete(correlationId);\n    clearTimeout(pending.timer);\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(msg.content.toString());\n    } catch (error: unknown) {\n      pending.resolve(\n        Result.Error(\n          new TechnicalError(`Failed to parse RPC reply JSON for \"${pending.rpcName}\"`, error),\n        ),\n      );\n      return;\n    }\n\n    // Wrap the validate call itself — a Standard Schema implementation may\n    // throw synchronously, and the throw would otherwise escape the consume\n    // callback and could crash the reply consumer.\n    let rawValidation: ReturnType<StandardSchemaV1[\"~standard\"][\"validate\"]>;\n    try {\n      rawValidation = pending.responseSchema[\"~standard\"].validate(parsed);\n    } catch (error: unknown) {\n      pending.resolve(\n        Result.Error(\n          new TechnicalError(`RPC reply validation threw for \"${pending.rpcName}\"`, error),\n        ),\n      );\n      return;\n    }\n    const validationPromise =\n      rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);\n\n    validationPromise.then(\n      (validation) => {\n        if (validation.issues) {\n          pending.resolve(\n            Result.Error(new MessageValidationError(pending.rpcName, validation.issues)),\n          );\n          return;\n        }\n        pending.resolve(Result.Ok(validation.value));\n      },\n      (error: unknown) => {\n        pending.resolve(\n          Result.Error(\n            new TechnicalError(`RPC reply validation threw for \"${pending.rpcName}\"`, error),\n          ),\n        );\n      },\n    );\n  }\n\n  /**\n   * Publish a message using a defined publisher\n   *\n   * @param publisherName - The name of the publisher to use\n   * @param message - The message to publish\n   * @param options - Optional publish options including compression, headers, priority, etc.\n   *\n   * @remarks\n   * If `options.compression` is specified, the message will be compressed before publishing\n   * and the `contentEncoding` property will be set automatically. Any `contentEncoding`\n   * value already in options will be overwritten by the compression algorithm.\n   *\n   * @returns Result.Ok(void) on success, or Result.Error with specific error on failure\n   */\n  /**\n   * Publish a message using a defined publisher.\n   * TypeScript guarantees publisher exists for valid publisher names.\n   */\n  publish<TName extends InferPublisherNames<TContract>>(\n    publisherName: TName,\n    message: ClientInferPublisherInput<TContract, TName>,\n    options?: PublishOptions,\n  ): Future<Result<void, TechnicalError | MessageValidationError>> {\n    const startTime = Date.now();\n    // Non-null assertions safe: TypeScript guarantees these exist for valid TName\n    const publisher = this.contract.publishers![publisherName as string]!;\n    const { exchange, routingKey } = publisher;\n\n    // Start telemetry span\n    const span = startPublishSpan(this.telemetry, exchange.name, routingKey, {\n      [MessagingSemanticConventions.AMQP_PUBLISHER_NAME]: String(publisherName),\n    });\n\n    const validateMessage = () => {\n      const validationResult = publisher.message.payload[\"~standard\"].validate(message);\n      return Future.fromPromise(\n        validationResult instanceof Promise ? validationResult : Promise.resolve(validationResult),\n      )\n        .mapError((error) => new TechnicalError(`Validation failed`, error))\n        .mapOkToResult((validation) => {\n          if (validation.issues) {\n            return Result.Error(\n              new MessageValidationError(String(publisherName), validation.issues),\n            );\n          }\n\n          return Result.Ok(validation.value);\n        });\n    };\n\n    const publishMessage = (validatedMessage: unknown): Future<Result<void, TechnicalError>> => {\n      // Merge default options with provided options\n      const mergedOptions = { ...this.defaultPublishOptions, ...options };\n\n      // Extract compression from merged options and create publish options without it\n      const { compression, ...restOptions } = mergedOptions;\n      const publishOptions: AmqpClientPublishOptions = { ...restOptions };\n\n      // Prepare payload and options based on compression configuration\n      const preparePayload = (): Future<Result<Buffer | unknown, TechnicalError>> => {\n        if (compression) {\n          // Compress the message payload\n          const messageBuffer = Buffer.from(JSON.stringify(validatedMessage));\n          publishOptions.contentEncoding = compression;\n\n          return compressBuffer(messageBuffer, compression);\n        }\n\n        // No compression: use the channel's built-in JSON serialization\n        return Future.value(Result.Ok(validatedMessage));\n      };\n\n      // Publish the prepared payload\n      return preparePayload().flatMapOk((payload) =>\n        this.amqpClient\n          .publish(publisher.exchange.name, publisher.routingKey ?? \"\", payload, publishOptions)\n          .mapOkToResult((published) => {\n            if (!published) {\n              return Result.Error(\n                new TechnicalError(\n                  `Failed to publish message for publisher \"${String(publisherName)}\": Channel rejected the message (buffer full or other channel issue)`,\n                ),\n              );\n            }\n\n            this.logger?.info(\"Message published successfully\", {\n              publisherName: String(publisherName),\n              exchange: publisher.exchange.name,\n              routingKey: publisher.routingKey,\n              compressed: !!compression,\n            });\n\n            return Result.Ok(undefined);\n          }),\n      );\n    };\n\n    // Validate message using schema\n    return validateMessage()\n      .flatMapOk((validatedMessage) => publishMessage(validatedMessage))\n      .tapOk(() => {\n        const durationMs = Date.now() - startTime;\n        endSpanSuccess(span);\n        recordPublishMetric(this.telemetry, exchange.name, routingKey, true, durationMs);\n      })\n      .tapError((error) => {\n        const durationMs = Date.now() - startTime;\n        endSpanError(span, error);\n        recordPublishMetric(this.telemetry, exchange.name, routingKey, false, durationMs);\n      });\n  }\n\n  /**\n   * Invoke an RPC defined via `defineRpc` and await the typed response.\n   *\n   * The request payload is validated against the RPC's request schema, then\n   * published to the AMQP default exchange with the server's queue name as\n   * routing key, `replyTo` set to `amq.rabbitmq.reply-to`, and a fresh UUID\n   * `correlationId`. The returned Future resolves once a matching reply\n   * arrives and validates against the response schema, or once `timeoutMs`\n   * elapses (whichever comes first).\n   *\n   * @typeParam TName - An RPC name from `contract.rpcs`.\n   * @param rpcName - The RPC name from the contract.\n   * @param request - The request payload, validated against the request schema.\n   * @param options - Per-call options. `timeoutMs` is required.\n   *\n   * @returns `Result.Ok(response)` on a successful round-trip; `Result.Error`\n   *   on validation, transport, timeout, or cancel.\n   *\n   * @example\n   * ```typescript\n   * const result = await client\n   *   .call('calculate', { a: 1, b: 2 }, { timeoutMs: 5_000 })\n   *   .toPromise();\n   * if (result.isOk()) console.log(result.value.sum); // 3\n   * ```\n   */\n  call<TName extends InferRpcNames<TContract>>(\n    rpcName: TName,\n    request: ClientInferRpcRequestInput<TContract, TName>,\n    options: CallOptions,\n  ): Future<\n    Result<\n      ClientInferRpcResponseOutput<TContract, TName>,\n      TechnicalError | MessageValidationError | RpcTimeoutError | RpcCancelledError\n    >\n  > {\n    type CallResult = Result<\n      ClientInferRpcResponseOutput<TContract, TName>,\n      TechnicalError | MessageValidationError | RpcTimeoutError | RpcCancelledError\n    >;\n\n    // setTimeout truncates fractional ms and clamps anything outside the\n    // 32-bit signed integer range (~24.8 days) to 1ms, so reject those up\n    // front as user errors rather than producing surprising behavior.\n    const TIMEOUT_MAX_MS = 2_147_483_647;\n    if (\n      typeof options.timeoutMs !== \"number\" ||\n      !Number.isFinite(options.timeoutMs) ||\n      options.timeoutMs <= 0 ||\n      options.timeoutMs > TIMEOUT_MAX_MS\n    ) {\n      return Future.value(\n        Result.Error(\n          new TechnicalError(\n            `Invalid timeoutMs for RPC call to \"${String(rpcName)}\": expected a finite positive number ≤ ${TIMEOUT_MAX_MS}, got ${String(options.timeoutMs)}`,\n          ),\n        ) as CallResult,\n      );\n    }\n\n    const startTime = Date.now();\n    // Non-null assertion safe: TName is constrained to RPC names in the contract.\n    const rpc = this.contract.rpcs![rpcName as string]!;\n    const requestSchema = rpc.request.payload;\n    const responseSchema = rpc.response.payload;\n    const queueName = extractQueue(rpc.queue).name;\n\n    // RPC publishes to the default exchange with the queue name as routing key.\n    const span = startPublishSpan(this.telemetry, \"\", queueName, {\n      [MessagingSemanticConventions.AMQP_PUBLISHER_NAME]: String(rpcName),\n    });\n\n    const correlationId = randomUUID();\n    const callFuture = Future.make<CallResult>((resolve) => {\n      const timer = setTimeout(() => {\n        const pending = this.pendingCalls.get(correlationId);\n        if (!pending) return;\n        this.pendingCalls.delete(correlationId);\n        resolve(Result.Error(new RpcTimeoutError(String(rpcName), options.timeoutMs)));\n      }, options.timeoutMs);\n\n      this.pendingCalls.set(correlationId, {\n        rpcName: String(rpcName),\n        responseSchema,\n        resolve: resolve as PendingCall[\"resolve\"],\n        timer,\n      });\n    });\n\n    const validateRequest = (): Future<\n      Result<unknown, TechnicalError | MessageValidationError>\n    > => {\n      // Wrap the validate call — a Standard Schema implementation may throw\n      // synchronously, and that throw would otherwise escape the Future chain\n      // and leave the pending-call entry/timer dangling until timeout.\n      let rawValidation: ReturnType<StandardSchemaV1[\"~standard\"][\"validate\"]>;\n      try {\n        rawValidation = requestSchema[\"~standard\"].validate(request);\n      } catch (error: unknown) {\n        return Future.value(\n          Result.Error<unknown, TechnicalError | MessageValidationError>(\n            new TechnicalError(\"RPC request validation threw\", error),\n          ),\n        );\n      }\n      const validationPromise =\n        rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);\n      return Future.fromPromise(validationPromise)\n        .mapError((error) => new TechnicalError(\"RPC request validation threw\", error))\n        .mapOkToResult((validation) =>\n          validation.issues\n            ? Result.Error<unknown, TechnicalError | MessageValidationError>(\n                new MessageValidationError(String(rpcName), validation.issues),\n              )\n            : Result.Ok<unknown, TechnicalError | MessageValidationError>(validation.value),\n        );\n    };\n\n    const publishRequest = (validatedRequest: unknown): Future<Result<void, TechnicalError>> => {\n      // Merge `defaultPublishOptions` (persistent, priority, headers, …) with\n      // the per-call options, then layer the RPC-managed fields on top so they\n      // cannot be overridden. `compression` is intentionally dropped: RPC v1\n      // does not implement reply-side decompression, so request-side\n      // compression would break the round-trip.\n      const { compression: _ignoredCompression, ...defaultsWithoutCompression } =\n        this.defaultPublishOptions;\n      const publishOptions: AmqpClientPublishOptions = {\n        ...defaultsWithoutCompression,\n        ...options.publishOptions,\n        replyTo: DIRECT_REPLY_TO,\n        correlationId,\n        contentType: \"application/json\",\n      };\n      return this.amqpClient\n        .publish(\"\", queueName, validatedRequest, publishOptions)\n        .mapOkToResult((published) =>\n          published\n            ? Result.Ok<void, TechnicalError>(undefined)\n            : Result.Error<void, TechnicalError>(\n                new TechnicalError(\n                  `Failed to publish RPC request for \"${String(rpcName)}\": channel buffer full`,\n                ),\n              ),\n        );\n    };\n\n    // Validate the request, publish it, and await the reply (or timeout).\n    return validateRequest()\n      .flatMapOk((validated) => publishRequest(validated))\n      .flatMap((preflight) => {\n        if (preflight.isError()) {\n          // Publish/validation failed before the request hit the broker — clean\n          // up the pending entry so the timer never fires.\n          const pending = this.pendingCalls.get(correlationId);\n          if (pending) {\n            clearTimeout(pending.timer);\n            this.pendingCalls.delete(correlationId);\n          }\n          return Future.value(Result.Error(preflight.error) as CallResult);\n        }\n        return callFuture;\n      })\n      .tapOk(() => {\n        const durationMs = Date.now() - startTime;\n        endSpanSuccess(span);\n        recordPublishMetric(this.telemetry, \"\", queueName, true, durationMs);\n      })\n      .tapError((error) => {\n        const durationMs = Date.now() - startTime;\n        endSpanError(span, error);\n        recordPublishMetric(this.telemetry, \"\", queueName, false, durationMs);\n      });\n  }\n\n  /**\n   * Close the channel and connection. Cancels the reply consumer (if any) and\n   * rejects every in-flight RPC call with `RpcCancelledError`.\n   */\n  close(): Future<Result<void, TechnicalError>> {\n    // Reject pending calls first — once close() runs, no reply will arrive.\n    for (const [, pending] of this.pendingCalls) {\n      clearTimeout(pending.timer);\n      pending.resolve(Result.Error(new RpcCancelledError(pending.rpcName)));\n    }\n    this.pendingCalls.clear();\n\n    const cancelReply = this.replyConsumerTag\n      ? this.amqpClient.cancel(this.replyConsumerTag).tapError((error) => {\n          this.logger?.warn(\"Failed to cancel RPC reply consumer during close\", { error });\n        })\n      : Future.value(Result.Ok<void, TechnicalError>(undefined));\n\n    return cancelReply.flatMap(() => this.amqpClient.close()).mapOk(() => undefined);\n  }\n\n  private waitForConnectionReady(): Future<Result<void, TechnicalError>> {\n    return this.amqpClient.waitForConnect();\n  }\n}\n"],"mappings":";;;;;;;;AAOA,MAAM,YAAY,UAAU,KAAK;AACjC,MAAM,eAAe,UAAU,QAAQ;;;;;;;;;;AAWvC,SAAgB,eACd,QACA,WACwC;AACxC,QAAO,MAAM,UAAU,CACpB,KAAK,cACJ,OAAO,YAAY,UAAU,OAAO,CAAC,CAAC,UACnC,UAAU,IAAI,eAAe,gCAAgC,MAAM,CACrE,CACF,CACA,KAAK,iBACJ,OAAO,YAAY,aAAa,OAAO,CAAC,CAAC,UACtC,UAAU,IAAI,eAAe,mCAAmC,MAAM,CACxE,CACF,CACA,YAAY;;;;;;;AC7BjB,SAAS,aAAa,QAAgB,MAAsB;CAC1D,MAAM,mBAAmB;AAGzB,KAAI,OAAO,iBAAiB,sBAAsB,WAChD,kBAAiB,kBAAkB,QAAQ,KAAK;;;;;;;;;;AAYpD,IAAa,kBAAb,cAAqC,MAAM;CACzC,YACE,SACA,WACA;AACA,QAAM,gBAAgB,QAAQ,oBAAoB,UAAU,2BAA2B;AAHvE,OAAA,UAAA;AACA,OAAA,YAAA;AAGhB,OAAK,OAAO;AACZ,eAAa,MAAM,KAAK,YAAY;;;;;;;;AASxC,IAAa,oBAAb,cAAuC,MAAM;CAC3C,YAAY,SAAiC;AAC3C,QAAM,gBAAgB,QAAQ,+CAA+C;AADnD,OAAA,UAAA;AAE1B,OAAK,OAAO;AACZ,eAAa,MAAM,KAAK,YAAY;;;;;;;;;;;;;ACFxC,MAAM,kBAAkB;;;;AAkFxB,IAAa,kBAAb,MAAa,gBAAsD;;;;;CAKjE,+BAAgC,IAAI,KAA0B;;;;;CAM9D;CAEA,YACE,UACA,YACA,uBACA,QACA,YAAgD,0BAChD;AALiB,OAAA,WAAA;AACA,OAAA,aAAA;AACA,OAAA,wBAAA;AACA,OAAA,SAAA;AACA,OAAA,YAAA;;;;;;;;;;;;CAanB,OAAO,OAA6C,EAClD,UACA,MACA,mBACA,uBACA,QACA,WACA,oBAC6F;EAC7F,MAAM,SAAS,IAAI,gBACjB,UACA,IAAI,WAAW,UAAU;GAAE;GAAM;GAAmB;GAAkB,CAAC,EACvE;GAAE,YAAY;GAAM,GAAG;GAAuB,EAC9C,QACA,aAAa,yBACd;AAED,SAAO,OACJ,wBAAwB,CACxB,gBAAgB,OAAO,4BAA4B,CAAC,CACpD,SAAS,WACR,OAAO,MAAM;GACX,UAAU,OAAO,MAAM,OAAO,GAA+C,OAAO,CAAC;GAErF,QAAQ,UACN,OACG,OAAO,CACP,UAAU,eAAe;AACxB,YAAQ,KAAK,mDAAmD,EAC9D,OAAO,YACR,CAAC;KACF,CACD,UAAU,OAAO,MAAkD,MAAM,CAAC;GAChF,CAAC,CACH;;;;;;;CAQL,6BAA2E;EACzE,MAAM,OAAO,KAAK,SAAS,QAAQ,EAAE;AACrC,MAAI,OAAO,KAAK,KAAK,CAAC,WAAW,EAC/B,QAAO,OAAO,MAAM,OAAO,GAAG,KAAA,EAAU,CAAC;AAG3C,SAAO,KAAK,WACT,QAAQ,kBAAkB,QAAQ,KAAK,eAAe,IAAI,EAAE,EAAE,OAAO,MAAM,CAAC,CAC5E,OAAO,QAAQ;AACd,QAAK,mBAAmB;IACxB,CACD,YAAY,KAAA,EAAU;;;;;;;;CAS3B,eAAuB,KAAgE;AACrF,MAAI,CAAC,IAAK;EACV,MAAM,gBAAgB,IAAI,WAAW;AACrC,MAAI,OAAO,kBAAkB,UAAU;AACrC,QAAK,QAAQ,KAAK,sDAAsD,EACtE,aAAa,IAAI,OAAO,aACzB,CAAC;AACF;;EAEF,MAAM,UAAU,KAAK,aAAa,IAAI,cAAc;AACpD,MAAI,CAAC,SAAS;AACZ,QAAK,QAAQ,MAAM,gDAAgD,EAAE,eAAe,CAAC;AACrF;;AAEF,OAAK,aAAa,OAAO,cAAc;AACvC,eAAa,QAAQ,MAAM;EAE3B,IAAI;AACJ,MAAI;AACF,YAAS,KAAK,MAAM,IAAI,QAAQ,UAAU,CAAC;WACpC,OAAgB;AACvB,WAAQ,QACN,OAAO,MACL,IAAI,eAAe,uCAAuC,QAAQ,QAAQ,IAAI,MAAM,CACrF,CACF;AACD;;EAMF,IAAI;AACJ,MAAI;AACF,mBAAgB,QAAQ,eAAe,aAAa,SAAS,OAAO;WAC7D,OAAgB;AACvB,WAAQ,QACN,OAAO,MACL,IAAI,eAAe,mCAAmC,QAAQ,QAAQ,IAAI,MAAM,CACjF,CACF;AACD;;AAKF,GAFE,yBAAyB,UAAU,gBAAgB,QAAQ,QAAQ,cAAc,EAEjE,MACf,eAAe;AACd,OAAI,WAAW,QAAQ;AACrB,YAAQ,QACN,OAAO,MAAM,IAAI,uBAAuB,QAAQ,SAAS,WAAW,OAAO,CAAC,CAC7E;AACD;;AAEF,WAAQ,QAAQ,OAAO,GAAG,WAAW,MAAM,CAAC;MAE7C,UAAmB;AAClB,WAAQ,QACN,OAAO,MACL,IAAI,eAAe,mCAAmC,QAAQ,QAAQ,IAAI,MAAM,CACjF,CACF;IAEJ;;;;;;;;;;;;;;;;;;;;CAqBH,QACE,eACA,SACA,SAC+D;EAC/D,MAAM,YAAY,KAAK,KAAK;EAE5B,MAAM,YAAY,KAAK,SAAS,WAAY;EAC5C,MAAM,EAAE,UAAU,eAAe;EAGjC,MAAM,OAAO,iBAAiB,KAAK,WAAW,SAAS,MAAM,YAAY,GACtE,6BAA6B,sBAAsB,OAAO,cAAc,EAC1E,CAAC;EAEF,MAAM,wBAAwB;GAC5B,MAAM,mBAAmB,UAAU,QAAQ,QAAQ,aAAa,SAAS,QAAQ;AACjF,UAAO,OAAO,YACZ,4BAA4B,UAAU,mBAAmB,QAAQ,QAAQ,iBAAiB,CAC3F,CACE,UAAU,UAAU,IAAI,eAAe,qBAAqB,MAAM,CAAC,CACnE,eAAe,eAAe;AAC7B,QAAI,WAAW,OACb,QAAO,OAAO,MACZ,IAAI,uBAAuB,OAAO,cAAc,EAAE,WAAW,OAAO,CACrE;AAGH,WAAO,OAAO,GAAG,WAAW,MAAM;KAClC;;EAGN,MAAM,kBAAkB,qBAAoE;GAK1F,MAAM,EAAE,aAAa,GAAG,gBAAgB;IAHhB,GAAG,KAAK;IAAuB,GAAG;IAGL;GACrD,MAAM,iBAA2C,EAAE,GAAG,aAAa;GAGnE,MAAM,uBAAyE;AAC7E,QAAI,aAAa;KAEf,MAAM,gBAAgB,OAAO,KAAK,KAAK,UAAU,iBAAiB,CAAC;AACnE,oBAAe,kBAAkB;AAEjC,YAAO,eAAe,eAAe,YAAY;;AAInD,WAAO,OAAO,MAAM,OAAO,GAAG,iBAAiB,CAAC;;AAIlD,UAAO,gBAAgB,CAAC,WAAW,YACjC,KAAK,WACF,QAAQ,UAAU,SAAS,MAAM,UAAU,cAAc,IAAI,SAAS,eAAe,CACrF,eAAe,cAAc;AAC5B,QAAI,CAAC,UACH,QAAO,OAAO,MACZ,IAAI,eACF,4CAA4C,OAAO,cAAc,CAAC,sEACnE,CACF;AAGH,SAAK,QAAQ,KAAK,kCAAkC;KAClD,eAAe,OAAO,cAAc;KACpC,UAAU,UAAU,SAAS;KAC7B,YAAY,UAAU;KACtB,YAAY,CAAC,CAAC;KACf,CAAC;AAEF,WAAO,OAAO,GAAG,KAAA,EAAU;KAC3B,CACL;;AAIH,SAAO,iBAAiB,CACrB,WAAW,qBAAqB,eAAe,iBAAiB,CAAC,CACjE,YAAY;GACX,MAAM,aAAa,KAAK,KAAK,GAAG;AAChC,kBAAe,KAAK;AACpB,uBAAoB,KAAK,WAAW,SAAS,MAAM,YAAY,MAAM,WAAW;IAChF,CACD,UAAU,UAAU;GACnB,MAAM,aAAa,KAAK,KAAK,GAAG;AAChC,gBAAa,MAAM,MAAM;AACzB,uBAAoB,KAAK,WAAW,SAAS,MAAM,YAAY,OAAO,WAAW;IACjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BN,KACE,SACA,SACA,SAMA;EASA,MAAM,iBAAiB;AACvB,MACE,OAAO,QAAQ,cAAc,YAC7B,CAAC,OAAO,SAAS,QAAQ,UAAU,IACnC,QAAQ,aAAa,KACrB,QAAQ,YAAY,eAEpB,QAAO,OAAO,MACZ,OAAO,MACL,IAAI,eACF,sCAAsC,OAAO,QAAQ,CAAC,yCAAyC,eAAe,QAAQ,OAAO,QAAQ,UAAU,GAChJ,CACF,CACF;EAGH,MAAM,YAAY,KAAK,KAAK;EAE5B,MAAM,MAAM,KAAK,SAAS,KAAM;EAChC,MAAM,gBAAgB,IAAI,QAAQ;EAClC,MAAM,iBAAiB,IAAI,SAAS;EACpC,MAAM,YAAY,aAAa,IAAI,MAAM,CAAC;EAG1C,MAAM,OAAO,iBAAiB,KAAK,WAAW,IAAI,WAAW,GAC1D,6BAA6B,sBAAsB,OAAO,QAAQ,EACpE,CAAC;EAEF,MAAM,gBAAgB,YAAY;EAClC,MAAM,aAAa,OAAO,MAAkB,YAAY;GACtD,MAAM,QAAQ,iBAAiB;AAE7B,QAAI,CADY,KAAK,aAAa,IAAI,cAC1B,CAAE;AACd,SAAK,aAAa,OAAO,cAAc;AACvC,YAAQ,OAAO,MAAM,IAAI,gBAAgB,OAAO,QAAQ,EAAE,QAAQ,UAAU,CAAC,CAAC;MAC7E,QAAQ,UAAU;AAErB,QAAK,aAAa,IAAI,eAAe;IACnC,SAAS,OAAO,QAAQ;IACxB;IACS;IACT;IACD,CAAC;IACF;EAEF,MAAM,wBAED;GAIH,IAAI;AACJ,OAAI;AACF,oBAAgB,cAAc,aAAa,SAAS,QAAQ;YACrD,OAAgB;AACvB,WAAO,OAAO,MACZ,OAAO,MACL,IAAI,eAAe,gCAAgC,MAAM,CAC1D,CACF;;GAEH,MAAM,oBACJ,yBAAyB,UAAU,gBAAgB,QAAQ,QAAQ,cAAc;AACnF,UAAO,OAAO,YAAY,kBAAkB,CACzC,UAAU,UAAU,IAAI,eAAe,gCAAgC,MAAM,CAAC,CAC9E,eAAe,eACd,WAAW,SACP,OAAO,MACL,IAAI,uBAAuB,OAAO,QAAQ,EAAE,WAAW,OAAO,CAC/D,GACD,OAAO,GAAqD,WAAW,MAAM,CAClF;;EAGL,MAAM,kBAAkB,qBAAoE;GAM1F,MAAM,EAAE,aAAa,qBAAqB,GAAG,+BAC3C,KAAK;GACP,MAAM,iBAA2C;IAC/C,GAAG;IACH,GAAG,QAAQ;IACX,SAAS;IACT;IACA,aAAa;IACd;AACD,UAAO,KAAK,WACT,QAAQ,IAAI,WAAW,kBAAkB,eAAe,CACxD,eAAe,cACd,YACI,OAAO,GAAyB,KAAA,EAAU,GAC1C,OAAO,MACL,IAAI,eACF,sCAAsC,OAAO,QAAQ,CAAC,wBACvD,CACF,CACN;;AAIL,SAAO,iBAAiB,CACrB,WAAW,cAAc,eAAe,UAAU,CAAC,CACnD,SAAS,cAAc;AACtB,OAAI,UAAU,SAAS,EAAE;IAGvB,MAAM,UAAU,KAAK,aAAa,IAAI,cAAc;AACpD,QAAI,SAAS;AACX,kBAAa,QAAQ,MAAM;AAC3B,UAAK,aAAa,OAAO,cAAc;;AAEzC,WAAO,OAAO,MAAM,OAAO,MAAM,UAAU,MAAM,CAAe;;AAElE,UAAO;IACP,CACD,YAAY;GACX,MAAM,aAAa,KAAK,KAAK,GAAG;AAChC,kBAAe,KAAK;AACpB,uBAAoB,KAAK,WAAW,IAAI,WAAW,MAAM,WAAW;IACpE,CACD,UAAU,UAAU;GACnB,MAAM,aAAa,KAAK,KAAK,GAAG;AAChC,gBAAa,MAAM,MAAM;AACzB,uBAAoB,KAAK,WAAW,IAAI,WAAW,OAAO,WAAW;IACrE;;;;;;CAON,QAA8C;AAE5C,OAAK,MAAM,GAAG,YAAY,KAAK,cAAc;AAC3C,gBAAa,QAAQ,MAAM;AAC3B,WAAQ,QAAQ,OAAO,MAAM,IAAI,kBAAkB,QAAQ,QAAQ,CAAC,CAAC;;AAEvE,OAAK,aAAa,OAAO;AAQzB,UANoB,KAAK,mBACrB,KAAK,WAAW,OAAO,KAAK,iBAAiB,CAAC,UAAU,UAAU;AAChE,QAAK,QAAQ,KAAK,oDAAoD,EAAE,OAAO,CAAC;IAChF,GACF,OAAO,MAAM,OAAO,GAAyB,KAAA,EAAU,CAAC,EAEzC,cAAc,KAAK,WAAW,OAAO,CAAC,CAAC,YAAY,KAAA,EAAU;;CAGlF,yBAAuE;AACrE,SAAO,KAAK,WAAW,gBAAgB"}