better-effect 0.10.0 → 0.12.0

package/dist/node.mjs

@@ -0,0 +1,233 @@
+import { h as RuntimeContextNotConfiguredError } from "./context-BUEf1qjL.mjs";
+import { n as nodeRuntimeContextStorage, t as NodeRuntimeContextStorage } from "./node-context-lggRF4bR.mjs";
+import { n as linkAbortSignals } from "./signal-D2UTcaaG.mjs";
+import { t as Runtime } from "./runtime-CBMrX8Wl.mjs";
+import { Err, Ok } from "better-result";
+//#region src/runtime/node-runtime.ts
+const DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
+const isLayerBackend = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	return "register" in value && "resolve" in value && "disposeAll" in value && typeof value.register === "function" && typeof value.resolve === "function" && typeof value.disposeAll === "function";
+};
+const isAbortSignal = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	return typeof value.aborted === "boolean" && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
+};
+const isOptionsObject = (value) => {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+const validateExitCode = (code) => {
+	if (!Number.isSafeInteger(code) || code < 0) throw new RangeError("NodeRuntime exit codes must be non-negative safe integers");
+	return code;
+};
+const ensureFailureExitCode = (code) => code === 0 ? 1 : code;
+const validateSignals = (signals) => {
+	if (signals !== void 0 && !Array.isArray(signals)) throw new TypeError("NodeRuntime signals must be an array of supported signal names");
+	for (const signal of signals ?? DEFAULT_SIGNALS) if (typeof signal !== "string" || signal !== "SIGINT" && signal !== "SIGTERM") throw new RangeError(`NodeRuntime signal "${String(signal)}" is not supported`);
+};
+const validateRuntimeOptions = (options) => {
+	if (options.signal !== void 0 && !isAbortSignal(options.signal)) throw new TypeError("NodeRuntime signal must be an AbortSignal");
+};
+const validateCallbacks = (options) => {
+	if (options.onSuccess !== void 0 && typeof options.onSuccess !== "function") throw new TypeError("NodeRuntime onSuccess must be a function");
+	if (options.onFailure !== void 0 && typeof options.onFailure !== "function") throw new TypeError("NodeRuntime onFailure must be a function");
+	if (options.onDefect !== void 0 && typeof options.onDefect !== "function") throw new TypeError("NodeRuntime onDefect must be a function");
+	if (options.onCleanupFailure !== void 0 && typeof options.onCleanupFailure !== "function") throw new TypeError("NodeRuntime onCleanupFailure must be a function");
+};
+const validateOptions = (options) => {
+	validateSignals(options.signals);
+	validateRuntimeOptions(options);
+	validateCallbacks(options);
+	if (options.observers !== void 0 && !Array.isArray(options.observers)) throw new TypeError("NodeRuntime observers must be an array");
+};
+const normalizeSignals = (signals) => {
+	const unique = /* @__PURE__ */ new Set();
+	for (const signal of signals ?? DEFAULT_SIGNALS) unique.add(signal);
+	return [...unique];
+};
+const removeSignalListeners = (listeners) => {
+	const failures = [];
+	for (const { signal, listener } of listeners) try {
+		process.removeListener(signal, listener);
+	} catch (cause) {
+		failures.push(cause);
+	}
+	listeners.length = 0;
+	return failures;
+};
+const combineFailures = (failures) => {
+	if (failures.length === 0) return [];
+	if (failures.length === 1) return [failures[0]];
+	return [new AggregateError(failures, "NodeRuntime cleanup failed")];
+};
+const setExitCode = (code) => {
+	process.exitCode = validateExitCode(code);
+};
+const reportDefect = (cause, handler) => {
+	let exitCode = 1;
+	if (handler) try {
+		const requestedExitCode = handler(cause);
+		if (requestedExitCode !== void 0) exitCode = validateExitCode(requestedExitCode);
+	} catch {
+		exitCode = 1;
+	}
+	setExitCode(ensureFailureExitCode(exitCode));
+};
+const installSignalListeners = (signals, listeners, onSignal) => {
+	for (const signal of signals) {
+		const listener = () => onSignal(signal);
+		process.on(signal, listener);
+		listeners.push({
+			signal,
+			listener
+		});
+	}
+};
+/** Node.js/Bun process lifecycle helpers. */
+var NodeRuntime = class {
+	static async runMain(layer, backendOrProgramOrOptions, programOrOptions, legacyOptions) {
+		let backend;
+		let program;
+		let options;
+		if (typeof backendOrProgramOrOptions === "function") {
+			program = backendOrProgramOrOptions;
+			options = programOrOptions;
+		} else if (isLayerBackend(backendOrProgramOrOptions)) {
+			backend = backendOrProgramOrOptions;
+			program = programOrOptions;
+			options = legacyOptions;
+		} else {
+			options = backendOrProgramOrOptions;
+			program = programOrOptions;
+		}
+		if (options !== void 0 && !isOptionsObject(options)) throw new TypeError("NodeRuntime options must be a non-array object");
+		const normalizedOptions = options ?? {};
+		validateOptions(normalizedOptions);
+		const shutdownController = new AbortController();
+		const configuredSignals = normalizeSignals(normalizedOptions.signals);
+		const { onSuccess, onFailure, onDefect, signal: callerSignal, ...runtimeOptions } = normalizedOptions;
+		const signalLink = linkAbortSignals(callerSignal, shutdownController.signal);
+		const listeners = [];
+		const cleanupFailures = [];
+		let runtime;
+		let disposalPromise;
+		let disposalObserved = false;
+		let firstSignal;
+		let setupFailed = false;
+		let setupFailure;
+		let programFailed = false;
+		let programFailure;
+		let executionCleanupFailed = false;
+		let executionOutcome;
+		let programSettled = false;
+		let programValue;
+		const requestDispose = () => {
+			if (disposalPromise) return disposalPromise;
+			try {
+				disposalPromise = runtime.dispose();
+			} catch (cause) {
+				disposalPromise = Promise.reject(cause);
+			}
+			return disposalPromise;
+		};
+		const observeDisposal = async () => {
+			if (!runtime || disposalObserved) return;
+			disposalObserved = true;
+			try {
+				await requestDispose();
+			} catch (cause) {
+				cleanupFailures.push(cause);
+			}
+		};
+		const onSignal = (signal) => {
+			if (firstSignal !== void 0) return;
+			firstSignal = signal;
+			try {
+				shutdownController.abort(signal);
+			} finally {
+				requestDispose().catch(() => {});
+			}
+		};
+		try {
+			const executionObserver = { onExecutionEnd: ({ outcome }) => {
+				executionOutcome = outcome;
+			} };
+			const runtimeOptionsWithSignal = {
+				...runtimeOptions,
+				observers: [executionObserver, ...runtimeOptions.observers ?? []],
+				signal: signalLink.signal
+			};
+			runtime = backend ? await Runtime.make(layer, backend, runtimeOptionsWithSignal) : await Runtime.make(layer, runtimeOptionsWithSignal);
+			installSignalListeners(configuredSignals, listeners, onSignal);
+			try {
+				programValue = await runtime.run(program);
+				programSettled = true;
+			} catch (cause) {
+				if (executionOutcome?.status === "success") executionCleanupFailed = true;
+				else programFailed = true;
+				programFailure = cause;
+			}
+			await observeDisposal();
+		} catch (cause) {
+			setupFailed = true;
+			setupFailure = cause;
+		} finally {
+			await observeDisposal();
+			cleanupFailures.push(...removeSignalListeners(listeners));
+			try {
+				signalLink.dispose();
+			} catch (cause) {
+				cleanupFailures.push(cause);
+			}
+		}
+		const cleanupFailureValues = combineFailures(cleanupFailures);
+		const hasCleanupFailure = cleanupFailureValues.length > 0;
+		const cleanupFailure = cleanupFailureValues[0];
+		if (setupFailed) {
+			reportDefect(setupFailure, onDefect);
+			throw setupFailure;
+		}
+		if (programFailed) {
+			reportDefect(programFailure, onDefect);
+			throw programFailure;
+		}
+		if (executionCleanupFailed) {
+			setExitCode(1);
+			throw programFailure;
+		}
+		if (!programSettled) {
+			const failure = /* @__PURE__ */ new Error("NodeRuntime main program did not settle");
+			reportDefect(failure, onDefect);
+			throw failure;
+		}
+		if (programValue instanceof Err) {
+			let exitCode = 1;
+			try {
+				if (onFailure) exitCode = validateExitCode(onFailure(programValue.error));
+			} catch (cause) {
+				reportDefect(cause, onDefect);
+				throw cause;
+			}
+			setExitCode(exitCode);
+			return programValue;
+		}
+		let exitCode = 0;
+		try {
+			if (onSuccess) {
+				const successValue = programValue instanceof Ok ? programValue.value : programValue;
+				exitCode = validateExitCode(onSuccess(successValue));
+			}
+		} catch (cause) {
+			reportDefect(cause, onDefect);
+			throw cause;
+		}
+		if (hasCleanupFailure) exitCode = ensureFailureExitCode(exitCode);
+		setExitCode(exitCode);
+		if (hasCleanupFailure) throw cleanupFailure;
+		return programValue;
+	}
+};
+//#endregion
+export { NodeRuntime, NodeRuntimeContextStorage, RuntimeContextNotConfiguredError, nodeRuntimeContextStorage };
+
+//# sourceMappingURL=node.mjs.map

package/dist/node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.mjs","names":[],"sources":["../src/runtime/node-runtime.ts"],"sourcesContent":["import { Err, Ok } from 'better-result'\n\nimport type { Result as ResultType } from 'better-result'\n\nimport type { EffectError, EffectSuccess } from '../effect'\nimport type { LayerBackend } from '../layer/backend'\nimport type {\n  CompleteExecution,\n  CompleteInput,\n  LayerInput,\n  ProvidedEnvironment\n} from '../layer/inference'\nimport { Runtime } from './runtime'\nimport { linkAbortSignals } from './signal'\n\nimport type { RuntimeOptions } from './outcome'\nimport type { RuntimeExecutionEndEvent, RuntimeObserver } from './observer'\nimport type { ScopeOutcome } from '../scope'\n\n/** Process signals supported by the Node.js/Bun process boundary. */\nexport type NodeRuntimeSignal = 'SIGINT' | 'SIGTERM'\n\n/** Translate a successful main result to a process exit code. */\nexport type NodeRuntimeSuccessHandler<Success> = (value: Success) => number\n\n/** Translate a typed main failure to a process exit code. */\nexport type NodeRuntimeFailureHandler<Failure> = (error: Failure) => number\n\n/** Observe a thrown or rejected main defect while it remains a rejected Promise. */\nexport type NodeRuntimeDefectHandler = (cause: unknown) => number | void\n\n/** Options for the Node.js/Bun process boundary. */\nexport type NodeRuntimeOptions<Success = unknown, Failure = unknown> = RuntimeOptions & {\n  /** Process signals that request cooperative shutdown. Defaults to SIGINT and SIGTERM. */\n  readonly signals?: readonly NodeRuntimeSignal[]\n  /** Map a nominal Result.ok value, or a plain successful value, to an exit code. */\n  readonly onSuccess?: NodeRuntimeSuccessHandler<Success>\n  /** Map a nominal Result.err error to an exit code. */\n  readonly onFailure?: NodeRuntimeFailureHandler<Failure>\n  /** Observe a defect. Defects are rethrown after the handler runs. */\n  readonly onDefect?: NodeRuntimeDefectHandler\n}\n\ntype NonResultMainSuccess<Value> = Value extends ResultType<any, any> ? never : Value\n\ntype PlainMainSuccess<Value> = NonResultMainSuccess<Awaited<Value>>\n\ntype MainSuccess<Value> = EffectSuccess<Value> | PlainMainSuccess<Value>\n\ntype MainFailure<Value> = EffectError<Value>\n\ntype MainOptions<Value> = NodeRuntimeOptions<MainSuccess<Value>, MainFailure<Value>>\n\nconst DEFAULT_SIGNALS = ['SIGINT', 'SIGTERM'] as const satisfies readonly NodeRuntimeSignal[]\n\ntype InstalledSignalListener = {\n  readonly signal: NodeRuntimeSignal\n  readonly listener: () => void\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- backend overload dispatch validates an opaque runtime value.\nconst isLayerBackend = (value: unknown): value is LayerBackend => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- runtime overload dispatch must inspect the backend shape.\n  if (value === null || typeof value !== 'object') {\n    return false\n  }\n\n  return (\n    'register' in value &&\n    'resolve' in value &&\n    'disposeAll' in value &&\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- the backend contract is validated at this runtime boundary.\n    typeof value.register === 'function' &&\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- the backend contract is validated at this runtime boundary.\n    typeof value.resolve === 'function' &&\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- the backend contract is validated at this runtime boundary.\n    typeof value.disposeAll === 'function'\n  )\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- AbortSignal validation receives an opaque public option.\nconst isAbortSignal = (value: unknown): value is AbortSignal => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the structural host signal contract.\n  if (value === null || typeof value !== 'object') {\n    return false\n  }\n\n  return (\n    // SAFETY: the preceding guard establishes that the opaque value is an object; these are the required AbortSignal members.\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the structural host signal contract.\n    typeof (value as AbortSignal).aborted === 'boolean' &&\n    // SAFETY: the preceding guard establishes that the opaque value is an object; these are the required AbortSignal members.\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the structural host signal contract.\n    typeof (value as AbortSignal).addEventListener === 'function' &&\n    // SAFETY: the preceding guard establishes that the opaque value is an object; these are the required AbortSignal members.\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the structural host signal contract.\n    typeof (value as AbortSignal).removeEventListener === 'function'\n  )\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- options are validated at the public boundary.\nconst isOptionsObject = (value: unknown): value is object => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the public options boundary before installing listeners.\n  return value !== null && typeof value === 'object' && !Array.isArray(value)\n}\n\nconst validateExitCode = (code: number): number => {\n  if (!Number.isSafeInteger(code) || code < 0) {\n    throw new RangeError('NodeRuntime exit codes must be non-negative safe integers')\n  }\n\n  return code\n}\n\nconst ensureFailureExitCode = (code: number): number => (code === 0 ? 1 : code)\n\nconst validateSignals = <Success, Failure>(\n  signals: NodeRuntimeOptions<Success, Failure>['signals']\n): void => {\n  if (signals !== undefined && !Array.isArray(signals)) {\n    throw new TypeError('NodeRuntime signals must be an array of supported signal names')\n  }\n\n  for (const signal of signals ?? DEFAULT_SIGNALS) {\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before process.on receives them.\n    if (typeof signal !== 'string' || (signal !== 'SIGINT' && signal !== 'SIGTERM')) {\n      throw new RangeError(`NodeRuntime signal \"${String(signal)}\" is not supported`)\n    }\n  }\n}\n\nconst validateRuntimeOptions = <Success, Failure>(\n  options: NodeRuntimeOptions<Success, Failure>\n): void => {\n  if (options.signal !== undefined && !isAbortSignal(options.signal)) {\n    throw new TypeError('NodeRuntime signal must be an AbortSignal')\n  }\n}\n\nconst validateCallbacks = <Success, Failure>(\n  options: NodeRuntimeOptions<Success, Failure>\n): void => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before invoking the callback.\n  if (options.onSuccess !== undefined && typeof options.onSuccess !== 'function') {\n    throw new TypeError('NodeRuntime onSuccess must be a function')\n  }\n\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before invoking the callback.\n  if (options.onFailure !== undefined && typeof options.onFailure !== 'function') {\n    throw new TypeError('NodeRuntime onFailure must be a function')\n  }\n\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before invoking the callback.\n  if (options.onDefect !== undefined && typeof options.onDefect !== 'function') {\n    throw new TypeError('NodeRuntime onDefect must be a function')\n  }\n\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before Runtime invokes the observer.\n  if (options.onCleanupFailure !== undefined && typeof options.onCleanupFailure !== 'function') {\n    throw new TypeError('NodeRuntime onCleanupFailure must be a function')\n  }\n}\n\nconst validateOptions = <Success, Failure>(options: NodeRuntimeOptions<Success, Failure>): void => {\n  validateSignals(options.signals)\n  validateRuntimeOptions(options)\n  validateCallbacks(options)\n\n  if (options.observers !== undefined && !Array.isArray(options.observers)) {\n    throw new TypeError('NodeRuntime observers must be an array')\n  }\n}\n\nconst normalizeSignals = (\n  signals: readonly NodeRuntimeSignal[] | undefined\n): readonly NodeRuntimeSignal[] => {\n  const unique = new Set<NodeRuntimeSignal>()\n\n  for (const signal of signals ?? DEFAULT_SIGNALS) {\n    unique.add(signal)\n  }\n\n  return [...unique]\n}\n\nconst removeSignalListeners = (listeners: InstalledSignalListener[]): readonly unknown[] => {\n  const failures: unknown[] = []\n\n  for (const { signal, listener } of listeners) {\n    try {\n      process.removeListener(signal, listener)\n    } catch (cause) {\n      failures.push(cause)\n    }\n  }\n\n  listeners.length = 0\n\n  return failures\n}\n\nconst combineFailures = (failures: readonly unknown[]): readonly unknown[] => {\n  if (failures.length === 0) {\n    return []\n  }\n\n  if (failures.length === 1) {\n    return [failures[0]]\n  }\n\n  return [new AggregateError(failures, 'NodeRuntime cleanup failed')]\n}\n\nconst setExitCode = (code: number): void => {\n  process.exitCode = validateExitCode(code)\n}\n\nconst reportDefect = (cause: unknown, handler: NodeRuntimeDefectHandler | undefined): void => {\n  let exitCode = 1\n\n  if (handler) {\n    try {\n      const requestedExitCode = handler(cause)\n\n      if (requestedExitCode !== undefined) {\n        exitCode = validateExitCode(requestedExitCode)\n      }\n    } catch {\n      exitCode = 1\n    }\n  }\n\n  setExitCode(ensureFailureExitCode(exitCode))\n}\n\nconst installSignalListeners = (\n  signals: readonly NodeRuntimeSignal[],\n  listeners: InstalledSignalListener[],\n  onSignal: (signal: NodeRuntimeSignal) => void\n): void => {\n  for (const signal of signals) {\n    const listener = (): void => onSignal(signal)\n    process.on(signal, listener)\n    listeners.push({ signal, listener })\n  }\n}\n\n/** Node.js/Bun process lifecycle helpers. */\nexport class NodeRuntime {\n  /**\n   * Run a typed main Program, translate its final result to `process.exitCode`,\n   * and dispose the Runtime when the program or a configured process signal settles.\n   */\n  static runMain<A, L extends LayerInput>(\n    layer: L & CompleteInput<L>,\n    backend: LayerBackend,\n    program: CompleteExecution<ProvidedEnvironment<L>, A>,\n    options?: MainOptions<A>\n  ): Promise<Awaited<A>>\n\n  static runMain<A, L extends LayerInput>(\n    layer: L & CompleteInput<L>,\n    program: CompleteExecution<ProvidedEnvironment<L>, A>,\n    options?: MainOptions<A>\n  ): Promise<Awaited<A>>\n\n  static runMain<A, L extends LayerInput>(\n    layer: L & CompleteInput<L>,\n    options: MainOptions<A>,\n    program: CompleteExecution<ProvidedEnvironment<L>, A>\n  ): Promise<Awaited<A>>\n\n  static async runMain<A, L extends LayerInput>(\n    layer: L & CompleteInput<L>,\n    backendOrProgramOrOptions:\n      | LayerBackend\n      | MainOptions<A>\n      | CompleteExecution<ProvidedEnvironment<L>, A>,\n    programOrOptions?: CompleteExecution<ProvidedEnvironment<L>, A> | MainOptions<A>,\n    legacyOptions?: MainOptions<A>\n  ): Promise<Awaited<A>> {\n    let backend: LayerBackend | undefined\n    let program!: CompleteExecution<ProvidedEnvironment<L>, A>\n    let options: MainOptions<A> | undefined\n\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- overload dispatch distinguishes the Program callback from configuration.\n    if (typeof backendOrProgramOrOptions === 'function') {\n      program = backendOrProgramOrOptions\n      // SAFETY: this branch is selected by the Program overload, so the optional value is its options object.\n      options = programOrOptions as MainOptions<A> | undefined\n    } else if (isLayerBackend(backendOrProgramOrOptions)) {\n      backend = backendOrProgramOrOptions\n      // SAFETY: the backend overload requires a Program in the third argument.\n      program = programOrOptions as CompleteExecution<ProvidedEnvironment<L>, A>\n      options = legacyOptions\n    } else {\n      options = backendOrProgramOrOptions\n      // SAFETY: the options overload requires a Program in the third argument.\n      program = programOrOptions as CompleteExecution<ProvidedEnvironment<L>, A>\n    }\n\n    if (options !== undefined && !isOptionsObject(options)) {\n      throw new TypeError('NodeRuntime options must be a non-array object')\n    }\n\n    // SAFETY: validation above establishes an object; the empty object is the omitted-options case.\n    const normalizedOptions = (options ?? {}) as MainOptions<A>\n    validateOptions(normalizedOptions)\n\n    const shutdownController = new AbortController()\n    const configuredSignals = normalizeSignals(normalizedOptions.signals)\n    const {\n      onSuccess,\n      onFailure,\n      onDefect,\n      signal: callerSignal,\n      ...runtimeOptions\n    } = normalizedOptions\n    const signalLink = linkAbortSignals(callerSignal, shutdownController.signal)\n    const listeners: InstalledSignalListener[] = []\n    const cleanupFailures: unknown[] = []\n\n    let runtime: Runtime<ProvidedEnvironment<L>> | undefined\n    let disposalPromise: Promise<void> | undefined\n    let disposalObserved = false\n    let firstSignal: NodeRuntimeSignal | undefined\n    let setupFailed = false\n    let setupFailure: unknown\n    let programFailed = false\n    let programFailure: unknown\n    let executionCleanupFailed = false\n    let executionOutcome: ScopeOutcome | undefined\n    let programSettled = false\n    let programValue!: Awaited<A>\n\n    const requestDispose = (): Promise<void> => {\n      if (disposalPromise) {\n        return disposalPromise\n      }\n\n      try {\n        disposalPromise = runtime!.dispose()\n      } catch (cause) {\n        disposalPromise = Promise.reject(cause)\n      }\n\n      return disposalPromise\n    }\n\n    const observeDisposal = async (): Promise<void> => {\n      if (!runtime || disposalObserved) {\n        return\n      }\n\n      disposalObserved = true\n\n      try {\n        await requestDispose()\n      } catch (cause) {\n        cleanupFailures.push(cause)\n      }\n    }\n\n    const onSignal = (signal: NodeRuntimeSignal): void => {\n      if (firstSignal !== undefined) {\n        return\n      }\n\n      firstSignal = signal\n\n      try {\n        shutdownController.abort(signal)\n      } finally {\n        void requestDispose().catch(() => {})\n      }\n    }\n\n    try {\n      const executionObserver: RuntimeObserver = {\n        onExecutionEnd: ({ outcome }: RuntimeExecutionEndEvent): void => {\n          executionOutcome = outcome\n        }\n      }\n      const runtimeOptionsWithSignal: RuntimeOptions = {\n        ...runtimeOptions,\n        observers: [executionObserver, ...(runtimeOptions.observers ?? [])],\n        signal: signalLink.signal\n      }\n\n      runtime = backend\n        ? await Runtime.make(layer, backend, runtimeOptionsWithSignal)\n        : await Runtime.make(layer, runtimeOptionsWithSignal)\n\n      installSignalListeners(configuredSignals, listeners, onSignal)\n\n      try {\n        programValue = await runtime.run(program)\n        programSettled = true\n      } catch (cause) {\n        if (executionOutcome?.status === 'success') {\n          executionCleanupFailed = true\n        } else {\n          programFailed = true\n        }\n        programFailure = cause\n      }\n\n      await observeDisposal()\n    } catch (cause) {\n      setupFailed = true\n      setupFailure = cause\n    } finally {\n      await observeDisposal()\n      cleanupFailures.push(...removeSignalListeners(listeners))\n\n      try {\n        signalLink.dispose()\n      } catch (cause) {\n        cleanupFailures.push(cause)\n      }\n    }\n\n    const cleanupFailureValues = combineFailures(cleanupFailures)\n    const hasCleanupFailure = cleanupFailureValues.length > 0\n    const cleanupFailure = cleanupFailureValues[0]\n\n    if (setupFailed) {\n      reportDefect(setupFailure, onDefect)\n      throw setupFailure\n    }\n\n    if (programFailed) {\n      reportDefect(programFailure, onDefect)\n      throw programFailure\n    }\n\n    if (executionCleanupFailed) {\n      setExitCode(1)\n      throw programFailure\n    }\n\n    if (!programSettled) {\n      const failure = new Error('NodeRuntime main program did not settle')\n      reportDefect(failure, onDefect)\n      throw failure\n    }\n\n    if (programValue instanceof Err) {\n      let exitCode = 1\n\n      try {\n        if (onFailure) {\n          // SAFETY: Err carries the failure channel represented by MainFailure<A>.\n          exitCode = validateExitCode(onFailure(programValue.error as MainFailure<A>))\n        }\n      } catch (cause) {\n        reportDefect(cause, onDefect)\n        throw cause\n      }\n\n      setExitCode(exitCode)\n      return programValue\n    }\n\n    let exitCode = 0\n\n    try {\n      if (onSuccess) {\n        const successValue = programValue instanceof Ok ? programValue.value : programValue\n        // SAFETY: Ok is unwrapped above; plain successful values retain the MainSuccess<A> channel.\n        exitCode = validateExitCode(onSuccess(successValue as MainSuccess<A>))\n      }\n    } catch (cause) {\n      reportDefect(cause, onDefect)\n      throw cause\n    }\n\n    if (hasCleanupFailure) {\n      exitCode = ensureFailureExitCode(exitCode)\n    }\n\n    setExitCode(exitCode)\n\n    if (hasCleanupFailure) {\n      throw cleanupFailure\n    }\n\n    return programValue\n  }\n}\n\n/** Type-level aliases for the Node.js/Bun process boundary. */\nexport declare namespace NodeRuntime {\n  /** Options for `NodeRuntime.runMain`. */\n  export type Options<Success = unknown, Failure = unknown> = NodeRuntimeOptions<Success, Failure>\n\n  /** A process signal accepted by `NodeRuntime.runMain`. */\n  export type Signal = NodeRuntimeSignal\n}\n"],"mappings":"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"}

package/dist/{index-C7KX5rAP.d.mts → outcome-CB43bnFW.d.mts}

@@ -1,11 +1,13 @@
-import { F as ServiceContract, H as ServiceToken, L as ServiceIdentityTypeId, M as AnyService, N as AnyServiceToken, P as ServiceClass, T as EffectRequirements, U as ServiceTokenOf, V as ServiceTagOf, c as RuntimeContextStorage, d as CleanupFailureDiagnostic, h as ScopeOutcome, j as ServiceRequirement, p as MaybePromise, u as Scope, z as ServiceRequirements } from "./index-CULgSzUw.mjs";
-import { a as LayerRegistration, i as LayerGeneratorRequirements, n as LayerBackend, o as MaybePromise$1, r as LayerGenerator } from "./map-layer-backend-rNwfH0Bz.mjs";
+import { F as ServiceContract, H as ServiceToken, L as ServiceIdentityTypeId, M as AnyService, N as AnyServiceToken, O as InferYieldRequirements, P as ServiceClass, T as EffectRequirements, U as ServiceTokenOf, V as ServiceTagOf, a as ServiceResolver, c as RuntimeContextStorage, d as CleanupFailureDiagnostic, f as DisposableResource, h as ScopeOutcome, j as ServiceRequirement, m as ScopeFinalizer, p as MaybePromise$1, u as Scope, z as ServiceRequirements } from "./index-heuaRmXR.mjs";
 //#region src/internal/variance.d.ts
 /** Type-level marker for a value produced by `A`. */
 type Covariant<A> = () => A;
 /** Type-level marker that both consumes and produces `A`. */
 type Invariant<A> = (value: A) => A;
 //#endregion
+//#region src/utils/types.d.ts
+type MaybePromise<T> = T | PromiseLike<T>;
+//#endregion
 //#region src/internal/missing-dependencies.d.ts
 type MissingDependencies<Missing extends AnyService> = {
   /** Names the Services that must be supplied before execution. */
@@ -33,7 +35,7 @@ interface LayerProvenance<out Entries extends ProviderEntry<AnyService, AnyServi
 //#region src/layer/inference.d.ts
 type IsAny<T> = 0 extends 1 & T ? true : false;
 type IsNever<T> = [T] extends [never] ? true : false;
-type IsUnion<T, Candidate = T> = T extends unknown ? [Candidate] extends [T] ? false : true : never;
+type IsUnion$1<T, Candidate = T> = T extends unknown ? [Candidate] extends [T] ? false : true : never;
 /** Any Layer shape accepted by type-level inference helpers. */
 type LayerInput = Layer<any, any> | Layer<never, any>;
 /** Extract the public Service environment channels from a Layer. */
@@ -65,21 +67,22 @@ type PreciseEntries<L extends LayerInput> = L extends LayerProvenance<infer Entr
  * explicitly annotated Layer.
  */
 type ErasedEntries<L extends LayerInput> = L extends LayerProvenance<any, infer Erased> ? Erased : [ProvidedEnvironment<L> | RequiredEnvironment<L>] extends [never] ? never : ErasedProvenance<ProvidedEnvironment<L>, RequiredEnvironment<L>>;
+type PossibleProvidedEnvironment<L extends LayerInput> = EntryProvided<PreciseEntries<L>> | ErasedProvided<ErasedEntries<L>>;
 type LayerMetadata<Entries extends AnyProviderEntry, Erased extends AnyErasedProvenance> = [Entries | Erased] extends [never] ? unknown : LayerProvenance<Entries, Erased>;
 /** Opaque internal result type used by Layer constructors and combinators. */
-type LayerResult<Entries extends AnyProviderEntry, Erased extends AnyErasedProvenance = never> = Layer<EntryProvided<Entries> | ErasedProvided<Erased>, LayerExternalRequirements<EntryRequired<Entries> | ErasedRequired<Erased>, EntryProvided<Entries> | ErasedProvided<Erased>>> & LayerMetadata<Entries, Erased>;
+type LayerResult<Entries extends AnyProviderEntry, Erased extends AnyErasedProvenance = never, VisibleProvided extends AnyService = EntryProvided<Entries> | ErasedProvided<Erased>> = Layer<VisibleProvided, LayerExternalRequirements<EntryRequired<Entries> | ErasedRequired<Erased>, VisibleProvided>> & LayerMetadata<Entries, Erased>;
 type LayerChannelPair<L> = L extends Layer<infer Provided, infer Required> ? [Provided, Required] : never;
 type ExactUncheckedArm<L> = LayerChannelPair<L> extends [infer Provided extends AnyService, infer Required extends AnyService] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? true : false : IsNever<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false;
 type HasUncheckedProvidedArm<L> = L extends unknown ? LayerChannelPair<L> extends [infer Provided, infer Required] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false : never;
 type HasUncheckedEmptyArm<L> = L extends unknown ? LayerChannelPair<L> extends [infer Provided, infer Required] ? IsNever<Provided> extends true ? IsAny<Required> extends true ? true : false : false : false : never;
 type HasNonUncheckedArm<L> = L extends unknown ? ExactUncheckedArm<L> extends true ? false : true : never;
 /** Recognize only the documented exact unchecked Layer sentinels. */
-type IsExactUncheckedLayer<L> = IsUnion<L> extends false ? ExactUncheckedArm<L> : true extends HasNonUncheckedArm<L> ? false : true extends HasUncheckedProvidedArm<L> ? true extends HasUncheckedEmptyArm<L> ? true : false : false;
+type IsExactUncheckedLayer<L> = IsUnion$1<L> extends false ? ExactUncheckedArm<L> : true extends HasNonUncheckedArm<L> ? false : true extends HasUncheckedProvidedArm<L> ? true extends HasUncheckedEmptyArm<L> ? true : false : false;
 type PartialAnyArm<L> = LayerChannelPair<L> extends [infer Provided extends AnyService, infer Required extends AnyService] ? IsAny<Provided> extends true ? IsAny<Required> extends true ? false : true : IsAny<Required> extends true ? IsNever<Provided> extends true ? false : true : false : false;
 /** Detect any Layer constituent with only one erased generic channel. */
 type HasPartialAnyChannel<L> = true extends (L extends unknown ? PartialAnyArm<L> : never) ? true : false;
 /** Detect a concrete union of Layer values, preserving the original shape. */
-type IsConcreteUnion<L> = IsAny<L> extends true ? false : IsUnion<L> extends true ? IsExactUncheckedLayer<L> extends true ? false : true : false;
+type IsConcreteUnion<L> = IsAny<L> extends true ? false : IsUnion$1<L> extends true ? IsExactUncheckedLayer<L> extends true ? false : true : false;
 type LayerInputState<L> = IsExactUncheckedLayer<L> extends true ? 'unchecked' : HasPartialAnyChannel<L> extends true ? 'invalid-partial-any' : IsConcreteUnion<L> extends true ? 'invalid-union' : 'typed';
 type InvalidLayerErasure = {
   readonly __betterEffectInvalidLayerErasure: unique symbol;
@@ -100,11 +103,16 @@ type ReplacePreciseOne<Entries extends AnyProviderEntry, Replacement extends Lay
 type ReplaceErasedOne<Erased extends AnyErasedProvenance, Replacement extends LayerInput> = Erased extends ErasedProvenance<infer Provided, infer StickyRequired> ? ErasedProvenance<RemoveCompatibleServices<Provided, Extract<ProvidedEnvironment<Replacement>, AnyService>>, StickyRequired> : never;
 type ApplyPreciseOverrides<Entries extends AnyProviderEntry, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ApplyPreciseOverrides<ReplacePreciseOne<Entries, Head>, Tail> : Entries;
 type ApplyErasedOverrides<Erased extends AnyErasedProvenance, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ApplyErasedOverrides<ReplaceErasedOne<Erased, Head> | Extract<ErasedEntries<Head>, AnyErasedProvenance>, Tail> : Erased;
-type HasUncheckedLayerInTuple<Layers extends readonly LayerInput[]> = true extends (Layers[number] extends unknown ? IsExactUncheckedLayer<Layers[number]> : never) ? true : false;
+type HasMatchingService<Candidate extends AnyService, Available extends AnyService> = true extends (Available extends AnyService ? SameService<Candidate, Available> : never) ? true : false;
+type GuaranteedServiceCandidates<Candidates extends AnyService, Branches extends LayerInput> = Candidates extends AnyService ? false extends (Branches extends LayerInput ? HasMatchingService<Candidates, Extract<ProvidedEnvironment<Branches>, AnyService>> : never) ? never : Candidates : never;
+type GuaranteedProvided<Branch extends LayerInput, Branches extends LayerInput = Branch> = Branch extends LayerInput ? GuaranteedServiceCandidates<Extract<ProvidedEnvironment<Branch>, AnyService>, Branches> : never;
+type HasUncheckedLayerInTuple<Layers extends readonly LayerInput[]> = true extends { [Index in keyof Layers]: IsExactUncheckedLayer<Layers[Index]>; }[number] ? true : false;
 type MergeLayerResult<Layers extends readonly LayerInput[]> = HasUncheckedLayerInTuple<Layers> extends true ? Layer<any, any> : LayerResult<PreciseEntries<Layers[number]>, ErasedEntries<Layers[number]>>;
 /** Internal result type for Layer.merge. */
 type MergeResult<Layers extends readonly LayerInput[]> = MergeLayerResult<Layers>;
-type OverrideLayerResultUnchecked<Base extends LayerInput, Overrides extends readonly LayerInput[]> = HasUncheckedLayerInTuple<[Base, ...Overrides]> extends true ? Layer<any, any> : LayerResult<ApplyPreciseOverrides<PreciseEntries<Base>, Overrides>, ApplyErasedOverrides<ErasedEntries<Base>, Overrides>>;
+type ApplyVisibleOverrides<CurrentProvided extends AnyService, Overrides extends readonly LayerInput[]> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? ApplyVisibleOverrides<RemoveCompatibleServices<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> | Extract<ProvidedEnvironment<Head>, AnyService>, Tail> : CurrentProvided;
+type OverrideLayerBranches<Base extends LayerInput, Overrides extends readonly LayerInput[]> = Overrides extends readonly LayerInput[] ? Layer<ApplyVisibleOverrides<Extract<ProvidedEnvironment<Base>, AnyService>, Overrides>, never> : never;
+type OverrideLayerResultUnchecked<Base extends LayerInput, Overrides extends readonly LayerInput[]> = HasUncheckedLayerInTuple<[Base, ...Overrides]> extends true ? Layer<any, any> : LayerResult<ApplyPreciseOverrides<PreciseEntries<Base>, Overrides>, ApplyErasedOverrides<ErasedEntries<Base>, Overrides>, Extract<GuaranteedProvided<OverrideLayerBranches<Base, Overrides>>, AnyService>>;
 /** Internal result type for an ordered override tuple. */
 type OverrideLayerResult<Base extends LayerInput, Overrides extends readonly LayerInput[]> = OverrideLayerResultUnchecked<Base, Overrides>;
 type IncompatibleOverridePair<Current extends AnyService, Replacement extends AnyService> = SameServiceTag<Current, Replacement> extends true ? SameServiceContract<Current, Replacement> extends true ? never : ServiceTokenOf<Replacement> : never;
@@ -117,7 +125,10 @@ type InvalidWidenedProvidedEnvironment = {
   readonly __betterEffectWidenedProvidedEnvironment: unique symbol;
 };
 type ValidateOverrideLayerInput<L extends LayerInput> = IsExactUncheckedLayer<L> extends true ? unknown : ValidateLayerInput<L> & (true extends HasWidenedTag<Extract<ProvidedEnvironment<L>, AnyService>> ? InvalidWidenedProvidedEnvironment : unknown);
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends ((value: infer Intersection) => void) ? Intersection : never;
+type ValidationFailuresToConstraint<Failures> = [Failures] extends [never] ? unknown : UnionToIntersection<Failures>;
 type ValidateOverrideTuple<Overrides extends readonly LayerInput[]> = { [Index in keyof Overrides]: ValidateOverrideLayerInput<Overrides[Index]>; };
+type ValidateOverrideTupleFailures<Overrides extends readonly LayerInput[]> = ValidationFailuresToConstraint<Overrides extends readonly LayerInput[] ? ValidationFailureWitness<{ [Index in keyof Overrides]: ValidateOverrideLayerInput<Overrides[Index]>; }> : never>;
 type ServiceAtTag<Services, Tag extends string> = Tag extends keyof Services ? Extract<Services[Tag], AnyService> : never;
 type ServiceTagMap<Services extends AnyService> = { [Tag in ServiceTagOf<Services>]: Extract<Services, {
   readonly [ServiceIdentityTypeId]: Tag;
@@ -133,11 +144,32 @@ type ValidateOverridePair<CurrentProvided extends AnyService, ReplacementProvide
  * Rebuilding the full Layer provenance for every step is quadratic and can
  * exhaust TypeScript's instantiation depth on otherwise simple override lists.
  */
-type ValidateOverridesFromState<Overrides extends readonly LayerInput[], BaseMap, CurrentProvided extends AnyService, CurrentChanged extends boolean, CurrentUnchecked extends boolean> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? CurrentUnchecked extends true ? ValidateOverridesFromState<Tail, BaseMap, AnyService, true, true> : IsExactUncheckedLayer<Head> extends true ? ValidateOverridesFromState<Tail, BaseMap, AnyService, true, true> : CurrentChanged extends false ? CanSkipBaseOverride<BaseMap, Extract<ProvidedEnvironment<Head>, AnyService>> extends true ? ValidateOverridesFromState<Tail, BaseMap, CurrentProvided, false, false> : ValidateOverridePair<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> & ValidateOverridesFromState<Tail, BaseMap, ApplyValidationOverride<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>>, true, false> : ValidateOverridePair<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> & ValidateOverridesFromState<Tail, BaseMap, ApplyValidationOverride<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>>, true, false> : unknown;
+type ValidateOverridesFromStateForArm<Overrides extends readonly LayerInput[], BaseMap, CurrentProvided extends AnyService, CurrentChanged extends boolean, CurrentUnchecked extends boolean> = Overrides extends readonly [infer Head extends LayerInput, ...infer Tail extends readonly LayerInput[]] ? CurrentUnchecked extends true ? ValidateOverridesFromStateForArm<Tail, BaseMap, AnyService, true, true> : IsExactUncheckedLayer<Head> extends true ? ValidateOverridesFromStateForArm<Tail, BaseMap, AnyService, true, true> : CurrentChanged extends false ? CanSkipBaseOverride<BaseMap, Extract<ProvidedEnvironment<Head>, AnyService>> extends true ? ValidateOverridesFromStateForArm<Tail, BaseMap, CurrentProvided, false, false> : ValidateOverridePair<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> & ValidateOverridesFromStateForArm<Tail, BaseMap, ApplyValidationOverride<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>>, true, false> : ValidateOverridePair<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>> & ValidateOverridesFromStateForArm<Tail, BaseMap, ApplyValidationOverride<CurrentProvided, Extract<ProvidedEnvironment<Head>, AnyService>>, true, false> : unknown;
+/** Validate every possible override tuple arm instead of accepting one valid arm. */
+type ValidateOverridesFromState<Overrides extends readonly LayerInput[], BaseMap, CurrentProvided extends AnyService, CurrentChanged extends boolean, CurrentUnchecked extends boolean> = ValidationFailuresToConstraint<Overrides extends readonly LayerInput[] ? ValidationFailureWitness<ValidateOverridesFromStateForArm<Overrides, BaseMap, CurrentProvided, CurrentChanged, CurrentUnchecked>> : never>;
 /** Validate one override against the currently accumulated Layer state. */
-type ValidateOneOverride<Current extends LayerInput, Replacement extends LayerInput> = ValidateOverrideLayerInput<Current> & ValidateOverrideLayerInput<Replacement> & (IsExactUncheckedLayer<Current> extends true ? unknown : IsExactUncheckedLayer<Replacement> extends true ? unknown : [IncompatibleOverridePairs<Extract<ProvidedEnvironment<Current>, AnyService>, Extract<ProvidedEnvironment<Replacement>, AnyService>>] extends [never] ? unknown : IncompatibleLayerOverride<IncompatibleOverridePairs<Extract<ProvidedEnvironment<Current>, AnyService>, Extract<ProvidedEnvironment<Replacement>, AnyService>>>);
+type ValidateOneOverride<Current extends LayerInput, Replacement extends LayerInput> = ValidateOverrideLayerInput<Current> & ValidateOverrideLayerInput<Replacement> & (IsExactUncheckedLayer<Current> extends true ? unknown : IsExactUncheckedLayer<Replacement> extends true ? unknown : [IncompatibleOverridePairs<Extract<PossibleProvidedEnvironment<Current>, AnyService>, Extract<PossibleProvidedEnvironment<Replacement>, AnyService>>] extends [never] ? unknown : IncompatibleLayerOverride<IncompatibleOverridePairs<Extract<PossibleProvidedEnvironment<Current>, AnyService>, Extract<PossibleProvidedEnvironment<Replacement>, AnyService>>>);
+type IsTuple<Values extends readonly unknown[]> = number extends Values['length'] ? false : true;
+type InvalidWidenedOverrideList = {
+  readonly __betterEffectWidenedOverrideList: unique symbol;
+};
 /** Validate ordered overrides against the state produced by earlier overrides. */
-type ValidateOverrides<Base extends LayerInput, Overrides extends readonly LayerInput[]> = Overrides extends readonly [] ? unknown : ValidateOverrideLayerInput<Base> & ValidateOverrideTuple<Overrides> & ValidateOverridesFromState<Overrides, ServiceTagMap<Extract<ProvidedEnvironment<Base>, AnyService>>, Extract<ProvidedEnvironment<Base>, AnyService>, false, IsExactUncheckedLayer<Base>>;
+type ValidateOverrides<Base extends LayerInput, Overrides extends readonly LayerInput[]> = [Overrides] extends [never] ? unknown : IsTuple<Overrides> extends false ? IsExactUncheckedLayer<Base> extends true ? unknown : InvalidWidenedOverrideList : ValidateOverrideLayerInput<Base> & ValidateOverrideTuple<Overrides> & ValidationFailuresToConstraint<Overrides extends readonly LayerInput[] ? [Overrides] extends [readonly []] ? never : ValidationFailureWitness<ValidateOverrideTuple<Overrides> & ValidateOverrideTupleFailures<Overrides> & ValidateOverridesFromState<Overrides, ServiceTagMap<Extract<PossibleProvidedEnvironment<Base>, AnyService>>, Extract<PossibleProvidedEnvironment<Base>, AnyService>, false, IsExactUncheckedLayer<Base>>> : never>;
+type ValidationFailureWitness<Value> = Value extends {
+  readonly __betterEffectIncompatibleLayerOverride: infer Tokens;
+} ? {
+  readonly __betterEffectIncompatibleLayerOverride: Tokens;
+} : Value extends {
+  readonly __betterEffectInvalidLayerErasure: unique symbol;
+} ? Value : Value extends {
+  readonly __betterEffectAmbiguousLayerUnion: unique symbol;
+} ? Value : Value extends {
+  readonly __betterEffectWidenedProvidedEnvironment: unique symbol;
+} ? Value : Value extends {
+  readonly __betterEffectWidenedOverrideList: unique symbol;
+} ? Value : Value extends readonly (infer Element)[] ? ValidationFailureWitness<Element> : never;
+/** Reduce Layer override validation to a usable call-site diagnostic witness. */
+type ValidateOverridesWitness<Base extends LayerInput, Overrides extends readonly LayerInput[]> = ValidationFailureWitness<ValidateOverrides<Base, Overrides>> extends (infer Failure) ? [Failure] extends [never] ? unknown : Failure : never;
 /** A Layer accepted by Runtime boundaries after completeness validation. */
 type CompleteInput<L extends LayerInput> = ValidateLayerInput<L> & (LayerInputState<L> extends 'unchecked' ? L : LayerInputState<L> extends 'typed' ? [RequiredEnvironment<L>] extends [never] ? L : L & MissingDependencies<Extract<RequiredEnvironment<L>, AnyService>> : L);
 type ExecutionRequirementsMissing<RootProvided extends AnyService, Request extends LayerInput> = MissingServices<Extract<RequiredEnvironment<Request>, AnyService>, Extract<RootProvided, AnyService>>;
@@ -150,18 +182,58 @@ type CompleteExecutionWithRequirements<Provided extends AnyService, A, Required
 /** Keep execution callbacks unchanged when their Effect requirements are met. */
 type CompleteExecution<Provided extends AnyService, A> = CompleteExecutionWithRequirements<Provided, A, EffectRequirements<A>>;
 //#endregion
+//#region src/layer/types.d.ts
+/** Runtime-facing provider registration supplied by a Layer backend. */
+interface LayerRegistration {
+  /** The class-backed Service token provided by this registration. */
+  readonly service: ServiceClass<any, any>;
+  /**
+   * The canonical tag captured when the provider was created.
+   *
+   * This remains optional for direct backend registrations created against the
+   * pre-inspection API; backends capture the token tag synchronously when it is
+   * omitted.
+   */
+  readonly serviceTag?: string;
+  /** Lazily acquire the Service instance; concrete types are erased at this backend boundary. */
+  readonly acquire: () => MaybePromise<unknown>;
+}
+/** Generator shape used by `Layer.gen` and `Layer.scopedGen`. */
+type LayerGenerator<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown> = ServiceRequirement<unknown>> = () => AsyncGenerator<Yield, ServiceContract<InstanceType<S>>, unknown>;
+/** Service requirements inferred from a provider's methods and generator. */
+type LayerGeneratorRequirements<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>> = ServiceRequirements<InstanceType<S>> | InferYieldRequirements<Yield>;
+//#endregion
 //#region src/layer/layer.d.ts
 declare const LayerTypeId: unique symbol;
 interface LayerVariance<in out Provided, out Required> {
   readonly _Provided: Invariant<Provided>;
   readonly _Required: Covariant<Required>;
 }
+type CapturedLayerAcquisition = {
+  readonly instance: unknown;
+  readonly release: ScopeFinalizer;
+};
 interface LayerProvider extends LayerRegistration {
+  /** The tag captured before this provider can cross an asynchronous boundary. */
+  readonly serviceTag: string;
   /** Provider storage deliberately erases the concrete instance type. */
-  readonly release?: (instance: unknown, outcome: ScopeOutcome) => MaybePromise$1<void>;
+  readonly release?: (instance: unknown, outcome: ScopeOutcome) => MaybePromise<void>;
+  /** Capture acquisition-local cleanup without retaining the acquired instance. */
+  readonly acquireWithRelease?: () => MaybePromise<CapturedLayerAcquisition>;
 }
 /** A Service class whose constructor can be called without arguments. */
 type DefaultConstructibleServiceClass<Tag extends string = string, Instance extends AnyService = AnyService> = ServiceClass<Tag, Instance> & (new () => Instance);
+type IsUnion<Type, Candidate = Type> = Type extends unknown ? [Candidate] extends [Type] ? false : true : never;
+type InvalidUnionAliasToken = {
+  readonly __betterEffectUnionLayerAliasToken: unique symbol;
+};
+type RejectUnionAliasToken<Token> = IsUnion<Token> extends true ? InvalidUnionAliasToken : unknown;
+type LayerAliasOptions<From extends ServiceClass<any, any>, To extends ServiceClass<any, any>> = {
+  readonly from: From;
+  readonly to: To;
+} & RejectUnionAliasToken<From> & RejectUnionAliasToken<To> & ([ServiceContract<InstanceType<From>>] extends [ServiceContract<InstanceType<To>>] ? unknown : {
+  readonly __betterEffectIncompatibleLayerAlias: unique symbol;
+});
 /**
  * Declarative collection of Service providers.
  *
@@ -184,15 +256,21 @@ declare class Layer<in out Provided extends AnyService = AnyService, out Require
   /** The provider registrations retained by this Layer. */
   readonly providers: readonly LayerProvider[];
   private constructor();
+  /** A stable provider-free Layer for composition roots with no Services. */
+  static readonly empty: Layer<never, never>;
   /** Create a Layer that lazily acquires a Service instance. */
   static make<S extends DefaultConstructibleServiceClass<any, any>>(service: S): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
-  static make<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise$1<ServiceContract<InstanceType<S>>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  static make<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
   /** Create a Layer from an already-constructed Service instance. */
   static succeed<S extends ServiceClass<any, any>>(service: S, instance: ServiceContract<InstanceType<S>>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Alias a source Service under a compatible target contract. */
+  static alias<From extends ServiceClass<any, any>, To extends ServiceClass<any, any>>(options: LayerAliasOptions<From, To>): LayerResult<ProviderEntry<InstanceType<To>, InstanceType<From> | ServiceRequirements<InstanceType<To>>>>;
   /** Define a provider with Runtime-root cleanup. */
-  static scoped<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise$1<ServiceContract<InstanceType<S>>>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise$1<void>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  static scoped<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>>>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise<void>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
+  /** Define a provider with Runtime-root cleanup through its disposal protocol. */
+  static scopedDisposable<S extends ServiceClass<any, any>>(service: S, acquire: () => MaybePromise<ServiceContract<InstanceType<S>> & DisposableResource>): LayerResult<ProviderEntry<InstanceType<S>, ServiceRequirements<InstanceType<S>>>>;
   /** Define a provider whose acquisition can yield contextual Services. */
-  static scopedGen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise$1<void>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
+  static scopedGen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>, release: (instance: InstanceType<S>, outcome: ScopeOutcome) => MaybePromise<void>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
   /** Define a provider whose acquisition can yield contextual Services. */
   static gen<S extends ServiceClass<any, any>, Yield extends ServiceRequirement<unknown>>(service: S, factory: LayerGenerator<S, Yield>): LayerResult<ProviderEntry<InstanceType<S>, LayerGeneratorRequirements<S, Yield>>>;
   /** Compose Layers without replacing providers. */
@@ -202,7 +280,7 @@ declare class Layer<in out Provided extends AnyService = AnyService, out Require
   /** Replace providers in a base Layer, using tag identity and compatible contracts. */
   static override<Base extends LayerInput>(base: Base & ValidateLayerInput<Base>): OverrideLayerResult<Base, readonly []>;
   static override<Base extends LayerInput, const Overrides extends readonly [LayerInput, ...LayerInput[]]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides & ValidateOverrides<Base, Overrides>): OverrideLayerResult<Base, Overrides>;
-  static override<Base extends LayerInput, const Overrides extends readonly LayerInput[]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides extends readonly [LayerInput, ...LayerInput[]] ? never : Overrides & ValidateOverrides<Base, Overrides>): OverrideLayerResult<Base, Overrides>;
+  static override<Base extends LayerInput, const Overrides extends readonly LayerInput[]>(base: Base & ValidateLayerInput<Base>, ...overrides: Overrides & ValidateOverrides<Base, Overrides>): OverrideLayerResult<Base, Overrides>;
 }
 /** Type-level aliases for inspecting Layer environments and completeness. */
 declare namespace Layer {
@@ -218,6 +296,23 @@ declare namespace Layer {
   type Complete<L extends LayerInput> = CompleteInput<L>;
 }
 //#endregion
+//#region src/layer/backend.d.ts
+/** Observation hook invoked for acquisitions that disposal will await. */
+type LayerBackendDisposeOptions = {
+  /**
+   * Receives the in-flight acquisition Promises when disposal begins. The callback
+   * is invoked synchronously and awaited before the backend clears its state.
+   */
+  readonly onPendingAcquisitions?: (acquisitions: readonly Promise<unknown>[]) => void | PromiseLike<void>;
+};
+/** Runtime adapter responsible for registering, resolving, and disposing Layer providers. */
+interface LayerBackend extends ServiceResolver {
+  /** Register one Service provider with the backend. */
+  register(registration: LayerRegistration): MaybePromise<void>;
+  /** Dispose all backend-owned instances and provider registrations. */
+  disposeAll(options?: LayerBackendDisposeOptions): MaybePromise<void>;
+}
+//#endregion
 //#region src/layer/errors.d.ts
 type LayerCause = Extract<ScopeOutcome, {
   readonly status: 'failure';
@@ -264,14 +359,26 @@ type RuntimeServiceAcquireEvent = {
   readonly resolutionPath: readonly AnyServiceToken[];
   readonly outcome: ScopeOutcome;
 };
+/** Values supplied to one Runtime execution for diagnostic correlation. */
+type RuntimeExecutionAttributes = Readonly<Record<string, unknown>>;
+/** Metadata shared by the start and end events for one execution. */
+type RuntimeExecutionMetadata = {
+  readonly executionId: string;
+  readonly name?: string;
+  readonly attributes?: RuntimeExecutionAttributes;
+  /** Monotonic host timestamp captured immediately before the Program starts. */
+  readonly startedAt: number;
+};
 /** Event emitted immediately before a program starts in an execution Scope. */
-type RuntimeExecutionStartEvent = {
+type RuntimeExecutionStartEvent = RuntimeExecutionMetadata & {
   readonly scope: Scope;
 };
 /** Event emitted after a program and its execution Scope settle. */
-type RuntimeExecutionEndEvent = {
+type RuntimeExecutionEndEvent = RuntimeExecutionMetadata & {
   readonly scope: Scope;
   readonly outcome: ScopeOutcome;
+  /** Monotonic elapsed time for the Program and its execution cleanup. */
+  readonly durationMs: number;
 };
 /** Event emitted after a Layer provider release callback settles. */
 type RuntimeResourceReleaseEvent = {
@@ -281,11 +388,15 @@ type RuntimeResourceReleaseEvent = {
 };
 /** Optional best-effort hooks for Runtime lifecycle and resolution events. */
 type RuntimeObserver = {
-  readonly onServiceResolve?: (event: RuntimeServiceResolveEvent) => MaybePromise$1<void>;
-  readonly onServiceAcquire?: (event: RuntimeServiceAcquireEvent) => MaybePromise$1<void>;
-  readonly onExecutionStart?: (event: RuntimeExecutionStartEvent) => MaybePromise$1<void>;
-  readonly onExecutionEnd?: (event: RuntimeExecutionEndEvent) => MaybePromise$1<void>;
-  readonly onResourceRelease?: (event: RuntimeResourceReleaseEvent) => MaybePromise$1<void>;
+  readonly onServiceResolve?: (event: RuntimeServiceResolveEvent) => MaybePromise<void>;
+  readonly onServiceAcquire?: (event: RuntimeServiceAcquireEvent) => MaybePromise<void>;
+  readonly onExecutionStart?: (event: RuntimeExecutionStartEvent) => MaybePromise<void>;
+  readonly onExecutionEnd?: (event: RuntimeExecutionEndEvent) => MaybePromise<void>;
+  readonly onResourceRelease?: (event: RuntimeResourceReleaseEvent) => MaybePromise<void>;
+};
+/** Compose best-effort Runtime observers into one observer. */
+declare const RuntimeObserver: {
+  compose: (...observers: readonly RuntimeObserver[]) => RuntimeObserver;
 };
 //#endregion
 //#region src/runtime/outcome.d.ts
@@ -297,7 +408,7 @@ type RuntimeShutdownDiagnostic = {
   readonly error: LayerDisposeError;
 };
 /** Observer notified about cleanup failures without changing primary results. */
-type CleanupFailureObserver = (diagnostic: CleanupFailureDiagnostic | RuntimeShutdownDiagnostic) => MaybePromise<void>;
+type CleanupFailureObserver = (diagnostic: CleanupFailureDiagnostic | RuntimeShutdownDiagnostic) => MaybePromise$1<void>;
 /** Optional Runtime configuration for cleanup diagnostics. */
 type RuntimeOptions = {
   /** Backend used to register and resolve the Layer. Defaults to MapLayerBackend. */
@@ -313,9 +424,11 @@ type RuntimeOptions = {
   /** Optional signal exposed through the RuntimeContext. */
   readonly signal?: AbortSignal;
 };
-/** Optional signal supplied to one managed Runtime execution. */
+/** Optional signal and diagnostic attributes supplied to one Runtime execution. */
 type RuntimeRunOptions = {
   readonly signal?: AbortSignal;
+  /** Copied once and exposed as a readonly event view. */
+  readonly attributes?: RuntimeExecutionAttributes;
 };
 /** Cooperative shutdown policy for a managed Runtime. */
 type RuntimeDisposeOptions = {
@@ -325,5 +438,5 @@ type RuntimeDisposeOptions = {
   readonly abortAfterGracePeriod?: boolean;
 };
 //#endregion
-export { MissingDependencies as A, LayerResult as C, ValidateLayerInput as D, RequiredEnvironment as E, ValidateOneOverride as O, LayerInput as S, ProvidedEnvironment as T, Layer as _, RuntimeShutdownDiagnostic as a, CompleteInput as b, RuntimeObserver as c, RuntimeServiceResolveEvent as d, DuplicateServiceError as f, ServiceTagCollisionError as g, LayerRegistrationError as h, RuntimeRunOptions as i, ProviderEntry as k, RuntimeResourceReleaseEvent as l, LayerGeneratorYieldError as m, RuntimeDisposeOptions as n, RuntimeExecutionEndEvent as o, LayerDisposeError as p, RuntimeOptions as r, RuntimeExecutionStartEvent as s, CleanupFailureObserver as t, RuntimeServiceAcquireEvent as u, CompleteExecution as v, MissingServices as w, ExecutionMissing as x, CompleteExecutionLayer as y };
-//# sourceMappingURL=index-C7KX5rAP.d.mts.map
+export { MissingServices as A, CompleteExecution as C, LayerInput as D, ExecutionMissing as E, ValidateOneOverride as F, ValidateOverrides as I, ValidateOverridesWitness as L, ProvidedEnvironment as M, RequiredEnvironment as N, LayerInputState as O, ValidateLayerInput as P, ProviderEntry as R, LayerRegistration as S, CompleteInput as T, LayerRegistrationError as _, RuntimeShutdownDiagnostic as a, LayerBackendDisposeOptions as b, RuntimeExecutionMetadata as c, RuntimeResourceReleaseEvent as d, RuntimeServiceAcquireEvent as f, LayerGeneratorYieldError as g, LayerDisposeError as h, RuntimeRunOptions as i, OverrideLayerResult as j, LayerResult as k, RuntimeExecutionStartEvent as l, DuplicateServiceError as m, RuntimeDisposeOptions as n, RuntimeExecutionAttributes as o, RuntimeServiceResolveEvent as p, RuntimeOptions as r, RuntimeExecutionEndEvent as s, CleanupFailureObserver as t, RuntimeObserver as u, ServiceTagCollisionError as v, CompleteExecutionLayer as w, Layer as x, LayerBackend as y, MissingDependencies as z };
+//# sourceMappingURL=outcome-CB43bnFW.d.mts.map