@amqp-contract/worker 0.23.0 → 0.24.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { extractConsumer, extractQueue, isQueueWithTtlBackoffInfrastructure } from "@amqp-contract/contract";
 import { AmqpClient, MessageValidationError, TechnicalError, defaultTelemetryProvider, endSpanError, endSpanSuccess, recordConsumeMetric, startConsumeSpan } from "@amqp-contract/core";
-import { Future, Result } from "@swan-io/boxed";
+import { Result, ResultAsync, err, errAsync, ok, okAsync } from "neverthrow";
 import { gunzip, inflate } from "node:zlib";
 import { promisify } from "node:util";
 //#region src/decompression.ts
@@ -21,17 +21,17 @@ function isSupportedEncoding(encoding) {
 *
 * @param buffer - The buffer to decompress
 * @param contentEncoding - The content-encoding header value (e.g., 'gzip', 'deflate')
-* @returns A Future with the decompressed buffer or a TechnicalError
+* @returns A ResultAsync resolving to the decompressed buffer or a TechnicalError
 *
 * @internal
 */
 function decompressBuffer(buffer, contentEncoding) {
-	if (!contentEncoding) return Future.value(Result.Ok(buffer));
+	if (!contentEncoding) return okAsync(buffer);
 	const normalizedEncoding = contentEncoding.toLowerCase();
-	if (!isSupportedEncoding(normalizedEncoding)) return Future.value(Result.Error(new TechnicalError(`Unsupported content-encoding: "${contentEncoding}". Supported encodings are: ${SUPPORTED_ENCODINGS.join(", ")}. Please check your publisher configuration.`)));
+	if (!isSupportedEncoding(normalizedEncoding)) return errAsync(new TechnicalError(`Unsupported content-encoding: "${contentEncoding}". Supported encodings are: ${SUPPORTED_ENCODINGS.join(", ")}. Please check your publisher configuration.`));
 	switch (normalizedEncoding) {
-		case "gzip": return Future.fromPromise(gunzipAsync(buffer)).mapError((error) => new TechnicalError("Failed to decompress gzip", error));
-		case "deflate": return Future.fromPromise(inflateAsync(buffer)).mapError((error) => new TechnicalError("Failed to decompress deflate", error));
+		case "gzip": return ResultAsync.fromPromise(gunzipAsync(buffer), (error) => new TechnicalError("Failed to decompress gzip", error));
+		case "deflate": return ResultAsync.fromPromise(inflateAsync(buffer), (error) => new TechnicalError("Failed to decompress deflate", error));
 	}
 }
 //#endregion
@@ -152,15 +152,16 @@ function isHandlerError(error) {
 * @example
 * ```typescript
 * import { retryable } from '@amqp-contract/worker';
-* import { Future, Result } from '@swan-io/boxed';
+* import { ResultAsync } from 'neverthrow';
 *
 * const handler = ({ payload }) =>
-*   Future.fromPromise(processPayment(payload))
-*     .mapOk(() => undefined)
-*     .mapError((e) => retryable('Payment service unavailable', e));
+*   ResultAsync.fromPromise(
+*     processPayment(payload),
+*     (e) => retryable('Payment service unavailable', e),
+*   ).map(() => undefined);
 *
 * // Equivalent to:
-* // .mapError((e) => new RetryableError('Payment service unavailable', e));
+* // ResultAsync.fromPromise(processPayment(payload), (e) => new RetryableError('...', e))
 * ```
 */
 function retryable(message, cause) {
@@ -179,17 +180,17 @@ function retryable(message, cause) {
 * @example
 * ```typescript
 * import { nonRetryable } from '@amqp-contract/worker';
-* import { Future, Result } from '@swan-io/boxed';
+* import { errAsync, okAsync } from 'neverthrow';
 *
 * const handler = ({ payload }) => {
 *   if (!isValidPayload(payload)) {
-*     return Future.value(Result.Error(nonRetryable('Invalid payload format')));
+*     return errAsync(nonRetryable('Invalid payload format'));
 *   }
-*   return Future.value(Result.Ok(undefined));
+*   return okAsync(undefined);
 * };
 *
 * // Equivalent to:
-* // return Future.value(Result.Error(new NonRetryableError('Invalid payload format')));
+* // return errAsync(new NonRetryableError('Invalid payload format'));
 * ```
 */
 function nonRetryable(message, cause) {
@@ -223,7 +224,7 @@ function handleError(ctx, error, msg, consumerName, consumer) {
 			error: error.message
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return Future.value(Result.Ok(void 0));
+		return okAsync(void 0);
 	}
 	const config = extractQueue(consumer.queue).retry;
 	if (config.mode === "immediate-requeue") return handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, config);
@@ -233,7 +234,7 @@ function handleError(ctx, error, msg, consumerName, consumer) {
 		error: error.message
 	});
 	sendToDLQ(ctx, msg, consumer);
-	return Future.value(Result.Ok(void 0));
+	return okAsync(void 0);
 }
 /**
 * Handle error by requeuing immediately.
@@ -257,7 +258,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 			error: error.message
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return Future.value(Result.Ok(void 0));
+		return okAsync(void 0);
 	}
 	ctx.logger?.warn("Retrying message (immediate-requeue mode)", {
 		consumerName,
@@ -268,7 +269,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 	});
 	if (queue.type === "quorum") {
 		ctx.amqpClient.nack(msg, false, true);
-		return Future.value(Result.Ok(void 0));
+		return okAsync(void 0);
 	} else return publishForRetry(ctx, {
 		msg,
 		exchange: msg.fields.exchange,
@@ -309,7 +310,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			consumerName,
 			queueName: consumer.queue.name
 		});
-		return Future.value(Result.Error(new TechnicalError("Queue does not have TTL-backoff infrastructure")));
+		return errAsync(new TechnicalError("Queue does not have TTL-backoff infrastructure"));
 	}
 	const queueEntry = consumer.queue;
 	const queueName = extractQueue(queueEntry).name;
@@ -323,7 +324,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			error: error.message
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return Future.value(Result.Ok(void 0));
+		return okAsync(void 0);
 	}
 	const delayMs = calculateRetryDelay(retryCount, config);
 	ctx.logger?.warn("Retrying message (ttl-backoff mode)", {
@@ -370,10 +371,10 @@ function parseMessageContentForRetry(ctx, msg, queueName) {
 	if (!(contentType === void 0 || contentType === "application/json" || contentType.startsWith("application/json;") || contentType.endsWith("+json"))) return msg.content;
 	try {
 		return JSON.parse(msg.content.toString());
-	} catch (err) {
+	} catch (parseErr) {
 		ctx.logger?.warn("Failed to parse JSON message for retry, using original buffer", {
 			queueName,
-			error: err
+			error: parseErr
 		});
 		return msg.content;
 	}
@@ -398,21 +399,21 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 				"x-retry-queue": queueName
 			} : {}
 		}
-	}).mapOkToResult((published) => {
+	}).andThen((published) => {
 		if (!published) {
 			ctx.logger?.error("Failed to publish message for retry (write buffer full)", {
 				queueName,
 				retryCount: newRetryCount,
 				...delayMs !== void 0 ? { delayMs } : {}
 			});
-			return Result.Error(new TechnicalError("Failed to publish message for retry (write buffer full)"));
+			return err(new TechnicalError("Failed to publish message for retry (write buffer full)"));
 		}
 		ctx.logger?.info("Message published for retry", {
 			queueName,
 			retryCount: newRetryCount,
 			...delayMs !== void 0 ? { delayMs } : {}
 		});
-		return Result.Ok(void 0);
+		return ok(void 0);
 	});
 }
 /**
@@ -449,6 +450,7 @@ function isHandlerTuple(entry) {
 * ```typescript
 * import { TypedAmqpWorker } from '@amqp-contract/worker';
 * import { defineQueue, defineMessage, defineContract, defineConsumer } from '@amqp-contract/contract';
+* import { okAsync } from 'neverthrow';
 * import { z } from 'zod';
 *
 * const orderQueue = defineQueue('order-processing');
@@ -463,19 +465,22 @@ function isHandlerTuple(entry) {
 *   }
 * });
 *
-* const worker = await TypedAmqpWorker.create({
+* const result = await TypedAmqpWorker.create({
 *   contract,
 *   handlers: {
-*     processOrder: async (message) => {
-*       console.log('Processing order', message.orderId);
-*       // Process the order...
-*     }
+*     processOrder: ({ payload }) => {
+*       console.log('Processing order', payload.orderId);
+*       return okAsync(undefined);
+*     },
 *   },
-*   urls: ['amqp://localhost']
-* }).resultToPromise();
+*   urls: ['amqp://localhost'],
+* });
+*
+* if (result.isErr()) throw result.error;
+* const worker = result.value;
 *
 * // Close when done
-* await worker.close().resultToPromise();
+* await worker.close();
 * ```
 */
 var TypedAmqpWorker = class TypedAmqpWorker {
@@ -551,18 +556,17 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* Connections are automatically shared across clients and workers with the same
 	* URLs and connection options, following RabbitMQ best practices.
 	*
-	* @param options - Configuration options for the worker
-	* @returns A Future that resolves to a Result containing the worker or an error
+	* @returns A ResultAsync that resolves to the worker or a TechnicalError.
 	*
 	* @example
 	* ```typescript
-	* const worker = await TypedAmqpWorker.create({
+	* const result = await TypedAmqpWorker.create({
 	*   contract: myContract,
 	*   handlers: {
-	*     processOrder: async ({ payload }) => console.log('Order:', payload.orderId)
+	*     processOrder: ({ payload }) => okAsync(undefined),
 	*   },
-	*   urls: ['amqp://localhost']
-	* }).resultToPromise();
+	*   urls: ['amqp://localhost'],
+	* });
 	* ```
 	*/
 	static create({ contract, handlers, urls, connectionOptions, defaultConsumerOptions, logger, telemetry, connectTimeoutMs }) {
@@ -571,12 +575,14 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 			connectionOptions,
 			connectTimeoutMs
 		}), handlers, defaultConsumerOptions ?? {}, logger, telemetry);
-		return worker.waitForConnectionReady().flatMapOk(() => worker.consumeAll()).flatMap((result) => result.match({
-			Ok: () => Future.value(Result.Ok(worker)),
-			Error: (error) => worker.close().tapError((closeError) => {
-				logger?.warn("Failed to close worker after setup failure", { error: closeError });
-			}).map(() => Result.Error(error))
-		}));
+		const setup = worker.waitForConnectionReady().andThen(() => worker.consumeAll());
+		return new ResultAsync((async () => {
+			const setupResult = await setup;
+			if (setupResult.isOk()) return ok(worker);
+			const closeResult = await worker.close();
+			if (closeResult.isErr()) logger?.warn("Failed to close worker after setup failure", { error: closeResult.error });
+			return err(setupResult.error);
+		})());
 	}
 	/**
 	* Close the AMQP channel and connection.
@@ -584,26 +590,25 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* 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();
+	* const closeResult = await worker.close();
 	* if (closeResult.isOk()) {
 	*   console.log('Worker closed successfully');
 	* }
 	* ```
 	*/
 	close() {
-		return Future.all(Array.from(this.consumerTags).map((consumerTag) => this.amqpClient.cancel(consumerTag).mapErrorToResult((error) => {
+		const cancellations = Array.from(this.consumerTags).map((consumerTag) => this.amqpClient.cancel(consumerTag).orElse((error) => {
 			this.logger?.warn("Failed to cancel consumer during close", {
 				consumerTag,
 				error
 			});
-			return Result.Ok(void 0);
-		}))).map(Result.all).tapOk(() => {
+			return ok(void 0);
+		}));
+		return ResultAsync.combine(cancellations).andTee(() => {
 			this.consumerTags.clear();
-		}).flatMapOk(() => this.amqpClient.close()).mapOk(() => void 0);
+		}).andThen(() => this.amqpClient.close()).map(() => void 0);
 	}
 	/**
 	* Start consuming for every entry in `contract.consumers` and `contract.rpcs`.
@@ -612,7 +617,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		const consumerNames = Object.keys(this.contract.consumers ?? {});
 		const rpcNames = Object.keys(this.contract.rpcs ?? {});
 		const allNames = [...consumerNames, ...rpcNames];
-		return Future.all(allNames.map((name) => this.consume(name))).map(Result.all).mapOk(() => void 0);
+		return ResultAsync.combine(allNames.map((name) => this.consume(name))).map(() => void 0);
 	}
 	waitForConnectionReady() {
 		return this.amqpClient.waitForConnect();
@@ -633,9 +638,9 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	validateSchema(schema, data, context) {
 		const rawValidation = schema["~standard"].validate(data);
 		const validationPromise = rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);
-		return Future.fromPromise(validationPromise).mapError((error) => new TechnicalError(`Error validating ${context.field}`, error)).mapOkToResult((result) => {
-			if (result.issues) return Result.Error(new TechnicalError(`${context.field} validation failed`, new MessageValidationError(context.consumerName, result.issues)));
-			return Result.Ok(result.value);
+		return ResultAsync.fromPromise(validationPromise, (error) => new TechnicalError(`Error validating ${context.field}`, error)).andThen((result) => {
+			if (result.issues) return err(new TechnicalError(`${context.field} validation failed`, new MessageValidationError(context.consumerName, result.issues)));
+			return ok(result.value);
 		});
 	}
 	/**
@@ -647,18 +652,18 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	*/
 	parseAndValidateMessage(msg, consumer, consumerName) {
 		const context = { consumerName: String(consumerName) };
-		const parsePayload = decompressBuffer(msg.content, msg.properties.contentEncoding).mapErrorToResult((error) => Result.Error(new TechnicalError("Failed to decompress message", error))).mapOkToResult((buffer) => Result.fromExecution(() => JSON.parse(buffer.toString())).mapError((error) => new TechnicalError("Failed to parse JSON", error))).flatMapOk((parsed) => this.validateSchema(consumer.message.payload, parsed, {
+		const parsePayload = decompressBuffer(msg.content, msg.properties.contentEncoding).andThen((buffer) => Result.fromThrowable(() => JSON.parse(buffer.toString()), (error) => new TechnicalError("Failed to parse JSON", error))()).andThen((parsed) => this.validateSchema(consumer.message.payload, parsed, {
 			...context,
 			field: "payload"
 		}));
 		const parseHeaders = consumer.message.headers ? this.validateSchema(consumer.message.headers, msg.properties.headers ?? {}, {
 			...context,
 			field: "headers"
-		}) : Future.value(Result.Ok(void 0));
-		return Future.allFromDict({
-			payload: parsePayload,
-			headers: parseHeaders
-		}).map(Result.allFromDict);
+		}) : okAsync(void 0);
+		return ResultAsync.combine([parsePayload, parseHeaders]).map(([payload, headers]) => ({
+			payload,
+			headers
+		}));
 	}
 	/**
 	* Validate an RPC handler's response and publish it back to the caller's reply
@@ -687,7 +692,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				rpcName: String(rpcName),
 				queueName
 			});
-			return Future.value(Result.Error(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`)));
+			return errAsync(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`));
 		}
 		if (typeof correlationId !== "string" || correlationId.length === 0) {
 			this.logger?.error("RPC handler returned a response but the incoming message has no correlationId", {
@@ -695,22 +700,22 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				queueName,
 				replyTo
 			});
-			return Future.value(Result.Error(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`)));
+			return errAsync(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`));
 		}
 		let rawValidation;
 		try {
 			rawValidation = responseSchema["~standard"].validate(response);
 		} catch (error) {
-			return Future.value(Result.Error(new NonRetryableError("RPC response schema validation threw", error)));
+			return errAsync(new NonRetryableError("RPC response schema validation threw", error));
 		}
 		const validationPromise = rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation);
-		return Future.fromPromise(validationPromise).mapError((error) => new NonRetryableError("RPC response schema validation threw", error)).mapOkToResult((validation) => {
-			if (validation.issues) return Result.Error(new NonRetryableError(`RPC response for "${String(rpcName)}" failed schema validation`, new MessageValidationError(String(rpcName), validation.issues)));
-			return Result.Ok(validation.value);
-		}).flatMapOk((validatedResponse) => this.amqpClient.publish("", replyTo, validatedResponse, {
+		return ResultAsync.fromPromise(validationPromise, (error) => new NonRetryableError("RPC response schema validation threw", error)).andThen((validation) => {
+			if (validation.issues) return err(new NonRetryableError(`RPC response for "${String(rpcName)}" failed schema validation`, new MessageValidationError(String(rpcName), validation.issues)));
+			return ok(validation.value);
+		}).andThen((validatedResponse) => this.amqpClient.publish("", replyTo, validatedResponse, {
 			correlationId,
 			contentType: "application/json"
-		}).mapErrorToResult((error) => Result.Error(new NonRetryableError("Failed to publish RPC response", error))).mapOkToResult((published) => published ? Result.Ok(void 0) : Result.Error(new NonRetryableError("Failed to publish RPC response: channel buffer full"))));
+		}).mapErr((error) => new NonRetryableError("Failed to publish RPC response", error)).andThen((published) => published ? ok(void 0) : err(new NonRetryableError("Failed to publish RPC response: channel buffer full"))));
 	}
 	/**
 	* Process a single consumed message: validate, invoke handler, optionally
@@ -723,58 +728,56 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		const span = startConsumeSpan(this.telemetry, queueName, String(name), { "messaging.rabbitmq.message.delivery_tag": msg.fields.deliveryTag });
 		let messageHandled = false;
 		let firstError;
-		return this.parseAndValidateMessage(msg, consumer, name).flatMap((parseResult) => parseResult.match({
-			Ok: (validatedMessage) => handler(validatedMessage, msg).flatMapOk((handlerResponse) => {
-				if (isRpc && responseSchema) return this.publishRpcResponse(msg, queueName, name, responseSchema, handlerResponse).flatMapOk(() => {
-					this.logger?.info("Message consumed successfully", {
-						consumerName: String(name),
-						queueName
-					});
-					this.amqpClient.ack(msg);
-					messageHandled = true;
-					return Future.value(Result.Ok(void 0));
-				});
+		const inner = this.parseAndValidateMessage(msg, consumer, name).orElse((parseError) => {
+			firstError = parseError;
+			this.logger?.error("Failed to parse/validate message; sending to DLQ", {
+				consumerName: String(name),
+				queueName,
+				error: parseError
+			});
+			this.amqpClient.nack(msg, false, false);
+			return errAsync(parseError);
+		}).andThen((validatedMessage) => handler(validatedMessage, msg).andThen((handlerResponse) => {
+			if (isRpc && responseSchema) return this.publishRpcResponse(msg, queueName, name, responseSchema, handlerResponse).map(() => {
 				this.logger?.info("Message consumed successfully", {
 					consumerName: String(name),
 					queueName
 				});
 				this.amqpClient.ack(msg);
 				messageHandled = true;
-				return Future.value(Result.Ok(void 0));
-			}).flatMapError((handlerError) => {
-				this.logger?.error("Error processing message", {
-					consumerName: String(name),
-					queueName,
-					errorType: handlerError.name,
-					error: handlerError.message
-				});
-				firstError = handlerError;
-				return handleError({
-					amqpClient: this.amqpClient,
-					logger: this.logger
-				}, handlerError, msg, String(name), consumer);
-			}),
-			Error: (parseError) => {
-				firstError = parseError;
-				this.logger?.error("Failed to parse/validate message; sending to DLQ", {
-					consumerName: String(name),
-					queueName,
-					error: parseError
-				});
-				this.amqpClient.nack(msg, false, false);
-				return Future.value(Result.Error(parseError));
-			}
-		})).map((result) => {
+			});
+			this.logger?.info("Message consumed successfully", {
+				consumerName: String(name),
+				queueName
+			});
+			this.amqpClient.ack(msg);
+			messageHandled = true;
+			return okAsync(void 0);
+		}).orElse((handlerError) => {
+			this.logger?.error("Error processing message", {
+				consumerName: String(name),
+				queueName,
+				errorType: handlerError.name,
+				error: handlerError.message
+			});
+			firstError = handlerError;
+			return handleError({
+				amqpClient: this.amqpClient,
+				logger: this.logger
+			}, handlerError, msg, String(name), consumer);
+		}));
+		return new ResultAsync((async () => {
+			const result = await inner;
 			const durationMs = Date.now() - startTime;
 			if (messageHandled) {
 				endSpanSuccess(span);
 				recordConsumeMetric(this.telemetry, queueName, String(name), true, durationMs);
 			} else {
-				endSpanError(span, result.isError() ? result.error : firstError ?? /* @__PURE__ */ new Error("Unknown error"));
+				endSpanError(span, result.isErr() ? result.error : firstError ?? /* @__PURE__ */ new Error("Unknown error"));
 				recordConsumeMetric(this.telemetry, queueName, String(name), false, durationMs);
 			}
 			return result;
-		});
+		})());
 	}
 	/**
 	* Consume messages one at a time.
@@ -790,7 +793,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				return;
 			}
 			try {
-				await this.processMessage(msg, view, name, handler).toPromise();
+				await this.processMessage(msg, view, name, handler);
 			} catch (error) {
 				this.logger?.error("Uncaught error in consume callback; nacking message", {
 					consumerName: String(name),
@@ -799,9 +802,9 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				});
 				this.amqpClient.nack(msg, false, false);
 			}
-		}, this.consumerOptions[name]).tapOk((consumerTag) => {
+		}, this.consumerOptions[name]).andTee((consumerTag) => {
 			this.consumerTags.add(consumerTag);
-		}).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(name)}"`, error)).mapOk(() => void 0);
+		}).map(() => void 0).mapErr((error) => new TechnicalError(`Failed to start consuming for "${String(name)}"`, error));
 	}
 };
 //#endregion
@@ -834,7 +837,7 @@ function defineHandler(contract, consumerName, handler, options) {
 /**
 * Define multiple type-safe handlers for consumers in a contract.
 *
-* **Recommended:** This function creates handlers that return `Future<Result<void, HandlerError>>`,
+* **Recommended:** This function creates handlers that return `ResultAsync<void, HandlerError>`,
 * providing explicit error handling and better control over retry behavior.
 *
 * @template TContract - The contract definition type
@@ -845,18 +848,20 @@ function defineHandler(contract, consumerName, handler, options) {
 * @example
 * ```typescript
 * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
-* import { Future } from '@swan-io/boxed';
+* import { ResultAsync } from 'neverthrow';
 * import { orderContract } from './contract';
 *
 * const handlers = defineHandlers(orderContract, {
 *   processOrder: ({ payload }) =>
-*     Future.fromPromise(processPayment(payload))
-*       .mapOk(() => undefined)
-*       .mapError((error) => new RetryableError('Payment failed', error)),
+*     ResultAsync.fromPromise(
+*       processPayment(payload),
+*       (error) => new RetryableError('Payment failed', error),
+*     ).map(() => undefined),
 *   notifyOrder: ({ payload }) =>
-*     Future.fromPromise(sendNotification(payload))
-*       .mapOk(() => undefined)
-*       .mapError((error) => new RetryableError('Notification failed', error)),
+*     ResultAsync.fromPromise(
+*       sendNotification(payload),
+*       (error) => new RetryableError('Notification failed', error),
+*     ).map(() => undefined),
 * });
 * ```
 */