resultar 3.6.0 → 3.7.0

package/dist/index.js

@@ -673,6 +673,897 @@ const runSync = (result) => result.unwrapOrThrow();
 /** Compatibility alias. Prefer `tryResult` in new code. */
 const tryCatch = tryResult;
 //#endregion
+//#region src/task/scope.ts
+/** Appends cleanup failures without replacing the original execution outcome. */
+const appendExit = (exit, cleanup) => {
+	if (cleanup._tag === "Success") return exit;
+	if (exit._tag === "Success") return cleanup;
+	return {
+		_tag: "Failure",
+		cause: {
+			_tag: "Sequential",
+			left: exit.cause,
+			right: cleanup.cause
+		}
+	};
+};
+/** Private runtime scope; each run owns its own finalizer stack. */
+var TaskScope = class {
+	finalizers = [];
+	closing;
+	add(finalizer) {
+		if (this.closing !== void 0) throw new Error("Cannot acquire into a closing ResultTask scope");
+		this.finalizers.push(finalizer);
+	}
+	adopt(child) {
+		if (this.closing !== void 0) throw new Error("Cannot acquire into a closing ResultTask scope");
+		this.finalizers.push(...child.finalizers.splice(0));
+	}
+	close(exit, cleanupOnly = false) {
+		this.closing ??= this.drain(exit, cleanupOnly);
+		return this.closing;
+	}
+	async drain(exit, cleanupOnly) {
+		let result = cleanupOnly ? {
+			_tag: "Success",
+			value: void 0
+		} : exit;
+		let finalizer = this.finalizers.pop();
+		while (finalizer !== void 0) {
+			try {
+				result = appendExit(result, await finalizer(exit));
+			} catch (error) {
+				result = appendExit(result, {
+					_tag: "Failure",
+					cause: {
+						_tag: "Die",
+						defect: error
+					}
+				});
+			}
+			finalizer = this.finalizers.pop();
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/result-task.ts
+/** Rejection used when a simplified boundary cannot represent multiple failures. */
+var ResultTaskCauseError = class extends Error {
+	cause;
+	constructor(cause) {
+		super("ResultTask execution failed with multiple causes");
+		this.name = "ResultTaskCauseError";
+		Object.defineProperty(this, "cause", {
+			configurable: true,
+			enumerable: false,
+			value: cause,
+			writable: true
+		});
+	}
+};
+/** Type identifier symbol for nominal `ResultTask` branding and variance checks. */
+const ResultTaskTypeId = Symbol.for("resultar/ResultTask");
+/** Type identifier symbol for nominal `ServiceTag` branding. */
+const ServiceTagTypeId = Symbol.for("resultar/ServiceTag");
+/** Type identifier symbol for nominal `ResultTask` yieldable objects. */
+const ResultTaskYieldTypeId = Symbol.for("resultar/ResultTaskYield");
+/** Error thrown as a Die cause when a requested service is not provided in the environment. */
+var MissingServiceError = class extends Error {
+	serviceIdentifier;
+	constructor(serviceIdentifier) {
+		super(`Missing ResultTask service: ${serviceIdentifier}`);
+		this.name = "MissingServiceError";
+		this.serviceIdentifier = serviceIdentifier;
+	}
+};
+const success = (value) => ({
+	_tag: "Success",
+	value
+});
+const failure = (cause) => ({
+	_tag: "Failure",
+	cause
+});
+const failed = (error) => failure({
+	_tag: "Fail",
+	error
+});
+const died = (defect) => failure({
+	_tag: "Die",
+	defect
+});
+const interrupted = (signal) => failure({
+	_tag: "Interrupt",
+	reason: signal.reason
+});
+const interruptSuccess = (exit, signal) => exit._tag === "Success" && signal.aborted ? interrupted(signal) : exit;
+const throwDefect = (defect) => {
+	throw defect;
+};
+const isObjectLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+const isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Returns true if a value is a nominal `ServiceTag`. */
+const isServiceTag = (value) => isObjectLike(value) && value[ServiceTagTypeId] === ServiceTagTypeId && value._tag === "ServiceTag" && typeof value.identifier === "string" && typeof value.key === "symbol" && typeof value[Symbol.iterator] === "function";
+/** Returns true if a value is a `ResultTask` instance. */
+const isResultTask = (value) => isObjectLike(value) && (value instanceof ResultTask || value[ResultTaskTypeId] !== void 0);
+const isResultTaskYield = (value) => isObjectLike(value) && value[ResultTaskYieldTypeId] === ResultTaskYieldTypeId && value._tag === "ResultTask" && isResultTask(value.task);
+const isServiceYield = (value) => isObjectLike(value) && value[ResultTaskYieldTypeId] === ResultTaskYieldTypeId && value._tag === "Service" && isServiceTag(value.tag);
+const isErrResult = (value) => isObjectLike(value) && "error" in value && typeof value.isErr === "function" && value.isErr();
+const lookupService = (tag, context) => {
+	if (context.services.has(tag.key)) return {
+		_tag: "Found",
+		value: context.services.get(tag.key)
+	};
+	if (context.namedServices.has(tag.identifier)) return {
+		_tag: "Found",
+		value: context.namedServices.get(tag.identifier)
+	};
+	return { _tag: "Missing" };
+};
+const resolveService = async (tag, context, executeTask) => {
+	const supplied = lookupService(tag, context);
+	if (supplied._tag === "Found") return supplied;
+	if (context.serviceResolver === void 0) return supplied;
+	let task = void 0;
+	try {
+		task = context.serviceResolver(tag);
+	} catch (error) {
+		return {
+			_tag: "Error",
+			error
+		};
+	}
+	if (task === void 0) return supplied;
+	const outcome = await executeTaskSafely(task, executeTask);
+	if ("error" in outcome) return {
+		_tag: "Error",
+		error: outcome.error
+	};
+	if (outcome._tag === "Failure") return {
+		_tag: "Failure",
+		exit: outcome
+	};
+	return {
+		_tag: "Found",
+		value: outcome.value
+	};
+};
+const executeTaskSafely = async (task, executeTask) => {
+	try {
+		return await executeTask(task);
+	} catch (error) {
+		return { error };
+	}
+};
+const closeGenerator = async (iterator, exit, runtime) => {
+	try {
+		let step = iterator.return(void 0);
+		let finalExit = exit;
+		while (step.done === false) if (isResultTaskYield(step.value)) {
+			const outcome = await executeTaskSafely(step.value.task, runtime.executeTask);
+			if ("error" in outcome) {
+				finalExit = died(outcome.error);
+				step = iterator.return(void 0);
+			} else if (outcome._tag === "Failure") {
+				finalExit = outcome;
+				step = iterator.return(void 0);
+			} else step = iterator.next(outcome);
+		} else if (isServiceYield(step.value)) {
+			const resolution = await resolveService(step.value.tag, runtime.context, runtime.executeTask);
+			if (resolution._tag === "Found") step = iterator.next(resolution.value);
+			else if (resolution._tag === "Failure") {
+				finalExit = resolution.exit;
+				step = iterator.return(void 0);
+			} else {
+				finalExit = died(resolution._tag === "Error" ? resolution.error : new MissingServiceError(step.value.tag.identifier));
+				step = iterator.return(void 0);
+			}
+		} else if (isErrResult(step.value)) {
+			finalExit = failed(step.value.error);
+			step = iterator.return(void 0);
+		} else {
+			finalExit = died(/* @__PURE__ */ new TypeError("ResultTask.gen yielded an unsupported value"));
+			step = iterator.return(void 0);
+		}
+		return finalExit;
+	} catch (error) {
+		return died(error);
+	}
+};
+const withServices = (context, services) => ({
+	scope: context.scope,
+	namedServices: context.namedServices,
+	services,
+	serviceResolver: context.serviceResolver,
+	signal: context.signal
+});
+const withScope = (context, scope, signal = context.signal) => ({
+	namedServices: context.namedServices,
+	services: context.services,
+	serviceResolver: context.serviceResolver,
+	signal,
+	scope
+});
+const withNamedServices = (context, namedServices) => ({
+	scope: context.scope,
+	namedServices,
+	services: context.services,
+	serviceResolver: context.serviceResolver,
+	signal: context.signal
+});
+const withServiceResolver = (context, serviceResolver) => ({
+	namedServices: context.namedServices,
+	services: context.services,
+	serviceResolver,
+	signal: context.signal,
+	scope: context.scope
+});
+var ServiceTagValue = class {
+	[ServiceTagTypeId] = ServiceTagTypeId;
+	_tag = "ServiceTag";
+	identifier;
+	key;
+	constructor(identifier) {
+		this.identifier = identifier;
+		this.key = Symbol(identifier);
+	}
+	*[Symbol.iterator]() {
+		return yield {
+			[ResultTaskYieldTypeId]: ResultTaskYieldTypeId,
+			_tag: "Service",
+			tag: this
+		};
+	}
+};
+/** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
+const serviceTag = (identifier) => new ServiceTagValue(identifier);
+const applySuccessContinuation = (continuation, exit) => {
+	switch (continuation._tag) {
+		case "Map": try {
+			return {
+				current: void 0,
+				currentExit: success(continuation.f(exit.value))
+			};
+		} catch (error) {
+			return {
+				current: void 0,
+				currentExit: died(error)
+			};
+		}
+		case "FlatMap": try {
+			return {
+				current: continuation.f(exit.value),
+				currentExit: void 0
+			};
+		} catch (error) {
+			return {
+				current: void 0,
+				currentExit: died(error)
+			};
+		}
+		case "Tap": try {
+			const res = continuation.f(exit.value);
+			return ResultTask.toTapContinuationStep(res, () => ResultTask.succeed(exit.value), exit);
+		} catch (error) {
+			return {
+				current: void 0,
+				currentExit: died(error)
+			};
+		}
+		case "MapError": return {
+			current: void 0,
+			currentExit: exit
+		};
+		case "TapError": return {
+			current: void 0,
+			currentExit: exit
+		};
+		case "CatchAll": return {
+			current: void 0,
+			currentExit: exit
+		};
+		default: return {
+			current: void 0,
+			currentExit: exit
+		};
+	}
+};
+const applyFailureContinuation = (continuation, exit) => {
+	switch (continuation._tag) {
+		case "MapError":
+			if (exit.cause._tag === "Fail") try {
+				return {
+					current: void 0,
+					currentExit: failed(continuation.f(exit.cause.error))
+				};
+			} catch (error) {
+				return {
+					current: void 0,
+					currentExit: died(error)
+				};
+			}
+			return {
+				current: void 0,
+				currentExit: exit
+			};
+		case "TapError":
+			if (exit.cause._tag === "Fail") try {
+				const failError = exit.cause.error;
+				const res = continuation.f(failError);
+				return ResultTask.toTapContinuationStep(res, () => ResultTask.fail(failError), exit);
+			} catch (error) {
+				return {
+					current: void 0,
+					currentExit: died(error)
+				};
+			}
+			return {
+				current: void 0,
+				currentExit: exit
+			};
+		case "CatchAll":
+			if (exit.cause._tag === "Sequential") return {
+				current: void 0,
+				currentExit: died(new ResultTaskCauseError(exit.cause))
+			};
+			if (exit.cause._tag === "Fail") try {
+				return {
+					current: continuation.f(exit.cause.error),
+					currentExit: void 0
+				};
+			} catch (error) {
+				return {
+					current: void 0,
+					currentExit: died(error)
+				};
+			}
+			return {
+				current: void 0,
+				currentExit: exit
+			};
+		case "Map": return {
+			current: void 0,
+			currentExit: exit
+		};
+		case "FlatMap": return {
+			current: void 0,
+			currentExit: exit
+		};
+		case "Tap": return {
+			current: void 0,
+			currentExit: exit
+		};
+		default: return {
+			current: void 0,
+			currentExit: exit
+		};
+	}
+};
+const applyContinuation = (continuation, exit) => exit._tag === "Success" ? applySuccessContinuation(continuation, exit) : applyFailureContinuation(continuation, exit);
+const executeInstruction = async (instruction, continuations, context) => {
+	switch (instruction._tag) {
+		case "FlatMap":
+		case "Map":
+		case "MapError":
+		case "Tap":
+		case "TapError":
+		case "CatchAll":
+			continuations.push(instruction);
+			return {
+				nextCurrent: instruction.task,
+				exit: void 0
+			};
+		case "Succeed": return {
+			nextCurrent: void 0,
+			exit: success(instruction.value)
+		};
+		case "Fail": return {
+			nextCurrent: void 0,
+			exit: failed(instruction.error)
+		};
+		case "Sync": try {
+			return {
+				nextCurrent: void 0,
+				exit: instruction.evaluate()
+			};
+		} catch (error) {
+			return {
+				nextCurrent: void 0,
+				exit: died(error)
+			};
+		}
+		case "Async": try {
+			return {
+				nextCurrent: void 0,
+				exit: await instruction.execute(context)
+			};
+		} catch (error) {
+			return {
+				nextCurrent: void 0,
+				exit: died(error)
+			};
+		}
+		default: return {
+			nextCurrent: void 0,
+			exit: void 0
+		};
+	}
+};
+var ResultTask = class ResultTask extends Pipeable {
+	instruction;
+	execute;
+	constructor(instructionOrExecute) {
+		super();
+		this.instruction = typeof instructionOrExecute === "function" ? {
+			_tag: "Async",
+			execute: instructionOrExecute
+		} : instructionOrExecute;
+		this.execute = (context) => ResultTask.runTaskLoop(this, context);
+	}
+	/** @internal */
+	static toTapContinuationStep(res, onSuccess, passThroughExit) {
+		if (res instanceof ResultTask) return {
+			current: res.flatMap(onSuccess),
+			currentExit: void 0
+		};
+		if (typeof res === "object" && res !== null && typeof res.then === "function") return {
+			current: new ResultTask(async () => {
+				try {
+					await res;
+					return success(void 0);
+				} catch (error) {
+					return died(error);
+				}
+			}).flatMap(onSuccess),
+			currentExit: void 0
+		};
+		return {
+			current: void 0,
+			currentExit: passThroughExit
+		};
+	}
+	static async runTaskLoop(rootTask, context) {
+		const continuations = [];
+		let current = rootTask;
+		let currentExit = void 0;
+		while (current !== void 0 || continuations.length > 0) if (current === void 0) {
+			if (currentExit !== void 0) {
+				const nextContinuation = continuations.pop();
+				if (nextContinuation === void 0) return currentExit;
+				const resolvedExit = context.signal.aborted && currentExit._tag === "Success" ? interrupted(context.signal) : currentExit;
+				const step = applyContinuation(nextContinuation, resolvedExit);
+				current = step.current;
+				currentExit = step.currentExit;
+			}
+		} else {
+			if (context.signal.aborted) return interrupted(context.signal);
+			const step = await executeInstruction(current.instruction, continuations, context);
+			current = step.nextCurrent;
+			currentExit = step.exit;
+		}
+		return currentExit ?? success(void 0);
+	}
+	static succeed(value) {
+		return new ResultTask({
+			_tag: "Succeed",
+			value
+		});
+	}
+	/** Creates a task that fails with `error` when it is executed. */
+	static fail(error) {
+		return new ResultTask({
+			_tag: "Fail",
+			error
+		});
+	}
+	/** Lifts an already computed Result into a lazy task. */
+	static fromResult(result) {
+		return new ResultTask({
+			_tag: "Sync",
+			evaluate: () => result.isOk() ? success(result.value) : failed(result.error)
+		});
+	}
+	/** Creates a task for synchronous work. Thrown values are defects, not typed failures. */
+	static sync(evaluate) {
+		return new ResultTask({
+			_tag: "Sync",
+			evaluate: () => success(evaluate())
+		});
+	}
+	/** Creates a task that maps synchronous throws into the typed error channel. */
+	static try(options) {
+		return new ResultTask({
+			_tag: "Sync",
+			evaluate: () => {
+				try {
+					return success(options.try());
+				} catch (error) {
+					return failed(options.catch(error));
+				}
+			}
+		});
+	}
+	static tryPromise(options) {
+		return new ResultTask(async (context) => {
+			try {
+				return success(await (typeof options === "function" ? options(context.signal) : options.try(context.signal)));
+			} catch (error) {
+				if (context.signal.aborted) return interrupted(context.signal);
+				return failed(typeof options === "function" ? error : options.catch(error));
+			}
+		});
+	}
+	/**
+	* Acquires lazily and registers release in the current scope. Release failures remain in the
+	* scope requirement until `scoped` or a run boundary closes it; catchAll cannot erase them early.
+	*/
+	static acquireRelease(options) {
+		return new ResultTask(async (context) => {
+			const acquired = await options.acquire.execute(context);
+			if (acquired._tag === "Failure") return acquired;
+			context.scope.add(async (exit) => {
+				const scope = new TaskScope();
+				const cleanupContext = withScope(context, scope, new AbortController().signal);
+				let released = success(void 0);
+				try {
+					released = await options.release(acquired.value, exit).execute(cleanupContext);
+				} catch (error) {
+					released = died(error);
+				}
+				return scope.close(released);
+			});
+			return acquired;
+		});
+	}
+	/** Closes a child scope before continuing, adding its deferred release errors to E. */
+	static scoped(task) {
+		return new ResultTask(async (context) => {
+			const scope = new TaskScope();
+			const exit = await task.execute(withScope(context, scope));
+			return interruptSuccess(await scope.close(interruptSuccess(exit, context.signal)), context.signal);
+		});
+	}
+	/** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
+	static service(identifier) {
+		return new ServiceTagValue(identifier);
+	}
+	/** Builds a task from a generator and short-circuits on the first failed task. */
+	static gen(body) {
+		return new ResultTask(async (context) => {
+			try {
+				const iterator = body();
+				const executeTask = async (task) => interruptSuccess(await task.execute(context), context.signal);
+				const closeRuntime = {
+					context,
+					executeTask: (task) => task.execute(withScope(context, context.scope, new AbortController().signal))
+				};
+				let step = iterator.next();
+				while (step.done === false) if (isResultTaskYield(step.value)) {
+					const outcome = await executeTaskSafely(step.value.task, executeTask);
+					if ("error" in outcome) return await closeGenerator(iterator, died(outcome.error), closeRuntime);
+					if (outcome._tag === "Failure") return await closeGenerator(iterator, outcome, closeRuntime);
+					step = iterator.next(outcome);
+				} else if (isServiceYield(step.value)) {
+					const resolution = await resolveService(step.value.tag, context, executeTask);
+					if (resolution._tag === "Found") step = iterator.next(resolution.value);
+					else if (resolution._tag === "Failure") return await closeGenerator(iterator, resolution.exit, closeRuntime);
+					else return await closeGenerator(iterator, died(resolution._tag === "Error" ? resolution.error : new MissingServiceError(step.value.tag.identifier)), closeRuntime);
+				} else if (isErrResult(step.value)) return await closeGenerator(iterator, failed(step.value.error), closeRuntime);
+				else return await closeGenerator(iterator, died(/* @__PURE__ */ new TypeError("ResultTask.gen yielded an unsupported value")), closeRuntime);
+				return success(step.value);
+			} catch (error) {
+				return died(error);
+			}
+		});
+	}
+	/** Maps the success value without executing the task. */
+	map(f) {
+		return new ResultTask({
+			_tag: "Map",
+			task: this,
+			f
+		});
+	}
+	/** Chains another task from the success value without executing either task immediately. */
+	flatMap(f) {
+		return new ResultTask({
+			_tag: "FlatMap",
+			task: this,
+			f
+		});
+	}
+	/** Alias for `flatMap`, matching the existing Resultar vocabulary. */
+	andThen(f) {
+		return this.flatMap(f);
+	}
+	/**
+	* Recovers a single typed failure. Composite causes become a Die(ResultTaskCauseError) so the
+	* removed E cannot escape through runExit; the original tree remains available on error.cause.
+	*/
+	catchAll(f) {
+		return new ResultTask({
+			_tag: "CatchAll",
+			task: this,
+			f
+		});
+	}
+	/** Maps the error value without executing the task. */
+	mapError(f) {
+		return new ResultTask({
+			_tag: "MapError",
+			task: this,
+			f
+		});
+	}
+	/**
+	* Executes a side effect on the success value without modifying it.
+	* If the callback returns a `ResultTask`, its requirements and errors are merged.
+	*/
+	tap(f) {
+		return new ResultTask({
+			_tag: "Tap",
+			task: this,
+			f
+		});
+	}
+	/**
+	* Executes a side effect on the error value without modifying it.
+	* If the callback returns a `ResultTask`, its requirements and errors are merged.
+	*/
+	tapError(f) {
+		return new ResultTask({
+			_tag: "TapError",
+			task: this,
+			f
+		});
+	}
+	/** Replaces the success value with a constant. */
+	as(value) {
+		return this.map(() => value);
+	}
+	/**
+	* Transforms both success and failure cases into a single value type.
+	*/
+	match(handlers) {
+		const onSuccess = "onSuccess" in handlers ? handlers.onSuccess : handlers.ok;
+		const onFailure = "onFailure" in handlers ? handlers.onFailure : handlers.err;
+		return this.map(onSuccess).catchAll((error) => ResultTask.succeed(onFailure(error)));
+	}
+	/** Converts this ResultTask into an eagerly started ResultAsync using the standard runtime. */
+	toResultAsync() {
+		return ResultTask.toResultAsync(this);
+	}
+	/** Provides one required service and removes it from the task's requirements. */
+	provideService(tag, ...args) {
+		if (args.length === 0) throw new TypeError("ResultTask.provideService requires a service implementation");
+		return ResultTask.provideService(this, tag, args[0]);
+	}
+	/** Provides all requirements using an object keyed by service identifier. */
+	provideServices(services) {
+		return ResultTask.provideServices(this, services);
+	}
+	/** Provides a lazy resolver for service tags that are not already in the environment. */
+	provideServiceResolver(resolvers) {
+		return ResultTask.provideServiceResolver(this, resolvers);
+	}
+	/** Enables `yield* task` inside `ResultTask.gen` workflows. */
+	*[Symbol.iterator]() {
+		const exit = yield {
+			[ResultTaskYieldTypeId]: ResultTaskYieldTypeId,
+			_tag: "ResultTask",
+			task: this
+		};
+		if (exit._tag === "Success") return exit.value;
+		return throwDefect(/* @__PURE__ */ new Error("ResultTask generator received a failed task result"));
+	}
+	static provideService(...args) {
+		if (args.length >= 3) {
+			const [task, tag, service] = args;
+			if (!isResultTask(task)) throw new TypeError("ResultTask.provideService expects a ResultTask as first argument");
+			if (!isServiceTag(tag)) throw new TypeError("ResultTask.provideService requires a valid service tag");
+			return new ResultTask(async (context) => {
+				const services = new Map([...context.services, [tag.key, service]]);
+				const namedServices = new Map([...context.namedServices, [tag.identifier, service]]);
+				return task.execute(withNamedServices(withServices(context, services), namedServices));
+			});
+		}
+		if (args.length === 2 && !isResultTask(args[0])) {
+			const [tag, service] = args;
+			if (!isServiceTag(tag)) throw new TypeError("ResultTask.provideService requires a valid service tag");
+			return (task) => ResultTask.provideService(task, tag, service);
+		}
+		throw new TypeError("ResultTask.provideService requires a service implementation");
+	}
+	static provideServiceResolver(...args) {
+		if (args.length >= 2) {
+			const [task, resolvers] = args;
+			if (!isResultTask(task)) throw new TypeError("ResultTask.provideServiceResolver expects a ResultTask as first argument");
+			if (!isPlainRecord(resolvers)) throw new TypeError("ResultTask.provideServiceResolver requires a resolvers object");
+			return new ResultTask(async (context) => {
+				const providers = resolvers;
+				return task.execute(withServiceResolver(context, (tag) => Object.hasOwn(providers, tag.identifier) ? providers[tag.identifier]?.() : context.serviceResolver?.(tag)));
+			});
+		}
+		if (!isResultTask(args[0])) {
+			const [resolvers] = args;
+			if (!isPlainRecord(resolvers)) throw new TypeError("ResultTask.provideServiceResolver requires a resolvers object");
+			return (task) => ResultTask.provideServiceResolver(task, resolvers);
+		}
+		throw new TypeError("ResultTask.provideServiceResolver requires a resolvers object");
+	}
+	/** Shares one in-flight execution and successful value. Failed executions can be retried. */
+	static memoize(task) {
+		let pending = void 0;
+		return new ResultTask(async (context) => {
+			pending ??= task.execute(context);
+			const current = pending;
+			const exit = await current;
+			if (exit._tag === "Failure" && pending === current) pending = void 0;
+			return exit;
+		});
+	}
+	/** Creates an explicit resource owner for adapters that manage long-lived scopes. */
+	static makeScope() {
+		const scope = new TaskScope();
+		const controller = new AbortController();
+		const pending = /* @__PURE__ */ new Set();
+		let closing = void 0;
+		return {
+			use: (task) => new ResultTask(async (context) => {
+				if (closing !== void 0) return died(/* @__PURE__ */ new Error("Cannot execute in a closed ResultTask scope"));
+				const attempt = new TaskScope();
+				const execution = task.execute(withScope(context, attempt, controller.signal)).then(async (exit) => {
+					if (exit._tag === "Failure") return attempt.close(exit);
+					scope.adopt(attempt);
+					return exit;
+				});
+				pending.add(execution);
+				execution.then(() => pending.delete(execution));
+				return new Promise((resolve) => {
+					const onAbort = () => {
+						resolve(interrupted(context.signal));
+					};
+					context.signal.addEventListener("abort", onAbort, { once: true });
+					if (context.signal.aborted) onAbort();
+					execution.then((exit) => {
+						context.signal.removeEventListener("abort", onAbort);
+						resolve(interruptSuccess(exit, context.signal));
+					});
+				});
+			}),
+			close: (exit = success(void 0)) => new ResultTask(async () => {
+				closing ??= (async () => {
+					controller.abort("ResultTask scope closed");
+					await Promise.all(pending);
+					return scope.close(exit, true);
+				})();
+				return await closing;
+			})
+		};
+	}
+	static provideServices(...args) {
+		if (args.length >= 2) {
+			const [task, services] = args;
+			if (!isResultTask(task)) throw new TypeError("ResultTask.provideServices expects a ResultTask as first argument");
+			if (!isPlainRecord(services)) throw new TypeError("ResultTask.provideServices requires a services object");
+			return new ResultTask(async (context) => {
+				const namedServices = new Map(context.namedServices);
+				for (const [identifier, service] of Object.entries(services)) namedServices.set(identifier, service);
+				return task.execute(withNamedServices(context, namedServices));
+			});
+		}
+		if (!isResultTask(args[0])) {
+			const [services] = args;
+			if (!isPlainRecord(services)) throw new TypeError("ResultTask.provideServices requires a services object");
+			return (task) => ResultTask.provideServices(task, services);
+		}
+		throw new TypeError("ResultTask.provideServices requires a services object");
+	}
+	static map(taskOrF, f) {
+		if (typeof taskOrF === "function") return (task) => task.map(taskOrF);
+		if (f === void 0) throw new TypeError("ResultTask.map requires a mapping function");
+		return taskOrF.map(f);
+	}
+	static mapError(taskOrF, f) {
+		if (typeof taskOrF === "function") return (task) => task.mapError(taskOrF);
+		if (f === void 0) throw new TypeError("ResultTask.mapError requires an error mapping function");
+		return taskOrF.mapError(f);
+	}
+	static flatMap(taskOrF, f) {
+		if (typeof taskOrF === "function") return (task) => task.flatMap(taskOrF);
+		if (f === void 0) throw new TypeError("ResultTask.flatMap requires a continuation function");
+		return taskOrF.flatMap(f);
+	}
+	static andThen(taskOrF, f) {
+		if (typeof taskOrF === "function") return (task) => task.flatMap(taskOrF);
+		if (f === void 0) throw new TypeError("ResultTask.andThen requires a continuation function");
+		return taskOrF.flatMap(f);
+	}
+	static catchAll(taskOrF, f) {
+		if (typeof taskOrF === "function") return (task) => task.catchAll(taskOrF);
+		if (f === void 0) throw new TypeError("ResultTask.catchAll requires a recovery function");
+		return taskOrF.catchAll(f);
+	}
+	static tap(taskOrF, f) {
+		if (typeof taskOrF === "function") return (task) => task.tap(taskOrF);
+		if (f === void 0) throw new TypeError("ResultTask.tap requires a side-effect function");
+		return taskOrF.tap(f);
+	}
+	static tapError(taskOrF, f) {
+		if (typeof taskOrF === "function") return (task) => task.tapError(taskOrF);
+		if (f === void 0) throw new TypeError("ResultTask.tapError requires an error side-effect function");
+		return taskOrF.tapError(f);
+	}
+	static as(taskOrValue, value) {
+		if (taskOrValue instanceof ResultTask) {
+			if (value === void 0) throw new TypeError("ResultTask.as requires a replacement value");
+			return taskOrValue.as(value);
+		}
+		return (task) => task.as(taskOrValue);
+	}
+	static match(taskOrHandlers, handlers) {
+		if (taskOrHandlers instanceof ResultTask) {
+			if (handlers === void 0) throw new TypeError("ResultTask.match requires match handlers");
+			return taskOrHandlers.match(handlers);
+		}
+		return (task) => task.match(taskOrHandlers);
+	}
+	/**
+	* Eagerly executes a ResultTask using the standard runtime and returns a ResultAsync.
+	*/
+	static toResultAsync(task) {
+		return createResultAsync(ResultTask.runResult(task));
+	}
+	/**
+	* Captures an existing ResultAsync or creates a lazy task from a ResultAsync factory.
+	*/
+	static fromResultAsync(asyncResultOrFactory) {
+		return new ResultTask(async (context) => {
+			if (context.signal.aborted) return interrupted(context.signal);
+			try {
+				const result = await (typeof asyncResultOrFactory === "function" ? asyncResultOrFactory(context.signal) : asyncResultOrFactory);
+				if (context.signal.aborted) return interrupted(context.signal);
+				return result.isOk() ? success(result.value) : failed(result.error);
+			} catch (error) {
+				return died(error);
+			}
+		});
+	}
+	static async runExitInternal(task, options) {
+		const signal = options?.signal ?? new AbortController().signal;
+		const suppliedServices = options !== void 0 && "services" in options ? options.services : void 0;
+		const namedServices = new Map(Object.entries(suppliedServices ?? {}));
+		const scope = new TaskScope();
+		const context = {
+			namedServices,
+			services: /* @__PURE__ */ new Map(),
+			serviceResolver: void 0,
+			signal,
+			scope
+		};
+		const exit = await task.execute(context);
+		return interruptSuccess(await scope.close(interruptSuccess(exit, signal)), signal);
+	}
+	static async runResultInternal(task, options) {
+		const exit = await ResultTask.runExitInternal(task, options);
+		if (exit._tag === "Success") return ok(exit.value);
+		if (exit.cause._tag === "Fail") return err(exit.cause.error);
+		if (exit.cause._tag === "Die") return throwDefect(exit.cause.defect);
+		if (exit.cause._tag === "Interrupt") throw new AbortError("ResultTask execution interrupted", { cause: exit.cause.reason });
+		throw new ResultTaskCauseError(exit.cause);
+	}
+	static runExit(task, ...args) {
+		return ResultTask.runExitInternal(task, args[0]);
+	}
+	static runResult(task, ...args) {
+		return ResultTask.runResultInternal(task, args[0]);
+	}
+	static async runPromise(task, ...args) {
+		return (await ResultTask.runResultInternal(task, args[0])).unwrapOrThrow();
+	}
+};
+//#endregion
 //#region src/redacted.ts
 const redactedValues = /* @__PURE__ */ new WeakMap();
 const formatRedacted = (label) => label === void 0 ? "<redacted>" : `<redacted:${label}>`;
@@ -1532,6 +2423,12 @@ var ResultAsync = class ResultAsync extends Pipeable {
 		const newPromise = promise.then((value) => ok(value));
 		return new ResultAsync(newPromise);
 	}
+	/**
+	* Eagerly executes a ResultTask using the standard runtime and wraps it in a ResultAsync.
+	*/
+	static fromTask(task) {
+		return ResultTask.toResultAsync(task);
+	}
 	static fromPromise(promise, errorFn) {
 		const newPromise = promise.then((value) => ok(value)).catch((error) => err(errorFn(error)));
 		return new ResultAsync(newPromise);
@@ -2027,282 +2924,4 @@ const runPromise = (result) => result.unwrapOrThrow();
 /** Compatibility alias. Prefer `tryResultAsync` in new code. */
 const tryCatchAsync = tryResultAsync;
 //#endregion
-//#region src/result-task.ts
-const success = (value) => ({
-	_tag: "Success",
-	value
-});
-const failure = (cause) => ({
-	_tag: "Failure",
-	cause
-});
-const failed = (error) => failure({
-	_tag: "Fail",
-	error
-});
-const died = (defect) => failure({
-	_tag: "Die",
-	defect
-});
-const throwDefect = (defect) => {
-	throw defect;
-};
-const isRecord = (value) => typeof value === "object" && value !== null;
-const createMissingServiceError = (identifier) => {
-	const error = /* @__PURE__ */ new Error(`Missing ResultTask service: ${identifier}`);
-	error.name = "MissingServiceError";
-	return error;
-};
-const isResultTaskYield = (value) => isRecord(value) && value["_tag"] === "ResultTask" && value["task"] instanceof ResultTask;
-const isServiceYield = (value) => isRecord(value) && value["_tag"] === "Service" && value["tag"] instanceof ServiceTagValue;
-const lookupService = (tag, context) => {
-	if (context.services.has(tag.key)) return context.services.get(tag.key);
-	return context.namedServices.get(tag.identifier);
-};
-const executeTaskSafely = async (task, executeTask) => {
-	try {
-		return await executeTask(task);
-	} catch (error) {
-		return { error };
-	}
-};
-const closeGenerator = async (iterator, exit, runtime) => {
-	try {
-		let step = iterator.return(void 0);
-		let finalExit = exit;
-		while (step.done === false) if (isResultTaskYield(step.value)) {
-			const outcome = await executeTaskSafely(step.value.task, runtime.executeTask);
-			if ("error" in outcome) {
-				finalExit = died(outcome.error);
-				step = iterator.return(void 0);
-			} else if (outcome._tag === "Failure") {
-				finalExit = outcome;
-				step = iterator.return(void 0);
-			} else step = iterator.next(outcome);
-		} else if (isServiceYield(step.value)) {
-			const service = lookupService(step.value.tag, runtime.context);
-			if (service === void 0) {
-				finalExit = died(createMissingServiceError(step.value.tag.identifier));
-				step = iterator.return(void 0);
-			} else step = iterator.next(service);
-		} else {
-			finalExit = died(/* @__PURE__ */ new TypeError("ResultTask.gen yielded an unsupported value"));
-			step = iterator.return(void 0);
-		}
-		return finalExit;
-	} catch (error) {
-		return died(error);
-	}
-};
-const withServices = (context, services) => ({
-	namedServices: context.namedServices,
-	services,
-	signal: context.signal
-});
-const withNamedServices = (context, namedServices) => ({
-	namedServices,
-	services: context.services,
-	signal: context.signal
-});
-var ServiceTagValue = class {
-	_tag = "ServiceTag";
-	identifier;
-	key;
-	constructor(identifier) {
-		this.identifier = identifier;
-		this.key = Symbol(identifier);
-	}
-	*[Symbol.iterator]() {
-		return yield {
-			_tag: "Service",
-			tag: this
-		};
-	}
-};
-/**
-* A lazy, composable workflow that can succeed with `A` or fail with `E`.
-*
-* Constructing a `ResultTask` never runs its work. Use `runResult`, `runExit`, or `runPromise` at an
-* explicit application boundary to execute it.
-*/
-var ResultTask = class ResultTask extends Pipeable {
-	execute;
-	constructor(execute) {
-		super();
-		this.execute = execute;
-	}
-	/** Creates a task that succeeds with `value` when it is executed. */
-	static succeed(value) {
-		return new ResultTask(() => Promise.resolve(success(value)));
-	}
-	/** Creates a task that fails with `error` when it is executed. */
-	static fail(error) {
-		return new ResultTask(() => Promise.resolve(failed(error)));
-	}
-	/** Lifts an already computed Result into a lazy task. */
-	static fromResult(result) {
-		return new ResultTask(() => Promise.resolve(result.isOk() ? success(result.value) : failed(result.error)));
-	}
-	/** Creates a task for synchronous work. Thrown values are defects, not typed failures. */
-	static sync(evaluate) {
-		return new ResultTask(() => Promise.resolve(success(evaluate())));
-	}
-	/** Creates a task that maps synchronous throws into the typed error channel. */
-	static try(options) {
-		return new ResultTask(() => {
-			try {
-				return Promise.resolve(success(options.try()));
-			} catch (error) {
-				return Promise.resolve(failed(options.catch(error)));
-			}
-		});
-	}
-	/** Creates a lazy task that maps synchronous throws and promise rejections into `E`. */
-	static tryPromise(options) {
-		return new ResultTask(async (context) => {
-			try {
-				return success(await options.try(context.signal));
-			} catch (error) {
-				return failed(options.catch(error));
-			}
-		});
-	}
-	/** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
-	static service(identifier) {
-		return new ServiceTagValue(identifier);
-	}
-	/** Builds a task from a generator and short-circuits on the first failed task. */
-	static gen(body) {
-		return new ResultTask(async (context) => {
-			try {
-				const iterator = body();
-				const executeTask = (task) => task.execute(context);
-				let step = iterator.next();
-				while (step.done === false) if (isResultTaskYield(step.value)) {
-					const outcome = await executeTaskSafely(step.value.task, executeTask);
-					if ("error" in outcome) return await closeGenerator(iterator, died(outcome.error), {
-						context,
-						executeTask
-					});
-					if (outcome._tag === "Failure") return await closeGenerator(iterator, outcome, {
-						context,
-						executeTask
-					});
-					step = iterator.next(outcome);
-				} else if (isServiceYield(step.value)) {
-					const service = lookupService(step.value.tag, context);
-					if (service === void 0) return await closeGenerator(iterator, died(createMissingServiceError(step.value.tag.identifier)), {
-						context,
-						executeTask
-					});
-					step = iterator.next(service);
-				} else return await closeGenerator(iterator, died(/* @__PURE__ */ new TypeError("ResultTask.gen yielded an unsupported value")), {
-					context,
-					executeTask
-				});
-				return success(step.value);
-			} catch (error) {
-				return died(error);
-			}
-		});
-	}
-	/** Maps the success value without executing the task. */
-	map(f) {
-		return new ResultTask(async (context) => {
-			const exit = await this.execute(context);
-			if (exit._tag === "Failure") return exit;
-			return success(f(exit.value));
-		});
-	}
-	/** Chains another task from the success value without executing either task immediately. */
-	flatMap(f) {
-		return new ResultTask(async (context) => {
-			const exit = await this.execute(context);
-			if (exit._tag === "Failure") return exit;
-			return f(exit.value).execute(context);
-		});
-	}
-	/** Alias for `flatMap`, matching the existing Resultar vocabulary. */
-	andThen(f) {
-		return this.flatMap(f);
-	}
-	/** Recovers from a typed failure without recovering from a runtime defect. */
-	catchAll(f) {
-		return new ResultTask(async (context) => {
-			const exit = await this.execute(context);
-			if (exit._tag === "Success") return exit;
-			if (exit.cause._tag === "Die") return exit;
-			return f(exit.cause.error).execute(context);
-		});
-	}
-	/** Enables `yield* task` inside `ResultTask.gen` workflows. */
-	*[Symbol.iterator]() {
-		const exit = yield {
-			_tag: "ResultTask",
-			task: this
-		};
-		if (exit._tag === "Success") return exit.value;
-		return throwDefect(/* @__PURE__ */ new Error("ResultTask generator received a failed task result"));
-	}
-	/** Provides one required service and removes it from the task's requirements. */
-	static provideService(task, tag, service) {
-		return new ResultTask(async (context) => {
-			const services = new Map([...context.services, [tag.key, service]]);
-			return task.execute(withServices(context, services));
-		});
-	}
-	/** Provides all requirements using an object keyed by service identifier. */
-	static provideServices(task, services) {
-		return new ResultTask(async (context) => {
-			const namedServices = new Map(context.namedServices);
-			for (const [identifier, service] of Object.entries(services)) namedServices.set(identifier, service);
-			return task.execute(withNamedServices(context, namedServices));
-		});
-	}
-	/** Maps the success value using the canonical functional form. */
-	static map(task, f) {
-		return task.map(f);
-	}
-	/** Chains a task using the canonical functional form. */
-	static flatMap(task, f) {
-		return task.flatMap(f);
-	}
-	/** Recovers from a typed failure using the canonical functional form. */
-	static catchAll(task, f) {
-		return task.catchAll(f);
-	}
-	static async runExitInternal(task, options) {
-		const signal = options?.signal ?? new AbortController().signal;
-		const suppliedServices = options !== void 0 && "services" in options ? options.services : void 0;
-		const context = {
-			namedServices: new Map(Object.entries(suppliedServices ?? {})),
-			services: /* @__PURE__ */ new Map(),
-			signal
-		};
-		try {
-			return await task.execute(context);
-		} catch (error) {
-			return died(error);
-		}
-	}
-	static async runResultInternal(task, options) {
-		const exit = await ResultTask.runExitInternal(task, options);
-		if (exit._tag === "Success") return ok(exit.value);
-		if (exit.cause._tag === "Fail") return err(exit.cause.error);
-		return throwDefect(exit.cause.defect);
-	}
-	/** Runs a task and preserves success, typed failure, and runtime defects in an `Exit`. */
-	static runExit(task, ...args) {
-		return ResultTask.runExitInternal(task, args[0]);
-	}
-	/** Runs a task and returns a Result, rejecting only when a runtime defect occurs. */
-	static runResult(task, ...args) {
-		return ResultTask.runResultInternal(task, args[0]);
-	}
-	/** Runs a task and returns the success value, rejecting on typed failures or defects. */
-	static async runPromise(task, ...args) {
-		return (await ResultTask.runResultInternal(task, args[0])).unwrapOrThrow();
-	}
-};
-//#endregion
-export { AbortError, DisposableResult, DisposableResultAsync, Result, ResultAsync, ResultTask, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+export { AbortError, DisposableResult, DisposableResultAsync, MissingServiceError, Result, ResultAsync, ResultTask, ResultTaskCauseError, ResultTaskTypeId, ResultTaskYieldTypeId, ServiceTagTypeId, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, isResultTask, isServiceTag, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, serviceTag, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };