better-effect 0.9.31 → 0.11.0

package/dist/effect-CZdZCZLW.mjs

@@ -1,522 +0,0 @@
-import { a as runRuntimeContext, i as makeRuntimeContext, n as currentRuntimeContext, r as getRuntimeContext, t as activeRuntimeContextStorage } from "./context-B4yO5LaH.mjs";
-import { t as isPromiseLike } from "./runtime-CDcCF5cb.mjs";
-import { Result } from "better-result";
-//#region src/scope/errors.ts
-/** Thrown when Scope context is accessed outside an active Scope execution. */
-var ScopeRuntimeNotConfiguredError = class extends Error {
-	constructor() {
-		super("No Scope is available in the current execution context");
-		this.name = "ScopeRuntimeNotConfiguredError";
-	}
-};
-/** Thrown when a resource or finalizer is added after Scope closure begins. */
-var ScopeClosedError = class extends Error {
-	constructor() {
-		super("Cannot add resources or finalizers to a closed Scope");
-		this.name = "ScopeClosedError";
-	}
-};
-/** Aggregates finalizer failures encountered while closing a Scope. */
-var ScopeCloseError = class extends Error {
-	causes;
-	constructor(causes) {
-		super(`Failed to close Scope (${causes.length} finalizer${causes.length === 1 ? "" : "s"} failed)`);
-		this.causes = causes;
-		this.name = "ScopeCloseError";
-	}
-};
-/** Thrown when a value has neither Symbol.dispose nor Symbol.asyncDispose. */
-var ResourceNotDisposableError = class extends Error {
-	constructor() {
-		super("Resource does not implement Symbol.dispose or Symbol.asyncDispose");
-		this.name = "ResourceNotDisposableError";
-	}
-};
-//#endregion
-//#region src/scope/disposable.ts
-const SCOPE_SUCCESS$1 = { status: "success" };
-/** Return a Scope finalizer for a value's async or sync disposal protocol. */
-const getDisposeFinalizer = (resource) => {
-	const candidate = Object(resource);
-	const asyncDispose = candidate[Symbol.asyncDispose];
-	if (asyncDispose instanceof Function) return () => asyncDispose.call(resource);
-	const dispose = candidate[Symbol.dispose];
-	if (dispose instanceof Function) return () => dispose.call(resource);
-};
-/** Dispose a value immediately when it implements a disposal protocol. */
-const disposeResource = (resource) => {
-	return getDisposeFinalizer(resource)?.(SCOPE_SUCCESS$1);
-};
-//#endregion
-//#region src/scope/runtime.ts
-const scopeStorages = /* @__PURE__ */ new WeakMap();
-/** Bridges the current Scope through async execution context. */
-var ScopeRuntime = class {
-	/** Supply a Scope while invoking a callback. */
-	static run(scope, program, storage = scopeStorages.get(scope) ?? activeRuntimeContextStorage()) {
-		scopeStorages.set(scope, storage);
-		const current = getRuntimeContext(storage);
-		const context = makeRuntimeContext(current?.resolver, scope, current?.resolutionPath ?? [], current?.signal);
-		return runRuntimeContext(storage, context, program);
-	}
-	/** Return the Scope active in the current execution context. */
-	static current() {
-		let context;
-		try {
-			context = currentRuntimeContext();
-		} catch {
-			throw new ScopeRuntimeNotConfiguredError();
-		}
-		if (!context.scope) throw new ScopeRuntimeNotConfiguredError();
-		return context.scope;
-	}
-	/** Associate a Runtime-owned Scope with its context storage. */
-	static bind(scope, storage) {
-		scopeStorages.set(scope, storage);
-	}
-};
-//#endregion
-//#region src/scope/internal.ts
-const notifyCleanupFailure = async (observer, diagnostic) => {
-	if (!observer) return;
-	try {
-		await observer(diagnostic);
-	} catch {}
-};
-const runScoped = async (scope, program, options) => {
-	let value;
-	let programFailed = false;
-	let programFailure;
-	try {
-		const run = () => ScopeRuntime.run(scope, program, options.contextStorage);
-		value = await (options.context && options.contextStorage ? runRuntimeContext(options.contextStorage, options.context, run) : run());
-	} catch (cause) {
-		programFailed = true;
-		programFailure = cause;
-	}
-	const outcome = programFailed ? {
-		status: "failure",
-		cause: programFailure
-	} : options.classify(value);
-	let cleanupFailed = false;
-	let cleanupFailure;
-	try {
-		await scope.close(outcome);
-	} catch (cause) {
-		cleanupFailed = true;
-		cleanupFailure = cause;
-	}
-	if (cleanupFailed) {
-		const error = cleanupFailure instanceof ScopeCloseError ? cleanupFailure : new ScopeCloseError([cleanupFailure]);
-		await notifyCleanupFailure(options.onCleanupFailure, {
-			outcome,
-			error
-		});
-		cleanupFailure = error;
-	}
-	if (programFailed) throw programFailure;
-	if (outcome.status === "failure") return value;
-	if (cleanupFailed) throw cleanupFailure;
-	return value;
-};
-//#endregion
-//#region src/scope/scope.ts
-const SCOPE_SUCCESS = Object.freeze({ status: "success" });
-var ScopeImpl = class ScopeImpl {
-	parent;
-	children = /* @__PURE__ */ new Set();
-	finalizers = [];
-	closePromise;
-	closeOutcome;
-	constructor(parent) {
-		this.parent = parent;
-	}
-	fork() {
-		this.assertOpen();
-		const child = new ScopeImpl(this);
-		this.children.add(child);
-		return child;
-	}
-	addFinalizer(finalizer) {
-		this.assertOpen();
-		this.finalizers.push(finalizer);
-	}
-	async acquire(acquire, release) {
-		this.assertOpen();
-		const resource = await acquire();
-		try {
-			this.addFinalizer((outcome) => release(resource, outcome));
-			return resource;
-		} catch (scopeFailure) {
-			try {
-				await release(resource, this.closeOutcome ?? SCOPE_SUCCESS);
-			} catch (releaseFailure) {
-				throw new AggregateError([scopeFailure, releaseFailure], "Scope closed while acquiring a resource and immediate cleanup also failed");
-			}
-			throw scopeFailure;
-		}
-	}
-	async add(resource) {
-		const finalizer = getDisposeFinalizer(resource);
-		if (!finalizer) throw new ResourceNotDisposableError();
-		try {
-			this.addFinalizer(finalizer);
-			return resource;
-		} catch (scopeFailure) {
-			try {
-				await finalizer(this.closeOutcome ?? SCOPE_SUCCESS);
-			} catch (releaseFailure) {
-				throw new AggregateError([scopeFailure, releaseFailure], "Scope closed while adding a disposable resource and cleanup also failed");
-			}
-			throw scopeFailure;
-		}
-	}
-	close(outcome = SCOPE_SUCCESS) {
-		if (this.closePromise) return this.closePromise;
-		this.closeOutcome = outcome;
-		this.closePromise = ScopeRuntime.run(this, () => this.closeInternal(outcome));
-		return this.closePromise;
-	}
-	async closeInternal(outcome) {
-		const failures = [];
-		const children = [...this.children];
-		this.children.clear();
-		for (let index = children.length - 1; index >= 0; index--) {
-			const child = children[index];
-			if (!child) continue;
-			try {
-				await child.close(outcome);
-			} catch (cause) {
-				if (cause instanceof ScopeCloseError) failures.push(...cause.causes);
-				else failures.push(cause);
-			}
-		}
-		for (let index = this.finalizers.length - 1; index >= 0; index--) {
-			const finalizer = this.finalizers[index];
-			if (!finalizer) continue;
-			try {
-				await finalizer(outcome);
-			} catch (cause) {
-				failures.push(cause);
-			}
-		}
-		this.finalizers.length = 0;
-		this.detach();
-		if (failures.length > 0) throw new ScopeCloseError(failures);
-	}
-	detach() {
-		const parent = this.parent;
-		if (!parent) return;
-		parent.children.delete(this);
-		this.parent = void 0;
-	}
-	assertOpen() {
-		if (this.closePromise) throw new ScopeClosedError();
-	}
-};
-const Scope = {
-	/** Create an owned, initially open Scope. */
-	make() {
-		return new ScopeImpl();
-	},
-	/** Return the non-owning Scope available in the current execution context. */
-	current() {
-		return ScopeRuntime.current();
-	},
-	/** Run a callback with an existing Scope supplied as the current context. */
-	provide(scope, program) {
-		return ScopeRuntime.run(scope, program);
-	},
-	/** Resolve the current Scope through `yield* Scope` inside an Effect. */
-	*[Symbol.iterator]() {
-		return ScopeRuntime.current();
-	},
-	/**
-	* Run a program in a newly owned Scope.
-	*
-	* Scope is independent from `better-result`, so returned values—including
-	* `Result.err`—close this Scope with a successful outcome. Result-aware
-	* outcome classification belongs to `Runtime.run`.
-	*
-	* @example
-	* ```ts
-	* await Scope.run(async (scope) => {
-	*   const connection = await scope.acquire(connect, (connection) => connection.close())
-	*   return connection.query()
-	* })
-	* ```
-	*/
-	run(program) {
-		const scope = new ScopeImpl();
-		return runScoped(scope, () => program(scope), { classify: () => SCOPE_SUCCESS });
-	}
-};
-//#endregion
-//#region src/effect/combinators.ts
-const asResult = (value) => {
-	return value;
-};
-const mapResult = (result, fn) => {
-	return Result.map(result, fn);
-};
-const mapErrorResult = (result, fn) => {
-	return Result.mapError(result, fn);
-};
-const andThenResult = (result, next) => {
-	const resultNext = next;
-	return Result.andThen(result, resultNext);
-};
-const andThenAsyncResult = (result, next) => {
-	const resultNext = (value) => {
-		return Promise.resolve(next(value));
-	};
-	return Result.andThenAsync(result, resultNext);
-};
-function map(first, second) {
-	if (first instanceof Function && second === void 0) {
-		const callback = first;
-		return (effect) => {
-			return map(effect, callback);
-		};
-	}
-	const fn = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
-		return mapResult(result, fn);
-	});
-	return mapResult(first, fn);
-}
-function mapError(first, second) {
-	if (first instanceof Function && second === void 0) {
-		const callback = first;
-		return (effect) => {
-			return mapError(effect, callback);
-		};
-	}
-	const fn = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
-		return mapErrorResult(result, fn);
-	});
-	return mapErrorResult(first, fn);
-}
-function andThen(first, second) {
-	if (first instanceof Function && second === void 0) {
-		const callback = first;
-		return (effect) => {
-			return andThen(effect, callback);
-		};
-	}
-	return andThenResult(first, second);
-}
-function andThenAsync(first, second) {
-	if (first instanceof Function && second === void 0) {
-		const callback = first;
-		return (effect) => {
-			return andThenAsync(effect, callback);
-		};
-	}
-	const next = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
-		return andThenAsyncResult(result, next);
-	});
-	return andThenAsyncResult(first, next);
-}
-const tapResult = (result, fn) => Result.tap(result, fn);
-const tapErrorResult = (result, fn) => Result.tapError(result, fn);
-const tapBothResult = (result, handlers) => Result.tapBoth(result, handlers);
-const recoverResult = (result, fn) => Result.tryRecover(result, fn);
-const recoverAsyncResult = (result, fn) => Result.tryRecoverAsync(result, (error) => Promise.resolve(fn(error)));
-const flattenResult = (result) => Result.flatten(result);
-const matchResult = (result, handlers) => Result.match(result, handlers);
-const allResult = (results) => Result.all(results);
-function tap(first, second) {
-	if (first instanceof Function && second === void 0) {
-		const callback = first;
-		return (effect) => tap(effect, callback);
-	}
-	if (second === void 0) throw new TypeError("Effect.tap requires a callback");
-	const fn = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapResult(asResult(result), fn));
-	return tapResult(asResult(first), fn);
-}
-function tapError(first, second) {
-	if (first instanceof Function && second === void 0) {
-		const callback = first;
-		return (effect) => tapError(effect, callback);
-	}
-	if (second === void 0) throw new TypeError("Effect.tapError requires a callback");
-	const fn = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapErrorResult(asResult(result), fn));
-	return tapErrorResult(asResult(first), fn);
-}
-function tapBoth(first, second) {
-	if (second === void 0) return (effect) => tapBoth(effect, first);
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapBothResult(result, second));
-	return tapBothResult(asResult(first), second);
-}
-function recover(first, second) {
-	if (first instanceof Function && second === void 0) {
-		const callback = first;
-		return (effect) => recover(effect, callback);
-	}
-	if (second === void 0) throw new TypeError("Effect.recover requires a callback");
-	const fn = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => recoverResult(asResult(result), fn));
-	return recoverResult(asResult(first), fn);
-}
-function recoverAsync(first, second) {
-	if (first instanceof Function && second === void 0) {
-		const callback = first;
-		return (effect) => recoverAsync(effect, callback);
-	}
-	if (second === void 0) throw new TypeError("Effect.recoverAsync requires a callback");
-	const fn = second;
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => recoverAsyncResult(asResult(result), fn));
-	return recoverAsyncResult(asResult(first), fn);
-}
-/** Remove one nested Result/Effect layer. */
-function flatten(effect) {
-	return flattenResult(asResult(effect));
-}
-function as(first, second) {
-	if (arguments.length < 2) return (effect) => as(effect, first);
-	return mapResult(asResult(first), () => second);
-}
-/** Replace a successful value with void. */
-function asVoid(effect) {
-	return mapResult(asResult(effect), () => void 0);
-}
-function match(first, second) {
-	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => match(asResult(result), second));
-	return matchResult(asResult(first), second);
-}
-/** Collect already-created Effects in input order. */
-function all(results) {
-	return allResult(results);
-}
-/** Combine two already-created Effects in input order. */
-function zip(left, right) {
-	return Result.all([left, right]);
-}
-//#endregion
-//#region src/effect/effect.ts
-const runResultGenerator = Result.gen;
-function gen(body) {
-	return runResultGenerator(body);
-}
-function fn(body) {
-	const program = () => runResultGenerator(body);
-	return program;
-}
-const validateProgramConcurrency = (concurrency) => {
-	if (concurrency !== void 0 && (!Number.isFinite(concurrency) || !Number.isInteger(concurrency) || concurrency <= 0)) throw new RangeError("Program.all concurrency must be a positive integer");
-};
-/** Build a lazy Program collection with optional bounded concurrency. */
-function programAll(programs, options = {}) {
-	validateProgramConcurrency(options.concurrency);
-	const concurrency = options.concurrency;
-	const program = async () => {
-		const results = Array.from({ length: programs.length });
-		const failures = Array.from({ length: programs.length }, () => false);
-		const causes = Array.from({ length: programs.length });
-		let nextIndex = 0;
-		const worker = async () => {
-			while (true) {
-				const index = nextIndex++;
-				if (index >= programs.length) return;
-				try {
-					results[index] = await programs[index]();
-				} catch (cause) {
-					failures[index] = true;
-					causes[index] = cause;
-				}
-			}
-		};
-		const workers = Math.min(concurrency ?? programs.length, programs.length);
-		await Promise.all(Array.from({ length: workers }, () => worker()));
-		const failureIndex = failures.findIndex(Boolean);
-		if (failureIndex >= 0) throw causes[failureIndex];
-		return Result.all(results);
-	};
-	return program;
-}
-/** Value-level namespace for lazy Program combinators. */
-const Program = { all: programAll };
-/**
-* Acquire a resource in the current Scope and register its release callback.
-*
-* Acquisition failures are represented in the Effect Result error channel;
-* release failures remain owned by Scope cleanup. The release callback
-* receives the final outcome chosen by the enclosing execution boundary.
-*
-* @example
-* ```ts
-* const connection = yield* Effect.acquireRelease(
-*   () => pool.connect(),
-*   (connection, outcome) => connection.close(outcome)
-* )
-* ```
-*/
-function acquireRelease(acquire, release) {
-	const scope = Scope.current();
-	return Result.await(Result.tryPromise(() => scope.acquire(acquire, release)));
-}
-/**
-* Register an already-acquired disposable resource in the current Scope.
-*
-* The resource is not acquired by this helper. Registration failures are
-* represented in the Effect Result error channel; disposal failures remain
-* owned by Scope cleanup.
-*
-* @example
-* ```ts
-* const file = yield* Effect.add(await openFile('notes.txt'))
-* ```
-*/
-function add(resource) {
-	const scope = Scope.current();
-	return Result.await(Result.tryPromise(() => scope.add(resource)));
-}
-const Effect = {
-	/** Compose a generator-based Effect program. */
-	gen,
-	/** Build a lazy Program from a generator. */
-	fn,
-	/** Acquire and register a resource in the current Scope. */
-	acquireRelease,
-	/** Register an already-acquired disposable in the current Scope. */
-	add,
-	/** Map a successful Effect result. */
-	map,
-	/** Map an Effect error. */
-	mapError,
-	/** Chain a synchronous Effect result. */
-	andThen,
-	/** Chain an asynchronous Effect result. */
-	andThenAsync,
-	/** Observe successful values without changing the Result. */
-	tap,
-	/** Observe error values without changing the Result. */
-	tapError,
-	/** Observe the active Result branch without changing the Result. */
-	tapBoth,
-	/** Recover an error with another Effect. */
-	recover,
-	/** Recover an error asynchronously with another Effect. */
-	recoverAsync,
-	/** Remove one nested Effect layer. */
-	flatten,
-	/** Replace a successful value. */
-	as,
-	/** Replace a successful value with void. */
-	asVoid,
-	/** Match either Result branch. */
-	match,
-	/** Collect Effects in input order. */
-	all,
-	/** Zip two Effects in input order. */
-	zip
-};
-//#endregion
-export { ScopeRuntime as a, ScopeCloseError as c, runScoped as i, ScopeClosedError as l, Program as n, disposeResource as o, Scope as r, ResourceNotDisposableError as s, Effect as t, ScopeRuntimeNotConfiguredError as u };
-
-//# sourceMappingURL=effect-CZdZCZLW.mjs.map

package/dist/effect-CZdZCZLW.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect-CZdZCZLW.mjs","names":["SCOPE_SUCCESS","next"],"sources":["../src/scope/errors.ts","../src/scope/disposable.ts","../src/scope/runtime.ts","../src/scope/internal.ts","../src/scope/scope.ts","../src/effect/combinators.ts","../src/effect/effect.ts"],"sourcesContent":["/** Thrown when Scope context is accessed outside an active Scope execution. */\nexport class ScopeRuntimeNotConfiguredError extends Error {\n  constructor() {\n    super('No Scope is available in the current execution context')\n\n    this.name = 'ScopeRuntimeNotConfiguredError'\n  }\n}\n\n/** Thrown when a resource or finalizer is added after Scope closure begins. */\nexport class ScopeClosedError extends Error {\n  constructor() {\n    super('Cannot add resources or finalizers to a closed Scope')\n\n    this.name = 'ScopeClosedError'\n  }\n}\n\n/** Aggregates finalizer failures encountered while closing a Scope. */\nexport class ScopeCloseError extends Error {\n  constructor(readonly causes: readonly unknown[]) {\n    super(\n      `Failed to close Scope (${causes.length} finalizer${causes.length === 1 ? '' : 's'} failed)`\n    )\n\n    this.name = 'ScopeCloseError'\n  }\n}\n\n/** Thrown when a value has neither Symbol.dispose nor Symbol.asyncDispose. */\nexport class ResourceNotDisposableError extends Error {\n  constructor() {\n    super('Resource does not implement Symbol.dispose or Symbol.asyncDispose')\n\n    this.name = 'ResourceNotDisposableError'\n  }\n}\n","import type { ScopeFinalizer } from './types'\n\nconst SCOPE_SUCCESS = { status: 'success' } as const\n\ntype Disposer = (...args: never[]) => void | PromiseLike<void>\n\ntype DisposableCandidate = {\n  [Symbol.dispose]?: Disposer\n\n  [Symbol.asyncDispose]?: Disposer\n}\n\n/** Return a Scope finalizer for a value's async or sync disposal protocol. */\nexport const getDisposeFinalizer = <Resource>(resource: Resource): ScopeFinalizer | undefined => {\n  // SAFETY: Object() provides a property-bearing view for protocol lookup; each method is checked for callability before invocation.\n  const candidate = Object(resource) as DisposableCandidate\n  const asyncDispose = candidate[Symbol.asyncDispose]\n\n  if (asyncDispose instanceof Function) {\n    return () => asyncDispose.call(resource)\n  }\n\n  const dispose = candidate[Symbol.dispose]\n\n  if (dispose instanceof Function) {\n    return () => dispose.call(resource)\n  }\n\n  return undefined\n}\n\n/** Dispose a value immediately when it implements a disposal protocol. */\nexport const disposeResource = <Resource>(resource: Resource): void | PromiseLike<void> => {\n  const finalizer = getDisposeFinalizer(resource)\n\n  return finalizer?.(SCOPE_SUCCESS)\n}\n","import { ScopeRuntimeNotConfiguredError } from './errors'\n\nimport type { Scope } from './scope'\n\nimport {\n  activeRuntimeContextStorage,\n  currentRuntimeContext,\n  getRuntimeContext,\n  makeRuntimeContext,\n  runRuntimeContext\n} from '../runtime/context'\n\nimport type { RuntimeContextStorage } from '../runtime/context'\n\nconst scopeStorages = new WeakMap<object, RuntimeContextStorage>()\n\n/** Bridges the current Scope through async execution context. */\nexport class ScopeRuntime {\n  /** Supply a Scope while invoking a callback. */\n  static run<A>(\n    scope: Scope,\n    program: () => A,\n    storage: RuntimeContextStorage = scopeStorages.get(scope) ?? activeRuntimeContextStorage()\n  ): A {\n    scopeStorages.set(scope, storage)\n\n    const current = getRuntimeContext(storage)\n    const context = makeRuntimeContext(\n      current?.resolver,\n      scope,\n      current?.resolutionPath ?? [],\n      current?.signal\n    )\n\n    return runRuntimeContext(storage, context, program)\n  }\n\n  /** Return the Scope active in the current execution context. */\n  static current(): Scope {\n    let context\n\n    try {\n      context = currentRuntimeContext()\n    } catch {\n      throw new ScopeRuntimeNotConfiguredError()\n    }\n\n    if (!context.scope) {\n      throw new ScopeRuntimeNotConfiguredError()\n    }\n\n    return context.scope\n  }\n\n  /** Associate a Runtime-owned Scope with its context storage. */\n  static bind(scope: Scope, storage: RuntimeContextStorage): void {\n    scopeStorages.set(scope, storage)\n  }\n}\n","import { ScopeCloseError } from './errors'\n\nimport { ScopeRuntime } from './runtime'\n\nimport type { CloseableScope } from './scope'\n\nimport {\n  runRuntimeContext,\n  type RuntimeContext,\n  type RuntimeContextStorage\n} from '../runtime/context'\n\nimport type { CleanupFailureDiagnostic, MaybePromise, ScopeOutcome } from './types'\n\nexport type OutcomeClassifier<A> = (value: A) => ScopeOutcome\n\nexport type RunScopedOptions<A> = {\n  readonly classify: OutcomeClassifier<A>\n  readonly onCleanupFailure?: (diagnostic: CleanupFailureDiagnostic) => MaybePromise<void>\n  readonly contextStorage?: RuntimeContextStorage\n  readonly context?: RuntimeContext\n}\n\nconst notifyCleanupFailure = async (\n  observer: ((diagnostic: CleanupFailureDiagnostic) => MaybePromise<void>) | undefined,\n  diagnostic: CleanupFailureDiagnostic\n): Promise<void> => {\n  if (!observer) {\n    return\n  }\n\n  try {\n    await observer(diagnostic)\n  } catch {\n    // Cleanup diagnostics are best effort and never affect the primary result.\n  }\n}\n\nexport const runScoped = async <A>(\n  scope: CloseableScope,\n  program: () => A | PromiseLike<A>,\n  options: RunScopedOptions<Awaited<A>>\n): Promise<Awaited<A>> => {\n  let value!: Awaited<A>\n\n  let programFailed = false\n  let programFailure: unknown\n\n  try {\n    const run = () => ScopeRuntime.run(scope, program, options.contextStorage)\n\n    value = await (options.context && options.contextStorage\n      ? runRuntimeContext(options.contextStorage, options.context, run)\n      : run())\n  } catch (cause) {\n    programFailed = true\n    programFailure = cause\n  }\n\n  const outcome: ScopeOutcome = programFailed\n    ? {\n        status: 'failure',\n        cause: programFailure\n      }\n    : options.classify(value)\n\n  let cleanupFailed = false\n  let cleanupFailure: unknown\n\n  try {\n    await scope.close(outcome)\n  } catch (cause) {\n    cleanupFailed = true\n    cleanupFailure = cause\n  }\n\n  if (cleanupFailed) {\n    const error =\n      cleanupFailure instanceof ScopeCloseError\n        ? cleanupFailure\n        : new ScopeCloseError([cleanupFailure])\n\n    await notifyCleanupFailure(options.onCleanupFailure, {\n      outcome,\n      error\n    })\n\n    cleanupFailure = error\n  }\n\n  if (programFailed) {\n    throw programFailure\n  }\n\n  if (outcome.status === 'failure') {\n    return value\n  }\n\n  if (cleanupFailed) {\n    throw cleanupFailure\n  }\n\n  return value\n}\n","import { ResourceNotDisposableError, ScopeCloseError, ScopeClosedError } from './errors'\n\nimport { getDisposeFinalizer } from './disposable'\n\nimport { runScoped } from './internal'\n\nimport { ScopeRuntime } from './runtime'\n\nimport type { DisposableResource, MaybePromise, ScopeFinalizer, ScopeOutcome } from './types'\n\n/**\n * Non-owning lifecycle context for finalizers and child Scopes.\n *\n * A Scope can register cleanup and create children, but it cannot close\n * itself. Use `Scope.make()` or `Scope.run()` when your code owns the Scope.\n */\nexport interface Scope {\n  /** Register a finalizer that runs when the owning Scope closes. */\n  addFinalizer(finalizer: ScopeFinalizer): void\n\n  /** Acquire a resource and register its outcome-aware release callback. */\n  acquire<R>(\n    acquire: () => MaybePromise<R>,\n    release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>\n  ): Promise<R>\n\n  /** Register an already-acquired disposable resource. */\n  add<R extends DisposableResource>(resource: R): Promise<R>\n\n  /** Create a child Scope owned by this Scope. */\n  fork(): CloseableScope\n}\n\n/** A Scope whose owner is responsible for calling `close()`. */\nexport interface CloseableScope extends Scope {\n  /** Close the Scope and run children and finalizers in child-first LIFO order. */\n  close(outcome?: ScopeOutcome): Promise<void>\n}\n\nconst SCOPE_SUCCESS: ScopeOutcome = Object.freeze({ status: 'success' })\n\nclass ScopeImpl implements CloseableScope {\n  private readonly children = new Set<ScopeImpl>()\n\n  private readonly finalizers: ScopeFinalizer[] = []\n\n  private closePromise: Promise<void> | undefined\n\n  private closeOutcome: ScopeOutcome | undefined\n\n  constructor(private parent?: ScopeImpl) {}\n\n  fork(): CloseableScope {\n    this.assertOpen()\n\n    const child = new ScopeImpl(this)\n\n    this.children.add(child)\n\n    return child\n  }\n\n  addFinalizer(finalizer: ScopeFinalizer): void {\n    this.assertOpen()\n\n    this.finalizers.push(finalizer)\n  }\n\n  async acquire<R>(\n    acquire: () => MaybePromise<R>,\n    release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>\n  ): Promise<R> {\n    this.assertOpen()\n\n    const resource = await acquire()\n\n    try {\n      this.addFinalizer((outcome) => release(resource, outcome))\n\n      return resource\n    } catch (scopeFailure) {\n      try {\n        await release(resource, this.closeOutcome ?? SCOPE_SUCCESS)\n      } catch (releaseFailure) {\n        throw new AggregateError(\n          [scopeFailure, releaseFailure],\n          'Scope closed while acquiring a resource and immediate cleanup also failed'\n        )\n      }\n\n      throw scopeFailure\n    }\n  }\n\n  async add<R extends DisposableResource>(resource: R): Promise<R> {\n    const finalizer = getDisposeFinalizer(resource)\n\n    if (!finalizer) {\n      throw new ResourceNotDisposableError()\n    }\n\n    try {\n      this.addFinalizer(finalizer)\n\n      return resource\n    } catch (scopeFailure) {\n      try {\n        await finalizer(this.closeOutcome ?? SCOPE_SUCCESS)\n      } catch (releaseFailure) {\n        throw new AggregateError(\n          [scopeFailure, releaseFailure],\n          'Scope closed while adding a disposable resource and cleanup also failed'\n        )\n      }\n\n      throw scopeFailure\n    }\n  }\n\n  close(outcome: ScopeOutcome = SCOPE_SUCCESS): Promise<void> {\n    if (this.closePromise) {\n      return this.closePromise\n    }\n\n    this.closeOutcome = outcome\n    this.closePromise = ScopeRuntime.run(this, () => this.closeInternal(outcome))\n\n    return this.closePromise\n  }\n\n  private async closeInternal(outcome: ScopeOutcome): Promise<void> {\n    const failures: unknown[] = []\n\n    const children = [...this.children]\n\n    this.children.clear()\n\n    for (let index = children.length - 1; index >= 0; index--) {\n      const child = children[index]\n\n      if (!child) {\n        continue\n      }\n\n      try {\n        await child.close(outcome)\n      } catch (cause) {\n        if (cause instanceof ScopeCloseError) {\n          failures.push(...cause.causes)\n        } else {\n          failures.push(cause)\n        }\n      }\n    }\n\n    for (let index = this.finalizers.length - 1; index >= 0; index--) {\n      const finalizer = this.finalizers[index]\n\n      if (!finalizer) {\n        continue\n      }\n\n      try {\n        await finalizer(outcome)\n      } catch (cause) {\n        failures.push(cause)\n      }\n    }\n\n    this.finalizers.length = 0\n\n    this.detach()\n\n    if (failures.length > 0) {\n      throw new ScopeCloseError(failures)\n    }\n  }\n\n  private detach(): void {\n    const parent = this.parent\n\n    if (!parent) {\n      return\n    }\n\n    parent.children.delete(this)\n    this.parent = undefined\n  }\n\n  private assertOpen(): void {\n    if (this.closePromise) {\n      throw new ScopeClosedError()\n    }\n  }\n}\n\nexport const Scope = {\n  /** Create an owned, initially open Scope. */\n  make(): CloseableScope {\n    return new ScopeImpl()\n  },\n\n  /** Return the non-owning Scope available in the current execution context. */\n  current(): Scope {\n    return ScopeRuntime.current()\n  },\n\n  /** Run a callback with an existing Scope supplied as the current context. */\n  provide<A>(scope: Scope, program: () => A): A {\n    return ScopeRuntime.run(scope, program)\n  },\n\n  /** Resolve the current Scope through `yield* Scope` inside an Effect. */\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<never, Scope, unknown> {\n    return ScopeRuntime.current()\n  },\n\n  /**\n   * Run a program in a newly owned Scope.\n   *\n   * Scope is independent from `better-result`, so returned values—including\n   * `Result.err`—close this Scope with a successful outcome. Result-aware\n   * outcome classification belongs to `Runtime.run`.\n   *\n   * @example\n   * ```ts\n   * await Scope.run(async (scope) => {\n   *   const connection = await scope.acquire(connect, (connection) => connection.close())\n   *   return connection.query()\n   * })\n   * ```\n   */\n  run<A>(program: (scope: Scope) => A | PromiseLike<A>): Promise<Awaited<A>> {\n    const scope = new ScopeImpl()\n\n    return runScoped(scope, () => program(scope), {\n      classify: () => SCOPE_SUCCESS\n    })\n  }\n} as const\n\n/** Type-level aliases for Scope ownership, outcomes, and cleanup contracts. */\nexport declare namespace Scope {\n  /** A Scope whose owner is responsible for calling `close()`. */\n  export type Closeable = CloseableScope\n\n  /** The outcome supplied to Scope finalizers and resource releases. */\n  export type Outcome = ScopeOutcome\n\n  /** A cleanup callback registered with a Scope. */\n  export type Finalizer = ScopeFinalizer\n\n  /** A value implementing a JavaScript disposal protocol. */\n  export type Disposable = DisposableResource\n}\n","import { Result } from 'better-result'\n\nimport type { Result as ResultType } from 'better-result'\n\nimport type { AnyService } from '../service'\nimport { isPromiseLike } from '../utils/runtime'\nimport type { Effect, EffectError, EffectRequirements, EffectSuccess } from './types'\n\ntype EffectInput<A, E> = ResultType<A, E> | PromiseLike<ResultType<A, E>>\n\ntype AnyEffectInput = EffectInput<any, any>\ntype AnyEffectValue = ResultType<any, any>\ntype AnyAsyncEffectInput = PromiseLike<ResultType<any, any>>\ntype CombinatorCallback = (value: any) => any\ntype CombinatorInput = AnyEffectInput | CombinatorCallback\n\ntype PreserveAsync<Input, Output> = Input extends PromiseLike<unknown> ? Promise<Output> : Output\n\ntype MappedResult<Input, B> = Effect<B, EffectError<Input>, EffectRequirements<Input>>\n\ntype ErrorMappedResult<Input, E2> = Effect<EffectSuccess<Input>, E2, EffectRequirements<Input>>\n\ntype ChainedResult<First, Next> = Effect<\n  EffectSuccess<Next>,\n  EffectError<First> | EffectError<Next>,\n  EffectRequirements<First> | EffectRequirements<Next>\n>\n\ntype ChainedOutput<First, Next> = ChainedResult<First, Next>\n\ntype AsyncChainedOutput<First, Next> = Promise<ChainedResult<First, Next>>\n\ntype MapOperation<A, B> = {\n  <Input>(effect: Input & EffectInput<A, any>): PreserveAsync<Input, MappedResult<Input, B>>\n}\n\ntype MapErrorOperation<E1, E2> = {\n  <Input>(effect: Input & EffectInput<any, E1>): PreserveAsync<Input, ErrorMappedResult<Input, E2>>\n}\n\ntype AndThenOperation<Next> = {\n  <Input>(effect: Input & AnyEffectValue): ChainedOutput<Input, Next>\n}\n\ntype AndThenAsyncOperation<A, Next> = {\n  <Input>(effect: Input & EffectInput<A, any>): AsyncChainedOutput<Input, Next>\n}\n\ntype TappedResult<Input> = Effect<\n  EffectSuccess<Input>,\n  EffectError<Input>,\n  EffectRequirements<Input>\n>\n\ntype RecoveredResult<Input, Next> = Effect<\n  EffectSuccess<Input> | EffectSuccess<Next>,\n  EffectError<Next>,\n  EffectRequirements<Input> | EffectRequirements<Next>\n>\n\ntype FlattenedResult<Input> = Effect<\n  EffectSuccess<EffectSuccess<Input>>,\n  EffectError<Input> | EffectError<EffectSuccess<Input>>,\n  EffectRequirements<Input> | EffectRequirements<EffectSuccess<Input>>\n>\n\ntype AsResult<Input, Value> = Effect<Value, EffectError<Input>, EffectRequirements<Input>>\n\ntype MatchedResult<Input, OkResult, ErrResult> = Effect<\n  EffectSuccess<OkResult> | EffectSuccess<ErrResult>,\n  EffectError<OkResult> | EffectError<ErrResult>,\n  EffectRequirements<Input> | EffectRequirements<OkResult> | EffectRequirements<ErrResult>\n>\n\ntype AllResult<Results extends readonly AnyEffectValue[]> = Effect<\n  { -readonly [Index in keyof Results]: EffectSuccess<Results[Index]> },\n  EffectError<Results[number]>,\n  EffectRequirements<Results[number]>\n>\n\ntype ZipResult<Left, Right> = Effect<\n  [EffectSuccess<Left>, EffectSuccess<Right>],\n  EffectError<Left> | EffectError<Right>,\n  EffectRequirements<Left> | EffectRequirements<Right>\n>\n\ntype TapOperation = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    fn: (value: EffectSuccess<Input>) => void\n  ): PreserveAsync<Input, TappedResult<Input>>\n}\n\ntype TapErrorOperation = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    fn: (error: EffectError<Input>) => void\n  ): PreserveAsync<Input, TappedResult<Input>>\n}\n\ntype TapBothOperation = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    handlers: {\n      ok: (value: EffectSuccess<Input>) => void\n      err: (error: EffectError<Input>) => void\n    }\n  ): PreserveAsync<Input, TappedResult<Input>>\n}\n\ntype RecoverOperation<Next> = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    fn: (error: EffectError<Input>) => Next\n  ): PreserveAsync<Input, RecoveredResult<Input, Next>>\n}\n\ntype RecoverAsyncOperation<Next> = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    fn: (error: EffectError<Input>) => Next\n  ): Promise<RecoveredResult<Input, Next>>\n}\n\nconst asResult = <Value>(value: Value): ResultType<any, any> => {\n  // SAFETY: Effect is the declaration-only Result facade, so every runtime value is a Result.\n  return value as ResultType<any, any>\n}\n\nconst mapResult = <A, B, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  fn: (value: A) => B\n): Effect<B, E, Requirements> => {\n  // SAFETY: Result.map changes only the success channel; the declaration-only Effect marker is restored by this adapter.\n  return Result.map(result, fn) as Effect<B, E, Requirements>\n}\n\nconst mapErrorResult = <A, E1, E2, Requirements extends AnyService>(\n  result: ResultType<A, E1>,\n  fn: (error: E1) => E2\n): Effect<A, E2, Requirements> => {\n  // SAFETY: Result.mapError changes only the error channel; the declaration-only Effect marker is restored by this adapter.\n  return Result.mapError(result, fn) as Effect<A, E2, Requirements>\n}\n\nconst andThenResult = <\n  A,\n  B,\n  E1,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<A, E1>,\n  next: (value: A) => ResultType<B, E2>\n): Effect<B, E1 | E2, Requirements1 | Requirements2> => {\n  // SAFETY: The public callback returns an Effect, whose only runtime contract is the underlying Result.\n  const resultNext = next as (value: A) => ResultType<B, E2>\n\n  // SAFETY: Result.andThen unions Result errors; the declaration-only Effect marker is restored by this adapter.\n  return Result.andThen(result, resultNext) as Effect<B, E1 | E2, Requirements1 | Requirements2>\n}\n\nconst andThenAsyncResult = <\n  A,\n  B,\n  E1,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<A, E1>,\n  next: (value: A) => PromiseLike<ResultType<B, E2>>\n): Promise<Effect<B, E1 | E2, Requirements1 | Requirements2>> => {\n  // SAFETY: The public callback returns an Effect, whose only runtime contract is the underlying Result.\n  const resultNext = (value: A) => {\n    // SAFETY: Promise resolution preserves the callback's Result value; only declaration-only Effect metadata is erased.\n    return Promise.resolve(next(value)) as Promise<ResultType<B, E2>>\n  }\n\n  // SAFETY: Result.andThenAsync unions Result errors; the declaration-only Effect marker is restored by this adapter.\n  return Result.andThenAsync(result, resultNext) as Promise<\n    Effect<B, E1 | E2, Requirements1 | Requirements2>\n  >\n}\n\n/**\n * Map the successful value of a Result or Effect result.\n *\n * Supports both data-first and data-last forms and preserves asynchronous\n * results and declaration-only Service requirements.\n *\n * @example\n * ```ts\n * const doubled = Effect.map(Result.ok(2), (value) => value * 2)\n * const toLabel = Effect.map((value: number) => `#${value}`)\n * ```\n */\nexport function map<A, B>(fn: (value: A) => B): MapOperation<A, B>\nexport function map<Input, B>(\n  effect: Input & AnyEffectInput,\n  fn: (value: EffectSuccess<Input>) => B\n): PreserveAsync<Input, MappedResult<Input, B>>\nexport function map(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    // SAFETY: The curried overload accepts a unary mapping callback in this branch.\n    const callback = first as CombinatorCallback\n\n    return (effect: AnyEffectInput) => {\n      // SAFETY: The overload implementation has already established the callback and Effect input positions.\n      return map(effect as never, callback as never)\n    }\n  }\n\n  // SAFETY: The data-first overload requires the second argument to be a unary mapping callback.\n  const fn = second as CombinatorCallback\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => {\n      // SAFETY: Result is the runtime representation shared by Effect and better-result.\n      return mapResult(result as ResultType<any, any>, fn)\n    })\n  }\n\n  // SAFETY: The data-first overload supplies a Result-compatible Effect value.\n  return mapResult(first as ResultType<any, any>, fn)\n}\n\n/**\n * Map the error value of a Result or Effect result while preserving its\n * successful value, asynchronous shape, and declaration-only Service requirements.\n *\n * @example\n * ```ts\n * const labelled = Effect.mapError(Result.err('missing'), (error) => ({ error }))\n * ```\n */\nexport function mapError<E1, E2>(fn: (error: E1) => E2): MapErrorOperation<E1, E2>\nexport function mapError<Input, E2>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => E2\n): PreserveAsync<Input, ErrorMappedResult<Input, E2>>\nexport function mapError(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    // SAFETY: The curried overload accepts a unary error-mapping callback in this branch.\n    const callback = first as CombinatorCallback\n\n    return (effect: AnyEffectInput) => {\n      // SAFETY: The overload implementation has already established the callback and Effect input positions.\n      return mapError(effect as never, callback as never)\n    }\n  }\n\n  // SAFETY: The data-first overload requires the second argument to be a unary error-mapping callback.\n  const fn = second as CombinatorCallback\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => {\n      // SAFETY: Result is the runtime representation shared by Effect and better-result.\n      return mapErrorResult(result as ResultType<any, any>, fn)\n    })\n  }\n\n  // SAFETY: The data-first overload supplies a Result-compatible Effect value.\n  return mapErrorResult(first as ResultType<any, any>, fn)\n}\n\n/**\n * Chain a synchronous Result-producing operation after a successful result.\n *\n * The next operation is skipped when the input is an error. Both error types\n * and both sets of Service requirements are preserved in the output.\n *\n * @example\n * ```ts\n * const user = Effect.andThen(Result.ok('u1'), (id) => repository.find(id))\n * ```\n */\nexport function andThen<A, Next extends AnyEffectValue>(\n  next: (value: A) => Next\n): AndThenOperation<Next>\nexport function andThen<Input, Next extends AnyEffectValue>(\n  effect: Input & AnyEffectValue,\n  next: (value: EffectSuccess<Input>) => Next\n): ChainedOutput<Input, Next>\nexport function andThen(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    // SAFETY: The curried overload accepts a unary continuation in this branch.\n    const callback = first as CombinatorCallback\n\n    return (effect: AnyEffectInput) => {\n      // SAFETY: The overload implementation has already established the callback and Effect input positions.\n      return andThen(effect as never, callback as never)\n    }\n  }\n\n  // SAFETY: The data-first overload requires the second argument to return a Result.\n  const next = second as CombinatorCallback\n\n  // SAFETY: The data-first overload supplies a Result-compatible Effect value.\n  return andThenResult(first as ResultType<any, any>, next)\n}\n\n/**\n * Chain an asynchronous Result-producing operation after a successful result.\n *\n * The returned value is always a Promise and retains both operations' error\n * and Service-requirement metadata.\n *\n * @example\n * ```ts\n * const user = Effect.andThenAsync(loadUser(), (user) => fetchProfile(user.id))\n * ```\n */\nexport function andThenAsync<A, Next extends AnyAsyncEffectInput>(\n  next: (value: A) => Next\n): AndThenAsyncOperation<A, Next>\nexport function andThenAsync<Input, Next extends AnyAsyncEffectInput>(\n  effect: Input & AnyEffectInput,\n  next: (value: EffectSuccess<Input>) => Next\n): AsyncChainedOutput<Input, Next>\nexport function andThenAsync(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    // SAFETY: The curried overload accepts a unary asynchronous continuation in this branch.\n    const callback = first as CombinatorCallback\n\n    return (effect: AnyEffectInput) => {\n      // SAFETY: The overload implementation has already established the callback and Effect input positions.\n      return andThenAsync(effect as never, callback as never)\n    }\n  }\n\n  // SAFETY: The data-first overload requires the second argument to return a PromiseLike Effect.\n  const next = second as CombinatorCallback\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => {\n      // SAFETY: Result is the runtime representation shared by Effect and better-result.\n      return andThenAsyncResult(result as ResultType<any, any>, next)\n    })\n  }\n\n  // SAFETY: The data-first overload supplies a Result-compatible Effect value.\n  return andThenAsyncResult(first as ResultType<any, any>, next)\n}\n\nconst tapResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  fn: (value: A) => void\n): Effect<A, E, Requirements> =>\n  // SAFETY: Result.tap preserves the Result value; the declaration-only Effect marker is restored here.\n  Result.tap(result, fn) as Effect<A, E, Requirements>\n\nconst tapErrorResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  fn: (error: E) => void\n): Effect<A, E, Requirements> =>\n  // SAFETY: Result.tapError preserves the Result value; the declaration-only Effect marker is restored here.\n  Result.tapError(result, fn) as Effect<A, E, Requirements>\n\nconst tapBothResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  handlers: { ok: (value: A) => void; err: (error: E) => void }\n): Effect<A, E, Requirements> =>\n  // SAFETY: Result.tapBoth preserves the Result value; the declaration-only Effect marker is restored here.\n  Result.tapBoth(result, handlers) as Effect<A, E, Requirements>\n\nconst recoverResult = <\n  A,\n  E,\n  B,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<A, E>,\n  fn: (error: E) => ResultType<B, E2>\n): Effect<A | B, E2, Requirements1 | Requirements2> =>\n  // SAFETY: Result.tryRecover owns recovery and short-circuiting; only Effect metadata is restored here.\n  Result.tryRecover(result, fn) as Effect<A | B, E2, Requirements1 | Requirements2>\n\nconst recoverAsyncResult = <\n  A,\n  E,\n  B,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<A, E>,\n  fn: (error: E) => PromiseLike<ResultType<B, E2>>\n): Promise<Effect<A | B, E2, Requirements1 | Requirements2>> =>\n  // SAFETY: Result.tryRecoverAsync owns asynchronous recovery; only Effect metadata is restored here.\n  Result.tryRecoverAsync(result, (error) => Promise.resolve(fn(error))) as Promise<\n    Effect<A | B, E2, Requirements1 | Requirements2>\n  >\n\nconst flattenResult = <\n  A,\n  E1,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<ResultType<A, E2>, E1>\n): Effect<A, E1 | E2, Requirements1 | Requirements2> =>\n  // SAFETY: Result.flatten removes one Result layer; the outer and inner Effect markers are restored here.\n  Result.flatten(result) as Effect<A, E1 | E2, Requirements1 | Requirements2>\n\nconst matchResult = <A, E, OkResult, ErrResult>(\n  result: ResultType<A, E>,\n  handlers: { ok: (value: A) => OkResult; err: (error: E) => ErrResult }\n): OkResult | ErrResult =>\n  // SAFETY: Result.match invokes only the selected branch; handler Results remain ordinary runtime values.\n  Result.match(result, handlers as never) as OkResult | ErrResult\n\nconst allResult = <const Results extends readonly AnyEffectValue[]>(\n  results: Results\n): AllResult<Results> =>\n  // SAFETY: Result.all preserves tuple order and short-circuiting; the declaration-only channels are restored here.\n  Result.all(results as readonly ResultType<any, any>[]) as AllResult<Results>\n\n/** Observe a successful value without changing the Result. */\nexport function tap(fn: (value: any) => void): TapOperation\nexport function tap<Input>(\n  effect: Input & AnyEffectInput,\n  fn: (value: EffectSuccess<Input>) => void\n): PreserveAsync<Input, TappedResult<Input>>\nexport function tap(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => tap(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.tap requires a callback')\n  }\n\n  const fn = second\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapResult(asResult(result), fn))\n  }\n\n  return tapResult(asResult(first), fn)\n}\n\n/** Observe an error value without changing the Result. */\nexport function tapError(fn: (error: any) => void): TapErrorOperation\nexport function tapError<Input>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => void\n): PreserveAsync<Input, TappedResult<Input>>\nexport function tapError(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => tapError(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.tapError requires a callback')\n  }\n\n  const fn = second\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapErrorResult(asResult(result), fn))\n  }\n\n  return tapErrorResult(asResult(first), fn)\n}\n\n/** Observe whichever Result branch is active without changing the Result. */\nexport function tapBoth(handlers: {\n  ok: (value: any) => void\n  err: (error: any) => void\n}): TapBothOperation\nexport function tapBoth<Input>(\n  effect: Input & AnyEffectInput,\n  handlers: {\n    ok: (value: EffectSuccess<Input>) => void\n    err: (error: EffectError<Input>) => void\n  }\n): PreserveAsync<Input, TappedResult<Input>>\nexport function tapBoth(first: any, second?: any): any {\n  if (second === undefined) {\n    return (effect: AnyEffectInput) => tapBoth(effect, first)\n  }\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapBothResult(result, second))\n  }\n\n  return tapBothResult(asResult(first), second)\n}\n\n/** Recover an Err with a synchronous Result-producing callback. */\nexport function recover<Next extends AnyEffectValue>(\n  fn: (error: any) => Next\n): RecoverOperation<Next>\nexport function recover<Input, Next extends AnyEffectValue>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => Next\n): PreserveAsync<Input, RecoveredResult<Input, Next>>\nexport function recover(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => recover(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.recover requires a callback')\n  }\n\n  const fn = second\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => recoverResult(asResult(result), fn))\n  }\n\n  return recoverResult(asResult(first), fn)\n}\n\n/** Recover an Err with an asynchronous Result-producing callback. */\nexport function recoverAsync<Next extends AnyAsyncEffectInput>(\n  fn: (error: any) => Next\n): RecoverAsyncOperation<Next>\nexport function recoverAsync<Input, Next extends AnyAsyncEffectInput>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => Next\n): Promise<RecoveredResult<Input, Next>>\nexport function recoverAsync(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => recoverAsync(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.recoverAsync requires a callback')\n  }\n\n  const fn = second\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => recoverAsyncResult(asResult(result), fn))\n  }\n\n  return recoverAsyncResult(asResult(first), fn)\n}\n\n/** Remove one nested Result/Effect layer. */\nexport function flatten<Input>(effect: Input & AnyEffectValue): FlattenedResult<Input> {\n  // SAFETY: flattenResult restores the nested Effect channels after Result.flatten removes one runtime layer.\n  return flattenResult(asResult(effect)) as FlattenedResult<Input>\n}\n\n/** Replace a successful value while preserving errors and requirements. */\nexport function as<Value>(\n  value: Value\n): <Input>(effect: Input & AnyEffectValue) => AsResult<Input, Value>\nexport function as<Input, Value>(\n  effect: Input & AnyEffectValue,\n  value: Value\n): AsResult<Input, Value>\nexport function as(first: any, second?: any): any {\n  if (arguments.length < 2) {\n    return (effect: AnyEffectValue) => as(effect, first)\n  }\n\n  return mapResult(asResult(first), () => second)\n}\n\n/** Replace a successful value with void. */\nexport function asVoid<Input>(effect: Input & AnyEffectValue): AsResult<Input, void> {\n  return mapResult(asResult(effect), () => undefined)\n}\n\n/** Match an Effect and return branch Effects with their channels unioned. */\nexport function match<Input, OkResult extends AnyEffectValue, ErrResult extends AnyEffectValue>(\n  effect: Input & AnyEffectValue,\n  handlers: {\n    ok: (value: EffectSuccess<Input>) => OkResult\n    err: (error: EffectError<Input>) => ErrResult\n  }\n): PreserveAsync<Input, MatchedResult<Input, OkResult, ErrResult>>\nexport function match<Input, OkValue, ErrValue>(\n  effect: Input & AnyEffectValue,\n  handlers: {\n    ok: (value: EffectSuccess<Input>) => OkValue\n    err: (error: EffectError<Input>) => ErrValue\n  }\n): PreserveAsync<Input, OkValue | ErrValue>\nexport function match(first: AnyEffectInput, second?: any): any {\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => match(asResult(result), second))\n  }\n\n  return matchResult(asResult(first), second)\n}\n\n/** Collect already-created Effects in input order. */\nexport function all<const Results extends readonly AnyEffectValue[]>(\n  results: Results\n): AllResult<Results> {\n  return allResult(results)\n}\n\n/** Combine two already-created Effects in input order. */\nexport function zip<Left, Right>(\n  left: Left & AnyEffectValue,\n  right: Right & AnyEffectValue\n): ZipResult<Left, Right> {\n  // SAFETY: Result.all returns the ordered pair; ZipResult restores only the declaration-only Effect channels.\n  return Result.all([left, right]) as ZipResult<Left, Right>\n}\n","import { Result } from 'better-result'\n\nimport type { Err, Result as ResultType, UnhandledException } from 'better-result'\n\nimport { Scope } from '../scope'\n\nimport type { DisposableResource, MaybePromise, ScopeOutcome } from '../scope'\nimport type { AnyService } from '../service'\n\nimport type {\n  AnyEffect,\n  Effect as EffectType,\n  EffectError,\n  EffectFromGenerator,\n  EffectRequirements,\n  EffectSuccess,\n  EffectYield,\n  Program as ProgramType,\n  ProgramFromGenerator\n} from './types'\n\nimport {\n  all,\n  andThen,\n  andThenAsync,\n  as,\n  asVoid,\n  flatten,\n  map,\n  mapError,\n  match,\n  recover,\n  recoverAsync,\n  tap,\n  tapBoth,\n  tapError,\n  zip\n} from './combinators'\n\nexport type Effect<A, E, R extends AnyService = never> = EffectType<A, E, R>\n\ntype LazyProgram<A, E, R extends AnyService = never> = ProgramType<A, E, R>\n\n/** A nominal lazy computation that produces an Effect when invoked. */\nexport type Program<A, E, R extends AnyService = never> = LazyProgram<A, E, R>\n\ntype AnyResult = ResultType<any, any>\n\ntype AnyProgram = ProgramType<any, any, AnyService>\n\ntype ProgramAllSuccess<Programs extends readonly AnyProgram[]> = {\n  -readonly [Index in keyof Programs]: EffectSuccess<Programs[Index]>\n}\n\ntype ProgramAllError<Programs extends readonly AnyProgram[]> = EffectError<Programs[number]>\n\ntype ProgramAllRequirements<Programs extends readonly AnyProgram[]> = EffectRequirements<\n  Programs[number]\n>\n\ntype ProgramAllResult<Programs extends readonly AnyProgram[]> = ProgramType<\n  ProgramAllSuccess<Programs>,\n  ProgramAllError<Programs>,\n  ProgramAllRequirements<Programs>\n>\n\nexport type ProgramAllOptions = {\n  readonly concurrency?: number\n}\n\ntype EffectGenerator =\n  | (() => Generator<EffectYield, AnyResult, unknown>)\n  | (() => AsyncGenerator<EffectYield, AnyResult, unknown>)\n\ntype RuntimeResultGenerator = (body: EffectGenerator) => AnyResult | Promise<AnyResult>\n\n// SAFETY: Service iterators yield no runtime markers, so Result.gen receives only the Err values that exist at runtime.\nconst runResultGenerator = Result.gen as RuntimeResultGenerator\n\n/**\n * Compose `better-result` operations while preserving Service requirements in\n * a declaration-only type channel.\n *\n * A generator may yield Service tokens and Result operations. It must return a\n * `Result` as its final value; Service yields are resolved by the active\n * Runtime and do not add runtime values to the Result stream.\n * Use `fn` when generator execution should wait for a Runtime boundary.\n *\n * @example\n * ```ts\n * const loadUser = Effect.gen(async function* () {\n *   const database = yield* Database\n *   const user = yield* Result.await(database.findUser('u1'))\n *\n *   return Result.ok(user)\n * })\n * ```\n */\nexport function gen<Yield extends EffectYield, Returned extends AnyResult>(\n  body: () => Generator<Yield, Returned, unknown>\n): EffectFromGenerator<Yield, Returned>\n\nexport function gen<Yield extends EffectYield, Returned extends AnyResult>(\n  body: () => AsyncGenerator<Yield, Returned, unknown>\n): Promise<EffectFromGenerator<Yield, Returned>>\n\nexport function gen(body: EffectGenerator): AnyResult | Promise<AnyResult> {\n  return runResultGenerator(body)\n}\n\n/** Build a lazy Program without running its generator. */\nexport function fn<Yield extends EffectYield, Returned extends AnyResult>(\n  body: () => Generator<Yield, Returned, unknown>\n): ProgramFromGenerator<Yield, Returned>\n\nexport function fn<Yield extends EffectYield, Returned extends AnyResult>(\n  body: () => AsyncGenerator<Yield, Returned, unknown>\n): ProgramFromGenerator<Yield, Returned>\n\nexport function fn(body: EffectGenerator): Program<any, any, AnyService> {\n  const program = () => runResultGenerator(body)\n\n  // SAFETY: The generator overloads derive the Program channels; this cast only adds the declaration-only nominal marker.\n  return program as Program<any, any, AnyService>\n}\n\nconst validateProgramConcurrency = (concurrency: number | undefined): void => {\n  if (\n    concurrency !== undefined &&\n    (!Number.isFinite(concurrency) || !Number.isInteger(concurrency) || concurrency <= 0)\n  ) {\n    throw new RangeError('Program.all concurrency must be a positive integer')\n  }\n}\n\n/** Build a lazy Program collection with optional bounded concurrency. */\nexport function programAll<const Programs extends readonly AnyProgram[]>(\n  programs: Programs,\n  options: ProgramAllOptions = {}\n): ProgramAllResult<Programs> {\n  validateProgramConcurrency(options.concurrency)\n\n  const concurrency = options.concurrency\n  const program = async (): Promise<AnyResult> => {\n    const results: Array<AnyResult | undefined> = Array.from({ length: programs.length })\n    const failures: boolean[] = Array.from({ length: programs.length }, () => false)\n    const causes: unknown[] = Array.from({ length: programs.length })\n    let nextIndex = 0\n\n    const worker = async (): Promise<void> => {\n      while (true) {\n        const index = nextIndex++\n\n        if (index >= programs.length) {\n          return\n        }\n\n        try {\n          results[index] = await programs[index]!()\n        } catch (cause) {\n          failures[index] = true\n          causes[index] = cause\n        }\n      }\n    }\n\n    const workers = Math.min(concurrency ?? programs.length, programs.length)\n    await Promise.all(Array.from({ length: workers }, () => worker()))\n\n    const failureIndex = failures.findIndex(Boolean)\n\n    if (failureIndex >= 0) {\n      throw causes[failureIndex]\n    }\n\n    // SAFETY: Program's callable contract produces Result values; the array is erased only at this collection boundary.\n    return Result.all(results as AnyResult[])\n  }\n\n  // SAFETY: Program channels are declaration-only and are restored from the input tuple here.\n  return program as ProgramAllResult<Programs>\n}\n\n/** Value-level namespace for lazy Program combinators. */\nexport const Program = {\n  all: programAll\n} as const\n\n/**\n * Acquire a resource in the current Scope and register its release callback.\n *\n * Acquisition failures are represented in the Effect Result error channel;\n * release failures remain owned by Scope cleanup. The release callback\n * receives the final outcome chosen by the enclosing execution boundary.\n *\n * @example\n * ```ts\n * const connection = yield* Effect.acquireRelease(\n *   () => pool.connect(),\n *   (connection, outcome) => connection.close(outcome)\n * )\n * ```\n */\nexport function acquireRelease<R>(\n  acquire: () => MaybePromise<R>,\n  release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>\n): AsyncGenerator<Err<never, UnhandledException>, R, unknown> {\n  const scope = Scope.current()\n\n  return Result.await(Result.tryPromise(() => scope.acquire(acquire, release)))\n}\n\n/**\n * Register an already-acquired disposable resource in the current Scope.\n *\n * The resource is not acquired by this helper. Registration failures are\n * represented in the Effect Result error channel; disposal failures remain\n * owned by Scope cleanup.\n *\n * @example\n * ```ts\n * const file = yield* Effect.add(await openFile('notes.txt'))\n * ```\n */\nexport function add<R extends DisposableResource>(\n  resource: R\n): AsyncGenerator<Err<never, UnhandledException>, R, unknown> {\n  const scope = Scope.current()\n\n  return Result.await(Result.tryPromise(() => scope.add(resource)))\n}\n\n/**\n * Effect namespace containing generator, resource, and Result combinators.\n *\n * Prefer these helpers when a program needs typed Service requirements or\n * Scope-aware acquisition and cleanup.\n */\ntype EffectNamespace = {\n  readonly gen: typeof gen\n  readonly fn: typeof fn\n  readonly acquireRelease: typeof acquireRelease\n  readonly add: typeof add\n  readonly map: typeof map\n  readonly mapError: typeof mapError\n  readonly andThen: typeof andThen\n  readonly andThenAsync: typeof andThenAsync\n  readonly tap: typeof tap\n  readonly tapError: typeof tapError\n  readonly tapBoth: typeof tapBoth\n  readonly recover: typeof recover\n  readonly recoverAsync: typeof recoverAsync\n  readonly flatten: typeof flatten\n  readonly as: typeof as\n  readonly asVoid: typeof asVoid\n  readonly match: typeof match\n  readonly all: typeof all\n  readonly zip: typeof zip\n}\n\nexport const Effect: EffectNamespace = {\n  /** Compose a generator-based Effect program. */\n  gen,\n  /** Build a lazy Program from a generator. */\n  fn,\n  /** Acquire and register a resource in the current Scope. */\n  acquireRelease,\n  /** Register an already-acquired disposable in the current Scope. */\n  add,\n  /** Map a successful Effect result. */\n  map,\n  /** Map an Effect error. */\n  mapError,\n  /** Chain a synchronous Effect result. */\n  andThen,\n  /** Chain an asynchronous Effect result. */\n  andThenAsync,\n  /** Observe successful values without changing the Result. */\n  tap,\n  /** Observe error values without changing the Result. */\n  tapError,\n  /** Observe the active Result branch without changing the Result. */\n  tapBoth,\n  /** Recover an error with another Effect. */\n  recover,\n  /** Recover an error asynchronously with another Effect. */\n  recoverAsync,\n  /** Remove one nested Effect layer. */\n  flatten,\n  /** Replace a successful value. */\n  as,\n  /** Replace a successful value with void. */\n  asVoid,\n  /** Match either Result branch. */\n  match,\n  /** Collect Effects in input order. */\n  all,\n  /** Zip two Effects in input order. */\n  zip\n} as const\n\n/** Type-level aliases for inspecting Effect result channels and requirements. */\nexport declare namespace Effect {\n  /** A nominal lazy computation that produces an Effect when invoked. */\n  export type Program<A, E, R extends AnyService = never> = LazyProgram<A, E, R>\n\n  /** Extract the success channel from an Effect result or Promise. */\n  export type Success<T> = EffectSuccess<T>\n\n  /** Extract the error channel from an Effect result or Promise. */\n  export type Error<T> = EffectError<T>\n\n  /** Extract the Service requirements from an Effect result or Promise. */\n  export type Requirements<T> = EffectRequirements<T>\n\n  /** An Effect with erased success, error, and requirements. */\n  export type Any = AnyEffect\n}\n"],"mappings":"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"}

package/dist/errors-BXKc7juX.d.mts

@@ -1,8 +0,0 @@
-//#region src/runtime/errors.d.ts
-/** Thrown when no RuntimeContext is active in the selected storage. */
-declare class RuntimeContextNotConfiguredError extends Error {
-  constructor();
-}
-//#endregion
-export { RuntimeContextNotConfiguredError as t };
-//# sourceMappingURL=errors-BXKc7juX.d.mts.map

package/dist/errors-BXKc7juX.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-BXKc7juX.d.mts","names":[],"sources":["../src/runtime/errors.ts"],"mappings":";;cACa,yCAAyC;EAAA"}