@amqp-contract/worker 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,12 @@
 # @amqp-contract/worker
 
-Type-safe AMQP worker for consuming messages using amqp-contract with standard async/await error handling.
+**Type-safe AMQP worker for consuming messages using amqp-contract with standard async/await error handling.**
+
+[![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/worker.svg?logo=npm)](https://www.npmjs.com/package/@amqp-contract/worker)
+[![npm downloads](https://img.shields.io/npm/dm/@amqp-contract/worker.svg)](https://www.npmjs.com/package/@amqp-contract/worker)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 📖 **[Full documentation →](https://btravers.github.io/amqp-contract/api/worker)**
 
@@ -76,6 +82,10 @@ These errors are logged but **handlers don't need to use them** - just throw sta
 
 See the [Worker API documentation](https://btravers.github.io/amqp-contract/api/worker) for complete API reference.
 
+## Documentation
+
+📖 **[Read the full documentation →](https://btravers.github.io/amqp-contract)**
+
 ## License
 
 MIT

package/dist/index.cjs

@@ -1,4 +1,3 @@
-let amqplib = require("amqplib");
 let _amqp_contract_core = require("@amqp-contract/core");
 let _swan_io_boxed = require("@swan-io/boxed");
 
@@ -40,109 +39,149 @@ var MessageValidationError = class extends WorkerError {
 //#endregion
 //#region src/worker.ts
 /**
-* Type-safe AMQP worker for consuming messages
+* Type-safe AMQP worker for consuming messages from RabbitMQ.
+*
+* This class provides automatic message validation, connection management,
+* and error handling for consuming messages based on a contract definition.
+*
+* @typeParam TContract - The contract definition type
+*
+* @example
+* ```typescript
+* import { TypedAmqpWorker } from '@amqp-contract/worker';
+* import { z } from 'zod';
+*
+* const contract = defineContract({
+*   queues: {
+*     orderProcessing: defineQueue('order-processing', { durable: true })
+*   },
+*   consumers: {
+*     processOrder: defineConsumer('order-processing', z.object({
+*       orderId: z.string(),
+*       amount: z.number()
+*     }))
+*   }
+* });
+*
+* const worker = await TypedAmqpWorker.create({
+*   contract,
+*   handlers: {
+*     processOrder: async (message) => {
+*       console.log('Processing order', message.orderId);
+*       // Process the order...
+*     }
+*   },
+*   urls: ['amqp://localhost']
+* }).resultToPromise();
+*
+* // Close when done
+* await worker.close().resultToPromise();
+* ```
 */
 var TypedAmqpWorker = class TypedAmqpWorker {
-	channel = null;
-	connection = null;
-	consumerTags = [];
-	constructor(contract, handlers, connectionOptions) {
+	constructor(contract, amqpClient, handlers) {
 		this.contract = contract;
+		this.amqpClient = amqpClient;
 		this.handlers = handlers;
-		this.connectionOptions = connectionOptions;
 	}
 	/**
-	* Create a type-safe AMQP worker from a contract
-	* The worker will automatically connect and start consuming all messages
+	* Create a type-safe AMQP worker from a contract.
+	*
+	* Connection management (including automatic reconnection) is handled internally
+	* by amqp-connection-manager via the {@link AmqpClient}. The worker will set up
+	* consumers for all contract-defined handlers asynchronously in the background
+	* once the underlying connection and channels are ready.
+	*
+	* @param options - Configuration options for the worker
+	* @returns A Future that resolves to a Result containing the worker or an error
+	*
+	* @example
+	* ```typescript
+	* const workerResult = await TypedAmqpWorker.create({
+	*   contract: myContract,
+	*   handlers: {
+	*     processOrder: async (msg) => console.log('Order:', msg.orderId)
+	*   },
+	*   urls: ['amqp://localhost']
+	* }).resultToPromise();
+	*
+	* if (workerResult.isError()) {
+	*   console.error('Failed to create worker:', workerResult.error);
+	* }
+	* ```
 	*/
-	static async create(options) {
-		const worker = new TypedAmqpWorker(options.contract, options.handlers, options.connection);
-		await worker.init();
-		await worker.consumeAll();
-		return worker;
+	static create({ contract, handlers, urls, connectionOptions }) {
+		const worker = new TypedAmqpWorker(contract, new _amqp_contract_core.AmqpClient(contract, {
+			urls,
+			connectionOptions
+		}), handlers);
+		return worker.waitForConnectionReady().flatMapOk(() => worker.consumeAll()).mapOk(() => worker);
 	}
 	/**
-	* Close the connection
+	* Close the AMQP channel and connection.
+	*
+	* This gracefully closes the connection to the AMQP broker,
+	* stopping all message consumption and cleaning up resources.
+	*
+	* @returns A Future that resolves to a Result indicating success or failure
+	*
+	* @example
+	* ```typescript
+	* const closeResult = await worker.close().resultToPromise();
+	* if (closeResult.isOk()) {
+	*   console.log('Worker closed successfully');
+	* }
+	* ```
 	*/
-	async close() {
-		await this.stopConsuming();
-		if (this.channel) {
-			await this.channel.close();
-			this.channel = null;
-		}
-		if (this.connection) {
-			await this.connection.close();
-			this.connection = null;
-		}
-	}
-	/**
-	* Connect to AMQP broker
-	*/
-	async init() {
-		this.connection = await (0, amqplib.connect)(this.connectionOptions);
-		this.channel = await this.connection.createChannel();
-		await (0, _amqp_contract_core.setupInfra)(this.channel, this.contract);
+	close() {
+		return _swan_io_boxed.Future.fromPromise(this.amqpClient.close()).mapError((error) => new TechnicalError("Failed to close AMQP connection", error)).mapOk(() => void 0);
 	}
 	/**
 	* Start consuming messages for all consumers
 	*/
-	async consumeAll() {
-		if (!this.contract.consumers) throw new Error("No consumers defined in contract");
+	consumeAll() {
+		if (!this.contract.consumers) return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new TechnicalError("No consumers defined in contract")));
 		const consumerNames = Object.keys(this.contract.consumers);
-		for (const consumerName of consumerNames) await this.consume(consumerName);
+		return _swan_io_boxed.Future.all(consumerNames.map((consumerName) => this.consume(consumerName))).map(_swan_io_boxed.Result.all).mapOk(() => void 0);
+	}
+	waitForConnectionReady() {
+		return _swan_io_boxed.Future.fromPromise(this.amqpClient.channel.waitForConnect()).mapError((error) => new TechnicalError("Failed to wait for connection ready", error));
 	}
 	/**
 	* Start consuming messages for a specific consumer
 	*/
-	async consume(consumerName) {
-		if (!this.channel) throw new Error("Worker not initialized. Use TypedAmqpWorker.create() to obtain an initialized worker instance.");
+	consume(consumerName) {
 		const consumers = this.contract.consumers;
-		if (!consumers) throw new Error("No consumers defined in contract");
+		if (!consumers) return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new TechnicalError("No consumers defined in contract")));
 		const consumer = consumers[consumerName];
-		if (!consumer || typeof consumer !== "object") {
+		if (!consumer) {
 			const availableConsumers = Object.keys(consumers);
 			const available = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
-			throw new Error(`Consumer not found: "${String(consumerName)}". Available consumers: ${available}`);
+			return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new TechnicalError(`Consumer not found: "${String(consumerName)}". Available consumers: ${available}`)));
 		}
-		const consumerDef = consumer;
 		const handler = this.handlers[consumerName];
-		if (!handler) throw new Error(`Handler for "${String(consumerName)}" not provided`);
-		if (consumerDef.prefetch !== void 0) await this.channel.prefetch(consumerDef.prefetch);
-		const result = await this.channel.consume(consumerDef.queue.name, async (msg) => {
-			if (!msg) return;
+		if (!handler) return _swan_io_boxed.Future.value(_swan_io_boxed.Result.Error(new TechnicalError(`Handler for "${String(consumerName)}" not provided`)));
+		return _swan_io_boxed.Future.fromPromise(this.amqpClient.channel.consume(consumer.queue.name, async (msg) => {
 			const parseResult = _swan_io_boxed.Result.fromExecution(() => JSON.parse(msg.content.toString()));
 			if (parseResult.isError()) {
 				console.error(new TechnicalError(`Error parsing message for consumer "${String(consumerName)}"`, parseResult.error));
-				this.channel?.nack(msg, false, false);
-				return;
-			}
-			const content = parseResult.value;
-			const rawValidation = consumerDef.message.payload["~standard"].validate(content);
-			const resolvedValidation = rawValidation instanceof Promise ? await rawValidation : rawValidation;
-			const validationResult = typeof resolvedValidation === "object" && resolvedValidation !== null && "issues" in resolvedValidation && resolvedValidation.issues ? _swan_io_boxed.Result.Error(new MessageValidationError(String(consumerName), resolvedValidation.issues)) : _swan_io_boxed.Result.Ok(typeof resolvedValidation === "object" && resolvedValidation !== null && "value" in resolvedValidation ? resolvedValidation.value : content);
-			if (validationResult.isError()) {
-				console.error(validationResult.error);
-				this.channel?.nack(msg, false, false);
+				this.amqpClient.channel.nack(msg, false, false);
 				return;
 			}
-			const validatedMessage = validationResult.value;
-			try {
-				await handler(validatedMessage);
-				if (!consumerDef.noAck) this.channel?.ack(msg);
-			} catch (error) {
+			const rawValidation = consumer.message.payload["~standard"].validate(parseResult.value);
+			await _swan_io_boxed.Future.fromPromise(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation)).mapOkToResult((validationResult) => {
+				if (validationResult.issues) return _swan_io_boxed.Result.Error(new MessageValidationError(String(consumerName), validationResult.issues));
+				return _swan_io_boxed.Result.Ok(validationResult.value);
+			}).tapError((error) => {
+				console.error(error);
+				this.amqpClient.channel.nack(msg, false, false);
+			}).flatMapOk((validatedMessage) => _swan_io_boxed.Future.fromPromise(handler(validatedMessage)).tapError((error) => {
 				console.error(new TechnicalError(`Error processing message for consumer "${String(consumerName)}"`, error));
-				this.channel?.nack(msg, false, true);
-			}
-		}, { noAck: consumerDef.noAck ?? false });
-		this.consumerTags.push(result.consumerTag);
-	}
-	/**
-	* Stop consuming messages
-	*/
-	async stopConsuming() {
-		if (!this.channel) return;
-		for (const tag of this.consumerTags) await this.channel.cancel(tag);
-		this.consumerTags = [];
+				this.amqpClient.channel.nack(msg, false, true);
+			})).tapOk(() => {
+				this.amqpClient.channel.ack(msg);
+			}).toPromise();
+		})).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(consumerName)}"`, error)).mapOk(() => void 0);
 	}
 };
 
@@ -284,11 +323,9 @@ function defineHandler(contract, consumerName, handler) {
 */
 function defineHandlers(contract, handlers) {
 	const consumers = contract.consumers;
-	const availableConsumers = consumers ? Object.keys(consumers) : [];
-	for (const handlerName of Object.keys(handlers)) if (!consumers || !(handlerName in consumers)) {
-		const available = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
-		throw new Error(`Consumer "${handlerName}" not found in contract. Available consumers: ${available}`);
-	}
+	const availableConsumers = Object.keys(consumers ?? {});
+	const availableConsumerNames = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
+	for (const handlerName of Object.keys(handlers)) if (!consumers || !(handlerName in consumers)) throw new Error(`Consumer "${handlerName}" not found in contract. Available consumers: ${availableConsumerNames}`);
 	return handlers;
 }
 

package/dist/index.d.cts

@@ -1,76 +1,197 @@
-import { Options } from "amqplib";
-import { ContractDefinition, InferConsumerNames, WorkerInferConsumerHandler, WorkerInferConsumerHandlers } from "@amqp-contract/contract";
+import { ConsumerDefinition, ContractDefinition, InferConsumerNames } from "@amqp-contract/contract";
+import { Future, Result } from "@swan-io/boxed";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { AmqpConnectionManagerOptions, ConnectionUrl } from "amqp-connection-manager";
 
+//#region src/errors.d.ts
+/**
+ * Base error class for worker errors
+ */
+declare abstract class WorkerError extends Error {
+  protected constructor(message: string);
+}
+/**
+ * Error for technical/runtime failures in worker operations
+ * This includes validation failures, parsing failures, and processing failures
+ */
+declare class TechnicalError extends WorkerError {
+  readonly cause?: unknown | undefined;
+  constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Error thrown when message validation fails
+ */
+declare class MessageValidationError extends WorkerError {
+  readonly consumerName: string;
+  readonly issues: unknown;
+  constructor(consumerName: string, issues: unknown);
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Infer the TypeScript type from a schema
+ */
+type InferSchemaInput<TSchema extends StandardSchemaV1> = TSchema extends StandardSchemaV1<infer TInput> ? TInput : never;
+/**
+ * Infer consumer message input type
+ */
+type ConsumerInferInput<TConsumer extends ConsumerDefinition> = InferSchemaInput<TConsumer["message"]["payload"]>;
+/**
+ * Infer all consumers from contract
+ */
+type InferConsumers<TContract extends ContractDefinition> = NonNullable<TContract["consumers"]>;
+/**
+ * Get specific consumer definition from contract
+ */
+type InferConsumer<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = InferConsumers<TContract>[TName];
+/**
+ * Worker perspective types - for consuming messages
+ */
+type WorkerInferConsumerInput<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = ConsumerInferInput<InferConsumer<TContract, TName>>;
+/**
+ * Infer consumer handler type for a specific consumer
+ */
+type WorkerInferConsumerHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = (message: WorkerInferConsumerInput<TContract, TName>) => Promise<void>;
+/**
+ * Infer all consumer handlers for a contract
+ */
+type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandler<TContract, K> };
+//#endregion
 //#region src/worker.d.ts
-
 /**
- * Options for creating a worker
+ * Options for creating a type-safe AMQP worker.
+ *
+ * @typeParam TContract - The contract definition type
+ *
+ * @example
+ * ```typescript
+ * const options: CreateWorkerOptions<typeof contract> = {
+ *   contract: myContract,
+ *   handlers: {
+ *     processOrder: async (message) => {
+ *       console.log('Processing order:', message.orderId);
+ *     }
+ *   },
+ *   urls: ['amqp://localhost'],
+ *   connectionOptions: {
+ *     heartbeatIntervalInSeconds: 30
+ *   }
+ * };
+ * ```
  */
-interface CreateWorkerOptions<TContract extends ContractDefinition> {
+type CreateWorkerOptions<TContract extends ContractDefinition> = {
+  /** The AMQP contract definition specifying consumers and their message schemas */
   contract: TContract;
+  /** Handlers for each consumer defined in the contract */
   handlers: WorkerInferConsumerHandlers<TContract>;
-  connection: string | Options.Connect;
-}
+  /** AMQP broker URL(s). Multiple URLs provide failover support */
+  urls: ConnectionUrl[];
+  /** Optional connection configuration (heartbeat, reconnect settings, etc.) */
+  connectionOptions?: AmqpConnectionManagerOptions | undefined;
+};
 /**
- * Type-safe AMQP worker for consuming messages
+ * Type-safe AMQP worker for consuming messages from RabbitMQ.
+ *
+ * This class provides automatic message validation, connection management,
+ * and error handling for consuming messages based on a contract definition.
+ *
+ * @typeParam TContract - The contract definition type
+ *
+ * @example
+ * ```typescript
+ * import { TypedAmqpWorker } from '@amqp-contract/worker';
+ * import { z } from 'zod';
+ *
+ * const contract = defineContract({
+ *   queues: {
+ *     orderProcessing: defineQueue('order-processing', { durable: true })
+ *   },
+ *   consumers: {
+ *     processOrder: defineConsumer('order-processing', z.object({
+ *       orderId: z.string(),
+ *       amount: z.number()
+ *     }))
+ *   }
+ * });
+ *
+ * const worker = await TypedAmqpWorker.create({
+ *   contract,
+ *   handlers: {
+ *     processOrder: async (message) => {
+ *       console.log('Processing order', message.orderId);
+ *       // Process the order...
+ *     }
+ *   },
+ *   urls: ['amqp://localhost']
+ * }).resultToPromise();
+ *
+ * // Close when done
+ * await worker.close().resultToPromise();
+ * ```
  */
 declare class TypedAmqpWorker<TContract extends ContractDefinition> {
   private readonly contract;
+  private readonly amqpClient;
   private readonly handlers;
-  private readonly connectionOptions;
-  private channel;
-  private connection;
-  private consumerTags;
   private constructor();
   /**
-   * Create a type-safe AMQP worker from a contract
-   * The worker will automatically connect and start consuming all messages
+   * Create a type-safe AMQP worker from a contract.
+   *
+   * Connection management (including automatic reconnection) is handled internally
+   * by amqp-connection-manager via the {@link AmqpClient}. The worker will set up
+   * consumers for all contract-defined handlers asynchronously in the background
+   * once the underlying connection and channels are ready.
+   *
+   * @param options - Configuration options for the worker
+   * @returns A Future that resolves to a Result containing the worker or an error
+   *
+   * @example
+   * ```typescript
+   * const workerResult = await TypedAmqpWorker.create({
+   *   contract: myContract,
+   *   handlers: {
+   *     processOrder: async (msg) => console.log('Order:', msg.orderId)
+   *   },
+   *   urls: ['amqp://localhost']
+   * }).resultToPromise();
+   *
+   * if (workerResult.isError()) {
+   *   console.error('Failed to create worker:', workerResult.error);
+   * }
+   * ```
    */
-  static create<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<TypedAmqpWorker<TContract>>;
+  static create<TContract extends ContractDefinition>({
+    contract,
+    handlers,
+    urls,
+    connectionOptions
+  }: CreateWorkerOptions<TContract>): Future<Result<TypedAmqpWorker<TContract>, TechnicalError>>;
   /**
-   * Close the connection
+   * Close the AMQP channel and connection.
+   *
+   * This gracefully closes the connection to the AMQP broker,
+   * stopping all message consumption and cleaning up resources.
+   *
+   * @returns A Future that resolves to a Result indicating success or failure
+   *
+   * @example
+   * ```typescript
+   * const closeResult = await worker.close().resultToPromise();
+   * if (closeResult.isOk()) {
+   *   console.log('Worker closed successfully');
+   * }
+   * ```
    */
-  close(): Promise<void>;
-  /**
-   * Connect to AMQP broker
-   */
-  private init;
+  close(): Future<Result<void, TechnicalError>>;
   /**
    * Start consuming messages for all consumers
    */
   private consumeAll;
+  private waitForConnectionReady;
   /**
    * Start consuming messages for a specific consumer
    */
   private consume;
-  /**
-   * Stop consuming messages
-   */
-  private stopConsuming;
-}
-//#endregion
-//#region src/errors.d.ts
-/**
- * Base error class for worker errors
- */
-declare abstract class WorkerError extends Error {
-  protected constructor(message: string);
-}
-/**
- * Error for technical/runtime failures in worker operations
- * This includes validation failures, parsing failures, and processing failures
- */
-declare class TechnicalError extends WorkerError {
-  readonly cause?: unknown | undefined;
-  constructor(message: string, cause?: unknown | undefined);
-}
-/**
- * Error thrown when message validation fails
- */
-declare class MessageValidationError extends WorkerError {
-  readonly consumerName: string;
-  readonly issues: unknown;
-  constructor(consumerName: string, issues: unknown);
 }
 //#endregion
 //#region src/handlers.d.ts
@@ -202,5 +323,5 @@ declare function defineHandler<TContract extends ContractDefinition, TName exten
  */
 declare function defineHandlers<TContract extends ContractDefinition>(contract: TContract, handlers: WorkerInferConsumerHandlers<TContract>): WorkerInferConsumerHandlers<TContract>;
 //#endregion
-export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker, defineHandler, defineHandlers };
+export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlers, type WorkerInferConsumerInput, defineHandler, defineHandlers };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/worker.ts","../src/errors.ts","../src/handlers.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;AAAuD,UAAtC,mBAAsC,CAAA,kBAAA,kBAAA,CAAA,CAAA;EAC3C,QAAA,EAAA,SAAA;EAC4B,QAAA,EAA5B,2BAA4B,CAAA,SAAA,CAAA;EAA5B,UAAA,EAAA,MAAA,GACW,OAAA,CAAQ,OADnB;;;AAOZ;;AAewC,cAf3B,eAe2B,CAAA,kBAfO,kBAeP,CAAA,CAAA;EACP,iBAAA,QAAA;EAApB,iBAAA,QAAA;EACgB,iBAAA,iBAAA;EAAhB,QAAA,OAAA;EAAR,QAAA,UAAA;EAUY,QAAA,YAAA;EAAO,QAAA,WAAA,CAAA;;;;;EC9BX,OAAA,MAAA,CAAA,kBDkB2B,kBClBO,CAAA,CAAA,OAAA,EDmBlC,mBCnBkC,CDmBd,SCnBc,CAAA,CAAA,EDoB1C,OCpB0C,CDoBlC,eCpBkC,CDoBlB,SCpBkB,CAAA,CAAA;EAalC;;;WDiBI;EEyBD;;;EAEA,QAAA,IAAA;EAEJ;;;EAEqC,QAAA,UAAA;EAAtC;;;EACR,QAAA,OAAA;EAA0B;AAuE7B;;EACY,QAAA,aAAA;;;;;;;uBDxJG,WAAA,SAAoB,KAAA;EDYlB,UAAA,WAAA,CAAmB,OAAA,EAAA,MAAA;;;;;;AAGE,cCGzB,cAAA,SAAuB,WAAA,CDHE;EAMzB,SAAA,KAAA,CAAA,EAAA,OAAe,GAAA,SAAA;EAAmB,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,KAAA,CAAA,EAAA,OAAA,GAAA,SAAA;;;;;AAiBlC,cCPA,sBAAA,SAA+B,WAAA,CDO/B;EAAR,SAAA,YAAA,EAAA,MAAA;EAUY,SAAA,MAAA,EAAA,OAAA;EAAO,WAAA,CAAA,YAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA;;;;;;;AApCxB;;;;;;;AASA;;;;;;;;;;;;;;ACHA;AAaA;;;;AC0CA;;;;;;;;;;;;;AA8EA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA9EgB,gCACI,kCACJ,mBAAmB,sBAEvB,yBACI,gBACL,2BAA2B,WAAW,SAC9C,2BAA2B,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuEzB,iCAAiC,8BACrC,qBACA,4BAA4B,aACrC,4BAA4B"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/errors.ts","../src/types.ts","../src/worker.ts","../src/handlers.ts"],"sourcesContent":[],"mappings":"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"}