resultar 3.0.0-alpha.3 → 3.1.0-beta.1

package/dist/index.js

@@ -1,3 +1,14 @@
+//#region src/abort-error.ts
+var AbortError = class extends Error {
+	constructor(message = "Operation aborted", options) {
+		super(message, options);
+		this.name = "AbortError";
+	}
+};
+const hasAbortName = (value) => typeof value === "object" && value !== null && "name" in value && value.name === "AbortError";
+const hasAbortCode = (value) => typeof value === "object" && value !== null && "code" in value && value.code === "ABORT_ERR";
+const isAbortError = (value) => value instanceof AbortError || hasAbortName(value) || hasAbortCode(value);
+//#endregion
 //#region src/pipe.ts
 const runPipe = (self, fns) => {
 	const first = fns[0];
@@ -79,6 +90,14 @@ const combineResultList = (resultList) => {
 	}
 	return ok(values);
 };
+const combineResultRecord = (resultRecord) => {
+	const values = {};
+	for (const [key, result] of Object.entries(resultRecord)) {
+		if (result.isErr()) return err(result.error);
+		values[key] = result.value;
+	}
+	return ok(values);
+};
 const combineResultListWithAllErrors = (resultList) => {
 	let acc = ok([]);
 	for (const result of resultList) if (result.isErr() && acc.isErr()) acc.error.push(result.error);
@@ -86,6 +105,15 @@ const combineResultListWithAllErrors = (resultList) => {
 	else if (result.isOk() && acc.isOk()) acc.value.push(result.value);
 	return acc;
 };
+const combineResultRecordWithAllErrors = (resultRecord) => {
+	const errors = [];
+	const values = {};
+	for (const [key, result] of Object.entries(resultRecord)) if (result.isErr()) errors.push(result.error);
+	else values[key] = result.value;
+	if (errors.length > 0) return err(errors);
+	return ok(values);
+};
+const isIterable$1 = (value) => typeof value === "object" && value !== null && Symbol.iterator in value;
 const validateAllResultItems = (items, f) => {
 	return combineResultListWithAllErrors(Array.from(items, f));
 };
@@ -106,6 +134,7 @@ const firstSuccessOfResultCandidates = (candidates) => {
 	if (!hasCandidates || latestError === void 0) throw createEmptyResultsCollectionError();
 	return latestError;
 };
+const getReason$1 = (value) => typeof value === "object" && value !== null && "reason" in value ? value.reason : void 0;
 const loopResult = (initial, options) => {
 	let state = initial;
 	const values = [];
@@ -223,11 +252,15 @@ var ResultNamespace = class {
 	static err(error) {
 		return err(error);
 	}
-	static combine(resultList) {
-		return combineResultList(resultList);
+	static combine(input) {
+		if (Array.isArray(input)) return combineResultList(input);
+		if (isIterable$1(input)) return combineResultList([...input]);
+		return combineResultRecord(input);
 	}
-	static combineWithAllErrors(resultList) {
-		return combineResultListWithAllErrors(resultList);
+	static combineWithAllErrors(input) {
+		if (Array.isArray(input)) return combineResultListWithAllErrors(input);
+		if (isIterable$1(input)) return combineResultListWithAllErrors([...input]);
+		return combineResultRecordWithAllErrors(input);
 	}
 	static validateAll(resultListOrItems, f) {
 		if (f === void 0) return combineResultListWithAllErrors(resultListOrItems);
@@ -314,6 +347,15 @@ var Ok = class extends ResultVariant {
 	catchTags(_handlers) {
 		return ok(this.value);
 	}
+	catchReason(_errorTag, _reasonTag, _f) {
+		return ok(this.value);
+	}
+	catchReasons(_errorTag, _handlers) {
+		return ok(this.value);
+	}
+	unwrapReason(_errorTag) {
+		return ok(this.value);
+	}
 	branchResult(fCondition, fTrue, fFalse) {
 		return fCondition(this.value) ? fTrue(this.value) : fFalse(this.value);
 	}
@@ -415,6 +457,27 @@ var Err = class extends ResultVariant {
 		if (handled.matched) return handled.value;
 		return err(error);
 	}
+	catchReason(errorTag, reasonTag, f) {
+		if (hasTag(this.error, errorTag)) {
+			const reason = getReason$1(this.error);
+			if (hasTag(reason, reasonTag)) return f(reason, this.error);
+		}
+		return err(this.error);
+	}
+	catchReasons(errorTag, handlers) {
+		if (hasTag(this.error, errorTag)) {
+			const reason = getReason$1(this.error);
+			if (typeof reason === "object" && reason !== null && "_tag" in reason) {
+				const handler = handlers[reason._tag];
+				if (handler !== void 0) return handler(reason, this.error);
+			}
+		}
+		return err(this.error);
+	}
+	unwrapReason(errorTag) {
+		if (hasTag(this.error, errorTag)) return err(getReason$1(this.error));
+		return err(this.error);
+	}
 	asyncAndThen(_f) {
 		return createResultAsync(Promise.resolve(err(this.error)));
 	}
@@ -559,9 +622,223 @@ function isTryResultAsyncOptions(input) {
 	return typeof input === "object" && input !== null && "try" in input;
 }
 const combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen((resultList) => Result.combine(resultList));
+const collectResultAsyncRecord = async (asyncResultRecord) => {
+	const entries = Object.entries(asyncResultRecord);
+	const resultList = await Promise.all(entries.map((entry) => entry[1]));
+	const resultRecord = {};
+	for (const [index, [key]] of entries.entries()) {
+		const result = resultList[index];
+		if (result !== void 0) resultRecord[key] = result;
+	}
+	return resultRecord;
+};
+const combineResultAsyncRecord = (asyncResultRecord) => {
+	return new ResultAsync(collectResultAsyncRecord(asyncResultRecord).then((resultRecord) => Result.combine(resultRecord)));
+};
 const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen((resultList) => Result.combineWithAllErrors(resultList));
-const validateAllResultAsyncItems = (items, f) => {
-	return combineResultAsyncListWithAllErrors(Array.from(items, f));
+const combineResultAsyncRecordWithAllErrors = (asyncResultRecord) => {
+	return new ResultAsync(collectResultAsyncRecord(asyncResultRecord).then((resultRecord) => Result.combineWithAllErrors(resultRecord)));
+};
+const isIterable = (value) => typeof value === "object" && value !== null && Symbol.iterator in value;
+const createIllegalArgumentException = (message) => {
+	const error = new Error(message);
+	error.name = "IllegalArgumentException";
+	return error;
+};
+const createInvalidResultAsyncConcurrencyError = () => createIllegalArgumentException("ResultAsync concurrency must be a positive integer or \"unbounded\"");
+const normalizeResultAsyncConcurrency = (concurrency) => {
+	if (concurrency === void 0) return 1;
+	if (concurrency === "unbounded") return Number.POSITIVE_INFINITY;
+	if (Number.isInteger(concurrency) && concurrency > 0) return concurrency;
+	throw createInvalidResultAsyncConcurrencyError();
+};
+const toResultAsyncRejectionError = (error) => error instanceof Error ? error : new Error(String(error));
+const sortIndexedResultAsyncErrors = (errors) => [...errors].toSorted((left, right) => left.index - right.index);
+const createResultAsyncTraversalState = () => ({
+	activeCount: 0,
+	errors: [],
+	iteratorDone: false,
+	nextIndex: 0,
+	stopScheduling: false,
+	values: []
+});
+const runConcurrentResultAsyncItems = (options) => Promise.try(async () => {
+	const concurrency = normalizeResultAsyncConcurrency(options.concurrency);
+	const iterator = options.items[Symbol.iterator]();
+	const state = createResultAsyncTraversalState();
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const rejectOnce = (error) => {
+			if (!settled) {
+				settled = true;
+				reject(toResultAsyncRejectionError(error));
+			}
+		};
+		const resolveOnce = (result) => {
+			if (!settled) {
+				settled = true;
+				resolve(result);
+			}
+		};
+		const finishIfDone = () => {
+			const result = options.finish(state);
+			if (result !== void 0) resolveOnce(result);
+		};
+		const readNext = () => {
+			try {
+				return iterator.next();
+			} catch (error) {
+				rejectOnce(error);
+				return;
+			}
+		};
+		const schedule = () => {
+			if (settled) return;
+			if (state.stopScheduling) {
+				finishIfDone();
+				return;
+			}
+			while (!state.iteratorDone && state.activeCount < concurrency) {
+				const next = readNext();
+				if (next === void 0) return;
+				if (next.done === true) {
+					state.iteratorDone = true;
+					break;
+				}
+				const currentIndex = state.nextIndex;
+				state.nextIndex += 1;
+				startItem(next.value, currentIndex);
+			}
+			finishIfDone();
+		};
+		const startItem = (item, currentIndex) => {
+			state.activeCount += 1;
+			try {
+				const resultAsync = options.run(item, currentIndex);
+				Promise.resolve(resultAsync).then((result) => {
+					options.onResult(result, currentIndex, state);
+				}, rejectOnce).finally(() => {
+					if (settled) return;
+					state.activeCount -= 1;
+					schedule();
+					finishIfDone();
+				});
+			} catch (error) {
+				rejectOnce(error);
+			}
+		};
+		schedule();
+	});
+});
+const createResultAsyncRetryContext = (attempt, times) => ({
+	attempt,
+	nextAttempt: attempt + 1,
+	retriesRemaining: Math.max(0, times - attempt)
+});
+const createResultAsyncRetryAbortError = (signal) => signal.reason === void 0 ? new AbortError("ResultAsync retry aborted") : new AbortError("ResultAsync retry aborted", { cause: signal.reason });
+const createResultAsyncResourceAbortError = (signal) => signal.reason === void 0 ? new AbortError("ResultAsync resource scope aborted") : new AbortError("ResultAsync resource scope aborted", { cause: signal.reason });
+const validateResultAsyncRetryTimes = (times) => {
+	if (!Number.isInteger(times) || times < 0) throw createIllegalArgumentException("ResultAsync retry times must be a non-negative integer");
+};
+const validateResultAsyncRetryDelayValue = (delayMs) => {
+	if (!Number.isFinite(delayMs) || delayMs < 0) throw createIllegalArgumentException("ResultAsync retry delayMs must be a non-negative finite number");
+};
+const validateResultAsyncRetryStaticDelay = (delay) => {
+	if (typeof delay === "number") validateResultAsyncRetryDelayValue(delay);
+};
+const normalizeResultAsyncRetryDelay = (delay, context) => {
+	const delayMs = typeof delay === "function" ? delay(context) : delay ?? 0;
+	validateResultAsyncRetryDelayValue(delayMs);
+	return delayMs;
+};
+const waitResultAsyncRetryDelay = async (delayMs, signal) => {
+	if (signal.aborted) return Result.err(createResultAsyncRetryAbortError(signal));
+	if (delayMs === 0) return Result.ok(void 0);
+	return new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", abort);
+			resolve(Result.ok(void 0));
+		}, delayMs);
+		const abort = () => {
+			clearTimeout(timeout);
+			resolve(Result.err(createResultAsyncRetryAbortError(signal)));
+		};
+		signal.addEventListener("abort", abort, { once: true });
+	});
+};
+const callResultAsyncRetryOnRetry = async (options, error, context) => {
+	try {
+		await options.onRetry?.(error, context);
+	} catch {}
+};
+const shouldRetryResultAsyncError = async (options, error, context) => options.while?.(error, context) ?? true;
+const resolveResultAsyncRetryRecovery = async (recovered) => recovered instanceof ResultAsync ? recovered : recovered;
+const runResultAsyncRetryAttempts = async (task, options, recover) => {
+	validateResultAsyncRetryTimes(options.times);
+	validateResultAsyncRetryStaticDelay(options.delayMs);
+	const signal = options.signal ?? new AbortController().signal;
+	let attempt = 0;
+	while (true) {
+		if (signal.aborted) return Result.err(createResultAsyncRetryAbortError(signal));
+		const result = await task(attempt, signal);
+		if (result.isOk()) return Result.ok(result.value);
+		const context = createResultAsyncRetryContext(attempt, options.times);
+		if (!await shouldRetryResultAsyncError(options, result.error, context) || attempt >= options.times) return resolveResultAsyncRetryRecovery(recover(result.error, context));
+		await callResultAsyncRetryOnRetry(options, result.error, context);
+		const delayResult = await waitResultAsyncRetryDelay(normalizeResultAsyncRetryDelay(options.delayMs, context), signal);
+		if (delayResult.isErr()) return Result.err(delayResult.error);
+		attempt += 1;
+	}
+};
+const retryResultAsyncTask = (task, options) => new ResultAsync(runResultAsyncRetryAttempts(task, options, (error) => Result.err(error)));
+const retryOrElseResultAsyncTask = (task, options) => new ResultAsync(runResultAsyncRetryAttempts(task, options, (error, context) => options.orElse(error, context)));
+const callResultAsyncResourceRelease = async (release, resource, context) => {
+	try {
+		await release(resource, context);
+	} catch {}
+};
+const runResultAsyncWithResource = async (options) => {
+	const signal = options.signal ?? new AbortController().signal;
+	if (signal.aborted) return Result.err(createResultAsyncResourceAbortError(signal));
+	const acquired = await options.acquire(signal);
+	if (acquired.isErr()) return Result.err(acquired.error);
+	let result = void 0;
+	try {
+		if (signal.aborted) {
+			result = Result.err(createResultAsyncResourceAbortError(signal));
+			return result;
+		}
+		result = await toResultAsync(options.use(acquired.value, signal));
+		return result;
+	} finally {
+		await callResultAsyncResourceRelease(options.release, acquired.value, {
+			result,
+			signal
+		});
+	}
+};
+const withResultAsyncResource = (options) => new ResultAsync(runResultAsyncWithResource(options));
+const validateAllResultAsyncItems = (items, f, options) => {
+	return new ResultAsync(runConcurrentResultAsyncItems({
+		concurrency: options?.concurrency,
+		finish: (state) => {
+			if (!state.iteratorDone || state.activeCount > 0) return;
+			if (state.errors.length > 0) return Result.err(sortIndexedResultAsyncErrors(state.errors).map((entry) => entry.error));
+			return Result.ok(state.values);
+		},
+		items,
+		onResult: (result, currentIndex, state) => {
+			if (result.isErr()) {
+				state.errors.push({
+					error: result.error,
+					index: currentIndex
+				});
+				return;
+			}
+			state.values[currentIndex] = result.value;
+		},
+		run: f
+	}));
 };
 const firstSuccessOfAsyncCandidates = (candidates) => {
 	return new ResultAsync(Promise.try(async () => {
@@ -577,6 +854,96 @@ const firstSuccessOfAsyncCandidates = (candidates) => {
 		return latestError;
 	}));
 };
+const getReason = (value) => typeof value === "object" && value !== null && "reason" in value ? value.reason : void 0;
+const createRaceAbortReason = () => new AbortError("ResultAsync race loser interrupted");
+const startRaceTask = (task, index) => {
+	const controller = new AbortController();
+	const result = task(controller.signal);
+	return {
+		controller,
+		result,
+		settled: Promise.resolve(result).then((taskResult) => ({
+			index,
+			result: taskResult
+		}))
+	};
+};
+const abortStartedRaceTask = (task, reason = createRaceAbortReason()) => {
+	if (!task.controller.signal.aborted) task.controller.abort(reason);
+};
+const createRaceHandle = (task) => ({
+	get signal() {
+		return task.controller.signal;
+	},
+	abort(reason) {
+		abortStartedRaceTask(task, reason);
+	},
+	wait() {
+		return task.result;
+	}
+});
+const abortRaceLosers = (startedTasks, winnerIndex) => {
+	const winner = startedTasks[winnerIndex];
+	for (const loser of startedTasks) if (loser !== winner) abortStartedRaceTask(loser);
+};
+const abortPendingRaceLosers = (startedTasks, winnerIndex, completedIndexes) => {
+	const winner = startedTasks[winnerIndex];
+	for (const [index, loser] of startedTasks.entries()) if (loser !== winner && !completedIndexes.has(index)) abortStartedRaceTask(loser);
+};
+const observeRaceFirstTask = (task, context) => {
+	task.settled.then(({ index, result }) => {
+		if (context.state.settled) return;
+		context.state.settled = true;
+		abortRaceLosers(context.startedTasks, index);
+		context.resolve(result);
+	});
+};
+const observeRaceSuccessTask = (task, context) => {
+	task.settled.then(({ index, result }) => {
+		if (context.state.settled) return;
+		context.state.completedIndexes.add(index);
+		if (result.isOk()) {
+			context.state.settled = true;
+			abortPendingRaceLosers(context.startedTasks, index, context.state.completedIndexes);
+			context.resolve(result);
+			return;
+		}
+		context.state.completedCount += 1;
+		context.state.latestError = result;
+		if (context.state.completedCount === context.startedTasks.length && context.state.latestError !== void 0) {
+			context.state.settled = true;
+			context.resolve(context.state.latestError);
+		}
+	});
+};
+const observeRaceResultAsyncTasks = (tasks, createContext, observeTask) => {
+	const taskList = [...tasks];
+	if (taskList.length === 0) return new ResultAsync(Promise.resolve(Result.err(createEmptyResultsCollectionError())));
+	return new ResultAsync(new Promise((resolve) => {
+		const startedTasks = taskList.map((task, index) => startRaceTask(task, index));
+		const context = createContext(resolve, startedTasks);
+		for (const task of startedTasks) observeTask(task, context);
+	}));
+};
+const raceFirstResultAsyncTasks = (tasks) => observeRaceResultAsyncTasks(tasks, (resolve, startedTasks) => ({
+	resolve,
+	startedTasks,
+	state: { settled: false }
+}), (task, context) => {
+	observeRaceFirstTask(task, context);
+});
+const raceResultAsyncTasks = (tasks) => observeRaceResultAsyncTasks(tasks, (resolve, startedTasks) => ({
+	resolve,
+	startedTasks,
+	state: {
+		completedCount: 0,
+		completedIndexes: /* @__PURE__ */ new Set(),
+		latestError: void 0,
+		settled: false
+	}
+}), (task, context) => {
+	observeRaceSuccessTask(task, context);
+});
 const loopResultAsync = (initial, options) => {
 	return new ResultAsync(Promise.try(async () => {
 		let state = initial;
@@ -603,17 +970,28 @@ const iterateResultAsync = (initial, options) => {
 	}));
 };
 const forEachResultAsync = (items, f, options) => {
-	return new ResultAsync(Promise.try(async () => {
-		const values = [];
-		let index = 0;
-		for (const item of items) {
-			const result = await f(item, index);
-			if (result.isErr()) return Result.err(result.error);
-			if (options?.discard !== true) values.push(result.value);
-			index += 1;
-		}
-		if (options?.discard === true) return Result.ok(void 0);
-		return Result.ok(values);
+	return new ResultAsync(runConcurrentResultAsyncItems({
+		concurrency: options?.concurrency,
+		finish: (state) => {
+			if (state.activeCount > 0 || !state.iteratorDone && !state.stopScheduling) return;
+			const firstError = sortIndexedResultAsyncErrors(state.errors)[0];
+			if (firstError !== void 0) return Result.err(firstError.error);
+			if (options?.discard === true) return Result.ok(void 0);
+			return Result.ok(state.values);
+		},
+		items,
+		onResult: (result, currentIndex, state) => {
+			if (result.isErr()) {
+				state.errors.push({
+					error: result.error,
+					index: currentIndex
+				});
+				state.stopScheduling = true;
+				return;
+			}
+			if (options?.discard !== true) state.values[currentIndex] = result.value;
+		},
+		run: f
 	}));
 };
 const resolveResultAsyncBooleanCondition = (condition) => typeof condition === "function" ? condition() : condition;
@@ -744,19 +1122,89 @@ var ResultAsync = class ResultAsync extends Pipeable {
 	static fromPromise(promise, errorFn) {
 		return new ResultAsync(promise.then((value) => Result.ok(value)).catch((error) => Result.err(errorFn(error))));
 	}
-	static combine(asyncResultList) {
-		return combineResultAsyncList(asyncResultList);
+	static combine(input) {
+		if (Array.isArray(input)) return combineResultAsyncList(input);
+		if (isIterable(input)) return combineResultAsyncList([...input]);
+		return combineResultAsyncRecord(input);
 	}
-	static combineWithAllErrors(asyncResultList) {
-		return combineResultAsyncListWithAllErrors(asyncResultList);
+	static combineWithAllErrors(input) {
+		if (Array.isArray(input)) return combineResultAsyncListWithAllErrors(input);
+		if (isIterable(input)) return combineResultAsyncListWithAllErrors([...input]);
+		return combineResultAsyncRecordWithAllErrors(input);
 	}
-	static validateAll(asyncResultListOrItems, f) {
+	static validateAll(asyncResultListOrItems, f, options) {
 		if (f === void 0) return combineResultAsyncListWithAllErrors(asyncResultListOrItems);
-		return validateAllResultAsyncItems(asyncResultListOrItems, f);
+		return validateAllResultAsyncItems(asyncResultListOrItems, f, options);
 	}
 	static zip(left, right) {
 		return combineResultAsyncList([left, right]);
 	}
+	static retry(task, options) {
+		return retryResultAsyncTask(task, options);
+	}
+	static retryOrElse(task, options) {
+		return retryOrElseResultAsyncTask(task, options);
+	}
+	static withResource(options) {
+		return withResultAsyncResource(options);
+	}
+	static race(left, right) {
+		return raceResultAsyncTasks([left, right]);
+	}
+	static raceAll(tasks) {
+		return raceResultAsyncTasks(tasks);
+	}
+	static raceFirst(left, right) {
+		return raceFirstResultAsyncTasks([left, right]);
+	}
+	static raceWith(left, right, handlers) {
+		return new ResultAsync(new Promise((resolve) => {
+			const leftTask = startRaceTask(left, 0);
+			const rightTask = startRaceTask(right, 1);
+			const leftHandle = createRaceHandle(leftTask);
+			const rightHandle = createRaceHandle(rightTask);
+			let settled = false;
+			leftTask.settled.then(({ result }) => {
+				if (settled) return;
+				settled = true;
+				const handled = handlers.onLeftDone(result, rightHandle);
+				Promise.resolve(toResultAsync(handled)).then((handledResult) => {
+					resolve(handledResult);
+				});
+			});
+			rightTask.settled.then(({ result }) => {
+				if (settled) return;
+				settled = true;
+				const handled = handlers.onRightDone(result, leftHandle);
+				Promise.resolve(toResultAsync(handled)).then((handledResult) => {
+					resolve(handledResult);
+				});
+			});
+		}));
+	}
+	static timeout(task, options) {
+		const timeoutTask = (signal) => {
+			return new ResultAsync(new Promise((resolve) => {
+				const timeout = setTimeout(() => {
+					resolve(Result.err(options.onTimeout()));
+				}, options.timeoutMs);
+				signal.addEventListener("abort", () => {
+					clearTimeout(timeout);
+				}, { once: true });
+			}));
+		};
+		return ResultAsync.raceWith(task, timeoutTask, {
+			onLeftDone: (result, timeoutHandle) => {
+				timeoutHandle.abort(createRaceAbortReason());
+				return result;
+			},
+			onRightDone: (result, taskHandle) => {
+				if (result.isErr()) taskHandle.abort(result.error);
+				else taskHandle.abort(createRaceAbortReason());
+				return result;
+			}
+		});
+	}
 	static firstSuccessOf(candidates) {
 		return firstSuccessOfAsyncCandidates(candidates);
 	}
@@ -881,6 +1329,42 @@ var ResultAsync = class ResultAsync extends Pipeable {
 			return Result.err(error);
 		}));
 	}
+	catchReason(errorTag, reasonTag, f) {
+		return new ResultAsync(this.innerPromise.then((res) => {
+			if (res.isOk()) return Result.ok(res.value);
+			if (hasTag(res.error, errorTag)) {
+				const reason = getReason(res.error);
+				if (hasTag(reason, reasonTag)) {
+					const next = f(reason, res.error);
+					return next instanceof ResultAsync ? next.innerPromise : next;
+				}
+			}
+			return Result.err(res.error);
+		}));
+	}
+	catchReasons(errorTag, handlers) {
+		return new ResultAsync(this.innerPromise.then((res) => {
+			if (res.isOk()) return Result.ok(res.value);
+			if (hasTag(res.error, errorTag)) {
+				const reason = getReason(res.error);
+				if (typeof reason === "object" && reason !== null && "_tag" in reason) {
+					const handler = handlers[reason._tag];
+					if (handler !== void 0) {
+						const next = handler(reason, res.error);
+						return next instanceof ResultAsync ? next.innerPromise : next;
+					}
+				}
+			}
+			return Result.err(res.error);
+		}));
+	}
+	unwrapReason(errorTag) {
+		return new ResultAsync(this.innerPromise.then((res) => {
+			if (res.isOk()) return Result.ok(res.value);
+			if (hasTag(res.error, errorTag)) return Result.err(getReason(res.error));
+			return Result.err(res.error);
+		}));
+	}
 	async match(input, fnErr) {
 		return this.innerPromise.then((res) => typeof input === "function" ? res.match(input, getMatchErrorHandler(input, fnErr)) : res.match(input));
 	}
@@ -984,6 +1468,28 @@ function tryResultAsync(input, errorFn) {
 /** Compatibility alias. Prefer `tryResultAsync` in new code. */
 const tryCatchAsync = tryResultAsync;
 //#endregion
+//#region src/redacted.ts
+const redactedValues = /* @__PURE__ */ new WeakMap();
+const formatRedacted = (label) => label === void 0 ? "<redacted>" : `<redacted:${label}>`;
+var RedactedValue = class {
+	__resultarRedacted = true;
+	label;
+	constructor(value, label) {
+		this.label = label;
+		redactedValues.set(this, value);
+	}
+	toJSON() {
+		return this.toString();
+	}
+	toString() {
+		return formatRedacted(this.label);
+	}
+};
+const redact = (value, label) => new RedactedValue(value, label);
+const isRedacted = (value) => typeof value === "object" && value !== null && redactedValues.has(value);
+const revealRedacted = (value) => redactedValues.get(value);
+const stringifyRedacted = (value) => value.toString();
+//#endregion
 //#region src/tagged-error.ts
 const defaultBaseError = Error;
 const defaultMessageTemplate = "$message";
@@ -1020,7 +1526,7 @@ const templateValueStringifiers = {
 	string: stringifyDirectTemplateValue,
 	symbol: stringifySymbolTemplateValue
 };
-const stringifyTemplateValue = (value) => templateValueStringifiers[typeof value]?.(value) ?? "";
+const stringifyTemplateValue = (value) => isRedacted(value) ? stringifyRedacted(value) : templateValueStringifiers[typeof value]?.(value) ?? "";
 const compileMessageInterpolator = (template) => (values) => template.replaceAll(templateVariableMatcher, (variable, key) => {
 	const value = values?.[key];
 	return value === void 0 ? variable : stringifyTemplateValue(value);
@@ -1043,13 +1549,23 @@ const assignReadonly = (target, key, value) => {
 		writable: false
 	});
 };
-const serializeCause = (cause) => {
-	if (!isError(cause)) return cause;
-	return {
+const serializeTaggedValue = (value) => isRedacted(value) ? stringifyRedacted(value) : value;
+const serializeCause = (cause, seen = /* @__PURE__ */ new Set()) => {
+	if (!isError(cause)) return serializeTaggedValue(cause);
+	if (seen.has(cause)) return {
+		cause: "[Circular]",
 		message: cause.message,
 		name: cause.name,
 		stack: cause.stack
 	};
+	seen.add(cause);
+	const json = {
+		message: cause.message,
+		name: cause.name,
+		stack: cause.stack
+	};
+	if (cause.cause !== void 0) json["cause"] = serializeCause(cause.cause, seen);
+	return json;
 };
 const findCause = (error, ErrorClass) => {
 	const seen = /* @__PURE__ */ new Set();
@@ -1097,12 +1613,34 @@ function createTaggedError(options) {
 				name: this.name
 			};
 			if (this.cause !== void 0) json["cause"] = serializeCause(this.cause);
-			for (const [key, value] of Object.entries(this)) if (!(key in json) && key !== "cause" && key !== "stack") json[key] = value;
+			for (const [key, value] of Object.entries(this)) if (!(key in json) && key !== "cause" && key !== "stack") json[key] = serializeTaggedValue(value);
 			return json;
 		}
 	}
 	return GeneratedTaggedError;
 }
+const taggedEnum = () => {
+	return new Proxy({
+		$is(tag, value) {
+			return typeof value === "object" && value !== null && "_tag" in value && value._tag === tag;
+		},
+		$match(value, handlers) {
+			const handler = handlers[value._tag];
+			if (handler === void 0) throw new Error(`No tagged enum handler for ${String(value._tag)}`);
+			return handler(value);
+		}
+	}, { get(base, property, receiver) {
+		if (property in base) return Reflect.get(base, property, receiver);
+		if (typeof property !== "string") return;
+		return (props) => {
+			const value = { _tag: property };
+			if (props !== void 0) {
+				for (const [key, propValue] of Object.entries(props)) if (key !== "_tag") value[key] = propValue;
+			}
+			return Object.freeze(value);
+		};
+	} });
+};
 const matchError = (error, handlers) => {
 	if ("_tag" in error && typeof error._tag === "string" && error._tag in handlers) {
 		const handler = handlers[error._tag];
@@ -1120,6 +1658,6 @@ const matchErrorPartial = (error, handlers, fallback) => {
 	return fallback(error);
 };
 //#endregion
-export { DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+export { AbortError, DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
 
 //# sourceMappingURL=index.js.map