@amqp-contract/core 0.23.1 → 0.25.0

package/README.md

@@ -5,7 +5,7 @@
 [![CI](https://github.com/btravers/amqp-contract/actions/workflows/ci.yml/badge.svg)](https://github.com/btravers/amqp-contract/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/@amqp-contract/core.svg?logo=npm)](https://www.npmjs.com/package/@amqp-contract/core)
 [![npm downloads](https://img.shields.io/npm/dm/@amqp-contract/core.svg)](https://www.npmjs.com/package/@amqp-contract/core)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![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)
 
 This package provides centralized functionality for establishing AMQP topology (exchanges, queues, and bindings) from contract definitions, and defines the `Logger` interface used across amqp-contract packages.
@@ -87,11 +87,13 @@ const logger: Logger = {
 // Pass the logger to client or worker
 import { TypedAmqpClient } from "@amqp-contract/client";
 
-const client = await TypedAmqpClient.create({
-  contract,
-  urls: ["amqp://localhost"],
-  logger, // Optional: logs published messages
-});
+const client = (
+  await TypedAmqpClient.create({
+    contract,
+    urls: ["amqp://localhost"],
+    logger, // Optional: logs published messages
+  })
+)._unsafeUnwrap();
 ```
 
 ## API

package/dist/index.cjs

@@ -21,7 +21,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let _swan_io_boxed = require("@swan-io/boxed");
+let neverthrow = require("neverthrow");
 let amqp_connection_manager = require("amqp-connection-manager");
 amqp_connection_manager = __toESM(amqp_connection_manager, 1);
 let _amqp_contract_contract = require("@amqp-contract/contract");
@@ -321,7 +321,7 @@ function callSetupFunc(setup, channel) {
 * Default time `waitForConnect` will wait for the broker before erroring out.
 * Defaulting to a finite value (rather than waiting forever) means a fail-fast
 * developer experience: a misconfigured URL, a down broker, or wrong
-* credentials surface as a Result.Error within 30 seconds. Pass `null`
+* credentials surface as an `err` within 30 seconds. Pass `null`
 * explicitly to disable the timeout — `Infinity` and other non-finite values
 * are also coerced to "no timeout" because Node's `setTimeout` clamps large
 * delays to ~24.8 days and silently fires near-immediately on `Infinity`.
@@ -348,7 +348,7 @@ function resolveConnectTimeoutMs(input) {
 * - Automatic AMQP topology setup (exchanges, queues, bindings) from contract
 * - Channel creation with JSON serialization enabled by default
 *
-* All operations return `Future<Result<T, TechnicalError>>` for consistent error handling.
+* All operations return `ResultAsync<T, TechnicalError>` for consistent error handling.
 *
 * @example
 * ```typescript
@@ -357,14 +357,14 @@ function resolveConnectTimeoutMs(input) {
 *   connectionOptions: { heartbeatIntervalInSeconds: 30 }
 * });
 *
-* // Wait for connection
-* await client.waitForConnect().resultToPromise();
+* // Wait for connection (ResultAsync is thenable)
+* await client.waitForConnect();
 *
 * // Publish a message
-* const result = await client.publish('exchange', 'routingKey', { data: 'value' }).resultToPromise();
+* const result = await client.publish('exchange', 'routingKey', { data: 'value' });
 *
 * // Close when done
-* await client.close().resultToPromise();
+* await client.close();
 * ```
 */
 var AmqpClient = class {
@@ -375,6 +375,15 @@ var AmqpClient = class {
 	/** Resolved timeout in ms; `null` means "wait forever". */
 	connectTimeoutMs;
 	/**
+	* Per-consumer prefetch setup functions registered via `addSetup` so they
+	* can be removed in {@link cancel} once the consumer is gone — otherwise
+	* the channel wrapper would replay the cancelled consumer's QoS on every
+	* reconnect and silently apply it to subsequent consumers.
+	*
+	* @internal
+	*/
+	prefetchSetups = /* @__PURE__ */ new Map();
+	/**
 	* Create a new AMQP client instance.
 	*
 	* The client will automatically:
@@ -422,7 +431,7 @@ var AmqpClient = class {
 	* Wait for the channel to be connected and ready.
 	*
 	* If `connectTimeoutMs` was provided in the constructor options, the returned
-	* Future resolves to `Result.Error<TechnicalError>` once the timeout elapses.
+	* ResultAsync resolves to `err(TechnicalError)` once the timeout elapses.
 	* Without a timeout, this waits forever — amqp-connection-manager retries
 	* connections indefinitely and never errors on its own.
 	*
@@ -431,9 +440,6 @@ var AmqpClient = class {
 	* connection's reference count. Callers must invoke `close()` on the error
 	* path to release the connection — `waitForConnect` does not do this
 	* automatically. The typed factories handle this cleanup for you.
-	*
-	* @returns A Future resolving to `Result.Ok(void)` on connect, or
-	*   `Result.Error(TechnicalError)` on timeout / connection failure.
 	*/
 	waitForConnect() {
 		const connectPromise = this.channelWrapper.waitForConnect();
@@ -450,50 +456,76 @@ var AmqpClient = class {
 				reject(error);
 			});
 		});
-		return _swan_io_boxed.Future.fromPromise(racedPromise).mapError((error) => new TechnicalError("Failed to connect to AMQP broker", error));
+		return neverthrow.ResultAsync.fromPromise(racedPromise, (error) => new TechnicalError("Failed to connect to AMQP broker", error));
 	}
 	/**
 	* Publish a message to an exchange.
 	*
-	* @param exchange - The exchange name
-	* @param routingKey - The routing key
-	* @param content - The message content (will be JSON serialized if json: true)
-	* @param options - Optional publish options
-	* @returns A Future with `Result<boolean>` - true if message was sent, false if channel buffer is full
+	* @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
 	*/
 	publish(exchange, routingKey, content, options) {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.publish(exchange, routingKey, content, options)).mapError((error) => new TechnicalError("Failed to publish message", error));
+		return neverthrow.ResultAsync.fromPromise(this.channelWrapper.publish(exchange, routingKey, content, options), (error) => new TechnicalError("Failed to publish message", error));
 	}
 	/**
 	* Publish a message directly to a queue.
 	*
-	* @param queue - The queue name
-	* @param content - The message content (will be JSON serialized if json: true)
-	* @param options - Optional publish options
-	* @returns A Future with `Result<boolean>` - true if message was sent, false if channel buffer is full
+	* @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
 	*/
 	sendToQueue(queue, content, options) {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.sendToQueue(queue, content, options)).mapError((error) => new TechnicalError("Failed to publish message to queue", error));
+		return neverthrow.ResultAsync.fromPromise(this.channelWrapper.sendToQueue(queue, content, options), (error) => new TechnicalError("Failed to publish message to queue", error));
 	}
 	/**
 	* Start consuming messages from a queue.
 	*
-	* @param queue - The queue name
-	* @param callback - The callback to invoke for each message
-	* @param options - Optional consume options
-	* @returns A Future with `Result<string>` - the consumer tag
+	* If `options.prefetch` is set, a per-consumer prefetch count is applied via
+	* `channel.prefetch(count, false)` registered as a setup function on the
+	* channel wrapper *before* the underlying `consume` call. Registering it via
+	* `addSetup` ensures the prefetch is reapplied automatically on channel
+	* reconnect; using `global=false` scopes it to subsequent consumers on the
+	* channel (RabbitMQ semantics — opposite of intuition: `false` is per-
+	* consumer, `true` is channel-wide).
+	*
+	* `prefetch` is stripped from the options handed to `channelWrapper.consume`
+	* because it is not a valid `amqplib` `Options.Consume` field — leaving it
+	* in would just travel as a no-op key-value pair on the consume frame.
+	*
+	* @returns ResultAsync resolving to the consumer tag.
 	*/
 	consume(queue, callback, options) {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.consume(queue, callback, options)).mapError((error) => new TechnicalError("Failed to start consuming messages", error)).mapOk((reply) => reply.consumerTag);
+		const { prefetch, ...consumeOptions } = options ?? {};
+		if (prefetch !== void 0) {
+			if (!Number.isInteger(prefetch) || prefetch < 0 || prefetch > 65535) return (0, neverthrow.errAsync)(new TechnicalError(`Invalid prefetch: expected a non-negative integer ≤ 65535, got ${String(prefetch)}`));
+		}
+		const prefetchSetup = typeof prefetch === "number" ? async (channel) => {
+			await channel.prefetch(prefetch, false);
+		} : void 0;
+		const consumePromise = (async () => {
+			if (prefetchSetup) await this.channelWrapper.addSetup(prefetchSetup);
+			let reply;
+			try {
+				reply = await this.channelWrapper.consume(queue, callback, consumeOptions);
+			} catch (error) {
+				if (prefetchSetup) await this.channelWrapper.removeSetup(prefetchSetup).catch(() => {});
+				throw error;
+			}
+			if (prefetchSetup) this.prefetchSetups.set(reply.consumerTag, prefetchSetup);
+			return reply;
+		})();
+		return neverthrow.ResultAsync.fromPromise(consumePromise, (error) => new TechnicalError("Failed to start consuming messages", error)).map((reply) => reply.consumerTag);
 	}
 	/**
 	* Cancel a consumer by its consumer tag.
-	*
-	* @param consumerTag - The consumer tag to cancel
-	* @returns A Future that resolves when the consumer is cancelled
 	*/
 	cancel(consumerTag) {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.cancel(consumerTag)).mapError((error) => new TechnicalError("Failed to cancel consumer", error)).mapOk(() => void 0);
+		return neverthrow.ResultAsync.fromPromise((async () => {
+			const setup = this.prefetchSetups.get(consumerTag);
+			this.prefetchSetups.delete(consumerTag);
+			try {
+				await this.channelWrapper.cancel(consumerTag);
+			} finally {
+				if (setup !== void 0) await this.channelWrapper.removeSetup(setup).catch(() => {});
+			}
+		})(), (error) => new TechnicalError("Failed to cancel consumer", error)).map(() => void 0);
 	}
 	/**
 	* Acknowledge a message.
@@ -546,13 +578,18 @@ var AmqpClient = class {
 	* - Decrease the reference count on the shared connection
 	* - Close the connection if this was the last client using it
 	*
-	* @returns A Future that resolves when the channel and connection are closed
+	* Both steps run regardless of each other's outcome; if both fail, the
+	* errors are wrapped in an AggregateError.
 	*/
 	close() {
-		return _swan_io_boxed.Future.fromPromise(this.channelWrapper.close()).mapError((error) => new TechnicalError("Failed to close channel", error)).flatMap((channelResult) => _swan_io_boxed.Future.fromPromise(ConnectionManagerSingleton.getInstance().releaseConnection(this.urls, this.connectionOptions)).mapError((error) => new TechnicalError("Failed to release connection", error)).map((releaseResult) => {
-			if (channelResult.isError() && releaseResult.isError()) return _swan_io_boxed.Result.Error(new TechnicalError("Failed to close channel and release connection", new AggregateError([channelResult.error, releaseResult.error], "Failed to close channel and release connection")));
-			return channelResult.isError() ? channelResult : releaseResult;
-		}));
+		return new neverthrow.ResultAsync((async () => {
+			const channelResult = await neverthrow.ResultAsync.fromPromise(this.channelWrapper.close(), (error) => new TechnicalError("Failed to close channel", error));
+			const releaseResult = await neverthrow.ResultAsync.fromPromise(ConnectionManagerSingleton.getInstance().releaseConnection(this.urls, this.connectionOptions), (error) => new TechnicalError("Failed to release connection", error));
+			if (channelResult.isErr() && releaseResult.isErr()) return (0, neverthrow.err)(new TechnicalError("Failed to close channel and release connection", new AggregateError([channelResult.error, releaseResult.error], "Failed to close channel and release connection")));
+			if (channelResult.isErr()) return channelResult;
+			if (releaseResult.isErr()) return releaseResult;
+			return (0, neverthrow.ok)(void 0);
+		})());
 	}
 	/**
 	* Reset connection singleton cache (for testing only)
@@ -563,6 +600,32 @@ var AmqpClient = class {
 	}
 };
 //#endregion
+//#region src/parsing.ts
+/**
+* Parse a `Buffer` as JSON, mapping any `JSON.parse` exception to the
+* caller-supplied error type.
+*
+* Use this in consume / reply paths where a parse failure is a typed value,
+* not a thrown exception — the caller decides how to translate the raw error
+* into a domain-level error (e.g. {@link TechnicalError}).
+*
+* @typeParam E - The error type produced by `errorFn`.
+* @param buffer - The raw message body to parse.
+* @param errorFn - Callback invoked with the underlying `JSON.parse` error.
+* @returns A `Result` containing the parsed `unknown` value or the mapped error.
+*
+* @example
+* ```typescript
+* const parsed = safeJsonParse(
+*   msg.content,
+*   (error) => new TechnicalError("Failed to parse JSON", error),
+* );
+* ```
+*/
+function safeJsonParse(buffer, errorFn) {
+	return neverthrow.Result.fromThrowable(() => JSON.parse(buffer.toString()), errorFn)();
+}
+//#endregion
 //#region src/telemetry.ts
 /**
 * SpanKind values from OpenTelemetry.
@@ -841,6 +904,7 @@ exports.endSpanSuccess = endSpanSuccess;
 exports.recordConsumeMetric = recordConsumeMetric;
 exports.recordLateRpcReply = recordLateRpcReply;
 exports.recordPublishMetric = recordPublishMetric;
+exports.safeJsonParse = safeJsonParse;
 exports.setupAmqpTopology = setupAmqpTopology;
 exports.startConsumeSpan = startConsumeSpan;
 exports.startPublishSpan = startPublishSpan;

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { ContractDefinition } from "@amqp-contract/contract";
-import { Future, Result } from "@swan-io/boxed";
 import { AmqpConnectionManager, AmqpConnectionManagerOptions, ConnectionUrl, CreateChannelOpts } from "amqp-connection-manager";
 import { Channel, ConsumeMessage, Options } from "amqplib";
+import { Result, ResultAsync } from "neverthrow";
 import { Attributes, Counter, Histogram, Span, Tracer } from "@opentelemetry/api";
 
 //#region src/errors.d.ts
@@ -35,7 +35,7 @@ declare class MessageValidationError extends Error {
  * Default time `waitForConnect` will wait for the broker before erroring out.
  * Defaulting to a finite value (rather than waiting forever) means a fail-fast
  * developer experience: a misconfigured URL, a down broker, or wrong
- * credentials surface as a Result.Error within 30 seconds. Pass `null`
+ * credentials surface as an `err` within 30 seconds. Pass `null`
  * explicitly to disable the timeout — `Infinity` and other non-finite values
  * are also coerced to "no timeout" because Node's `setTimeout` clamps large
  * delays to ~24.8 days and silently fires near-immediately on `Infinity`.
@@ -63,16 +63,29 @@ type AmqpClientOptions = {
  */
 type ConsumeCallback = (msg: ConsumeMessage | null) => void | Promise<void>;
 /**
- * Publish options that extend amqplib's Options.Publish with optional timeout support.
+ * Publish options for `AmqpClient.publish` / `AmqpClient.sendToQueue`.
+ *
+ * Currently a re-export of amqplib's `Options.Publish`. A previous version of
+ * this type also exposed a `timeout` field, but that field never had a
+ * meaningful AMQP-level effect in this codebase and has been removed to avoid
+ * suggesting behaviour we do not provide. (`amqp-connection-manager`'s own
+ * `publishTimeout` channel option is unrelated and is configured at channel
+ * creation, not per-publish.)
  */
-type PublishOptions = Options.Publish & {
-  /** Message will be rejected after timeout ms */timeout?: number;
-};
+type PublishOptions = Options.Publish;
 /**
- * Consume options that extend amqplib's Options.Consume with optional prefetch support.
+ * Consume options that extend amqplib's `Options.Consume` with an optional
+ * per-consumer prefetch count.
+ *
+ * `prefetch` is intercepted by {@link AmqpClient.consume}: it is stripped from
+ * the options handed to the underlying `channelWrapper.consume(...)` call
+ * (since amqplib's `Options.Consume` does not include it) and applied via
+ * `channel.prefetch(count, false)` registered through `addSetup` *before* the
+ * consume so the value is in effect when the consumer starts and is reapplied
+ * automatically on channel reconnect.
  */
 type ConsumerOptions = Options.Consume & {
-  /** Number of messages to prefetch */prefetch?: number;
+  /** Per-consumer prefetch count. Applied before `channel.consume(...)`. */prefetch?: number;
 };
 /**
  * AMQP client that manages connections and channels with automatic topology setup.
@@ -83,7 +96,7 @@ type ConsumerOptions = Options.Consume & {
  * - Automatic AMQP topology setup (exchanges, queues, bindings) from contract
  * - Channel creation with JSON serialization enabled by default
  *
- * All operations return `Future<Result<T, TechnicalError>>` for consistent error handling.
+ * All operations return `ResultAsync<T, TechnicalError>` for consistent error handling.
  *
  * @example
  * ```typescript
@@ -92,14 +105,14 @@ type ConsumerOptions = Options.Consume & {
  *   connectionOptions: { heartbeatIntervalInSeconds: 30 }
  * });
  *
- * // Wait for connection
- * await client.waitForConnect().resultToPromise();
+ * // Wait for connection (ResultAsync is thenable)
+ * await client.waitForConnect();
  *
  * // Publish a message
- * const result = await client.publish('exchange', 'routingKey', { data: 'value' }).resultToPromise();
+ * const result = await client.publish('exchange', 'routingKey', { data: 'value' });
  *
  * // Close when done
- * await client.close().resultToPromise();
+ * await client.close();
  * ```
  */
 declare class AmqpClient {
@@ -110,6 +123,15 @@ declare class AmqpClient {
   private readonly connectionOptions?;
   /** Resolved timeout in ms; `null` means "wait forever". */
   private readonly connectTimeoutMs;
+  /**
+   * Per-consumer prefetch setup functions registered via `addSetup` so they
+   * can be removed in {@link cancel} once the consumer is gone — otherwise
+   * the channel wrapper would replay the cancelled consumer's QoS on every
+   * reconnect and silently apply it to subsequent consumers.
+   *
+   * @internal
+   */
+  private readonly prefetchSetups;
   /**
    * Create a new AMQP client instance.
    *
@@ -136,7 +158,7 @@ declare class AmqpClient {
    * Wait for the channel to be connected and ready.
    *
    * If `connectTimeoutMs` was provided in the constructor options, the returned
-   * Future resolves to `Result.Error<TechnicalError>` once the timeout elapses.
+   * ResultAsync resolves to `err(TechnicalError)` once the timeout elapses.
    * Without a timeout, this waits forever — amqp-connection-manager retries
    * connections indefinitely and never errors on its own.
    *
@@ -145,46 +167,42 @@ declare class AmqpClient {
    * connection's reference count. Callers must invoke `close()` on the error
    * path to release the connection — `waitForConnect` does not do this
    * automatically. The typed factories handle this cleanup for you.
-   *
-   * @returns A Future resolving to `Result.Ok(void)` on connect, or
-   *   `Result.Error(TechnicalError)` on timeout / connection failure.
    */
-  waitForConnect(): Future<Result<void, TechnicalError>>;
+  waitForConnect(): ResultAsync<void, TechnicalError>;
   /**
    * Publish a message to an exchange.
    *
-   * @param exchange - The exchange name
-   * @param routingKey - The routing key
-   * @param content - The message content (will be JSON serialized if json: true)
-   * @param options - Optional publish options
-   * @returns A Future with `Result<boolean>` - true if message was sent, false if channel buffer is full
+   * @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
    */
-  publish(exchange: string, routingKey: string, content: Buffer | unknown, options?: PublishOptions): Future<Result<boolean, TechnicalError>>;
+  publish(exchange: string, routingKey: string, content: Buffer | unknown, options?: PublishOptions): ResultAsync<boolean, TechnicalError>;
   /**
    * Publish a message directly to a queue.
    *
-   * @param queue - The queue name
-   * @param content - The message content (will be JSON serialized if json: true)
-   * @param options - Optional publish options
-   * @returns A Future with `Result<boolean>` - true if message was sent, false if channel buffer is full
+   * @returns ResultAsync resolving to `true` if the message was sent, `false` if the channel buffer is full.
    */
-  sendToQueue(queue: string, content: Buffer | unknown, options?: PublishOptions): Future<Result<boolean, TechnicalError>>;
+  sendToQueue(queue: string, content: Buffer | unknown, options?: PublishOptions): ResultAsync<boolean, TechnicalError>;
   /**
    * Start consuming messages from a queue.
    *
-   * @param queue - The queue name
-   * @param callback - The callback to invoke for each message
-   * @param options - Optional consume options
-   * @returns A Future with `Result<string>` - the consumer tag
+   * If `options.prefetch` is set, a per-consumer prefetch count is applied via
+   * `channel.prefetch(count, false)` registered as a setup function on the
+   * channel wrapper *before* the underlying `consume` call. Registering it via
+   * `addSetup` ensures the prefetch is reapplied automatically on channel
+   * reconnect; using `global=false` scopes it to subsequent consumers on the
+   * channel (RabbitMQ semantics — opposite of intuition: `false` is per-
+   * consumer, `true` is channel-wide).
+   *
+   * `prefetch` is stripped from the options handed to `channelWrapper.consume`
+   * because it is not a valid `amqplib` `Options.Consume` field — leaving it
+   * in would just travel as a no-op key-value pair on the consume frame.
+   *
+   * @returns ResultAsync resolving to the consumer tag.
    */
-  consume(queue: string, callback: ConsumeCallback, options?: ConsumerOptions): Future<Result<string, TechnicalError>>;
+  consume(queue: string, callback: ConsumeCallback, options?: ConsumerOptions): ResultAsync<string, TechnicalError>;
   /**
    * Cancel a consumer by its consumer tag.
-   *
-   * @param consumerTag - The consumer tag to cancel
-   * @returns A Future that resolves when the consumer is cancelled
    */
-  cancel(consumerTag: string): Future<Result<void, TechnicalError>>;
+  cancel(consumerTag: string): ResultAsync<void, TechnicalError>;
   /**
    * Acknowledge a message.
    *
@@ -228,9 +246,10 @@ declare class AmqpClient {
    * - Decrease the reference count on the shared connection
    * - Close the connection if this was the last client using it
    *
-   * @returns A Future that resolves when the channel and connection are closed
+   * Both steps run regardless of each other's outcome; if both fail, the
+   * errors are wrapped in an AggregateError.
    */
-  close(): Future<Result<void, TechnicalError>>;
+  close(): ResultAsync<void, TechnicalError>;
   /**
    * Reset connection singleton cache (for testing only)
    * @internal
@@ -311,6 +330,30 @@ type Logger = {
   error(message: string, context?: LoggerContext): void;
 };
 //#endregion
+//#region src/parsing.d.ts
+/**
+ * Parse a `Buffer` as JSON, mapping any `JSON.parse` exception to the
+ * caller-supplied error type.
+ *
+ * Use this in consume / reply paths where a parse failure is a typed value,
+ * not a thrown exception — the caller decides how to translate the raw error
+ * into a domain-level error (e.g. {@link TechnicalError}).
+ *
+ * @typeParam E - The error type produced by `errorFn`.
+ * @param buffer - The raw message body to parse.
+ * @param errorFn - Callback invoked with the underlying `JSON.parse` error.
+ * @returns A `Result` containing the parsed `unknown` value or the mapped error.
+ *
+ * @example
+ * ```typescript
+ * const parsed = safeJsonParse(
+ *   msg.content,
+ *   (error) => new TechnicalError("Failed to parse JSON", error),
+ * );
+ * ```
+ */
+declare function safeJsonParse<E>(buffer: Buffer, errorFn: (raw: unknown) => E): Result<unknown, E>;
+//#endregion
 //#region src/setup.d.ts
 /**
  * Setup AMQP topology (exchanges, queues, and bindings) from a contract definition.
@@ -438,5 +481,5 @@ declare function recordLateRpcReply(provider: TelemetryProvider, reason: "unknow
  */
 declare function _resetTelemetryCacheForTesting(): void;
 //#endregion
-export { AmqpClient, type AmqpClientOptions, type ConsumeCallback, type ConsumerOptions, DEFAULT_CONNECT_TIMEOUT_MS, type Logger, type LoggerContext, MessageValidationError, MessagingSemanticConventions, type PublishOptions, TechnicalError, type TelemetryProvider, _getConnectionCountForTesting, _resetConnectionsForTesting, _resetTelemetryCacheForTesting, defaultTelemetryProvider, endSpanError, endSpanSuccess, recordConsumeMetric, recordLateRpcReply, recordPublishMetric, setupAmqpTopology, startConsumeSpan, startPublishSpan };
+export { AmqpClient, type AmqpClientOptions, type ConsumeCallback, type ConsumerOptions, DEFAULT_CONNECT_TIMEOUT_MS, type Logger, type LoggerContext, MessageValidationError, MessagingSemanticConventions, type PublishOptions, TechnicalError, type TelemetryProvider, _getConnectionCountForTesting, _resetConnectionsForTesting, _resetTelemetryCacheForTesting, defaultTelemetryProvider, endSpanError, endSpanSuccess, recordConsumeMetric, recordLateRpcReply, recordPublishMetric, safeJsonParse, setupAmqpTopology, startConsumeSpan, startPublishSpan };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/errors.ts","../src/amqp-client.ts","../src/connection-manager.ts","../src/logger.ts","../src/setup.ts","../src/telemetry.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/errors.ts","../src/amqp-client.ts","../src/connection-manager.ts","../src/logger.ts","../src/parsing.ts","../src/setup.ts","../src/telemetry.ts"],"mappings":"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"}