better-effect 0.13.0 → 0.14.0

package/dist/runtime-qpcVwaz_.mjs

@@ -0,0 +1,1680 @@
+import { c as CircularDependencyError, f as captureServiceTag, i as LayerDisposeError, l as ServiceAcquisitionError, n as normalizeLayerRegistration, o as LayerRegistrationError, r as DuplicateServiceError, s as ServiceTagCollisionError, t as captureLayerRegistrationTag, u as ServiceNotFoundError } from "./registration-Bwe2GbVu.mjs";
+import { _ as RuntimeExecutorNotConfiguredError, h as RuntimeContextNotConfiguredError, i as getRuntimeContext, l as makeRuntimeContext, n as currentRuntimeContext, t as activeRuntimeContextStorage, u as runRuntimeContext } from "./context-DSGSqcJj.mjs";
+import { a as ResourceNotDisposableError, c as ScopeRuntimeNotConfiguredError, i as getDisposeFinalizer, n as getLayerEntries, o as ScopeCloseError, s as ScopeClosedError, u as defaultRuntimeContextStorage } from "./layer-2kjHVv4N.mjs";
+import { t as assertServiceCompatibility } from "./internal-identity-BuHBtP0k.mjs";
+import { n as linkAbortSignals } from "./signal-5Rg9bUUe.mjs";
+import { Err } from "better-result";
+//#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, current);
+		return runRuntimeContext(storage, context, program);
+	}
+	/** Return the Scope active in the current execution context. */
+	static current() {
+		let context;
+		try {
+			context = currentRuntimeContext();
+		} catch (cause) {
+			if (cause instanceof RuntimeContextNotConfiguredError) throw new ScopeRuntimeNotConfiguredError();
+			throw cause;
+		}
+		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 scopeImplementations = /* @__PURE__ */ new WeakMap();
+/** Register the private implementation hook used by lifecycle primitives. */
+const registerScopeImplementation = (scope, implementation) => {
+	scopeImplementations.set(scope, implementation);
+};
+/** Register work that must run before attached child Scopes close. */
+const addScopePreFinalizer = (scope, finalizer) => {
+	const implementation = scopeImplementations.get(scope);
+	if (!implementation) throw new TypeError("Scope does not support internal pre-finalizers");
+	implementation.addPreFinalizer(finalizer);
+};
+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;
+	}
+	let outcome;
+	let outcomeStatus;
+	if (programFailed) {
+		outcome = {
+			status: "failure",
+			cause: programFailure
+		};
+		outcomeStatus = "failure";
+	} else try {
+		outcome = options.classify(value);
+		outcomeStatus = outcome.status;
+	} catch (cause) {
+		programFailed = true;
+		programFailure = cause;
+		outcome = {
+			status: "failure",
+			cause
+		};
+		outcomeStatus = "failure";
+	}
+	options.onOutcome?.(outcome);
+	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 (outcomeStatus === "failure") return value;
+	if (cleanupFailed) throw cleanupFailure;
+	return value;
+};
+//#endregion
+//#region src/scope/scope.ts
+const SCOPE_SUCCESS$1 = Object.freeze({ status: "success" });
+var ScopeImpl = class ScopeImpl {
+	parent;
+	children = /* @__PURE__ */ new Set();
+	finalizers = [];
+	preFinalizers = [];
+	closePromise;
+	closeOutcome;
+	constructor(parent) {
+		this.parent = parent;
+		registerScopeImplementation(this, { addPreFinalizer: (finalizer) => this.addPreFinalizer(finalizer) });
+	}
+	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$1);
+			} 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$1);
+			} catch (releaseFailure) {
+				throw new AggregateError([scopeFailure, releaseFailure], "Scope closed while adding a disposable resource and cleanup also failed");
+			}
+			throw scopeFailure;
+		}
+	}
+	close(outcome = SCOPE_SUCCESS$1) {
+		if (this.closePromise) return this.closePromise;
+		this.closeOutcome = outcome;
+		this.closePromise = Promise.resolve().then(() => this.closeWithRuntime(outcome));
+		return this.closePromise;
+	}
+	async closeWithRuntime(outcome) {
+		let started = false;
+		try {
+			await ScopeRuntime.run(this, () => {
+				started = true;
+				return this.closeInternal(outcome);
+			});
+		} catch (storageFailure) {
+			if (started) throw storageFailure;
+			try {
+				await this.closeInternal(outcome);
+			} catch (cleanupFailure) {
+				const cleanupCauses = cleanupFailure instanceof ScopeCloseError ? cleanupFailure.causes : [cleanupFailure];
+				throw new ScopeCloseError([storageFailure, ...cleanupCauses]);
+			}
+			throw storageFailure;
+		}
+	}
+	async closeInternal(outcome) {
+		const failures = [];
+		const preFinalizers = this.preFinalizers.splice(0);
+		for (let index = preFinalizers.length - 1; index >= 0; index--) {
+			const finalizer = preFinalizers[index];
+			if (!finalizer) continue;
+			try {
+				await finalizer(outcome);
+			} catch (cause) {
+				failures.push(cause);
+			}
+		}
+		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();
+	}
+	addPreFinalizer(finalizer) {
+		this.assertOpen();
+		this.preFinalizers.push(finalizer);
+	}
+};
+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$1 });
+	}
+};
+//#endregion
+//#region src/layer/map-layer-backend.ts
+/** Native map-backed Layer backend used by Runtime when no adapter is supplied. */
+var MapLayerBackend = class {
+	providers = /* @__PURE__ */ new Map();
+	instances = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	/** Register a provider, rejecting duplicate or colliding Service tags. */
+	register(registration) {
+		const normalized = normalizeLayerRegistration(registration);
+		const tag = captureLayerRegistrationTag(normalized);
+		const existing = this.providers.get(tag);
+		if (existing) {
+			if (existing.service !== normalized.service) throw new ServiceTagCollisionError(existing.service, normalized.service);
+			throw new DuplicateServiceError(normalized.service);
+		}
+		this.providers.set(tag, normalized);
+	}
+	/** Resolve and cache a provider instance by Service tag. */
+	async resolve(token) {
+		const tag = captureServiceTag(token);
+		const provider = this.providers.get(tag);
+		if (!provider) throw new ServiceNotFoundError(token);
+		const validate = (instance) => {
+			assertServiceCompatibility(token, provider.service, instance);
+			return instance;
+		};
+		const cached = this.instances.get(tag);
+		if (cached !== void 0) return validate(cached);
+		const pending = this.pending.get(tag);
+		if (pending) return validate(await pending);
+		const acquisition = Promise.resolve().then(() => provider.acquire()).then((instance) => {
+			validate(instance);
+			this.instances.set(tag, instance);
+			return instance;
+		}).finally(() => {
+			this.pending.delete(tag);
+		});
+		this.pending.set(tag, acquisition);
+		return validate(await acquisition);
+	}
+	/** Clear pending acquisitions, cached instances, and provider registrations. */
+	async disposeAll(options) {
+		const acquisitions = [...this.pending.values()];
+		if (acquisitions.length > 0) {
+			const observePending = options?.onPendingAcquisitions;
+			if (observePending) await observePending(acquisitions);
+			await Promise.allSettled(acquisitions);
+		}
+		this.instances.clear();
+		this.pending.clear();
+		this.providers.clear();
+	}
+};
+//#endregion
+//#region src/effect/program-metadata.ts
+const programNames = /* @__PURE__ */ new WeakMap();
+/** Return the private diagnostic name attached to a callable Program. */
+const getProgramName = (program) => programNames.get(program);
+/** Attach a name without changing the callable Program facade. */
+const setProgramName = (program, name) => {
+	programNames.set(program, name);
+	return program;
+};
+/** Copy a source Program's name to a lazily-created derived Program. */
+const inheritProgramName = (source, derived) => {
+	const name = getProgramName(source);
+	return name === void 0 ? derived : setProgramName(derived, name);
+};
+//#endregion
+//#region src/runtime/observer.ts
+/** Compose best-effort Runtime observers into one observer. */
+const RuntimeObserver = { compose: (...observers) => ({
+	onServiceResolve: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onServiceResolve, event);
+	},
+	onServiceAcquire: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onServiceAcquire, event);
+	},
+	onExecutionStart: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onExecutionStart, event);
+	},
+	onExecutionEnd: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onExecutionEnd, event);
+	},
+	onTaskStart: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onTaskStart, event);
+	},
+	onTaskEnd: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onTaskEnd, event);
+	},
+	onResourceRelease: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onResourceRelease, event);
+	},
+	onLifecycleStart: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onLifecycleStart, event);
+	},
+	onLifecycleEnd: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onLifecycleEnd, event);
+	},
+	onLifecycleRelease: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onLifecycleRelease, event);
+	},
+	onShutdown: (event) => {
+		notifyRuntimeObservers(observers, (observer) => observer.onShutdown, event);
+	}
+}) };
+const notifyRuntimeObservers = (observers, select, event) => {
+	for (const observer of observers) {
+		const callback = select(observer);
+		if (!callback) continue;
+		try {
+			Promise.resolve(callback(event)).catch(() => {});
+		} catch {}
+	}
+};
+//#endregion
+//#region src/runtime/outcome.ts
+/** Classify only a nominal better-result Err as a failed Runtime outcome. */
+const classifyRuntimeOutcome = (value) => {
+	if (value instanceof Err) return {
+		status: "failure",
+		cause: value.error
+	};
+	return { status: "success" };
+};
+//#endregion
+//#region src/runtime/task.ts
+const taskSupervisors = /* @__PURE__ */ new WeakMap();
+/** Associate one Runtime task supervisor with a Runtime-owned Scope. */
+const bindRuntimeTaskSupervisor = (scope, supervisor) => {
+	taskSupervisors.set(scope, supervisor);
+};
+/** Return the supervisor associated with the current Runtime-owned Scope. */
+const getRuntimeTaskSupervisor = (scope) => taskSupervisors.get(scope);
+const defaultInterruptionReason = () => {
+	const reason = /* @__PURE__ */ new Error("Scoped task interrupted");
+	reason.name = "ScopedTaskInterruptedError";
+	return reason;
+};
+const signalReason = (signal) => signal.reason === void 0 ? defaultInterruptionReason() : signal.reason;
+const taskStateFromExit = (exit) => exit.status;
+const copyMetadata = (metadata) => {
+	const copy = {
+		taskId: metadata.taskId,
+		startedAt: metadata.startedAt
+	};
+	if (metadata.parentExecutionId !== void 0) copy.parentExecutionId = metadata.parentExecutionId;
+	if (metadata.name !== void 0) copy.name = metadata.name;
+	return Object.freeze(copy);
+};
+var ScopedTaskHandle = class {
+	controller;
+	handleState;
+	constructor(controller) {
+		this.controller = controller;
+		let resolveCompletion;
+		const completion = new Promise((resolve) => {
+			resolveCompletion = resolve;
+		});
+		this.handleState = {
+			completion,
+			resolveCompletion,
+			currentState: "running",
+			terminalResult: void 0,
+			interruptionReasonValue: void 0
+		};
+		Object.freeze(this);
+	}
+	get state() {
+		return this.handleState.currentState;
+	}
+	await() {
+		return this.handleState.completion.then((exit) => {
+			if (exit.status === "succeeded" || exit.status === "failed") return this.handleState.terminalResult;
+			if (exit.status === "defected") throw exit.cause;
+			throw exit.reason;
+		});
+	}
+	awaitExit() {
+		return this.handleState.completion;
+	}
+	interrupt(reason) {
+		if (this.handleState.currentState !== "running") return this.handleState.completion.then(() => void 0);
+		const interruption = reason === void 0 ? this.handleState.interruptionReasonValue ?? defaultInterruptionReason() : reason;
+		this.handleState.interruptionReasonValue = interruption;
+		if (!this.controller.signal.aborted) this.controller.abort(interruption);
+		return this.handleState.completion.then(() => void 0);
+	}
+	markInterrupted(reason) {
+		if (this.handleState.currentState === "running" && this.handleState.interruptionReasonValue === void 0) this.handleState.interruptionReasonValue = reason;
+	}
+	isInterrupted() {
+		return this.handleState.interruptionReasonValue !== void 0 || this.controller.signal.aborted;
+	}
+	interruptionReason(signal) {
+		return this.handleState.interruptionReasonValue ?? signalReason(signal);
+	}
+	settle(exit, result) {
+		if (this.handleState.currentState !== "running") return;
+		const terminalExit = Object.freeze(exit);
+		this.handleState.currentState = taskStateFromExit(terminalExit);
+		this.handleState.terminalResult = result;
+		this.handleState.resolveCompletion(terminalExit);
+	}
+};
+const withCleanupFailure = (value, cleanupFailure) => {
+	if (cleanupFailure === void 0) return Object.freeze({ ...value });
+	return Object.freeze({
+		...value,
+		cleanupFailure
+	});
+};
+/** Runtime-owned supervisor for Scope child tasks. */
+var RuntimeTaskSupervisor = class {
+	createTaskId;
+	now;
+	observers;
+	onCleanupFailure;
+	tasks = /* @__PURE__ */ new Map();
+	constructor(createTaskId, now, observers, onCleanupFailure) {
+		this.createTaskId = createTaskId;
+		this.now = now;
+		this.observers = observers;
+		this.onCleanupFailure = onCleanupFailure;
+	}
+	bindScope(scope) {
+		bindRuntimeTaskSupervisor(scope, this);
+	}
+	inspect() {
+		return Object.freeze([...this.tasks.values()].map(({ metadata }) => Object.freeze({
+			...copyMetadata(metadata),
+			state: "running"
+		})));
+	}
+	forkScoped(program, context) {
+		if (!context.resolver || !context.scope) throw new RuntimeContextNotConfiguredError();
+		const parentScope = context.scope;
+		const childScope = parentScope.fork();
+		const controller = new AbortController();
+		const signalLink = linkAbortSignals(context.signal, controller.signal);
+		const handle = new ScopedTaskHandle(controller);
+		const metadata = this.makeMetadata(program, context);
+		const record = {
+			metadata,
+			childScope,
+			signalLink,
+			handle,
+			program,
+			context,
+			storage: activeRuntimeContextStorage()
+		};
+		const onAbort = () => handle.markInterrupted(signalReason(signalLink.signal));
+		try {
+			addScopePreFinalizer(parentScope, (outcome) => handle.interrupt(outcome.status === "failure" ? outcome.cause : void 0));
+			this.bindScope(childScope);
+			this.tasks.set(metadata.taskId, record);
+			signalLink.signal.addEventListener("abort", onAbort, { once: true });
+			if (signalLink.signal.aborted) onAbort();
+			this.notifyStart(metadata);
+		} catch (cause) {
+			signalLink.signal.removeEventListener("abort", onAbort);
+			signalLink.dispose();
+			childScope.close({
+				status: "failure",
+				cause
+			}).catch(() => {});
+			throw cause;
+		}
+		this.runTask(record, onAbort);
+		return handle;
+	}
+	makeMetadata(program, context) {
+		const metadata = {
+			taskId: this.createTaskId(),
+			startedAt: this.now()
+		};
+		const name = getProgramName(program);
+		if (name !== void 0) metadata.name = name;
+		if (context.executionId !== void 0) metadata.parentExecutionId = context.executionId;
+		return Object.freeze(metadata);
+	}
+	notifyStart(metadata) {
+		const event = {
+			...copyMetadata(metadata),
+			state: "running"
+		};
+		notifyRuntimeObservers(this.observers, (observer) => observer.onTaskStart, Object.freeze(event));
+	}
+	notifyEnd(metadata, exit) {
+		const event = {
+			...copyMetadata(metadata),
+			state: exit.status
+		};
+		if (exit.cleanupFailure !== void 0) event.cleanupFailure = exit.cleanupFailure;
+		const frozenEvent = Object.freeze(event);
+		notifyRuntimeObservers(this.observers, (observer) => observer.onTaskEnd, frozenEvent);
+	}
+	async runTask(record, onAbort) {
+		let cleanupFailure;
+		const onChildCleanupFailure = async (diagnostic) => {
+			cleanupFailure = diagnostic.error;
+			if (this.onCleanupFailure !== void 0) await this.onCleanupFailure(diagnostic);
+		};
+		const taskContext = makeRuntimeContext(record.context.resolver, record.childScope, [], record.signalLink.signal, record.context, record.context.executionId, record.context.executor);
+		const classify = (value) => record.handle.isInterrupted() ? {
+			status: "failure",
+			cause: record.handle.interruptionReason(record.signalLink.signal)
+		} : classifyRuntimeOutcome(value);
+		let exit;
+		let result;
+		try {
+			if (record.handle.isInterrupted()) {
+				await record.childScope.close({
+					status: "failure",
+					cause: record.handle.interruptionReason(record.signalLink.signal)
+				});
+				exit = withCleanupFailure({
+					status: "interrupted",
+					reason: record.handle.interruptionReason(record.signalLink.signal)
+				}, cleanupFailure);
+			} else {
+				const childResult = await runScoped(record.childScope, () => record.program(), {
+					classify,
+					onCleanupFailure: onChildCleanupFailure,
+					contextStorage: record.storage,
+					context: taskContext
+				});
+				result = childResult;
+				if (record.handle.isInterrupted()) exit = withCleanupFailure({
+					status: "interrupted",
+					reason: record.handle.interruptionReason(record.signalLink.signal)
+				}, cleanupFailure);
+				else if (childResult instanceof Err) exit = withCleanupFailure({
+					status: "failed",
+					error: childResult.error
+				}, cleanupFailure);
+				else exit = withCleanupFailure({
+					status: "succeeded",
+					value: childResult.value
+				}, cleanupFailure);
+			}
+		} catch (cause) {
+			exit = record.handle.isInterrupted() ? withCleanupFailure({
+				status: "interrupted",
+				reason: record.handle.interruptionReason(record.signalLink.signal)
+			}, cleanupFailure) : withCleanupFailure({
+				status: "defected",
+				cause
+			}, cleanupFailure);
+		}
+		record.signalLink.signal.removeEventListener("abort", onAbort);
+		record.signalLink.dispose();
+		record.handle.settle(exit, result);
+		this.tasks.delete(record.metadata.taskId);
+		this.notifyEnd(record.metadata, exit);
+	}
+};
+//#endregion
+//#region src/runtime/executor.ts
+const castRuntimeExecutor = (value) => {
+	return value;
+};
+const currentExecutor = () => {
+	let context;
+	try {
+		context = currentRuntimeContext();
+	} catch (cause) {
+		if (cause instanceof RuntimeContextNotConfiguredError) throw new RuntimeExecutorNotConfiguredError();
+		throw cause;
+	}
+	if (context.executor === void 0) throw new RuntimeExecutorNotConfiguredError();
+	return castRuntimeExecutor(context.executor);
+};
+/** Erase a Runtime executor's concrete environment for contextual storage. */
+const eraseRuntimeExecutor = (executor) => castRuntimeExecutor(executor);
+/** Create one stable executor view from an existing Runtime execution handle. */
+const createRuntimeExecutor = (executor) => Object.freeze({ ...executor });
+/** Build the yieldable contextual executor request used by `Runtime.executor()`. */
+const makeRuntimeExecutorRequest = () => {
+	return {
+		*[Symbol.iterator]() {
+			return currentExecutor();
+		},
+		async *[Symbol.asyncIterator]() {
+			return currentExecutor();
+		}
+	};
+};
+//#endregion
+//#region src/layer/resolution.ts
+const findCycleStart = (path, tag) => path.findIndex((current) => captureServiceTag(current) === tag);
+const shouldPreserve = (cause) => cause instanceof CircularDependencyError || cause instanceof ServiceAcquisitionError || cause instanceof ServiceNotFoundError || cause instanceof ServiceTagCollisionError;
+/** Wrap a backend with Runtime-local resolution paths and acquisition errors. */
+const createResolutionResolver = (resolver, storage = defaultRuntimeContextStorage, observers = []) => {
+	const wrapped = { async resolve(token) {
+		const tag = captureServiceTag(token);
+		const context = getRuntimeContext(storage);
+		const path = context?.resolutionPath ?? [];
+		const cycleStart = findCycleStart(path, tag);
+		const resolutionPath = [...path, token];
+		const notifyResolve = (outcome) => {
+			const event = {
+				service: token,
+				resolutionPath,
+				outcome
+			};
+			if (context?.executionId !== void 0) Object.assign(event, { executionId: context.executionId });
+			notifyRuntimeObservers(observers, (observer) => observer.onServiceResolve, event);
+		};
+		if (cycleStart >= 0) {
+			const error = new CircularDependencyError([...path.slice(cycleStart), token]);
+			notifyResolve({
+				status: "failure",
+				cause: error
+			});
+			throw error;
+		}
+		const nextContext = makeRuntimeContext(wrapped, context?.scope, resolutionPath, context?.signal, context);
+		return await runRuntimeContext(storage, nextContext, async () => {
+			try {
+				const instance = await resolver.resolve(token);
+				notifyResolve({ status: "success" });
+				return instance;
+			} catch (cause) {
+				if (shouldPreserve(cause)) {
+					notifyResolve({
+						status: "failure",
+						cause
+					});
+					throw cause;
+				}
+				const error = new ServiceAcquisitionError(token, resolutionPath, cause);
+				notifyResolve({
+					status: "failure",
+					cause: error
+				});
+				throw error;
+			}
+		});
+	} };
+	return wrapped;
+};
+//#endregion
+//#region src/runtime/execution.ts
+const hostMonotonicNow = () => {
+	if (typeof globalThis.performance?.now === "function") {
+		const value = globalThis.performance.now();
+		if (Number.isFinite(value)) return value;
+	}
+	const wallClock = Date.now();
+	return Number.isFinite(wallClock) ? wallClock : 0;
+};
+const makeMonotonicClock = () => {
+	let previous = 0;
+	return () => {
+		previous = Math.max(previous, hostMonotonicNow());
+		return previous;
+	};
+};
+let fallbackExecutionSequence = 0;
+const makeExecutionIdGenerator = () => () => {
+	if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+	fallbackExecutionSequence += 1;
+	return `execution-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}-${fallbackExecutionSequence.toString(36)}`;
+};
+/** Create isolated execution capabilities for one Runtime handle. */
+const makeRuntimeExecutionDependencies = (overrides = {}) => ({
+	createExecutionId: overrides.createExecutionId ?? makeExecutionIdGenerator(),
+	now: overrides.now ?? makeMonotonicClock()
+});
+//#endregion
+//#region src/layer/runtime.ts
+const SCOPE_SUCCESS = Object.freeze({ status: "success" });
+var RuntimeHandleDisposedError = class extends Error {
+	constructor() {
+		super("Cannot run a program using a disposed Layer");
+		this.name = "RuntimeHandleDisposedError";
+	}
+};
+const normalizeDisposeCauses = (cause) => {
+	if (cause instanceof AggregateError) return [...cause.errors];
+	return [cause];
+};
+const isScopeOutcome = (input) => input !== void 0 && "status" in input;
+const validateDisposeOptions = (options) => {
+	const { gracePeriod, abortAfterGracePeriod } = options;
+	if (gracePeriod !== void 0 && (!Number.isFinite(gracePeriod) || gracePeriod < 0)) throw new RangeError("Runtime dispose gracePeriod must be a finite non-negative number");
+	if (abortAfterGracePeriod !== void 0 && typeof abortAfterGracePeriod !== "boolean") throw new TypeError("Runtime dispose abortAfterGracePeriod must be a boolean");
+};
+const copyExecutionAttributes = (attributes) => {
+	if (attributes === void 0) return;
+	if (typeof attributes !== "object" || attributes === null) throw new TypeError("Runtime execution attributes must be an object");
+	return Object.freeze({ ...attributes });
+};
+const prepareExecution = (program, options, dependencies, runtimeSignal, shutdownSignal, additionalSignal) => ({
+	metadata: makeExecutionMetadata(program, options?.attributes, dependencies),
+	signalLink: linkAbortSignals(runtimeSignal, options?.signal, additionalSignal, shutdownSignal)
+});
+const makeExecutionMetadata = (program, attributes, dependencies) => {
+	const name = getProgramName(program);
+	const copiedAttributes = copyExecutionAttributes(attributes);
+	const metadata = {
+		executionId: dependencies.createExecutionId(),
+		startedAt: dependencies.now()
+	};
+	if (name !== void 0) metadata.name = name;
+	if (copiedAttributes !== void 0) metadata.attributes = copiedAttributes;
+	return Object.freeze(metadata);
+};
+const executionDuration = (metadata, dependencies) => {
+	try {
+		const elapsed = dependencies.now() - metadata.startedAt;
+		return Number.isFinite(elapsed) ? Math.max(0, elapsed) : 0;
+	} catch {
+		return 0;
+	}
+};
+const readRuntimeTimestamp = (dependencies) => {
+	try {
+		const timestamp = dependencies.now();
+		return Number.isFinite(timestamp) ? timestamp : void 0;
+	} catch {
+		return;
+	}
+};
+const makeShutdownReason = (outcome) => {
+	if (outcome.status === "failure") return {
+		kind: "main-settled",
+		cause: outcome.cause
+	};
+	return { kind: "main-settled" };
+};
+const notifyShutdownFailure = async (observer, diagnostic) => {
+	if (!observer) return;
+	try {
+		await observer(diagnostic);
+	} catch {}
+};
+const releaseLayerResource = async (service, release, outcome, observers, executionId) => {
+	try {
+		await release(outcome);
+		const event = {
+			service,
+			outcome
+		};
+		if (executionId !== void 0) Object.assign(event, { executionId });
+		notifyRuntimeObservers(observers, (observer) => observer.onResourceRelease, event);
+	} catch (cause) {
+		const event = {
+			service,
+			outcome,
+			error: cause
+		};
+		if (executionId !== void 0) Object.assign(event, { executionId });
+		notifyRuntimeObservers(observers, (observer) => observer.onResourceRelease, event);
+		throw cause;
+	}
+};
+const lifecycleEventMetadata = (entry) => ({
+	kind: "lifecycle",
+	lifecycleId: entry.id
+});
+const releaseLifecycleResource = async (entry, resource, outcome, observers) => {
+	const metadata = lifecycleEventMetadata(entry);
+	try {
+		await entry.release(resource, outcome);
+		const event = {
+			...metadata,
+			outcome
+		};
+		notifyRuntimeObservers(observers, (observer) => observer.onLifecycleRelease, event);
+	} catch (cause) {
+		const event = {
+			...metadata,
+			outcome,
+			error: cause
+		};
+		notifyRuntimeObservers(observers, (observer) => observer.onLifecycleRelease, event);
+		throw cause;
+	}
+};
+const bindProviderToScope = (provider, scope, contextStorage, resolver, observers, executor, ownerExecutionId, beforeAcquire, onAcquired) => ({
+	service: provider.service,
+	serviceTag: provider.serviceTag,
+	acquire: () => {
+		beforeAcquire?.();
+		const current = getRuntimeContext(contextStorage);
+		const executionId = current?.executionId ?? ownerExecutionId;
+		const context = makeRuntimeContext(resolver, scope, current?.resolutionPath ?? [], current?.signal, current, void 0, executor);
+		return runRuntimeContext(contextStorage, context, () => ScopeRuntime.run(scope, async () => {
+			const resolutionPath = current?.resolutionPath ?? [provider.service];
+			try {
+				const instance = provider.acquireWithRelease ? (await scope.acquire(provider.acquireWithRelease, (acquired, outcome) => releaseLayerResource(provider.service, acquired.release, outcome, observers, ownerExecutionId))).instance : provider.release ? await scope.acquire(() => provider.acquire(), (resource, outcome) => releaseLayerResource(provider.service, (releaseOutcome) => provider.release(resource, releaseOutcome), outcome, observers, ownerExecutionId)) : await provider.acquire();
+				onAcquired?.(instance);
+				const event = {
+					service: provider.service,
+					resolutionPath,
+					outcome: SCOPE_SUCCESS
+				};
+				if (executionId !== void 0) Object.assign(event, { executionId });
+				notifyRuntimeObservers(observers, (observer) => observer.onServiceAcquire, event);
+				return instance;
+			} catch (cause) {
+				const event = {
+					service: provider.service,
+					resolutionPath,
+					outcome: {
+						status: "failure",
+						cause
+					}
+				};
+				if (executionId !== void 0) Object.assign(event, { executionId });
+				notifyRuntimeObservers(observers, (observer) => observer.onServiceAcquire, event);
+				throw cause;
+			}
+		}, contextStorage));
+	}
+});
+/** Resolve request-local providers first, then fall back to the Runtime root. */
+var ExecutionLayerBackend = class {
+	local;
+	root;
+	localTags = /* @__PURE__ */ new Set();
+	constructor(local, root) {
+		this.local = local;
+		this.root = root;
+	}
+	register(registration) {
+		this.localTags.add(captureLayerRegistrationTag(registration));
+		this.local.register(registration);
+	}
+	async resolve(token) {
+		const tag = captureServiceTag(token);
+		if (this.localTags.has(tag)) return await this.local.resolve(token);
+		return await this.root.resolve(token);
+	}
+	async disposeAll() {
+		await this.local.disposeAll();
+		this.localTags.clear();
+	}
+};
+var RuntimeHandleImpl = class {
+	backend;
+	resolver;
+	rootScope;
+	onCleanupFailure;
+	contextStorage;
+	signal;
+	observers;
+	services;
+	executionDependencies;
+	executor;
+	lifecycleEntries;
+	disposePromise;
+	warmupPromise;
+	executions = /* @__PURE__ */ new Set();
+	rootQuiesces = [];
+	serviceTags;
+	shutdownController = new AbortController();
+	taskSupervisor;
+	state = "active";
+	warmupState = "idle";
+	constructor(backend, resolver, rootScope, onCleanupFailure, contextStorage, signal, observers, services, serviceTags, executionDependencies, executor, lifecycleEntries) {
+		this.backend = backend;
+		this.resolver = resolver;
+		this.rootScope = rootScope;
+		this.onCleanupFailure = onCleanupFailure;
+		this.contextStorage = contextStorage;
+		this.signal = signal;
+		this.observers = observers;
+		this.services = services;
+		this.executionDependencies = executionDependencies;
+		this.executor = executor;
+		this.lifecycleEntries = lifecycleEntries;
+		this.serviceTags = Object.freeze([...serviceTags]);
+		this.taskSupervisor = new RuntimeTaskSupervisor(() => this.executionDependencies.createExecutionId(), () => this.executionDependencies.now(), this.observers, this.onCleanupFailure);
+		this.taskSupervisor.bindScope(this.rootScope);
+	}
+	registerRootQuiesce(provider, instance) {
+		if (provider.quiesce === void 0) return;
+		this.rootQuiesces.push({
+			started: false,
+			quiesce: (reason) => provider.quiesce(instance, reason)
+		});
+	}
+	registerLifecycleQuiesce(entry, instance) {
+		if (entry.quiesce === void 0) return;
+		this.rootQuiesces.push({
+			started: false,
+			quiesce: (reason) => entry.quiesce(instance, reason)
+		});
+	}
+	assertRootAcquisitionAllowed() {
+		this.assertActive();
+	}
+	emitShutdown(event) {
+		notifyRuntimeObservers(this.observers, (observer) => observer.onShutdown, event);
+	}
+	async quiesceResources(reason) {
+		const failures = [];
+		for (;;) {
+			const registration = [...this.rootQuiesces].reverse().find((candidate) => !candidate.started);
+			if (registration === void 0) return failures;
+			registration.started = true;
+			try {
+				await registration.quiesce(reason);
+			} catch (cause) {
+				failures.push(cause);
+			}
+		}
+	}
+	inspect() {
+		const tasks = this.taskSupervisor.inspect();
+		const executions = Object.freeze([...this.executions].map(({ metadata }) => {
+			const inspection = {
+				executionId: metadata.executionId,
+				startedAt: metadata.startedAt
+			};
+			if (metadata.name !== void 0) inspection.name = metadata.name;
+			return Object.freeze(inspection);
+		}));
+		return Object.freeze({
+			state: this.state,
+			warmup: this.warmupState,
+			activeExecutions: executions.length,
+			executions,
+			activeTasks: tasks.length,
+			tasks,
+			services: Object.freeze([...this.serviceTags]),
+			shutdownSignalAborted: this.shutdownController.signal.aborted
+		});
+	}
+	run(program, options) {
+		this.assertActive();
+		let prepared;
+		try {
+			prepared = prepareExecution(program, options, this.executionDependencies, this.signal, this.shutdownController.signal);
+		} catch (cause) {
+			return Promise.reject(cause);
+		}
+		try {
+			this.assertActive();
+		} catch (cause) {
+			prepared.signalLink.dispose();
+			throw cause;
+		}
+		let executionScope;
+		try {
+			executionScope = this.rootScope.fork();
+			this.taskSupervisor.bindScope(executionScope);
+		} catch (cause) {
+			prepared.signalLink.dispose();
+			throw cause;
+		}
+		return this.startExecution(prepared.signalLink, prepared.metadata, () => this.runExecution(executionScope, program, this.resolver, prepared.signalLink.signal, prepared.metadata));
+	}
+	runWith(layer, program, options) {
+		this.assertActive();
+		let prepared;
+		try {
+			prepared = prepareExecution(program, options, this.executionDependencies, this.signal, this.shutdownController.signal);
+		} catch (cause) {
+			return Promise.reject(cause);
+		}
+		try {
+			this.assertActive();
+		} catch (cause) {
+			prepared.signalLink.dispose();
+			throw cause;
+		}
+		const localBackend = new MapLayerBackend();
+		const backend = new ExecutionLayerBackend(localBackend, this.backend);
+		const resolver = createResolutionResolver(backend, this.contextStorage, this.observers);
+		let executionScope;
+		try {
+			executionScope = this.rootScope.fork();
+			this.taskSupervisor.bindScope(executionScope);
+		} catch (cause) {
+			prepared.signalLink.dispose();
+			throw cause;
+		}
+		return this.startExecution(prepared.signalLink, prepared.metadata, async () => {
+			try {
+				return await this.runExecution(executionScope, async () => {
+					for (const provider of layer.providers) backend.register(bindProviderToScope(provider, executionScope, this.contextStorage, resolver, this.observers, this.executor, prepared.metadata.executionId));
+					return await program();
+				}, resolver, prepared.signalLink.signal, prepared.metadata);
+			} finally {
+				await localBackend.disposeAll();
+			}
+		});
+	}
+	runWithManaged(layer, program, options) {
+		this.assertActive();
+		const managedController = new AbortController();
+		let prepared;
+		prepared = prepareExecution(program, options, this.executionDependencies, this.signal, this.shutdownController.signal, managedController.signal);
+		try {
+			this.assertActive();
+		} catch (cause) {
+			prepared.signalLink.dispose();
+			throw cause;
+		}
+		const localBackend = new MapLayerBackend();
+		const backend = new ExecutionLayerBackend(localBackend, this.backend);
+		const resolver = createResolutionResolver(backend, this.contextStorage, this.observers);
+		let executionScope;
+		try {
+			executionScope = this.rootScope.fork();
+		} catch (cause) {
+			prepared.signalLink.dispose();
+			throw cause;
+		}
+		this.taskSupervisor.bindScope(executionScope);
+		const executionContext = makeRuntimeContext(resolver, executionScope, [], prepared.signalLink.signal, void 0, prepared.metadata.executionId, this.executor);
+		let plan;
+		let pendingCancel;
+		let cancelPromise;
+		let executionPromise;
+		let settled = false;
+		let resolveReadiness;
+		let rejectReadiness;
+		const readiness = new Promise((resolve, reject) => {
+			resolveReadiness = resolve;
+			rejectReadiness = reject;
+		});
+		readiness.catch(() => void 0);
+		const runInExecution = (operation) => {
+			if (settled) return Promise.reject(new RuntimeHandleDisposedError());
+			return Promise.resolve(runRuntimeContext(this.contextStorage, executionContext, () => ScopeRuntime.run(executionScope, operation, this.contextStorage)));
+		};
+		const cancel = (reason) => {
+			if (cancelPromise !== void 0) return cancelPromise;
+			cancelPromise = (async () => {
+				pendingCancel = reason === void 0 ? /* @__PURE__ */ new Error("Managed execution cancelled") : reason;
+				if (!managedController.signal.aborted) managedController.abort(pendingCancel);
+				const currentPlan = plan;
+				if (currentPlan?.cancel !== void 0) try {
+					await currentPlan.cancel(pendingCancel);
+				} catch {}
+				if (executionPromise !== void 0) await executionPromise.catch(() => void 0);
+			})();
+			return cancelPromise;
+		};
+		const run = async () => {
+			try {
+				for (const provider of layer.providers) backend.register(bindProviderToScope(provider, executionScope, this.contextStorage, resolver, this.observers, this.executor, prepared.metadata.executionId));
+				const next = await program();
+				plan = next;
+				if (pendingCancel !== void 0) {
+					rejectReadiness(pendingCancel);
+					await next.cancel?.(pendingCancel);
+					throw pendingCancel;
+				}
+				try {
+					resolveReadiness(await next.readiness);
+				} catch (cause) {
+					rejectReadiness(cause);
+					await next.cancel?.(cause);
+					throw cause;
+				}
+				return await next.completion;
+			} catch (cause) {
+				rejectReadiness(cause);
+				throw cause;
+			}
+		};
+		executionPromise = this.startExecution(prepared.signalLink, prepared.metadata, async () => {
+			try {
+				return await this.runExecution(executionScope, run, resolver, prepared.signalLink.signal, prepared.metadata, executionContext);
+			} finally {
+				await localBackend.disposeAll();
+			}
+		});
+		executionPromise.then(() => {
+			settled = true;
+		}, () => {
+			settled = true;
+		});
+		executionPromise.catch(() => void 0);
+		const signalListener = () => {
+			cancel(prepared.signalLink.signal.reason);
+		};
+		if (!prepared.signalLink.signal.aborted) prepared.signalLink.signal.addEventListener("abort", signalListener, { once: true });
+		executionPromise.then(() => prepared.signalLink.signal.removeEventListener("abort", signalListener), () => prepared.signalLink.signal.removeEventListener("abort", signalListener));
+		const completion = executionPromise.then(() => void 0);
+		completion.catch(() => void 0);
+		return Object.freeze({
+			readiness,
+			completion,
+			signal: prepared.signalLink.signal,
+			run: runInExecution,
+			cancel
+		});
+	}
+	warmup() {
+		this.assertActive();
+		if (this.warmupPromise) return this.warmupPromise;
+		this.warmupState = "running";
+		let warmup;
+		try {
+			warmup = runRuntimeContext(this.contextStorage, makeRuntimeContext(this.resolver, this.rootScope, [], this.signal, void 0, void 0, this.executor), async () => {
+				for (const service of this.services) await this.resolver.resolve(service);
+			});
+		} catch (cause) {
+			this.warmupState = "failed";
+			return Promise.reject(cause);
+		}
+		this.warmupPromise = warmup;
+		warmup.then(() => {
+			if (this.warmupPromise === warmup) {
+				this.warmupState = "completed";
+				this.warmupPromise = void 0;
+			}
+		}, () => {
+			if (this.warmupPromise === warmup) {
+				this.warmupState = "failed";
+				this.warmupPromise = void 0;
+			}
+		});
+		return warmup;
+	}
+	activateLifecycle() {
+		this.assertActive();
+		if (this.lifecycleEntries.length === 0) return Promise.resolve();
+		return runRuntimeContext(this.contextStorage, makeRuntimeContext(this.resolver, this.rootScope, [], this.signal, void 0, void 0, this.executor), () => ScopeRuntime.run(this.rootScope, async () => {
+			for (const entry of this.lifecycleEntries) {
+				const metadata = lifecycleEventMetadata(entry);
+				const startEvent = Object.freeze({ ...metadata });
+				notifyRuntimeObservers(this.observers, (observer) => observer.onLifecycleStart, startEvent);
+				try {
+					const resource = await this.rootScope.acquire(() => entry.acquire(), (resource, outcome) => releaseLifecycleResource(entry, resource, outcome, this.observers));
+					this.registerLifecycleQuiesce(entry, resource);
+					const endEvent = Object.freeze({
+						...metadata,
+						outcome: SCOPE_SUCCESS
+					});
+					notifyRuntimeObservers(this.observers, (observer) => observer.onLifecycleEnd, endEvent);
+				} catch (cause) {
+					const endEvent = Object.freeze({
+						...metadata,
+						outcome: {
+							status: "failure",
+							cause
+						},
+						error: cause
+					});
+					notifyRuntimeObservers(this.observers, (observer) => observer.onLifecycleEnd, endEvent);
+					throw cause;
+				}
+			}
+		}));
+	}
+	startExecution(signalLink, metadata, run) {
+		let resolveExecution;
+		let rejectExecution;
+		const execution = new Promise((resolve, reject) => {
+			resolveExecution = resolve;
+			rejectExecution = reject;
+		});
+		const activeExecution = {
+			promise: execution,
+			metadata
+		};
+		this.executions.add(activeExecution);
+		execution.then(() => {
+			this.executions.delete(activeExecution);
+			signalLink.dispose();
+		}, () => {
+			this.executions.delete(activeExecution);
+			signalLink.dispose();
+		});
+		try {
+			run(metadata).then((value) => {
+				resolveExecution(value);
+			}, (cause) => {
+				rejectExecution(cause);
+			});
+		} catch (cause) {
+			rejectExecution(cause);
+		}
+		return execution;
+	}
+	runExecution(executionScope, program, resolver = this.resolver, signal = this.shutdownController.signal, metadata, executionContext) {
+		let outcome;
+		let cleanupFailure;
+		const onOutcome = (determinedOutcome) => {
+			outcome = determinedOutcome;
+		};
+		const onExecutionCleanupFailure = async (diagnostic) => {
+			cleanupFailure = diagnostic.error;
+			if (this.onCleanupFailure !== void 0) await this.onCleanupFailure(diagnostic);
+		};
+		const runOptions = {
+			classify: classifyRuntimeOutcome,
+			onOutcome,
+			onCleanupFailure: onExecutionCleanupFailure
+		};
+		const startEvent = Object.freeze({
+			...metadata,
+			scope: executionScope
+		});
+		notifyRuntimeObservers(this.observers, (observer) => observer.onExecutionStart, startEvent);
+		let ended = false;
+		const notifyEnd = (finalOutcome) => {
+			if (ended) return;
+			ended = true;
+			const endEvent = {
+				...metadata,
+				scope: executionScope,
+				outcome: finalOutcome,
+				durationMs: executionDuration(metadata, this.executionDependencies)
+			};
+			if (cleanupFailure !== void 0) Object.assign(endEvent, { cleanupFailure });
+			notifyRuntimeObservers(this.observers, (observer) => observer.onExecutionEnd, Object.freeze(endEvent));
+		};
+		let execution;
+		try {
+			execution = runScoped(executionScope, program, {
+				...runOptions,
+				contextStorage: this.contextStorage,
+				context: executionContext ?? makeRuntimeContext(resolver, executionScope, [], signal, void 0, metadata.executionId, this.executor)
+			});
+		} catch (cause) {
+			notifyEnd({
+				status: "failure",
+				cause
+			});
+			return Promise.reject(cause);
+		}
+		return execution.then((value) => {
+			notifyEnd(outcome ?? { status: "success" });
+			return value;
+		}, (cause) => {
+			notifyEnd(outcome ?? {
+				status: "failure",
+				cause
+			});
+			throw cause;
+		});
+	}
+	dispose(input) {
+		if (this.disposePromise) return this.disposePromise;
+		const outcome = isScopeOutcome(input) || input === void 0 ? input ?? SCOPE_SUCCESS : SCOPE_SUCCESS;
+		const options = isScopeOutcome(input) || input === void 0 ? {} : input;
+		validateDisposeOptions(options);
+		const reason = Object.freeze(options.reason ?? (isScopeOutcome(input) ? makeShutdownReason(input) : { kind: "dispose" }));
+		this.state = "quiescing";
+		let resolveDispose;
+		let rejectDispose;
+		const disposePromise = new Promise((resolve, reject) => {
+			resolveDispose = resolve;
+			rejectDispose = reject;
+		});
+		this.disposePromise = disposePromise;
+		this.emitShutdown(Object.freeze({
+			phase: "shutdown-requested",
+			reason,
+			activeExecutions: this.executions.size
+		}));
+		this.performDispose(outcome, options, reason).then(resolveDispose, rejectDispose);
+		return disposePromise;
+	}
+	async performDispose(outcome, options, reason) {
+		const failures = [];
+		if (this.warmupPromise !== void 0) await Promise.allSettled([this.warmupPromise]);
+		const quiesceStartedAt = readRuntimeTimestamp(this.executionDependencies);
+		this.emitShutdown({
+			phase: "quiesce-start",
+			reason
+		});
+		failures.push(...await this.quiesceResources(reason));
+		const quiesceEnd = {
+			phase: "quiesce-end",
+			reason
+		};
+		if (quiesceStartedAt !== void 0) Object.assign(quiesceEnd, { durationMs: Math.max(0, (readRuntimeTimestamp(this.executionDependencies) ?? quiesceStartedAt) - quiesceStartedAt) });
+		this.emitShutdown(quiesceEnd);
+		this.state = "draining";
+		const executions = [...this.executions];
+		this.emitShutdown({
+			phase: "drain-start",
+			reason,
+			activeExecutions: executions.length
+		});
+		await this.waitForExecutions(executions, options, reason);
+		failures.push(...await this.quiesceResources(reason));
+		this.emitShutdown({
+			phase: "drain-end",
+			reason,
+			activeExecutions: this.executions.size
+		});
+		this.state = "releasing";
+		this.emitShutdown({
+			phase: "release-start",
+			reason
+		});
+		try {
+			const signalLink = linkAbortSignals(this.signal, this.shutdownController.signal);
+			try {
+				await runRuntimeContext(this.contextStorage, makeRuntimeContext(this.resolver, this.rootScope, [], signalLink.signal, void 0, void 0, this.executor), () => this.rootScope.close(outcome));
+			} finally {
+				signalLink.dispose();
+			}
+		} catch (cause) {
+			failures.push(cause);
+		}
+		try {
+			await this.backend.disposeAll();
+		} catch (cause) {
+			failures.push(cause);
+		}
+		this.state = "disposed";
+		this.emitShutdown({
+			phase: "release-end",
+			reason
+		});
+		if (failures.length > 0) {
+			const error = new LayerDisposeError(failures.flatMap(normalizeDisposeCauses));
+			this.emitShutdown({
+				phase: "shutdown-failure",
+				reason,
+				error
+			});
+			await notifyShutdownFailure(this.onCleanupFailure, {
+				outcome,
+				error
+			});
+			throw error;
+		}
+		this.emitShutdown({
+			phase: "shutdown-complete",
+			reason
+		});
+	}
+	async waitForExecutions(executions, options, reason) {
+		const settled = Promise.allSettled(executions.map((execution) => execution.promise));
+		if (options.abortAfterGracePeriod !== true || executions.length === 0) {
+			await settled;
+			return;
+		}
+		const gracePeriod = options.gracePeriod ?? 0;
+		let timer;
+		const timedOut = await Promise.race([settled.then(() => false), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(true), gracePeriod);
+		})]);
+		if (timer !== void 0) clearTimeout(timer);
+		if (timedOut && !this.shutdownController.signal.aborted) {
+			this.state = "aborting";
+			this.emitShutdown({
+				phase: "abort-active",
+				reason,
+				activeExecutions: this.executions.size
+			});
+			this.shutdownController.abort(/* @__PURE__ */ new Error("Runtime shutdown grace period exceeded"));
+		}
+		await settled;
+	}
+	assertActive() {
+		if (this.state !== "active") throw new RuntimeHandleDisposedError();
+	}
+};
+/** Build a Runtime handle for a complete Layer and register its providers. */
+const createRuntimeHandle = async (layer, backend, options = {}, executionOverrides = {}, providedExecutor) => {
+	const entries = getLayerEntries(layer);
+	const providers = entries.filter((entry) => !isLifecycleEntry(entry));
+	const lifecycleEntries = entries.filter(isLifecycleEntry);
+	const services = providers.map((provider) => provider.service);
+	const serviceTags = providers.map((provider) => captureLayerRegistrationTag(provider));
+	const rootScope = Scope.make();
+	const contextStorage = options.contextStorage ?? defaultRuntimeContextStorage;
+	const observers = options.observers ?? [];
+	const resolver = createResolutionResolver(backend, contextStorage, observers);
+	const executionDependencies = makeRuntimeExecutionDependencies(executionOverrides);
+	ScopeRuntime.bind(rootScope, contextStorage);
+	let handle;
+	const pendingRootQuiesces = [];
+	const executor = providedExecutor ?? createRuntimeExecutor({
+		run: (program, runOptions) => handle.run(program, runOptions),
+		runWith: (request, program, runOptions) => handle.runWith(request, program, runOptions),
+		runWithManaged: (request, program, runOptions) => handle.runWithManaged(request, program, runOptions)
+	});
+	const contextExecutor = eraseRuntimeExecutor(executor);
+	let current;
+	try {
+		for (const provider of providers) {
+			current = provider;
+			await backend.register(bindProviderToScope(provider, rootScope, contextStorage, resolver, observers, contextExecutor, void 0, () => handle?.assertRootAcquisitionAllowed(), (instance) => {
+				if (handle === void 0) pendingRootQuiesces.push({
+					provider,
+					instance
+				});
+				else handle.registerRootQuiesce(provider, instance);
+			}));
+		}
+	} catch (registrationCause) {
+		const outcome = {
+			status: "failure",
+			cause: registrationCause
+		};
+		const cleanupCauses = [];
+		try {
+			await runRuntimeContext(contextStorage, makeRuntimeContext(resolver, rootScope, [], options.signal, void 0, void 0, contextExecutor), () => rootScope.close(outcome));
+		} catch (cause) {
+			cleanupCauses.push(cause);
+		}
+		try {
+			await backend.disposeAll();
+		} catch (cause) {
+			cleanupCauses.push(cause);
+		}
+		if (cleanupCauses.length > 0) {
+			const shutdownError = new LayerDisposeError(cleanupCauses.flatMap(normalizeDisposeCauses));
+			await notifyShutdownFailure(options.onCleanupFailure, {
+				outcome,
+				error: shutdownError
+			});
+		}
+		const cleanupCause = cleanupCauses.length === 1 ? cleanupCauses[0] : cleanupCauses.length > 1 ? new LayerDisposeError(cleanupCauses.flatMap(normalizeDisposeCauses)) : void 0;
+		throw new LayerRegistrationError(current?.service, registrationCause, cleanupCause);
+	}
+	handle = new RuntimeHandleImpl(backend, resolver, rootScope, options.onCleanupFailure, contextStorage, options.signal, observers, services, serviceTags, executionDependencies, contextExecutor, lifecycleEntries);
+	for (const { provider, instance } of pendingRootQuiesces) handle.registerRootQuiesce(provider, instance);
+	return handle;
+};
+const isLifecycleEntry = (entry) => "kind" in entry && entry.kind === "lifecycle";
+//#endregion
+//#region src/runtime/runtime.ts
+const isLayerBackend = (value) => value !== void 0 && "register" in value && "resolve" in value && "disposeAll" in value;
+const resolveRuntimeConfig = (backendOrOptions, legacyOptions) => {
+	if (isLayerBackend(backendOrOptions)) return {
+		backend: backendOrOptions,
+		options: legacyOptions ?? {}
+	};
+	const options = backendOrOptions ?? {};
+	return {
+		backend: options.backend ?? new MapLayerBackend(),
+		options
+	};
+};
+/**
+* Long-lived execution environment backed by a complete Layer.
+*
+* A Runtime owns Layer resources until `dispose()` is called. Each `run()` is
+* isolated in a child Scope, while Layer-scoped resources remain shared.
+*
+* @example
+* ```ts
+* const runtime = await Runtime.make(AppLive)
+* const result = await runtime.run(loadUser('u1'))
+* await runtime.dispose()
+* ```
+*
+* @typeParam Provided The branded Service instances supplied by the Layer.
+*/
+var Runtime = class Runtime {
+	handle;
+	executor;
+	constructor(handle, executor) {
+		this.handle = handle;
+		this.executor = executor;
+	}
+	static async make(layer, backendOrOptions, legacyOptions) {
+		const { backend, options } = resolveRuntimeConfig(backendOrOptions, legacyOptions);
+		let handle;
+		const executor = createRuntimeExecutor({
+			run: (program, runOptions) => handle.run(program, runOptions),
+			runWith: (request, program, runOptions) => handle.runWith(request, program, runOptions),
+			runWithManaged: (request, program, runOptions) => handle.runWithManaged(request, program, runOptions)
+		});
+		handle = await createRuntimeHandle(layer, backend, options, {}, executor);
+		const runtime = new Runtime(handle, executor);
+		try {
+			if (options.warmup) await runtime.warmup();
+			await handle.activateLifecycle();
+		} catch (cause) {
+			try {
+				await runtime.disposeWithOutcome({
+					status: "failure",
+					cause
+				});
+			} catch {}
+			throw cause;
+		}
+		return runtime;
+	}
+	static async run(layer, backendOrProgramOrOptions, programOrOptions, legacyOptions) {
+		let program;
+		let backendOrOptions;
+		let options;
+		if (typeof backendOrProgramOrOptions === "function") {
+			program = backendOrProgramOrOptions;
+			backendOrOptions = programOrOptions;
+			options = void 0;
+		} else {
+			backendOrOptions = backendOrProgramOrOptions;
+			program = programOrOptions;
+			options = legacyOptions;
+		}
+		const config = resolveRuntimeConfig(backendOrOptions, options);
+		let programOutcome;
+		const outcomeObserver = { onExecutionEnd: ({ outcome }) => {
+			programOutcome = outcome;
+		} };
+		const runtimeOptions = {
+			...config.options,
+			observers: [outcomeObserver, ...config.options.observers ?? []]
+		};
+		const runtime = await Runtime.make(layer, config.backend, runtimeOptions);
+		let value;
+		let executionFailed = false;
+		let executionFailure;
+		try {
+			value = await runtime.runUnchecked(program, config.options);
+		} catch (cause) {
+			executionFailed = true;
+			executionFailure = cause;
+		}
+		const outcome = programOutcome ?? {
+			status: "failure",
+			cause: executionFailure
+		};
+		try {
+			await runtime.disposeWithOutcome(outcome);
+		} catch (shutdownFailure) {
+			if (!executionFailed && outcome.status === "success") throw shutdownFailure;
+		}
+		if (executionFailed) throw executionFailure;
+		return value;
+	}
+	static async use(layer, use, options) {
+		const runtime = await Runtime.make(layer, options);
+		let value;
+		let executionFailed = false;
+		let executionFailure;
+		let programOutcome;
+		try {
+			value = await use(runtime);
+			programOutcome = classifyRuntimeOutcome(value);
+		} catch (cause) {
+			executionFailed = true;
+			executionFailure = cause;
+			programOutcome = {
+				status: "failure",
+				cause
+			};
+		}
+		const outcome = programOutcome ?? {
+			status: "failure",
+			cause: executionFailure
+		};
+		try {
+			await runtime.disposeWithOutcome(outcome);
+		} catch (shutdownFailure) {
+			if (!executionFailed && outcome.status === "success") throw shutdownFailure;
+		}
+		if (executionFailed) throw executionFailure;
+		return value;
+	}
+	/** Request the non-owning executor view from the current Runtime context. */
+	static executor() {
+		return makeRuntimeExecutorRequest();
+	}
+	/** Resolve every Layer provider and dispose the Runtime if warmup fails. */
+	async warmup() {
+		try {
+			await this.handle.warmup();
+		} catch (cause) {
+			try {
+				await this.handle.dispose({
+					status: "failure",
+					cause
+				});
+			} catch {}
+			throw cause;
+		}
+	}
+	/** Return a detached diagnostic snapshot without changing Runtime state. */
+	inspect() {
+		return this.handle.inspect();
+	}
+	/** Run one execution in this Runtime's child Scope. */
+	run(program, options) {
+		return this.handle.run(program, options);
+	}
+	/** Run one execution with a Layer owned by that execution's child Scope. */
+	runWith(layer, program, options) {
+		return this.handle.runWith(layer, program, options);
+	}
+	runUnchecked(program, options) {
+		return this.handle.run(program, options);
+	}
+	dispose(optionsOrOutcome) {
+		return this.handle.dispose(optionsOrOutcome);
+	}
+	/** Release Runtime-owned resources through JavaScript's async disposal protocol. */
+	async [Symbol.asyncDispose]() {
+		await this.dispose();
+	}
+	disposeWithOutcome(outcome) {
+		return this.handle.dispose(outcome);
+	}
+};
+//#endregion
+export { RuntimeObserver as a, MapLayerBackend as c, classifyRuntimeOutcome as i, Scope as l, eraseRuntimeExecutor as n, inheritProgramName as o, getRuntimeTaskSupervisor as r, setProgramName as s, Runtime as t, ScopeRuntime as u };
+
+//# sourceMappingURL=runtime-qpcVwaz_.mjs.map