injeca 0.2.0 → 0.4.0

package/dist/global-B5N-d-TO.mjs

@@ -0,0 +1,3600 @@
+import { $ as candidatesOf, A as causeOf, B as withoutUndefined, Dt as StartTimeoutError, E as ensureConsumerService, Et as StaleRegistrationError, F as resolvePlain, G as nodeOf, H as affectedContainers, I as acceptsCandidate, J as releasePresent, K as publishService, L as emitRecord, N as resolveFallback, O as createService, Ot as TransactionIncompleteError, P as resolveKey, Q as buildLost, R as recordAbortedWait, S as normalizeName, St as InvalidArgumentError, U as assertActive, V as createDeferred, W as awaitWithdrawal, X as subtreeOf, Y as releaseService, Z as blockingFailure, _ as timeoutOf, _t as BuildAfterDisposeError, a as releaseReservations, at as resolutionOf, bt as HookTimeoutError, c as cancelPending, ct as serviceFor, d as currentService, dt as removeDeclaration, et as epochOf, f as releaseRegistration, ft as errorFrom, g as timeoutHandlerOf, gt as withOwner, h as readPolicy, ht as untracked, i as releaseReservation, it as requiredWithdrawn, j as sameStatus, k as setPhase, kt as WaitTimeoutError, l as cancelSuccessor, lt as slotOf, m as maxAttemptsOf, mt as batch, n as defaultDecision, nt as requiredAvailable, o as reserveKey, ot as resolvedInstance, p as readDefinition, pt as messageOf, q as registerNode, r as validateDecision, rt as requiredChanged, s as reservedBy, st as selectProvider, t as createDecide, tt as findProvider, u as createRegistration, ut as inConflict, v as readEdges, vt as DuplicateServiceError, wt as ReplaceWhileStoppingError, x as isExclusiveKey, yt as HookOutsideBuildError } from "./decision-BXZu3N1O.mjs";
+import { effectScope, getActiveSub, signal } from "alien-signals";
+import ErrorStackParser from "error-stack-parser";
+import { nanoid } from "nanoid";
+// package.json
+var name = "injeca";
+// src/diagnostics/logger.ts
+function formatDuration(ms) {
+	if (ms < 1) return `${(ms * 1e3).toFixed(3)}µs`;
+	if (ms < 1e3) return `${ms.toFixed(3)}ms`;
+	return `${(ms / 1e3).toFixed(3)}s`;
+}
+function createDefaultLogger() {
+	return {
+		provide: (name, dependencies) => {
+			const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(", ")})` : "";
+			console.log(`[${name}] PROVIDE    ${name}${depsStr}`);
+		},
+		invoke: (dependencies) => {
+			const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(", ")})` : "";
+			console.log(`[${name}] INVOKE${depsStr}`);
+		},
+		beforeRun: (name) => {
+			console.log(`[${name}] BEFORE RUN provide: ${name}()`);
+		},
+		run: (name, duration) => {
+			console.log(`[${name}] RUN        provide: ${name}() in ${formatDuration(duration)}`);
+		},
+		hookOnStart: (name) => {
+			console.log(`[${name}] HOOK OnStart        ${name}() executing`);
+		},
+		hookOnStartComplete: (name, duration) => {
+			console.log(`[${name}] HOOK OnStart        ${name}() ran successfully in ${formatDuration(duration)}`);
+		},
+		hookOnStop: (name) => {
+			console.log(`[${name}] HOOK OnStop         ${name}() executing`);
+		},
+		hookOnStopComplete: (name, duration) => {
+			console.log(`[${name}] HOOK OnStop         ${name}() ran successfully in ${formatDuration(duration)}`);
+		},
+		running: () => {
+			console.log(`[${name}] RUNNING`);
+		},
+		warn: (message) => {
+			console.warn(`[${name}] WARN       ${message}`);
+		}
+	};
+}
+function createLoggLogger(logg) {
+	return {
+		provide: (name, dependencies) => {
+			const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(", ")})` : "";
+			logg.log(`PROVIDE    ${name}${depsStr}`);
+		},
+		invoke: (dependencies) => {
+			const depsStr = dependencies.length > 0 ? ` (depends on: ${dependencies.join(", ")})` : "";
+			logg.log(`INVOKE${depsStr}`);
+		},
+		beforeRun: (name) => {
+			logg.log(`BEFORE RUN provide: ${name}()`);
+		},
+		run: (name, duration) => {
+			logg.log(`RUN        provide: ${name}() in ${formatDuration(duration)}`);
+		},
+		hookOnStart: (name) => {
+			logg.log(`HOOK OnStart        ${name}() executing`);
+		},
+		hookOnStartComplete: (name, duration) => {
+			logg.log(`HOOK OnStart        ${name}() ran successfully in ${formatDuration(duration)}`);
+		},
+		hookOnStop: (name) => {
+			logg.log(`HOOK OnStop         ${name}() executing`);
+		},
+		hookOnStopComplete: (name, duration) => {
+			logg.log(`HOOK OnStop         ${name}() ran successfully in ${formatDuration(duration)}`);
+		},
+		running: () => {
+			logg.log(`RUNNING`);
+		},
+		warn: (message) => {
+			logg.warn(message);
+		}
+	};
+}
+function createNoopLogger() {
+	return {
+		provide: () => {},
+		invoke: () => {},
+		beforeRun: () => {},
+		run: () => {},
+		hookOnStart: () => {},
+		hookOnStartComplete: () => {},
+		hookOnStop: () => {},
+		hookOnStopComplete: () => {},
+		running: () => {},
+		warn: () => {}
+	};
+}
+// src/helpers/clock.ts
+const systemClock = Object.freeze({
+	now: () => Date.now(),
+	setTimeout: (callback, ms) => {
+		const handle = globalThis.setTimeout(callback, ms);
+		return () => globalThis.clearTimeout(handle);
+	}
+});
+/**
+* Calls `callback` after `ms` milliseconds of `clock`, like `clock.setTimeout`. Returns a function that cancels the call.
+*
+* With `systemClock`, the timer does not keep a Node process alive, as for `AbortSignal.timeout()`. Other clocks get a plain `setTimeout` call.
+*/
+function setWeakTimeout(clock, callback, ms) {
+	if (clock !== systemClock) return clock.setTimeout(callback, ms);
+	const handle = globalThis.setTimeout(callback, ms);
+	if (typeof handle === "object" && handle !== null && typeof handle.unref === "function") handle.unref();
+	return () => globalThis.clearTimeout(handle);
+}
+// src/helpers/abort.ts
+/** The reason of a timeout signal: a `DOMException` with the name `TimeoutError`, as for `AbortSignal.timeout()`. */
+function timeoutReason(message) {
+	return new DOMException(message, "TimeoutError");
+}
+/** Returns `true` when `reason` names itself a timeout: `reason.name === 'TimeoutError'`. The reason of `AbortSignal.timeout()` and of `timeout()` passes. */
+function isTimeoutReason(reason) {
+	return typeof reason === "object" && reason !== null && reason.name === "TimeoutError";
+}
+/** The rejection of a wait for a state that `reason` aborted: `wait-timeout` with the reason as `cause` for a timeout reason, else the reason itself. */
+function waitAbortError(reason, message) {
+	return isTimeoutReason(reason) ? new WaitTimeoutError(message, { cause: reason }) : reason;
+}
+/**
+* Aborts `controller` when one of `sources` aborts, with the reason of that source.
+* Returns a function that removes the listeners. The listeners also go when the first source aborts.
+*/
+function forwardAbort(controller, sources) {
+	const listeners = [];
+	const release = () => {
+		for (const [source, listener] of listeners.splice(0)) source.removeEventListener("abort", listener);
+	};
+	for (const source of sources) {
+		if (source.aborted) {
+			release();
+			controller.abort(source.reason);
+			return release;
+		}
+		const listener = () => {
+			release();
+			controller.abort(source.reason);
+		};
+		source.addEventListener("abort", listener, { once: true });
+		listeners.push([source, listener]);
+	}
+	return release;
+}
+/** The signals that each combined signal of `anySignal` comes from. A derived signal keeps the origin of its sources. */
+const parents = /* @__PURE__ */ new WeakMap();
+/**
+* Returns a signal that aborts when one of `signals` aborts, with the reason of the first one. `undefined` entries are skipped.
+*
+* It uses `AbortSignal.any` when the runtime has it. Otherwise it forwards the abort, and removes its listeners from all signals when it aborts.
+*/
+function anySignal(...signals) {
+	const sources = signals.filter((signal) => signal !== void 0);
+	if (sources.length === 1) return sources[0];
+	let signal;
+	if (typeof AbortSignal.any === "function") signal = AbortSignal.any(sources);
+	else {
+		const controller = new AbortController();
+		forwardAbort(controller, sources);
+		signal = controller.signal;
+	}
+	parents.set(signal, sources);
+	return signal;
+}
+/** Lists `signal` and each signal that it comes from through `anySignal`, `withTimeout` included, nearest first. */
+function signalSources(signal) {
+	const seen = /* @__PURE__ */ new Set([signal]);
+	const queue = [signal];
+	for (let index = 0; index < queue.length; index++) for (const parent of parents.get(queue[index]) ?? []) if (!seen.has(parent)) {
+		seen.add(parent);
+		queue.push(parent);
+	}
+	return queue;
+}
+/**
+* Creates a signal that aborts after `ms` milliseconds of `clock`, with the result of `reason`.
+*
+* With `weak` and the system clock, the timer does not keep a Node process alive, as for `AbortSignal.timeout()`.
+*/
+function timeoutSignal(clock, ms, reason, weak = false) {
+	const controller = new AbortController();
+	const abort = () => untracked(() => controller.abort(reason()));
+	const cancel = weak ? setWeakTimeout(clock, abort, ms) : clock.setTimeout(abort, ms);
+	return {
+		signal: controller.signal,
+		cancel
+	};
+}
+/** Reads and checks the `signal` option of `options` once. `action` names the call in errors. */
+function readSignal(options, action) {
+	let signal;
+	try {
+		signal = options?.signal;
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the ${action} options.`, { cause: error });
+	}
+	if (signal !== void 0 && !(signal instanceof AbortSignal)) throw new InvalidArgumentError(`The signal option of ${action} must be an AbortSignal.`);
+	return signal;
+}
+/** Calls `callback` with the reason when `signal` aborts. Returns a function that removes the listener. The callback is an entry point, so it runs untracked. */
+function onAbort(signal, callback) {
+	if (!signal) return () => {};
+	const listener = () => untracked(() => callback(signal.reason));
+	signal.addEventListener("abort", listener, { once: true });
+	return () => signal.removeEventListener("abort", listener);
+}
+/**
+* Waits for `promise` until `signal` aborts. At the abort, it rejects with the result of `reasonOf`, and nothing waits for `promise` any more.
+*
+* A rejection of `promise` after the abort is not reported. The listener goes when the wait settles.
+*/
+function abortable(promise, signal, reasonOf = (reason) => reason) {
+	if (!signal) return promise;
+	if (signal.aborted) {
+		promise.catch(() => {});
+		return Promise.reject(reasonOf(signal.reason));
+	}
+	return new Promise((resolve, reject) => {
+		const remove = onAbort(signal, (reason) => {
+			promise.catch(() => {});
+			reject(reasonOf(reason));
+		});
+		promise.then((value) => {
+			remove();
+			resolve(value);
+		}, (error) => {
+			remove();
+			reject(error);
+		});
+	});
+}
+/**
+* Waits for `promise` until `signal` aborts. An aborted signal gives `aborted` at once.
+*
+* A rejection of `promise` before the abort rejects the result. After the abort, nothing waits for `promise`, and its rejection is not reported.
+*/
+function raceAbort(promise, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			promise.catch(() => {});
+			resolve({ kind: "aborted" });
+			return;
+		}
+		const remove = onAbort(signal, () => {
+			promise.catch(() => {});
+			resolve({ kind: "aborted" });
+		});
+		promise.then((value) => {
+			remove();
+			resolve({
+				kind: "settled",
+				value
+			});
+		}, (error) => {
+			remove();
+			reject(error);
+		});
+	});
+}
+// src/helpers/cleanup-context.ts
+function activeIn(frame, owner) {
+	for (let current = frame; current; current = current.parent) if (current.active && current.owner === owner) return true;
+	return false;
+}
+function createSynchronousContext() {
+	let currentFrame;
+	return {
+		current: () => currentFrame,
+		run: (frame, fn) => {
+			const previous = currentFrame;
+			currentFrame = frame;
+			try {
+				return fn();
+			} finally {
+				currentFrame = previous;
+			}
+		},
+		isActive: (owner) => activeIn(currentFrame, owner)
+	};
+}
+function createCleanupContext() {
+	return createSynchronousContext();
+}
+// src/helpers/delivery-queue.ts
+function createDeliveryQueue() {
+	const queue = [];
+	let draining = false;
+	function deliver(deliveries) {
+		queue.push(...deliveries);
+		if (draining) return;
+		draining = true;
+		try {
+			while (queue.length > 0) {
+				const { run, onError } = queue.shift();
+				untracked(() => {
+					try {
+						run();
+					} catch (error) {
+						onError(error);
+					}
+				});
+			}
+		} finally {
+			draining = false;
+		}
+	}
+	return { deliver };
+}
+// src/reconciler/build-context.ts
+const serviceHooks = /* @__PURE__ */ new Set([
+	"start",
+	"stop",
+	"dependency-change",
+	"dependency-status-change"
+]);
+const statuses = /* @__PURE__ */ new Set([
+	"ready",
+	"degraded",
+	"unavailable"
+]);
+/** A cause chain longer than this is cut. It protects against a cyclic cause object. */
+const maxCauseDepth = 32;
+function readOwner$1(value) {
+	try {
+		const copy = structuredClone(value);
+		if (typeof copy === "object" && copy !== null && !Array.isArray(copy)) return Object.freeze(copy);
+	} catch (error) {
+		throw new InvalidArgumentError("The owner of a status cause must be a serializable record.", { cause: error });
+	}
+	throw new InvalidArgumentError("The owner of a status cause must be a serializable record.");
+}
+function readStatusValue(value, what) {
+	if (typeof value !== "string" || !statuses.has(value)) throw new InvalidArgumentError(`${what} must be 'ready', 'degraded', or 'unavailable'. Got ${String(value)}.`);
+	return value;
+}
+function readReason(value, what) {
+	if (value !== void 0 && typeof value !== "string") throw new InvalidArgumentError(`${what} must be a string.`);
+	return value;
+}
+/** Reads a caller-owned cause chain once, into frozen records. */
+function readCause(value, depth = 0) {
+	if (value === void 0 || depth >= maxCauseDepth) return void 0;
+	if (typeof value !== "object" || value === null) throw new InvalidArgumentError("A status cause must be an object with key, owner, and status.");
+	let fields;
+	try {
+		const source = value;
+		fields = {
+			key: source.key,
+			owner: source.owner,
+			status: source.status,
+			reason: source.reason,
+			cause: source.cause
+		};
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the status cause.", { cause: error });
+	}
+	if (typeof fields.key !== "string" || fields.key.length === 0) throw new InvalidArgumentError("The key of a status cause must be a non-empty string.");
+	const reason = readReason(fields.reason, "The reason of a status cause");
+	const cause = readCause(fields.cause, depth + 1);
+	return Object.freeze({
+		key: fields.key,
+		owner: readOwner$1(fields.owner ?? {}),
+		status: readStatusValue(fields.status, "The status of a status cause"),
+		...withoutUndefined({
+			reason,
+			cause
+		})
+	});
+}
+/** Reads the arguments of `setStatus` once. */
+function readOwnStatus(service, status, reasonOrOptions) {
+	const checked = readStatusValue(status, `The status of '${service.name}'`);
+	if (reasonOrOptions === void 0 || typeof reasonOrOptions === "string") return Object.freeze({
+		status: checked,
+		...withoutUndefined({ reason: reasonOrOptions })
+	});
+	if (typeof reasonOrOptions !== "object" || reasonOrOptions === null) throw new InvalidArgumentError(`The second argument of setStatus for '${service.name}' must be a string or an object.`);
+	let fields;
+	try {
+		const options = reasonOrOptions;
+		fields = {
+			reason: options.reason,
+			cause: options.cause
+		};
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the setStatus options of '${service.name}'.`, { cause: error });
+	}
+	const reason = readReason(fields.reason, `The setStatus reason of '${service.name}'`);
+	const cause = readCause(fields.cause);
+	return Object.freeze({
+		status: checked,
+		...withoutUndefined({
+			reason,
+			cause
+		})
+	});
+}
+/** Creates the context that `build` gets. `on` is valid only while the build runs. `setStatus` stays valid after it. */
+function createBuildContext(service, instance) {
+	const dependsOn = {};
+	for (const edge of service.edges) {
+		const binding = instance.bindings.get(edge.name);
+		const state = instance.handled.get(edge.name);
+		dependsOn[edge.name] = edge.optional ? binding && state ? Object.freeze({
+			value: binding.value,
+			status: state.status
+		}) : void 0 : binding?.value;
+	}
+	return Object.freeze({
+		container: service.container.api,
+		name: service.name,
+		instanceId: instance.id,
+		...withoutUndefined({ consumer: service.consumer }),
+		dependsOn: Object.freeze(dependsOn),
+		on: (hook, handler) => {
+			if (!instance.building) throw new HookOutsideBuildError(`'on' was called for '${service.name}' after its build settled.`);
+			if (typeof hook !== "string" || !serviceHooks.has(hook)) throw new InvalidArgumentError(`'${String(hook)}' is not a service hook.`);
+			if (typeof handler !== "function") throw new InvalidArgumentError(`The '${hook}' handler of '${service.name}' is not a function.`);
+			instance.hooks[hook].push(handler);
+		},
+		effect: (setup) => {
+			if (instance.disposed) throw new BuildAfterDisposeError(`'effect' was called for '${service.name}' after its instance was disposed.`);
+			if (typeof setup !== "function") throw new InvalidArgumentError(`The effect setup of '${service.name}' is not a function.`);
+			const disposer = untracked(setup);
+			if (typeof disposer === "function") instance.effects.push(disposer);
+		},
+		signal: instance.controller.signal,
+		setStatus: (status, reasonOrOptions) => untracked(() => {
+			const next = readOwnStatus(service, status, reasonOrOptions);
+			if (instance.disposed) {
+				emitRecord(service.container, {
+					type: "ignored",
+					call: "setStatus",
+					key: service.name,
+					owner: service.container.owner,
+					instanceId: instance.id,
+					reason: `setStatus('${next.status}') was called after the instance was disposed.`
+				});
+				return;
+			}
+			if (!sameStatus(instance.signals.own(), next)) instance.signals.own(next);
+		})
+	});
+}
+// src/reconciler/calls.ts
+/** Calls a user callback with tracking paused. A synchronous throw becomes a rejection. */
+function invokeUser(fn) {
+	try {
+		return Promise.resolve(untracked(fn));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+/** The logger of the lifecycle trace of `container`, or `undefined` when its `logging` option is off. `warn` does not use it. */
+function traceLoggerOf(container) {
+	return container.logging ? container.logger : void 0;
+}
+/** Only services with a key write the lifecycle trace. Invocations and resolvers do not. */
+function loggerOf(service) {
+	return service.kind === "service" ? traceLoggerOf(service.container.api) : void 0;
+}
+function callListeners(listeners, ...args) {
+	for (const listener of [...listeners]) try {
+		listener(...args);
+	} catch (error) {
+		queueMicrotask(() => {
+			throw error;
+		});
+	}
+}
+// src/reconciler/demand.ts
+/**
+* An active service makes the providers of its edges converge too, before `start()`. A fallback edge demands each candidate.
+* A `perConsumer` registration gets a service for the scope of `service`. The nearest registration of each key is demanded.
+*
+* A pending service demands its providers before it builds. A running service demands them too, so that an optional or a fallback edge to a key that registers later gets its consumer service.
+*/
+function demandProviders(service) {
+	for (const edge of service.edges) for (const keyName of edge.candidates) {
+		const [nearest] = candidatesOf(service.scope, keyName, service).map((registration) => registration.perConsumer ? ensureConsumerService(registration, service.scope, service) : registration);
+		if (nearest && !nearest.signals.serving() && !nearest.signals.demanded()) nearest.signals.demanded(true);
+	}
+}
+// src/reconciler/holds.ts
+function addHolder(provider, holder) {
+	const holders = provider.signals.holders();
+	if (!holders.has(holder)) provider.signals.holders(/* @__PURE__ */ new Set([...holders, holder]));
+}
+function removeHolder(provider, holder) {
+	const holders = provider.signals.holders();
+	if (holders.has(holder)) provider.signals.holders(new Set([...holders].filter((service) => service !== holder)));
+}
+/** Registers `service` as a holder of each bound instance and of each extra hold, and releases the rest. */
+function syncHolds(service, instance) {
+	const wanted = /* @__PURE__ */ new Set([...instance.bindings.values(), ...instance.extraHolds]);
+	for (const provider of [...instance.held]) if (!wanted.has(provider)) {
+		removeHolder(provider, service);
+		instance.held.delete(provider);
+	}
+	for (const provider of wanted) if (!instance.held.has(provider)) {
+		addHolder(provider, service);
+		instance.held.add(provider);
+	}
+}
+function releaseExtraHolds(service, instance) {
+	instance.extraHolds.clear();
+	batch(() => syncHolds(service, instance));
+}
+// src/reconciler/reentry.ts
+/** The instance of each signal that injeca gives to a run: the build signal of an instance, and the signal of each hook run. */
+const signalOrigins = /* @__PURE__ */ new WeakMap();
+/** The service of each cleanup frame of a teardown. */
+const frameServices = /* @__PURE__ */ new WeakMap();
+/** Records that `signal` belongs to the runs of `instance`. A signal from `anySignal` or `withTimeout` on top of it keeps this origin. */
+function recordSignalOrigin(signal, instance) {
+	signalOrigins.set(signal, instance);
+}
+/** Creates the cleanup frame of a teardown of `service`, inside `parent`. The teardown sets `active` to `false` when it ends. */
+function serviceFrame(service, parent) {
+	const frame = {
+		owner: service,
+		parent,
+		active: true
+	};
+	frameServices.set(frame, service);
+	return frame;
+}
+function within(container, ancestor) {
+	for (let current = container; current; current = current.parent) if (current === ancestor) return true;
+	return false;
+}
+/** Finds a cleanup that `covers` names, by the origin of `signal`, then by the synchronous cleanup frames. The instance of a signal counts only while its teardown runs. */
+function findCleanup(context, signal, covers) {
+	if (signal) for (const source of signalSources(signal)) {
+		const instance = signalOrigins.get(source);
+		if (instance && instance.tearingDown && !instance.disposed && covers(instance.service, instance)) return {
+			service: instance.service,
+			instance
+		};
+	}
+	for (let frame = context.current(); frame; frame = frame.parent) {
+		const service = frame.active ? frameServices.get(frame) : void 0;
+		if (service && covers(service, service.signals.instance())) return { service };
+	}
+}
+/**
+* Tells whether the teardown of `instance` is part of a stop that waits for each service that `stops` names.
+* It is when the service of `instance` is such a service, or when `instance` holds an instance of one, directly or through other instances.
+* The teardown of a held instance waits until its holders release it, so it waits for `instance` too.
+*/
+function waitedFor(instance, stops) {
+	const seen = /* @__PURE__ */ new Set([instance]);
+	const queue = [instance];
+	for (let index = 0; index < queue.length; index++) {
+		const current = queue[index];
+		if (stops(current.service)) return true;
+		for (const provider of current.held) if (!seen.has(provider)) {
+			seen.add(provider);
+			queue.push(provider);
+		}
+	}
+	return false;
+}
+/** Finds a cleanup whose teardown the wait for the services that `stops` names includes. */
+function findWaitedCleanup(context, signal, stops) {
+	return findCleanup(context, signal, (service, instance) => stops(service) || instance !== void 0 && waitedFor(instance, stops));
+}
+/**
+* Finds out whether a `stop()` or `dispose()` of `target` comes from a cleanup that the call waits for. Such a call cannot wait, because the wait includes the caller.
+*
+* - The cleanup is of a service of the subtree, or of a container effect of the subtree.
+* - Or the cleanup is of a service outside the subtree that holds a service that the call stops, directly or through other instances. That service waits for its holders.
+*   `dispose()` also withdraws the consumer services of each `perConsumer` registration of the subtree, so they count for it.
+* - With `signal`: the signal, or a signal that it comes from, belongs to such an instance whose teardown runs.
+*   The check uses the instance, not the phase of its service. So the teardown of a successor whose build failed, or of an old instance during a rebuild, counts too.
+* - Without it: the synchronous part of such a teardown makes the call.
+*
+* A call without a signal after an `await` is not found. A configured `stop` timeout ends that cleanup.
+*/
+function findReentry(target, call, signal) {
+	const { context } = target.runtime;
+	const found = findWaitedCleanup(context, signal, call === "dispose" ? (service) => within(service.container, target) || service.template !== void 0 && within(service.template.container, target) : (service) => within(service.container, target));
+	if (found) return found;
+	return context.isActive(target) ? { service: void 0 } : void 0;
+}
+/**
+* Finds out whether a `withdraw()` of `target` comes from a cleanup that the withdrawal waits for: of `target`, of a consumer service of it, or of a service that holds one of them, directly or through other instances.
+* The rules are the same as for `findReentry`.
+*/
+function findWithdrawReentry(target, signal) {
+	return findWaitedCleanup(target.container.runtime.context, signal, (service) => service === target || service.template === target);
+}
+function describeOwner(container) {
+	return JSON.stringify(container.owner);
+}
+const actions = {
+	stop: "stop",
+	dispose: "disposal",
+	withdraw: "withdrawal"
+};
+/**
+* Warns on the logger of `target` and sends a `reentrant-call` record. The call then resolves at once.
+* `subject` names the target of the call. It defaults to the owner of `target`.
+*/
+function reportReentry(target, call, reentry, subject = describeOwner(target)) {
+	const { service } = reentry;
+	const reason = `${service ? `The cleanup of '${service.name}' in ${describeOwner(service.container)}` : `A container effect in ${describeOwner(target)}`} called ${call}() of ${subject}, and the wait includes that cleanup. injeca resolved the call at once. The ${actions[call]} continues.`;
+	target.api.logger.warn(reason);
+	emitRecord(service?.container ?? target, {
+		type: "reentrant-call",
+		key: service?.name ?? "",
+		owner: (service?.container ?? target).owner,
+		instanceId: reentry.instance?.id ?? service?.signals.instance()?.id,
+		call,
+		reason
+	});
+}
+// src/reconciler/snapshot.ts
+/** The current snapshot of all dependencies. */
+function currentSnapshot(service) {
+	const snapshot = /* @__PURE__ */ new Map();
+	for (const edge of service.edges) {
+		const resolution = resolutionOf(service, edge);
+		snapshot.set(edge.name, resolution.kind === "resolved" ? {
+			state: Object.freeze({
+				provider: resolution.provider.name,
+				instanceId: resolution.instance.id,
+				status: resolution.provider.signals.effective()?.status ?? "unavailable"
+			}),
+			instance: resolution.instance
+		} : void 0);
+	}
+	return snapshot;
+}
+/** The difference between the last handled snapshot and `snapshot`. An identity change wins over a status change. */
+function diffSnapshot(service, handled, snapshot) {
+	const changes = [];
+	for (const edge of service.edges) {
+		const from = handled.get(edge.name);
+		const to = snapshot.get(edge.name)?.state;
+		if (from?.instanceId !== to?.instanceId || from && to && from.status !== to.status) changes.push(Object.freeze({
+			key: edge.name,
+			from,
+			to
+		}));
+	}
+	return changes;
+}
+function isIdentityChange(change) {
+	return change.from?.instanceId !== change.to?.instanceId;
+}
+function describeChanges(changes) {
+	return changes.map((change) => `${change.key}: ${change.from ? `${change.from.instanceId}/${change.from.status}` : "-"} -> ${change.to ? `${change.to.instanceId}/${change.to.status}` : "-"}`).join(", ");
+}
+function hookDependsOn(service, snapshot) {
+	const dependsOn = {};
+	for (const edge of service.edges) {
+		const entry = snapshot.get(edge.name);
+		dependsOn[edge.name] = entry ? Object.freeze({
+			...entry.state,
+			value: entry.instance.value
+		}) : void 0;
+	}
+	return Object.freeze(dependsOn);
+}
+/** Marks `snapshot` as handled and moves the bindings to its instances. */
+function acceptSnapshot(service, instance, snapshot) {
+	instance.extraHolds.clear();
+	instance.handled = new Map([...snapshot].map(([name, entry]) => [name, entry?.state]));
+	instance.bindings.clear();
+	for (const [name, entry] of snapshot) if (entry) instance.bindings.set(name, entry.instance);
+	batch(() => syncHolds(service, instance));
+}
+// src/reconciler/hook-run.ts
+function hookStateOf(instance, hook) {
+	let state = instance.hookStates.get(hook);
+	if (!state) {
+		state = {
+			attempt: 1,
+			previous: void 0
+		};
+		instance.hookStates.set(hook, state);
+	}
+	return state;
+}
+/** A requeue keeps the attempt count. Any other decision resets it. */
+function finishRun(instance, hook, decision) {
+	const state = hookStateOf(instance, hook);
+	state.previous = decision;
+	state.attempt = decision.kind === "requeue" ? state.attempt + 1 : 1;
+}
+function recordDecision(service, instance, decision, ignored) {
+	emitRecord(service.container, {
+		type: "decision",
+		key: service.name,
+		owner: service.container.owner,
+		instanceId: instance.id,
+		hook: decision.hook,
+		decision: decision.kind,
+		attempt: decision.attempt,
+		ignored,
+		...withoutUndefined({ reason: decision.reason })
+	});
+}
+/**
+* Reports a failure of a callback that injeca stopped waiting for, after a timeout or a newer target. Nothing else gets the error, so injeca writes it with `logger.warn`.
+*
+* A failure with the reason of one of `signals` is not reported, because the callback only followed its abort.
+*/
+function reportLateFailure(service, source, error, signals) {
+	if (signals.some((signal) => signal?.aborted && signal.reason === error)) return;
+	const callback = source === "effect" ? `An effect disposer of '${service.name}'` : `The '${source}' hook of '${service.name}'`;
+	service.container.api.logger.warn(`${callback} failed after injeca stopped waiting for it: ${messageOf(error)}`);
+}
+/** Records the late decision of a hook run that injeca stopped waiting for. A late `fail` is reported with `reportLateFailure`. */
+function recordLateDecision(service, instance, decision, signals) {
+	recordDecision(service, instance, decision, true);
+	if (decision.kind === "fail") reportLateFailure(service, decision.hook, decision.error, signals);
+}
+/**
+* Starts a hook run. Its signal aborts when a newer target supersedes it, when the instance is disposed, or when `timeout` aborts.
+* The signal has the reason of the first one. `end` removes the listeners.
+*/
+function beginHookRun(instance, timeout) {
+	const controller = new AbortController();
+	const release = forwardAbort(controller, timeout ? [instance.controller.signal, timeout] : [instance.controller.signal]);
+	recordSignalOrigin(controller.signal, instance);
+	instance.hookRun = controller;
+	return {
+		signal: controller.signal,
+		end: () => {
+			release();
+			if (instance.hookRun === controller) instance.hookRun = void 0;
+		}
+	};
+}
+/** Calls one handler with a new hook context. A throw becomes `fail`. A value that is not a decision counts as `undefined`. A decision from another run, or of a kind that the hook does not accept, becomes `fail` with `invalid-decision`. */
+async function callHandler(service, instance, hook, handler, runSignal, extras, call = invokeUser) {
+	const state = hookStateOf(instance, hook);
+	const run = {
+		service: service.name,
+		instanceId: instance.id,
+		hook,
+		attempt: state.attempt,
+		now: () => service.container.runtime.clock.now()
+	};
+	const hookContext = Object.freeze({
+		decide: createDecide(run),
+		attempt: run.attempt,
+		previous: state.previous,
+		signal: runSignal,
+		...extras
+	});
+	try {
+		const value = await call(() => handler(hookContext));
+		return validateDecision(run, value) ?? defaultDecision(run);
+	} catch (error) {
+		return createDecide(run).fail(error);
+	}
+}
+/** Runs the handlers of `hook` in order. It stops at the first decision that is not `handled`, unless `all` is set. */
+async function runHandlers(service, instance, hook, runSignal, extras, options = {}) {
+	const decisions = [];
+	const handlers = [...instance.hooks[hook]];
+	for (let index = options.from ?? 0; index < handlers.length; index++) {
+		if (options.stopped?.()) break;
+		if (options.progress) options.progress.index = index;
+		const decision = await callHandler(service, instance, hook, handlers[index], runSignal, extras);
+		decisions.push(decision);
+		if (!options.all && decision.kind !== "handled") break;
+	}
+	return decisions;
+}
+/**
+* Records a timeout of a `start` or `stop` hook in the observe stream, and returns the decision of the `onTimeout` handler.
+*
+* The handler runs synchronously. For `start`, a value that is not a decision of this hook, a promise, or no handler gives `fail` with `hook-timeout`.
+* For `stop`, they give `handled` with the timeout as the reason, so that the stop continues and its callers do not fail. A throw gives `fail` for both hooks.
+*/
+function decideTimeout(service, instance, hook, timeoutMs) {
+	const state = hookStateOf(instance, hook);
+	const run = {
+		service: service.name,
+		instanceId: instance.id,
+		hook,
+		attempt: state.attempt,
+		now: () => service.container.runtime.clock.now()
+	};
+	const decide = createDecide(run);
+	const error = new HookTimeoutError(`The '${hook}' hook of '${service.name}' did not settle within ${timeoutMs}ms.`, hook, timeoutMs);
+	emitRecord(service.container, {
+		type: "timeout",
+		key: service.name,
+		owner: service.container.owner,
+		instanceId: instance.id,
+		hook,
+		timeoutMs,
+		attempt: state.attempt,
+		reason: error.message
+	});
+	const fallback = () => hook === "stop" ? decide.handled({ reason: error.message }) : decide.fail(error, { reason: error.message });
+	const handler = timeoutHandlerOf(service);
+	if (!handler) return fallback();
+	try {
+		const value = untracked(() => handler(Object.freeze({
+			hook,
+			timeoutMs,
+			attempt: state.attempt,
+			previous: state.previous,
+			decide
+		})));
+		return validateDecision(run, value) ?? fallback();
+	} catch (handlerError) {
+		return decide.fail(handlerError, { reason: `The onTimeout handler of '${service.name}' threw.` });
+	}
+}
+// src/reconciler/requeue.ts
+/**
+* The delay of a requeue in milliseconds.
+*
+* `after` is a fixed delay. An exponential backoff doubles `initial` for each attempt, up to `max`.
+* `jitter` is a fraction from 0 to 1. It takes a random part of that size away from the delay, so the delay is between `delay * (1 - jitter)` and `delay`.
+*/
+function requeueDelay(decision, random) {
+	if (decision.after !== void 0) return Math.max(0, decision.after);
+	if (decision.backoff) {
+		const { initial, max, jitter } = decision.backoff;
+		const delay = Math.max(0, Math.min(max, initial * 2 ** (decision.attempt - 1)));
+		if (jitter === void 0) return delay;
+		return delay * (1 - Math.min(1, Math.max(0, jitter)) * random());
+	}
+	return 0;
+}
+/**
+* The stop intent of a requeue that reached its attempt limit. The service stops, then goes to `failed` with the last reason.
+* The limit comes from the decision, then the service, then the containers. It is `undefined` when the requeue can wait.
+*/
+function exhaustedIntent(service, decision) {
+	const maxAttempts = maxAttemptsOf(service, decision.maxAttempts);
+	if (maxAttempts === void 0 || decision.attempt < maxAttempts) return void 0;
+	const message = decision.reason ?? `The '${decision.hook}' hook of '${service.name}' reached maxAttempts (${maxAttempts}).`;
+	return {
+		failure: { error: new Error(message, { cause: decision }) },
+		reason: message,
+		decision: "requeue"
+	};
+}
+/** Waits before the next run of a requeued hook. When the wait ends, the service goes back to the work queue. */
+function scheduleRequeue(service, instance, decision) {
+	const { clock, random, reconciler } = service.container.runtime;
+	const wait = { cancel: () => {} };
+	wait.cancel = clock.setTimeout(() => {
+		if (instance.requeueWait !== wait) return;
+		instance.requeueWait = void 0;
+		reconciler.markDirty(service);
+	}, requeueDelay(decision, random));
+	instance.requeueWait = wait;
+}
+function cancelRequeueWait(instance) {
+	instance.requeueWait?.cancel();
+	instance.requeueWait = void 0;
+}
+// src/reconciler/stop.ts
+function mergeIntent(current, next) {
+	if (current.failure) return current;
+	if (next.failure) return next;
+	return {
+		parkEpoch: next.parkEpoch ?? current.parkEpoch,
+		reason: next.reason ?? current.reason,
+		decision: next.decision ?? current.decision
+	};
+}
+function enterStopping(service, intent) {
+	service.stopIntent = mergeIntent(service.stopIntent, intent);
+	setPhase(service, "stopping", {
+		reason: service.stopIntent.reason,
+		decision: service.stopIntent.decision
+	});
+	service.container.runtime.reconciler.markDirty(service);
+}
+function reconcileStopping(service) {
+	const instance = service.signals.instance();
+	if (!instance) {
+		settleAfterStop(service, []);
+		return;
+	}
+	if (instance.signals.holders().size > 0) return;
+	teardown(service, instance, true);
+}
+/** The warning of a `stop` timeout. During a stop or a disposal of the container, it tells the most common cause. */
+function stopTimeoutWarning(service, timeoutMs) {
+	const warning = `The cleanups of '${service.name}' did not settle within the stop timeout of ${timeoutMs}ms. injeca stopped waiting for them, and the stop continues.`;
+	const { container } = service;
+	const action = container.state === "disposing" ? "disposing" : container.signals.started() ? void 0 : "stopping";
+	if (!action) return warning;
+	return `${warning} The container is ${action}. A cleanup can be waiting for its own container. It must pass its signal to stop() or dispose().`;
+}
+/**
+* Runs the `stop` hooks in reverse order, then the effect disposers in reverse order.
+*
+* A configured `stop` timeout covers all of them. It is a timeout signal on the container clock. The `stop` handlers get it in their `signal`.
+* When it aborts, injeca records it, warns, applies the `onTimeout` decision, and stops waiting. Without `onTimeout`, the timeout counts as `handled`, so the callers of `stop()` and `dispose()` do not fail.
+* The callback in progress is abandoned. The remaining callbacks still run, but injeca does not wait for them. So a cleanup that awaits the disposal of its own container without its signal cannot block that disposal.
+* The late decisions of the abandoned `stop` handlers are recorded as ignored. A late failure of an abandoned callback goes to `logger.warn`, unless it is the abort reason of its signal.
+*/
+async function runTeardownCallbacks(service, instance, stopHooks, frame) {
+	const errors = [];
+	const { clock, context } = service.container.runtime;
+	const call = (fn) => context.run(frame, () => invokeUser(fn));
+	const timeoutMs = timeoutOf(service, "stop");
+	const deadline = timeoutMs === void 0 ? void 0 : timeoutSignal(clock, timeoutMs, () => new HookTimeoutError(`The 'stop' hook of '${service.name}' timed out.`, "stop", timeoutMs));
+	const hookSignal = anySignal(instance.controller.signal, deadline?.signal);
+	let timedOut = false;
+	/**
+	* Waits for one callback until the deadline. `undefined` means that the deadline passed.
+	* After the deadline, `late` gets the value of the callback, and a rejection is reported with `logger.warn`.
+	*/
+	const settle = async (promise, source, late) => {
+		const abandon = () => {
+			promise.then((value) => late?.(value), (error) => reportLateFailure(service, source, error, [hookSignal, instance.controller.signal]));
+		};
+		if (!deadline) return { value: await promise };
+		if (timedOut) return abandon();
+		const result = await raceAbort(promise, deadline.signal);
+		if (result.kind === "settled") return { value: result.value };
+		abandon();
+		timedOut = true;
+		service.container.api.logger.warn(stopTimeoutWarning(service, timeoutMs));
+		const decision = decideTimeout(service, instance, "stop", timeoutMs);
+		recordDecision(service, instance, decision, false);
+		finishRun(instance, "stop", decision);
+		if (decision.kind === "fail") errors.push(decision.error);
+	};
+	if (stopHooks && instance.hooks.stop.length > 0) {
+		const logger = loggerOf(service);
+		logger?.hookOnStop(service.name);
+		const startTime = performance.now();
+		for (const handler of [...instance.hooks.stop].reverse()) {
+			const settled = await settle(callHandler(service, instance, "stop", handler, hookSignal, {}, call), "stop", (late) => recordLateDecision(service, instance, late, [hookSignal, instance.controller.signal]));
+			if (!settled) continue;
+			const decision = settled.value;
+			recordDecision(service, instance, decision, false);
+			finishRun(instance, "stop", decision);
+			if (decision.kind === "fail") errors.push(decision.error);
+		}
+		logger?.hookOnStopComplete(service.name, performance.now() - startTime);
+	}
+	const effects = instance.effects.splice(0).reverse();
+	for (const disposer of effects) try {
+		await settle(call(disposer), "effect");
+	} catch (error) {
+		errors.push(error);
+	}
+	deadline?.cancel();
+	return errors;
+}
+async function teardown(service, instance, stopHooks, phase) {
+	service.busy = true;
+	instance.tearingDown = true;
+	cancelRequeueWait(instance);
+	instance.extraHolds.clear();
+	if (phase) setPhase(service, phase, { reason: service.stopIntent.reason });
+	const frame = serviceFrame(service, service.container.frame);
+	const errors = await service.container.runtime.context.run(frame, () => runTeardownCallbacks(service, instance, stopHooks, frame));
+	frame.active = false;
+	instance.disposed = true;
+	instance.controller.abort(/* @__PURE__ */ new Error(`The instance '${instance.id}' of '${service.name}' was disposed.`));
+	service.busy = false;
+	service.container.runtime.reconciler.notifyTeardown(service, errors);
+	batch(() => {
+		instance.bindings.clear();
+		syncHolds(service, instance);
+		settleAfterStop(service, errors);
+		service.signals.instance(void 0);
+	});
+}
+function settleAfterStop(service, errors) {
+	const intent = service.stopIntent;
+	service.stopIntent = {};
+	const { swap } = service;
+	if (swap) {
+		const failure = intent.failure ?? (errors.length > 0 ? { error: errors[0] } : void 0);
+		service.swap = void 0;
+		if (failure) {
+			service.failure = failure;
+			setPhase(service, "failed", {
+				reason: intent.reason ?? "The replacement failed. The old instance stays.",
+				decision: intent.decision
+			});
+			swap.settle({
+				kind: "failed",
+				error: failure.error
+			});
+		} else swap.settle(service.signals.active() ? { kind: "cancelled" } : { kind: "stopping" });
+		service.signals.present(false);
+		service.teardownErrors.push(...errors);
+		finalize(service);
+		return;
+	}
+	if (!service.signals.present()) {
+		service.teardownErrors.push(...errors);
+		finalize(service);
+		return;
+	}
+	if (intent.failure || errors.length > 0) {
+		service.failure = intent.failure ?? { error: errors[0] };
+		setPhase(service, "failed", {
+			reason: intent.reason,
+			decision: intent.decision
+		});
+		return;
+	}
+	service.parkedEpoch = intent.parkEpoch;
+	setPhase(service, "pending", {
+		reason: intent.reason,
+		decision: intent.decision
+	});
+	service.container.runtime.reconciler.markDirty(service);
+}
+function finalize(service) {
+	const { swap, template } = service;
+	service.swap = void 0;
+	swap?.settle({ kind: "cancelled" });
+	service.disposeEffects();
+	service.container.services.delete(service);
+	batch(() => {
+		removeDeclaration(service);
+		if (template) {
+			const consumers = template.signals.consumers();
+			if (consumers.get(service.container) === service) template.signals.consumers(new Map([...consumers].filter(([, consumer]) => consumer !== service)));
+		}
+		setPhase(service, "withdrawn");
+	});
+	service.withdrawal.resolve([...service.teardownErrors]);
+	if (template) service.container.runtime.reconciler.markDirty(template);
+	service.container.runtime.reconciler.requestDrain();
+}
+// src/reconciler/swap.ts
+/**
+* Creates a new service that replaces `target` after it completes `start`. It is not published before the swap.
+* `target.successor` names it until the replacement ends. It gets the demand of `target`, so that it converges as `target` does.
+*/
+function createSuccessor(target, definition, options) {
+	const outcome = createDeferred();
+	let settled = false;
+	let service;
+	batch(() => {
+		service = createService({
+			container: target.container,
+			kind: "service",
+			name: target.name,
+			edges: definition.edges,
+			build: definition.build,
+			metadata: definition.metadata,
+			policy: definition.policy,
+			exclusive: target.exclusive,
+			exported: target.exported,
+			template: options.template,
+			consumer: target.consumer,
+			registration: target.registration,
+			...options.rebuild ? { seq: target.seq } : {},
+			...options.extra,
+			swap: {
+				target,
+				ready: options.ready,
+				held: false,
+				...options.rebuild ? { rebuild: true } : {},
+				settle: (result) => {
+					if (settled) return;
+					settled = true;
+					if (target.successor === service) target.successor = void 0;
+					options.onSettle(service, result);
+					outcome.resolve(result);
+				}
+			}
+		});
+		service.signals.demanded(target.signals.demanded());
+		service.signals.subscribers(target.signals.subscribers());
+		target.container.services.add(service);
+		target.successor = service;
+	});
+	return {
+		service,
+		outcome: outcome.promise
+	};
+}
+/**
+* Cancels a replacement that cannot complete: the old service was withdrawn, or the container stopped.
+* The new service leaves. The old service does not change.
+*/
+function checkSwap(service) {
+	const { swap } = service;
+	if (!swap || !service.signals.present()) return;
+	if (!swap.target.signals.present()) {
+		swap.settle({ kind: "cancelled" });
+		service.signals.present(false);
+	} else if (!service.signals.active()) {
+		swap.settle({ kind: "stopping" });
+		service.signals.present(false);
+	}
+}
+/**
+* Swaps a new service that completed `start` in for the old one, in one batch.
+*
+* The new service takes the slot and goes to `running`. The old service leaves.
+* It stops and disposes after each holder releases it. Dependents follow the rule for a replaced dependency.
+*/
+function completeSwap(service) {
+	const swap = service.swap;
+	if (!swap) return;
+	const { target } = swap;
+	service.swap = void 0;
+	batch(() => {
+		target.replacedBy = service;
+		publishService(service);
+		target.signals.present(false);
+		setPhase(service, "running", { reason: `The new instance replaced '${target.signals.instance()?.id ?? target.name}'.` });
+	});
+	swap.settle({ kind: "swapped" });
+}
+// src/reconciler/start.ts
+/**
+* Runs the `start` handlers of one attempt, from `instance.startFrom`, within the configured `start` timeout.
+*
+* The run signal includes a timeout signal on the container clock. At the timeout, the run signal aborts with `hook-timeout`, later handlers do not run, and the `onTimeout` decision replaces the result.
+* When a newer target aborts the run, for example `stop()` or `dispose()`, injeca does not wait for the handler in progress. The service stops at once.
+* Late decisions are recorded as ignored.
+*/
+async function runAttempt(service, instance) {
+	const timeoutMs = timeoutOf(service, "start");
+	const timer = timeoutMs === void 0 ? void 0 : timeoutSignal(service.container.runtime.clock, timeoutMs, () => new HookTimeoutError(`The 'start' hook of '${service.name}' timed out.`, "start", timeoutMs));
+	const run = beginHookRun(instance, timer?.signal);
+	const progress = { index: instance.startFrom };
+	let abandoned = false;
+	const running = runHandlers(service, instance, "start", run.signal, {}, {
+		from: instance.startFrom,
+		progress,
+		stopped: () => abandoned
+	});
+	const result = await raceAbort(running, run.signal);
+	timer?.cancel();
+	const timedOut = timer !== void 0 && timer.signal.aborted && run.signal.reason === timer.signal.reason;
+	run.end();
+	instance.startFrom = progress.index;
+	if (result.kind === "settled") return {
+		decisions: result.value,
+		superseded: false
+	};
+	abandoned = true;
+	running.then((late) => {
+		for (const decision of late) recordLateDecision(service, instance, decision, [run.signal]);
+	});
+	if (!timedOut) return {
+		decisions: [],
+		superseded: true
+	};
+	return {
+		decisions: [decideTimeout(service, instance, "start", timeoutMs)],
+		superseded: false
+	};
+}
+/**
+* Runs the `start` hooks of a built instance. The service moves to `running`, waits in `retrying` for a requeue, or stops.
+*
+* A requeue keeps the instance and its bindings. The next attempt runs the requeued handler again, then the later ones. `build` does not run again.
+*/
+async function runStart(service, instance) {
+	service.busy = true;
+	const handlers = instance.hooks.start;
+	const logger = handlers.length > 0 ? loggerOf(service) : void 0;
+	if (instance.startFrom === 0) logger?.hookOnStart(service.name);
+	const startTime = performance.now();
+	const attempt = handlers.length > instance.startFrom ? await runAttempt(service, instance) : {
+		decisions: [],
+		superseded: false
+	};
+	const { decisions } = attempt;
+	service.busy = false;
+	const ignored = attempt.superseded || service.signals.targetLost();
+	for (const decision of decisions) recordDecision(service, instance, decision, ignored);
+	if (ignored) {
+		enterStopping(service, { reason: "A newer target superseded the start." });
+		return;
+	}
+	const decision = decisions.at(-1);
+	if (!decision || decision.kind === "handled") {
+		service.demanders.clear();
+		if (decision) finishRun(instance, "start", decision);
+		logger?.hookOnStartComplete(service.name, performance.now() - startTime);
+		if (service.swap?.ready) {
+			service.swap.held = true;
+			service.swap.ready(service);
+		} else if (service.swap) completeSwap(service);
+		else setPhase(service, "running");
+		return;
+	}
+	finishRun(instance, "start", decision);
+	switch (decision.kind) {
+		case "stop":
+			enterStopping(service, {
+				parkEpoch: epochOf(service, (edge) => instance.bindings.get(edge.name)),
+				reason: decision.reason,
+				decision: "stop"
+			});
+			return;
+		case "fail":
+			enterStopping(service, {
+				failure: { error: decision.error },
+				reason: decision.reason,
+				decision: "fail"
+			});
+			return;
+		case "requeue": {
+			const exhausted = exhaustedIntent(service, decision);
+			if (exhausted) {
+				enterStopping(service, exhausted);
+				return;
+			}
+			setPhase(service, "retrying", {
+				reason: decision.reason,
+				decision: "requeue"
+			});
+			scheduleRequeue(service, instance, decision);
+		}
+	}
+}
+// src/reconciler/build.ts
+/**
+* Tells whether each optional edge has a final answer for a `resolve` call: no provider, a running provider, or a failed one.
+* A service does not wait for optional edges. A `resolve` call does, so that it does not miss a provider that is still starting.
+*/
+function optionalSettled(service) {
+	return service.edges.every((edge) => {
+		if (!edge.optional) return true;
+		const resolution = resolutionOf(service, edge);
+		return resolution.kind !== "not-running" || resolution.provider.signals.phase() === "failed";
+	});
+}
+/** Builds a pending service when it is active and its required dependencies are available. An absent one is withdrawn. */
+function reconcilePending(service) {
+	if (!service.signals.present()) {
+		finalize(service);
+		return;
+	}
+	if (inConflict(service)) {
+		setPhase(service, "conflict", { reason: `The exclusive key '${service.name}' has more than one declaration.` });
+		return;
+	}
+	if (!service.signals.active()) return;
+	demandProviders(service);
+	if (!requiredAvailable(service) || service.kind === "resolver" && !optionalSettled(service)) return;
+	if (service.parkedEpoch !== void 0) {
+		if (epochOf(service, (edge) => resolvedInstance(service, edge)) === service.parkedEpoch) return;
+		service.parkedEpoch = void 0;
+	}
+	beginBuild(service);
+}
+function beginBuild(service) {
+	const instance = prepareInstance(service, currentSnapshot(service));
+	runBuild(service, instance).then((result) => completeBuild(service, instance, result));
+}
+/** Creates the instance of a build from a snapshot of its dependencies, and moves the service to `building`. The service holds each bound provider. */
+function prepareInstance(service, snapshot) {
+	const bindings = /* @__PURE__ */ new Map();
+	const handled = /* @__PURE__ */ new Map();
+	for (const [name, entry] of snapshot) {
+		handled.set(name, entry?.state);
+		if (entry) bindings.set(name, entry.instance);
+	}
+	const instance = {
+		id: service.container.runtime.nextInstanceId(),
+		service,
+		bindings,
+		extraHolds: /* @__PURE__ */ new Set(),
+		held: /* @__PURE__ */ new Set(),
+		hooks: {
+			"start": [],
+			"stop": [],
+			"dependency-change": [],
+			"dependency-status-change": []
+		},
+		hookStates: /* @__PURE__ */ new Map(),
+		handled,
+		effects: [],
+		controller: new AbortController(),
+		signals: {
+			holders: signal(/* @__PURE__ */ new Set()),
+			own: signal(Object.freeze({ status: "ready" }))
+		},
+		hookRun: void 0,
+		requeueWait: void 0,
+		startFrom: 0,
+		value: void 0,
+		building: true,
+		tearingDown: false,
+		disposed: false
+	};
+	recordSignalOrigin(instance.controller.signal, instance);
+	service.busy = true;
+	batch(() => {
+		syncHolds(service, instance);
+		service.signals.instance(instance);
+		setPhase(service, "building");
+	});
+	return instance;
+}
+/** Runs `build` for a prepared instance. It never rejects. */
+function runBuild(service, instance) {
+	const logger = loggerOf(service);
+	logger?.beforeRun(service.name);
+	const startTime = performance.now();
+	const buildContext = createBuildContext(service, instance);
+	return invokeUser(() => service.build(buildContext)).then((value) => {
+		logger?.run(service.name, performance.now() - startTime);
+		return {
+			ok: true,
+			value
+		};
+	}, (error) => ({
+		ok: false,
+		error
+	}));
+}
+function completeBuild(service, instance, result) {
+	instance.building = false;
+	service.busy = false;
+	if (!result.ok) {
+		service.stopIntent = mergeIntent(service.stopIntent, {
+			failure: { error: result.error },
+			reason: "The build failed."
+		});
+		teardown(service, instance, false);
+		return;
+	}
+	if (buildLost(service, instance)) {
+		service.stopIntent = mergeIntent(service.stopIntent, { reason: "The target changed during the build. The result is discarded." });
+		teardown(service, instance, false, "stopping");
+		return;
+	}
+	instance.value = result.value;
+	setPhase(service, "starting");
+	runStart(service, instance);
+}
+// src/reconciler/commit.ts
+/**
+* Orders the members so that each member comes after the members that it depends on.
+* Members in a cycle come last, in registration order. They cannot build in the transaction.
+*/
+function orderMembers(members) {
+	const order = [];
+	const placed = /* @__PURE__ */ new Set();
+	const remaining = [...members.values()];
+	let progress = true;
+	while (progress) {
+		progress = false;
+		for (const member of remaining) {
+			if (placed.has(member)) continue;
+			if (member.edges.every((edge) => edge.candidates.every((keyName) => {
+				const provider = members.get(keyName);
+				return !provider || provider === member || placed.has(provider);
+			}))) {
+				placed.add(member);
+				order.push(member);
+				progress = true;
+			}
+		}
+	}
+	return [...order, ...remaining.filter((member) => !placed.has(member))];
+}
+function memberEntry(member, built) {
+	const instance = built.get(member);
+	if (!instance) return void 0;
+	return {
+		state: Object.freeze({
+			provider: member.name,
+			instanceId: instance.id,
+			status: instance.signals.own().status
+		}),
+		instance
+	};
+}
+/** Resolves one key inside a transaction: a built member first, then the published providers. */
+function resolveInTransaction(service, keyName, edge, members, built) {
+	const member = members.get(keyName);
+	if (member && member !== service) {
+		if (inConflict(member) || !acceptsCandidate(service, edge, keyName, member)) return void 0;
+		return memberEntry(member, built);
+	}
+	const resolution = resolveKey(service, keyName, edge);
+	if (resolution.kind !== "resolved") return void 0;
+	return {
+		state: Object.freeze({
+			provider: resolution.provider.name,
+			instanceId: resolution.instance.id,
+			status: resolution.provider.signals.effective()?.status ?? "unavailable"
+		}),
+		instance: resolution.instance
+	};
+}
+/** The snapshot of a member for its build in the transaction. It is `undefined` when a required dependency is not available. */
+function transactionSnapshot(service, members, built) {
+	const snapshot = /* @__PURE__ */ new Map();
+	for (const edge of service.edges) {
+		const entries = edge.candidates.map((keyName) => resolveInTransaction(service, keyName, edge, members, built));
+		const entry = entries.find((candidate) => candidate !== void 0 && candidate.state.status !== "unavailable") ?? entries.find((candidate) => candidate !== void 0);
+		if (!edge.optional && (!entry || entry.state.status === "unavailable")) return void 0;
+		snapshot.set(edge.name, entry);
+	}
+	return snapshot;
+}
+/**
+* Builds the members of a transaction in `order`. Nothing is published, and no `start` hook runs.
+*
+* A member whose required dependencies are not available, that is not active, or whose key is in conflict, does not build. It goes to `pending` at the publish.
+* The first failed build ends the loop. An abort ends it after the build in progress settles.
+*/
+async function buildMembers(transaction, order, members) {
+	const built = /* @__PURE__ */ new Map();
+	for (const member of order) {
+		if (transaction.state === "aborted") return {
+			kind: "aborted",
+			built
+		};
+		if (member.perConsumer || !member.signals.active() || inConflict(member)) continue;
+		const snapshot = transactionSnapshot(member, members, built);
+		if (!snapshot) continue;
+		const instance = prepareInstance(member, snapshot);
+		transaction.controllers.add(instance.controller);
+		const result = await runBuild(member, instance);
+		transaction.controllers.delete(instance.controller);
+		instance.building = false;
+		built.set(member, instance);
+		if (!result.ok) return {
+			kind: "failed",
+			error: result.error,
+			built
+		};
+		instance.value = result.value;
+	}
+	return transaction.state === "aborted" ? {
+		kind: "aborted",
+		built
+	} : {
+		kind: "built",
+		built
+	};
+}
+/**
+* Removes all members after a failed build or an abort. A built instance runs its effect disposers. No `stop` hook runs, because no `start` hook ran.
+* Resolves when each member is `withdrawn`.
+*/
+async function rollbackMembers(members, built) {
+	for (const member of members.values()) member.signals.present(false);
+	await Promise.all([...members.values()].map((member) => {
+		const instance = built.get(member);
+		if (instance) return teardown(member, instance, false);
+		finalize(member);
+	}));
+}
+/**
+* Runs the `start` hooks of the built members after the publish, in dependency order.
+* A member whose target changed, or whose dependency did not reach `running`, is discarded without its `stop` hooks. It builds again later.
+*/
+async function startMembers(order, built) {
+	for (const member of order) {
+		const instance = built.get(member);
+		if (!instance) continue;
+		if (member.signals.targetLost() || requiredChanged(member, instance)) await teardown(member, instance, false, "stopping");
+		else await runStart(member, instance);
+	}
+}
+/**
+* Aborts a transaction. Before the commit, it drops the transaction. During the commit, it aborts the builds in progress, and the commit rolls back.
+* Resolves when the transaction ended.
+*/
+function abortTransaction(transaction, error) {
+	if (transaction.state === "done" || transaction.state === "aborted") return transaction.settled ?? Promise.resolve();
+	const committing = transaction.state === "committing";
+	transaction.state = "aborted";
+	transaction.abortError = error;
+	for (const controller of transaction.controllers) controller.abort(error);
+	if (!committing) {
+		transaction.container.transactions.delete(transaction);
+		transaction.settled = Promise.resolve();
+		releaseReservations(transaction);
+	}
+	return transaction.settled ?? Promise.resolve();
+}
+// src/reconciler/conflict.ts
+/** A service in `conflict` runs no code. It goes back to `pending` when only one declaration remains. */
+function reconcileConflict(service) {
+	if (!service.signals.present()) {
+		finalize(service);
+		return;
+	}
+	if (inConflict(service)) return;
+	setPhase(service, "pending", { reason: `Only one declaration of the exclusive key '${service.name}' remains.` });
+	service.container.runtime.reconciler.markDirty(service);
+}
+// src/reconciler/rebuild.ts
+/**
+* Tells whether the old instance of a running service can keep serving while its successor builds and starts.
+*
+* - Only a service with a key rebuilds make-before-break. An invocation has no dependents, so it stops, then runs again.
+* - Each edge that the old instance is bound to still resolves, maybe to a new instance. An edge without a provider has nothing to build against, so the service stops first.
+* - The container is not in disposal.
+*
+* A bound provider instance stays usable until its last holder releases it, so the old instance keeps working with its bindings.
+*/
+function keepsServing(service, instance) {
+	if (service.kind !== "service" || service.container.state !== "active") return false;
+	return service.edges.every((edge) => !instance.bindings.has(edge.name) || resolvedInstance(service, edge) !== void 0);
+}
+/**
+* Rebuilds a running service, for a changed dependency without a handler, or for a `rebuild` decision.
+*
+* When the old instance can keep serving, the rebuild is make-before-break: a successor with the same options builds and starts against the current dependencies.
+* The old instance serves until the successor completes `start`. Then one batch swaps them, as for `replace()`. The dependents get `dependency-change`, not a withdrawal.
+* If the successor fails, the old instance stops and the service goes to `failed`.
+* Otherwise the service stops first and builds again from `pending`.
+*
+* A replacement in progress, from `replace()` or a transaction, takes precedence. The old instance serves until it ends, and the service reconciles again then.
+*/
+function rebuild(service, instance, intent) {
+	if (service.successor) return;
+	if (!keepsServing(service, instance)) {
+		enterStopping(service, intent);
+		return;
+	}
+	const { registration } = service;
+	const { service: successor } = createSuccessor(service, service, {
+		template: service.template,
+		rebuild: true,
+		onSettle: (next, outcome) => {
+			if (registration?.pending === next) registration.pending = void 0;
+			if (outcome.kind === "swapped" && registration) registration.current = next;
+			if (outcome.kind === "swapped" && service.signals.phase() === "running") enterStopping(service, intent);
+			if (outcome.kind === "failed" && service.signals.present()) enterStopping(service, {
+				failure: { error: outcome.error },
+				reason: "The rebuild failed. The old instance stops.",
+				decision: intent.decision
+			});
+			service.container.runtime.reconciler.markDirty(service);
+		}
+	});
+	if (registration) registration.pending = successor;
+}
+// src/reconciler/dependency-hooks.ts
+/** Handles a running service: it stops it, or it runs a dependency hook for the changes since the last handled snapshot. */
+function reconcileRunning(service) {
+	const instance = service.signals.instance();
+	if (!instance) {
+		enterStopping(service, {});
+		return;
+	}
+	if (!service.signals.present() || !service.signals.active()) {
+		cancelRequeueWait(instance);
+		enterStopping(service, { reason: service.signals.present() ? "The container stopped." : service.replacedBy ? "The service was replaced." : "The service was withdrawn." });
+		return;
+	}
+	if (inConflict(service)) {
+		cancelRequeueWait(instance);
+		enterStopping(service, { reason: `The exclusive key '${service.name}' got another declaration.` });
+		return;
+	}
+	demandProviders(service);
+	const snapshot = currentSnapshot(service);
+	if (requiredWithdrawn(service)) {
+		cancelRequeueWait(instance);
+		if (instance.hooks["dependency-change"].length > 0) runNotice(service, instance, snapshot);
+		else enterStopping(service, { reason: "A required dependency was withdrawn." });
+		return;
+	}
+	if (service.successor?.swap?.rebuild) return;
+	const changes = diffSnapshot(service, instance.handled, snapshot);
+	if (changes.length === 0 || instance.requeueWait) return;
+	const identity = changes.some(isIdentityChange);
+	const hook = identity ? "dependency-change" : "dependency-status-change";
+	if (instance.hooks[hook].length === 0) {
+		if (identity) rebuild(service, instance, {
+			reason: `A dependency changed without a handler: ${describeChanges(changes)}.`,
+			decision: "rebuild"
+		});
+		else acceptSnapshot(service, instance, snapshot);
+		return;
+	}
+	runDependencyHook(service, instance, hook, snapshot, changes);
+}
+/** Calls `dependency-change` as a notice before the service stops for a withdrawn required dependency. The decisions are ignored. */
+async function runNotice(service, instance, snapshot) {
+	service.busy = true;
+	const changes = diffSnapshot(service, instance.handled, snapshot);
+	const view = new Map(snapshot);
+	for (const [name, binding] of instance.bindings) if (!view.get(name)) view.set(name, {
+		state: Object.freeze({
+			provider: binding.service.name,
+			instanceId: binding.id,
+			status: "unavailable"
+		}),
+		instance: binding
+	});
+	const decisions = await runHandlers(service, instance, "dependency-change", instance.controller.signal, {
+		dependsOn: hookDependsOn(service, view),
+		changes: Object.freeze(changes)
+	}, { all: true });
+	service.busy = false;
+	for (const decision of decisions) recordDecision(service, instance, decision, true);
+	enterStopping(service, { reason: `A required dependency was withdrawn: ${describeChanges(changes)}.` });
+}
+async function runDependencyHook(service, instance, hook, snapshot, changes) {
+	service.busy = true;
+	for (const entry of snapshot.values()) if (entry) instance.extraHolds.add(entry.instance);
+	batch(() => syncHolds(service, instance));
+	const run = beginHookRun(instance);
+	const decisions = await runHandlers(service, instance, hook, run.signal, {
+		dependsOn: hookDependsOn(service, snapshot),
+		changes: Object.freeze([...changes])
+	});
+	run.end();
+	service.busy = false;
+	const ignored = service.signals.targetLost();
+	for (const decision of decisions) recordDecision(service, instance, decision, ignored);
+	if (ignored) {
+		releaseExtraHolds(service, instance);
+		service.container.runtime.reconciler.markDirty(service);
+		return;
+	}
+	const decision = decisions.at(-1);
+	finishRun(instance, hook, decision);
+	switch (decision.kind) {
+		case "handled":
+			acceptSnapshot(service, instance, snapshot);
+			service.container.runtime.reconciler.markDirty(service);
+			return;
+		case "requeue": {
+			releaseExtraHolds(service, instance);
+			const exhausted = exhaustedIntent(service, decision);
+			if (exhausted) enterStopping(service, exhausted);
+			else scheduleRequeue(service, instance, decision);
+			return;
+		}
+		case "rebuild":
+			releaseExtraHolds(service, instance);
+			rebuild(service, instance, {
+				reason: decision.reason,
+				decision: "rebuild"
+			});
+			return;
+		case "stop":
+			releaseExtraHolds(service, instance);
+			enterStopping(service, {
+				parkEpoch: epochOf(service, (edge) => snapshot.get(edge.name)?.instance),
+				reason: decision.reason,
+				decision: "stop"
+			});
+			return;
+		case "fail":
+			releaseExtraHolds(service, instance);
+			enterStopping(service, {
+				failure: { error: decision.error },
+				reason: decision.reason,
+				decision: "fail"
+			});
+	}
+}
+// src/reconciler/registration.ts
+/**
+* Handles a `perConsumer` registration. It never builds. The service of each consumer container builds.
+* A withdrawn registration finalizes after its last consumer service.
+*/
+function reconcileRegistration(service) {
+	const phase = service.signals.phase();
+	if (!service.signals.present()) {
+		if (service.signals.consumers().size === 0) finalize(service);
+		return;
+	}
+	if (phase === "pending" && inConflict(service)) setPhase(service, "conflict", { reason: `The exclusive key '${service.name}' has more than one declaration.` });
+	else if (phase === "conflict" && !inConflict(service)) setPhase(service, "pending", { reason: `Only one declaration of the exclusive key '${service.name}' remains.` });
+}
+// src/reconciler/retry.ts
+function lostReason(service) {
+	if (!service.signals.present()) return service.replacedBy ? "The service was replaced during a start requeue." : "The service was withdrawn during a start requeue.";
+	if (!service.signals.active()) return "The container stopped during a start requeue.";
+	if (requiredWithdrawn(service)) return "A required dependency was withdrawn during a start requeue.";
+	return `The exclusive key '${service.name}' got another declaration during a start requeue.`;
+}
+/**
+* Handles a service in `retrying`: a `start` hook returned `requeue`.
+*
+* Changes during the wait merge into the next attempt. When the wait ends, `start` runs again with the same instance.
+* A requeue cannot keep a service alive. A lost target, for example a withdrawn required dependency, cancels the wait and stops the service at once.
+*/
+function reconcileRetrying(service) {
+	const instance = service.signals.instance();
+	if (!instance) {
+		enterStopping(service, {});
+		return;
+	}
+	if (service.signals.targetLost()) {
+		cancelRequeueWait(instance);
+		enterStopping(service, { reason: lostReason(service) });
+		return;
+	}
+	if (instance.requeueWait) return;
+	setPhase(service, "starting", { reason: "The requeue wait ended." });
+	runStart(service, instance);
+}
+// src/reconciler/reconciler.ts
+/**
+* Creates the execution layer.
+*
+* A work queue holds dirty services, each at most once. The reconciler runs one transition at a time for each service.
+* Each transition reads the latest derived values when it starts and when it ends.
+*/
+function createReconciler(options) {
+	const { context } = options;
+	const queue = /* @__PURE__ */ new Set();
+	const drainedListeners = /* @__PURE__ */ new Set();
+	const teardownListeners = /* @__PURE__ */ new Set();
+	let drainRequested = false;
+	let draining = false;
+	function requestDrain() {
+		if (drainRequested || draining) return;
+		drainRequested = true;
+		queueMicrotask(drain);
+	}
+	function markDirty(service) {
+		queue.add(service);
+		requestDrain();
+	}
+	function drain() {
+		drainRequested = false;
+		untracked(() => context.run(void 0, () => {
+			draining = true;
+			try {
+				for (const service of queue) {
+					queue.delete(service);
+					reconcile(service);
+				}
+			} finally {
+				draining = false;
+				if (queue.size > 0) requestDrain();
+				else callListeners(drainedListeners);
+			}
+		}));
+	}
+	function reconcile(service) {
+		if (service.transaction) return;
+		const phase = service.signals.phase();
+		if (phase === "withdrawn") return;
+		if (service.perConsumer) {
+			reconcileRegistration(service);
+			return;
+		}
+		checkSwap(service);
+		if (service.busy) {
+			const instance = service.signals.instance();
+			if (!instance) return;
+			if (phase === "building") {
+				if (buildLost(service, instance)) instance.controller.abort(/* @__PURE__ */ new Error(`The build of '${service.name}' was superseded.`));
+			} else if (instance.hookRun && service.signals.targetLost()) instance.hookRun.abort(/* @__PURE__ */ new Error(`A newer target superseded the hook run of '${service.name}'.`));
+			return;
+		}
+		switch (phase) {
+			case "pending":
+				reconcilePending(service);
+				return;
+			case "conflict":
+				reconcileConflict(service);
+				return;
+			case "failed":
+				if (!service.signals.present()) finalize(service);
+				return;
+			case "starting":
+				if (service.swap?.held && service.signals.targetLost()) enterStopping(service, { reason: "The replacement was cancelled before the swap." });
+				return;
+			case "running":
+				reconcileRunning(service);
+				return;
+			case "retrying":
+				reconcileRetrying(service);
+				return;
+			case "stopping": reconcileStopping(service);
+		}
+	}
+	return {
+		markDirty,
+		onDrained: (listener) => {
+			drainedListeners.add(listener);
+			return () => drainedListeners.delete(listener);
+		},
+		onTeardown: (listener) => {
+			teardownListeners.add(listener);
+			return () => teardownListeners.delete(listener);
+		},
+		notifyTeardown: (service, errors) => callListeners(teardownListeners, service, errors),
+		requestDrain
+	};
+}
+// src/primitives/container.ts
+function deepFreeze(value) {
+	if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const child of Object.values(value)) deepFreeze(child);
+	}
+	return value;
+}
+function readOwner(owner) {
+	if (owner === void 0) return Object.freeze({});
+	let copy;
+	try {
+		copy = structuredClone(owner);
+	} catch (error) {
+		throw new InvalidArgumentError("The container owner must be a serializable record.", { cause: error });
+	}
+	if (typeof copy !== "object" || copy === null || Array.isArray(copy)) throw new InvalidArgumentError("The container owner must be a serializable record.");
+	return deepFreeze(copy);
+}
+function readIsolated(options) {
+	let isolate;
+	try {
+		isolate = options.isolate;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the isolate option.", { cause: error });
+	}
+	if (isolate === void 0) return /* @__PURE__ */ new Set();
+	if (!Array.isArray(isolate)) throw new InvalidArgumentError("The isolate option must be a list of keys or names.");
+	return new Set(isolate.map((key) => {
+		let name;
+		try {
+			name = normalizeName(key);
+		} catch (error) {
+			throw new InvalidArgumentError("Cannot read a key of the isolate option.", { cause: error });
+		}
+		if (typeof name !== "string" || name.length === 0) throw new InvalidArgumentError("Each entry of the isolate option must be a key or a non-empty name.");
+		return name;
+	}));
+}
+function readContainerPolicy(options) {
+	let fields;
+	try {
+		fields = {
+			maxAttempts: options.maxAttempts,
+			timeouts: options.timeouts,
+			onTimeout: options.onTimeout
+		};
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the container options.", { cause: error });
+	}
+	return readPolicy("the container", fields);
+}
+function readRandom(options) {
+	let random;
+	try {
+		random = options.random;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the random option.", { cause: error });
+	}
+	if (random !== void 0 && typeof random !== "function") throw new InvalidArgumentError("The random option must be a function.");
+	return random ?? Math.random;
+}
+function readLogging(options, parent) {
+	let logging;
+	try {
+		logging = options.logging;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the logging option.", { cause: error });
+	}
+	if (logging !== void 0 && typeof logging !== "boolean") throw new InvalidArgumentError("The logging option must be a boolean.");
+	return logging ?? parent?.api.logging ?? false;
+}
+function createRuntime(options) {
+	let seq = 0;
+	let instanceSeq = 0;
+	const context = createCleanupContext();
+	return {
+		clock: options.clock ?? systemClock,
+		random: readRandom(options),
+		context,
+		deliveries: createDeliveryQueue(),
+		observers: /* @__PURE__ */ new Set(),
+		declarations: /* @__PURE__ */ new Map(),
+		reconciler: createReconciler({ context }),
+		nextSeq: () => ++seq,
+		nextInstanceId: () => `i${++instanceSeq}`
+	};
+}
+/**
+* Creates a container. With `options.parent`, the container is a child of that container.
+*
+* A child container does not start when it is created, even under a started parent. It waits for `start(child)`.
+*/
+function createContainer(options = {}) {
+	const parent = options.parent === void 0 ? void 0 : nodeOf(options.parent);
+	if (parent) assertActive(parent, "create a child container");
+	const owner = readOwner(options.owner);
+	const isolated = readIsolated(options);
+	const policy = readContainerPolicy(options);
+	const logging = readLogging(options, parent);
+	const logger = options.logger ?? parent?.api.logger ?? createDefaultLogger();
+	const runtime = parent?.runtime ?? createRuntime(options);
+	let reactiveOwner;
+	const stopReactive = withOwner(parent?.reactiveOwner, () => effectScope(() => {
+		reactiveOwner = getActiveSub();
+	}));
+	const api = {
+		logger,
+		logging,
+		owner,
+		parent: parent?.api
+	};
+	const node = {
+		seq: runtime.nextSeq(),
+		api,
+		owner,
+		parent,
+		runtime,
+		children: /* @__PURE__ */ new Set(),
+		services: /* @__PURE__ */ new Set(),
+		signals: {
+			started: signal(false),
+			slots: /* @__PURE__ */ new Map(),
+			exports: /* @__PURE__ */ new Map()
+		},
+		isolated,
+		policy,
+		listeners: /* @__PURE__ */ new Map(),
+		transactions: /* @__PURE__ */ new Set(),
+		effects: [],
+		reactiveOwner,
+		stopReactive,
+		enrolled: false,
+		state: "active",
+		frame: void 0,
+		disposal: void 0,
+		disposedListeners: /* @__PURE__ */ new Set()
+	};
+	parent?.children.add(node);
+	registerNode(api, node);
+	return api;
+}
+/**
+* Runs `setup` and stores the returned disposer on the container. `dispose(container)` runs the disposers in reverse order.
+*
+* When the disposal of the container started or ended, the disposer runs at once after `setup`, so that the resource does not leak.
+* A disposer that throws throws to the caller. A disposer promise that rejects is reported outside the call, as an unhandled error.
+*/
+function effect$1(container, setup) {
+	const node = nodeOf(container);
+	if (typeof setup !== "function") throw new InvalidArgumentError("The effect setup is not a function.");
+	const disposer = untracked(setup);
+	if (typeof disposer !== "function") return;
+	if (node.state === "active") {
+		node.effects.push(disposer);
+		return;
+	}
+	const result = untracked(disposer);
+	if (result instanceof Promise) result.catch((error) => queueMicrotask(() => {
+		throw error;
+	}));
+}
+/**
+* Starts the disposal of `container` and of its descendants. The whole subtree enters `disposing` at once, so nothing new registers in it.
+*
+* The child containers dispose first, one after the other, in reverse creation order. Then the services of the container withdraw in one batch, so that dependents stop without a rebuild.
+* Then the effects of the container run in reverse order. `after` delays the work until an earlier sibling completed its disposal.
+*/
+function beginDisposal(container, parentFrame, after) {
+	if (container.disposal) return container.disposal;
+	const { context } = container.runtime;
+	const frame = {
+		owner: container,
+		parent: parentFrame,
+		active: true
+	};
+	container.state = "disposing";
+	container.frame = frame;
+	for (const transaction of [...container.transactions]) abortTransaction(transaction, new BuildAfterDisposeError("The container was disposed before the transaction committed."));
+	let previous = after;
+	const children = [...container.children].reverse().map((child) => {
+		const disposal = beginDisposal(child, frame, previous);
+		disposal.catch(() => {});
+		previous = disposal.then(() => {}, () => {});
+		return disposal;
+	});
+	const withdrawn = /* @__PURE__ */ new Set();
+	const withdrawServices = () => untracked(() => batch(() => {
+		for (const service of container.services) if (service.signals.present()) {
+			releaseService(service);
+			withdrawn.add(service);
+		}
+	}));
+	const immediate = after === void 0 && children.length === 0;
+	if (immediate) withdrawServices();
+	container.disposal = context.run(frame, async () => {
+		const errors = [];
+		if (after) await after;
+		for (const child of children) try {
+			await child;
+		} catch (error) {
+			errors.push(error);
+		}
+		if (!immediate) withdrawServices();
+		for (const service of [...container.services]) {
+			const serviceErrors = await service.withdrawal.promise;
+			if (withdrawn.has(service)) errors.push(...serviceErrors);
+		}
+		for (const disposer of container.effects.splice(0).reverse()) try {
+			await context.run(frame, () => untracked(disposer));
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw errorFrom(errors, "Container disposal failed.");
+	}).finally(() => {
+		frame.active = false;
+		container.state = "disposed";
+		container.listeners.clear();
+		container.stopReactive();
+		container.parent?.children.delete(container);
+		for (const listener of [...container.disposedListeners]) try {
+			listener();
+		} catch (error) {
+			queueMicrotask(() => {
+				throw error;
+			});
+		}
+		container.disposedListeners.clear();
+	});
+	return container.disposal;
+}
+/** The services of `container` and of its descendants that did not finish their withdrawal. */
+function unfinishedServices(container) {
+	return [...[...container.services].filter((service) => service.kind !== "resolver" && service.signals.phase() !== "withdrawn"), ...[...container.children].flatMap(unfinishedServices)];
+}
+/**
+* Withdraws the registrations and invocations of the container, disposes the child containers, and runs the container effects in reverse order.
+*
+* One error keeps its identity. More than one error becomes an `AggregateError`. A second call from outside without a signal gets the same promise.
+*
+* A call from the cleanup chain of the container or of a descendant cannot wait, because the disposal waits for that cleanup.
+* The same is true for a cleanup of a service that holds a service of the subtree, directly or through other instances, or a consumer service of a `perConsumer` registration of it.
+* injeca finds such a call by the signal of the cleanup, or by the synchronous part of the cleanup. It warns, sends a `reentrant-call` record, and resolves at once. The disposal continues.
+*
+* When `options.signal` aborts, the call rejects with the reason and stops waiting. The disposal continues: the container stays in `disposing`, and calls on it fail with `build-after-dispose`.
+* A later `dispose()` waits for the same disposal and gets its result. An aborted signal starts the disposal, then rejects at once.
+*/
+function dispose(container, options) {
+	const node = nodeOf(container);
+	const abortSignal = readSignal(options, "dispose");
+	const { context } = node.runtime;
+	const reentry = untracked(() => findReentry(node, "dispose", abortSignal));
+	const disposal = node.disposal ?? untracked(() => {
+		let started;
+		batch(() => {
+			started = beginDisposal(node, context.current());
+		});
+		return started;
+	});
+	if (reentry) {
+		untracked(() => reportReentry(node, "dispose", reentry));
+		disposal.catch(() => {});
+		return Promise.resolve();
+	}
+	return abortable(disposal, abortSignal, (reason) => {
+		recordAbortedWait(unfinishedServices(node), "dispose", reason);
+		return reason;
+	});
+}
+// src/primitives/withdraw.ts
+/**
+* Runs a `withdraw()` call. `release` releases the service and returns it, or `undefined` when there is nothing to withdraw.
+*
+* - Resolves `true` after the withdrawal, and rejects with the teardown errors.
+* - When `options.signal` aborts, it rejects with the reason and stops waiting. The withdrawal continues. An aborted signal still starts it.
+* - A call from a cleanup that the withdrawal waits for warns, sends a `reentrant-call` record, and resolves `true` at once.
+*/
+function withdrawWith(release, options) {
+	let signal;
+	try {
+		signal = readSignal(options, "withdraw");
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	const service = release();
+	if (!service) return Promise.resolve(false);
+	const withdrawal = awaitWithdrawal(service).then(() => true);
+	const reentry = untracked(() => findWithdrawReentry(service, signal));
+	if (reentry) {
+		untracked(() => reportReentry(service.container, "withdraw", reentry, `'${service.name}' in ${JSON.stringify(service.container.owner)}`));
+		withdrawal.catch(() => {});
+		return Promise.resolve(true);
+	}
+	return abortable(withdrawal, signal, (reason) => {
+		recordAbortedWait(untracked(() => service.signals.phase()) === "withdrawn" ? [] : [service], "withdraw", reason);
+		return reason;
+	});
+}
+/** The `withdraw()` of a registration. Resolves `false` for a stale registration. */
+function withdrawRegistration(registration, options) {
+	return withdrawWith(() => releaseRegistration(registration), options);
+}
+/** The `withdraw()` of an invocation. Resolves `false` when it is already withdrawn. */
+function withdrawInvocation(service, options) {
+	return withdrawWith(() => releasePresent(service) ? service : void 0, options);
+}
+// src/primitives/invoke.ts
+function invoke$1(container, option) {
+	return invokeIn(container, option);
+}
+/** Registers an invocation. The public `invoke` functions call it. */
+function invokeIn(container, option) {
+	const node = nodeOf(container);
+	assertActive(node, "invoke");
+	let callback;
+	let dependsOn;
+	try {
+		const invocationObject = typeof option === "function" ? { callback: option } : option;
+		callback = invocationObject.callback;
+		dependsOn = invocationObject.dependsOn;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the invoke options.", { cause: error });
+	}
+	if (typeof callback !== "function") throw new InvalidArgumentError("The callback option of invoke is not a function.");
+	const name = `invocation:${node.runtime.nextSeq()}`;
+	const edges = readEdges(name, dependsOn);
+	const userCallback = callback;
+	const build = (context) => userCallback(context.dependsOn, Object.freeze({
+		on: context.on,
+		effect: context.effect,
+		signal: context.signal
+	}));
+	const registered = untracked(() => {
+		let service;
+		batch(() => {
+			service = createService({
+				container: node,
+				kind: "invocation",
+				name,
+				edges,
+				build
+			});
+			node.services.add(service);
+		});
+		return service;
+	});
+	traceLoggerOf(container)?.invoke(edges.map((edge) => edge.keyName));
+	return Object.freeze({
+		key: name,
+		withdraw: (options) => withdrawInvocation(registered, options)
+	});
+}
+// src/diagnostics/explain.ts
+/** The owners of conflicting declarations, in container order. The order of the registrations has no effect. */
+function ownersOf(declarations) {
+	return Object.freeze([...declarations].sort((a, b) => a.container.seq - b.container.seq).map((declaration) => declaration.container.owner));
+}
+/** Explains one service from its current resolution data. It is a pure read. */
+function explainService(service) {
+	const blockers = [];
+	const phase = service.signals.phase();
+	if (phase === "failed") blockers.push({
+		kind: "failed",
+		error: service.failure?.error
+	});
+	if (phase === "retrying") {
+		const previous = service.signals.instance()?.hookStates.get("start")?.previous;
+		blockers.push({
+			kind: "retrying",
+			attempt: previous?.attempt ?? 1,
+			...withoutUndefined({ reason: previous?.reason })
+		});
+	}
+	const rivals = service.signals.rivals();
+	if (rivals.length > 0) {
+		const registration = service.template ?? service;
+		blockers.push({
+			kind: "conflict",
+			key: service.name,
+			owners: ownersOf([registration, ...rivals])
+		});
+	}
+	if (!service.signals.active() && !service.perConsumer) blockers.push({ kind: "not-started" });
+	for (const edge of service.edges) {
+		if (edge.optional) continue;
+		const resolution = resolutionOf(service, edge);
+		if (edge.fallback && resolution.kind !== "resolved") {
+			for (const keyName of edge.candidates) {
+				const candidate = resolveKey(service, keyName, edge);
+				if (candidate.kind === "rejected") blockers.push({
+					kind: "rejected-provider",
+					dependency: edge.name,
+					key: candidate.provider.name,
+					owner: candidate.provider.container.owner,
+					metadata: candidate.provider.metadata
+				});
+			}
+			if (resolution.kind === "rejected") continue;
+		}
+		switch (resolution.kind) {
+			case "missing":
+				blockers.push({
+					kind: "missing-provider",
+					dependency: edge.name,
+					key: edge.keyName
+				});
+				continue;
+			case "rejected":
+				blockers.push({
+					kind: "rejected-provider",
+					dependency: edge.name,
+					key: resolution.provider.name,
+					owner: resolution.provider.container.owner,
+					metadata: resolution.provider.metadata
+				});
+				continue;
+			case "conflict":
+				blockers.push({
+					kind: "conflicting-dependency",
+					dependency: edge.name,
+					key: resolution.provider.name,
+					owners: ownersOf([resolution.provider, ...resolution.rivals])
+				});
+				continue;
+			case "resolved": {
+				const status = resolution.provider.signals.effective();
+				if (phase !== "running" && status?.status === "unavailable") blockers.push({
+					kind: "unavailable-dependency",
+					dependency: edge.name,
+					key: resolution.provider.name,
+					cause: causeOf(resolution.provider, status)
+				});
+				continue;
+			}
+			case "not-running": {
+				const providerPhase = resolution.provider.signals.phase();
+				blockers.push(providerPhase === "failed" ? {
+					kind: "failed-dependency",
+					dependency: edge.name,
+					key: edge.keyName,
+					error: resolution.provider.failure?.error
+				} : {
+					kind: "pending-dependency",
+					dependency: edge.name,
+					key: edge.keyName,
+					phase: providerPhase
+				});
+			}
+		}
+	}
+	const status = service.signals.effective();
+	const successor = service.successor;
+	return Object.freeze({
+		name: service.name,
+		kind: service.kind === "invocation" ? "invocation" : "service",
+		owner: service.container.owner,
+		phase,
+		...withoutUndefined({
+			status: status?.status,
+			reason: status?.reason,
+			cause: status?.cause
+		}),
+		blockers: Object.freeze(blockers),
+		...withoutUndefined({ replacement: successor?.signals.present() ? explainService(successor) : void 0 })
+	});
+}
+/** Formats a cause chain, for example `'airi.llm' is unavailable (reason), because 'gateway/store' is unavailable`. */
+function describeCause(cause) {
+	const parts = [];
+	for (let current = cause; current; current = current.cause) parts.push(`'${current.key}' is ${current.status}${current.reason === void 0 ? "" : ` (${current.reason})`}`);
+	return parts.join(", because ");
+}
+function describeOwners(owners) {
+	return owners.map((owner) => JSON.stringify(owner)).join(", ");
+}
+function describeBlocker(blocker) {
+	switch (blocker.kind) {
+		case "missing-provider": return `no provider for '${blocker.key}' (${blocker.dependency})`;
+		case "failed-dependency": return `'${blocker.key}' (${blocker.dependency}) failed`;
+		case "pending-dependency": return `'${blocker.key}' (${blocker.dependency}) is ${blocker.phase}`;
+		case "unavailable-dependency": return `${describeCause(blocker.cause)} (${blocker.dependency})`;
+		case "rejected-provider": return `a resolution condition rejected the provider of '${blocker.key}' from ${JSON.stringify(blocker.owner)} (${blocker.dependency})`;
+		case "conflicting-dependency": return `the exclusive key '${blocker.key}' (${blocker.dependency}) has more than one declaration: ${describeOwners(blocker.owners)}`;
+		case "conflict": return `the exclusive key '${blocker.key}' has more than one declaration: ${describeOwners(blocker.owners)}`;
+		case "failed": return "the service failed";
+		case "retrying": return `its start hook requeued after attempt ${blocker.attempt}${blocker.reason === void 0 ? "" : ` (${blocker.reason})`}`;
+		case "not-started": return "its container is not started";
+	}
+}
+/** Formats explanations as one line for each service. */
+function describeExplanations(explanations) {
+	return explanations.map((explanation) => {
+		const reasons = explanation.blockers.map(describeBlocker);
+		if (explanation.cause) reasons.push(`it is ${explanation.status ?? "unavailable"}, because ${describeCause(explanation.cause)}`);
+		const { replacement } = explanation;
+		if (replacement) {
+			const blockers = replacement.blockers.map(describeBlocker);
+			reasons.push(`its replacement is ${replacement.phase ?? "missing"}${blockers.length > 0 ? ` (${blockers.join(", ")})` : ""}`);
+		}
+		return `- ${explanation.name} is ${explanation.phase}${reasons.length > 0 ? `: ${reasons.join(", ")}` : ""}`;
+	}).join("\n");
+}
+// src/primitives/lifecycle.ts
+const visibleKinds = /* @__PURE__ */ new Set(["service", "invocation"]);
+const transitionalPhases = /* @__PURE__ */ new Set([
+	"building",
+	"starting",
+	"retrying",
+	"stopping"
+]);
+/** Lists the present services and invocations of `containers`. A `perConsumer` registration never runs, so it is not in the list. Its consumer services are. */
+function presentServices(containers) {
+	return containers.flatMap((container) => [...container.services].filter((service) => visibleKinds.has(service.kind) && service.signals.present() && !service.perConsumer));
+}
+/**
+* Runs `check` each time the work queue drains, until the result is not `'waiting'`.
+* When `signal` aborts first, it stops checking and rejects with the result of `onAborted`. An aborted signal rejects at once.
+*/
+function waitUntilSettled(containers, check, signal, onAborted) {
+	const { reconciler } = containers[0].runtime;
+	return new Promise((done, fail) => {
+		if (signal?.aborted) {
+			fail(onAborted(signal.reason));
+			return;
+		}
+		let removeAbort = () => {};
+		const stopListening = reconciler.onDrained(() => {
+			const result = check(presentServices(containers));
+			if (result === "waiting") return;
+			stopListening();
+			removeAbort();
+			if (result.kind === "done") done();
+			else fail(errorFrom(result.errors, "Start failed."));
+		});
+		removeAbort = onAbort(signal, (reason) => {
+			stopListening();
+			fail(onAborted(reason));
+		});
+		reconciler.requestDrain();
+	});
+}
+/**
+* Begins convergence of the container and of each child container that was started.
+*
+* Resolves when all their services and invocations are `running`. Rejects with the build and start errors.
+* A service in `failed` tries again. A required key without a provider keeps the promise pending, unless `options.signal` aborts.
+* A child container that was never started does not start. Call `start(child)` for it.
+*/
+function start$1(container, options) {
+	const node = nodeOf(container);
+	assertActive(node, "start");
+	const signal = readSignal(options, "start");
+	node.enrolled = true;
+	const containers = affectedContainers(node);
+	return untracked(() => {
+		batch(() => {
+			for (const current of containers) current.signals.started(true);
+			for (const service of presentServices(containers)) if (service.signals.phase() === "failed") {
+				service.failure = void 0;
+				setPhase(service, "pending", { reason: "start() tries the failed service again." });
+			}
+		});
+		return waitUntilSettled(containers, (services) => {
+			if (services.every((service) => service.signals.phase() === "running")) return { kind: "done" };
+			if (services.some((service) => transitionalPhases.has(service.signals.phase()))) return "waiting";
+			const errors = services.flatMap((service) => service.signals.phase() === "failed" && service.failure ? [service.failure.error] : []);
+			return errors.length > 0 ? {
+				kind: "failed",
+				errors
+			} : "waiting";
+		}, signal, (reason) => {
+			if (!isTimeoutReason(reason)) return reason;
+			const explanations = presentServices(containers).filter((service) => service.signals.phase() !== "running").map(explainService);
+			return new StartTimeoutError(`start() timed out. These services are not running:\n${describeExplanations(explanations)}`, explanations, { cause: reason });
+		});
+	}).then(() => traceLoggerOf(container)?.running());
+}
+/**
+* Stops all instances of the container and of each child container that was started. Dependents stop before their providers.
+*
+* The registrations stay. The container stays usable, and a later `start()` builds them again. `dispose()` clears the container.
+* Rejects with the teardown errors.
+*
+* When `options.signal` aborts, it rejects with the reason and stops waiting. The container stays stopped: a later `start()` builds again.
+* The services that did not stop yet stay in `stopping` until their cleanups settle.
+*
+* A call from the cleanup chain of the container or of a descendant cannot wait, because the stop waits for that cleanup.
+* The same is true for a cleanup of a service that holds a service of the subtree, directly or through other instances.
+* injeca finds such a call by the signal of the cleanup, or by the synchronous part of the cleanup. It warns, sends a `reentrant-call` record, and resolves at once. The stop continues.
+*/
+function stop$1(container, options) {
+	let node;
+	let signal;
+	try {
+		node = nodeOf(container);
+		signal = readSignal(options, "stop");
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	const reentry = untracked(() => findReentry(node, "stop", signal));
+	if (!reentry) return stopAndWait(node, signal);
+	untracked(() => reportReentry(node, "stop", reentry));
+	stopAndWait(node, void 0).catch(() => {});
+	return Promise.resolve();
+}
+async function stopAndWait(node, signal) {
+	const containers = affectedContainers(node);
+	const affected = new Set(containers);
+	node.enrolled = false;
+	const errors = [];
+	const stopTeardown = node.runtime.reconciler.onTeardown((service, teardownErrors) => {
+		if (service.kind !== "resolver" && affected.has(service.container)) errors.push(...teardownErrors);
+	});
+	const settled = untracked(() => {
+		batch(() => {
+			for (const current of containers) current.signals.started(false);
+			for (const service of presentServices(containers)) {
+				service.signals.demanded(false);
+				service.signals.subscribers(/* @__PURE__ */ new Set());
+			}
+		});
+		const stopped = (service) => service.signals.instance() === void 0 && !transitionalPhases.has(service.signals.phase());
+		return waitUntilSettled(containers, (services) => services.every(stopped) ? { kind: "done" } : "waiting", signal, (reason) => {
+			recordAbortedWait(presentServices(containers).filter((service) => !stopped(service)), "stop", reason);
+			return reason;
+		});
+	});
+	try {
+		await settled;
+	} finally {
+		stopTeardown();
+	}
+	if (errors.length > 0) throw errorFrom(errors, "Stop failed.");
+}
+// src/primitives/listen.ts
+/** Reads the `id` of an event key once. Any object with a non-empty string `id` is an event key. */
+function readEventId(eventKey) {
+	let id;
+	try {
+		id = typeof eventKey === "object" && eventKey !== null ? eventKey.id : void 0;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the id of the event key.", { cause: error });
+	}
+	if (typeof id !== "string" || id.length === 0) throw new InvalidArgumentError("An event key must be an object with a non-empty string id.");
+	return id;
+}
+function readListenerMetadata(metadata) {
+	if (metadata === void 0) return Object.freeze({});
+	if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) throw new InvalidArgumentError("The metadata of a listener must be a record.");
+	try {
+		return Object.freeze({ ...metadata });
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the metadata of the listener.", { cause: error });
+	}
+}
+/**
+* Stores a listener for `eventKey`. The container owns it: `dispose(container)` removes it.
+*
+* injeca does not call the listener. The consumer reads the listeners with `listeners()` and runs them by its own rules.
+* Returns a function that removes the listener.
+*/
+function listen(container, eventKey, handler, metadata) {
+	const node = nodeOf(container);
+	assertActive(node, "listen");
+	const id = readEventId(eventKey);
+	if (typeof handler !== "function") throw new InvalidArgumentError(`The listener for '${id}' is not a function.`);
+	const record = Object.freeze({
+		seq: node.runtime.nextSeq(),
+		handler,
+		metadata: readListenerMetadata(metadata)
+	});
+	const records = node.listeners.get(id) ?? [];
+	node.listeners.set(id, [...records, record]);
+	return () => {
+		const current = node.listeners.get(id);
+		if (!current?.includes(record)) return;
+		const rest = current.filter((entry) => entry !== record);
+		if (rest.length > 0) node.listeners.set(id, rest);
+		else node.listeners.delete(id);
+	};
+}
+// src/primitives/replace.ts
+function outcomeResult(outcome, name) {
+	switch (outcome.kind) {
+		case "swapped": return true;
+		case "cancelled": return false;
+		case "failed": throw outcome.error;
+		case "stopping": throw new ReplaceWhileStoppingError(`'${name}' started to stop before its replacement completed.`);
+	}
+}
+/** Makes `service` the current registration in place of `target`, in the caller's batch. */
+function takeOver(registration, target, service) {
+	cancelPending(registration);
+	target.replacedBy = service;
+	releaseService(target);
+	publishService(service);
+	registration.current = service;
+}
+/** Replaces a service that has no serving instance. The new service takes the slot at once. */
+function replaceAtOnce(registration, target, definition) {
+	let service;
+	batch(() => {
+		service = createService({
+			container: target.container,
+			kind: "service",
+			name: target.name,
+			edges: definition.edges,
+			build: definition.build,
+			metadata: definition.metadata,
+			policy: definition.policy,
+			exclusive: target.exclusive,
+			exported: target.exported,
+			perConsumer: target.perConsumer,
+			registration
+		});
+		service.signals.demanded(target.signals.demanded());
+		target.container.services.add(service);
+		takeOver(registration, target, service);
+	});
+	return service;
+}
+/**
+* Replaces the `perConsumer` registration `target` with the unpublished registration `template`. Resolves with the outcome.
+*
+* Each running consumer service gets a successor that builds and starts from `definition`. A successor that completes `start` waits.
+* When every successor waits, one batch publishes `template` and swaps in all successors. The other consumer services leave and build again on demand.
+* When one successor fails, all successors leave, `template` leaves, and the old registration and its consumer services do not change.
+* A consumer service that leaves during the replacement, for example with its container, drops out of the batch.
+* A newer `replace` or a withdrawal cancels the replacement.
+*/
+function replaceTemplate(registration, target, template) {
+	const definition = {
+		edges: template.edges,
+		build: template.build,
+		metadata: template.metadata,
+		perConsumer: true,
+		exported: false,
+		policy: template.policy
+	};
+	const outcome = createDeferred();
+	const waiting = /* @__PURE__ */ new Set();
+	const held = /* @__PURE__ */ new Set();
+	let settled = false;
+	const finish = (result) => {
+		settled = true;
+		template.swap = void 0;
+		if (target.successor === template) target.successor = void 0;
+		if (registration.pending === template) registration.pending = void 0;
+		outcome.resolve(result);
+	};
+	const abandon = (result) => {
+		if (settled) return;
+		batch(() => {
+			finish(result);
+			for (const successor of [...waiting, ...held]) {
+				successor.signals.present(false);
+				successor.container.runtime.reconciler.markDirty(successor);
+			}
+			releaseService(template);
+		});
+	};
+	const commitIfReady = () => {
+		if (settled || waiting.size > 0) return;
+		batch(() => {
+			finish({ kind: "swapped" });
+			takeOver(registration, target, template);
+			for (const successor of held) completeSwap(successor);
+		});
+	};
+	batch(() => {
+		cancelPending(registration);
+		template.swap = {
+			target,
+			held: false,
+			settle: abandon
+		};
+		registration.pending = template;
+		target.successor = template;
+		for (const consumer of target.signals.consumers().values()) {
+			if (!consumer.signals.serving()) continue;
+			cancelSuccessor(consumer);
+			const { service } = createSuccessor(consumer, definition, {
+				template,
+				onSettle: (successor, result) => {
+					waiting.delete(successor);
+					held.delete(successor);
+					if (result.kind === "failed") abandon(result);
+					else if (result.kind !== "swapped") commitIfReady();
+				},
+				ready: (successor) => {
+					waiting.delete(successor);
+					held.add(successor);
+					commitIfReady();
+				}
+			});
+			waiting.add(service);
+		}
+	});
+	commitIfReady();
+	return outcome.promise;
+}
+/** Settles a replacement for its registration. */
+function settleRegistration(registration) {
+	return (service, outcome) => {
+		if (registration.pending === service) registration.pending = void 0;
+		if (outcome.kind === "swapped") registration.current = service;
+	};
+}
+/**
+* Starts the replacement of a running service. The old instance serves until the new one completes `start`.
+* A transaction passes `extra`, and it sets `registration.pending` at its publish.
+*/
+function replaceRunning(registration, target, definition, extra) {
+	const pending = createSuccessor(target, definition, {
+		onSettle: settleRegistration(registration),
+		extra
+	});
+	if (!extra?.transaction) {
+		cancelPending(registration);
+		registration.pending = pending.service;
+	}
+	return pending;
+}
+/**
+* Waits for the outcome of the pending replacement `pending`. When `signal` aborts first, it cancels the replacement, as a newer `replace` does.
+* The cancel settles the outcome as `cancelled`. The listener goes when the outcome settles.
+*/
+async function awaitOutcome(registration, pending, outcome, signal) {
+	const removeAbort = onAbort(signal, () => {
+		if (registration.pending === pending) batch(() => cancelPending(registration));
+	});
+	try {
+		return outcomeResult(await outcome, registration.name);
+	} finally {
+		removeAbort();
+	}
+}
+/** The `replace()` of a registration. */
+async function replace(registration, option, options) {
+	const signal = readSignal(options, "replace");
+	const target = untracked(() => currentService(registration));
+	if (!target) return false;
+	const definition = readDefinition(registration.name, option, target);
+	if (signal?.aborted) return false;
+	const phase = untracked(() => target.signals.phase());
+	if (phase === "stopping") throw new ReplaceWhileStoppingError(`'${registration.name}' is stopping. Wait until it stops, then call provide.`);
+	if (target.perConsumer) {
+		let template;
+		const outcome = untracked(() => {
+			batch(() => {
+				template = createService({
+					container: target.container,
+					kind: "service",
+					name: target.name,
+					edges: definition.edges,
+					build: definition.build,
+					metadata: definition.metadata,
+					policy: definition.policy,
+					exclusive: target.exclusive,
+					exported: target.exported,
+					perConsumer: true,
+					registration
+				});
+				target.container.services.add(template);
+			});
+			return replaceTemplate(registration, target, template);
+		});
+		return awaitOutcome(registration, template, outcome, signal);
+	}
+	if (phase !== "running") {
+		untracked(() => replaceAtOnce(registration, target, definition));
+		return true;
+	}
+	const pending = untracked(() => replaceRunning(registration, target, definition));
+	return awaitOutcome(registration, pending.service, pending.outcome, signal);
+}
+const registrations = /* @__PURE__ */ new WeakMap();
+/** The registration behind a result of `provide`, or `undefined` for any other value. */
+function registrationOf(key) {
+	return typeof key === "object" && key !== null ? registrations.get(key) : void 0;
+}
+/** Creates the public result of `provide`: the typed key with `withdraw()` and `replace()`. A transaction passes its own `withdraw`. */
+function registrationApi(registration, overrides = {}) {
+	const api = Object.freeze({
+		key: registration.name,
+		...registration.exclusive ? { exclusive: true } : {},
+		withdraw: overrides.withdraw ?? ((options) => withdrawRegistration(registration, options)),
+		replace: ((option, options) => replace(registration, option, options))
+	});
+	registrations.set(api, registration);
+	return api;
+}
+// src/primitives/provide.ts
+function normalizeProvideOption(nameOrOption, option) {
+	if (typeof nameOrOption === "string") {
+		if (option == null || !("build" in option) && typeof option !== "function") throw new Error("When using provide(...) as named callback, the second argument must be either a valid ProvideOptionObject<T, D> or a ProvideOptionFunc<T, D>.");
+		if (typeof option === "function") return { build: option };
+		return option;
+	}
+	if (typeof nameOrOption === "object" && "key" in nameOrOption) {
+		if (option == null || !("build" in option) && typeof option !== "function") throw new Error("When using provide(...) as typed ProvideOptionWithKeys<T, D, Key> callback, the second argument must be either a valid ProvideOptionObject<T, D> or a ProvideOptionFunc<T, D>.");
+		if (typeof option === "function") return { build: option };
+		return option;
+	}
+	if (typeof nameOrOption === "function") return { build: nameOrOption };
+	return nameOrOption;
+}
+function isProvidedKey(value) {
+	return typeof value === "object" && value !== null && "key" in value && !("build" in value);
+}
+function autoName(stackIndex, nameOrOption, option) {
+	const fromFirst = typeof nameOrOption === "object" && "autoNameStackIndex" in nameOrOption ? nameOrOption.autoNameStackIndex : void 0;
+	const requested = (typeof option === "object" ? option.autoNameStackIndex : void 0) ?? fromFirst;
+	const index = typeof requested === "number" ? requested + stackIndex - 1 : stackIndex;
+	const parentFile = ErrorStackParser.parse(/* @__PURE__ */ new Error("providing"))[index];
+	return `${parentFile?.fileName ?? `unknown-${nanoid()}`}:${parentFile?.lineNumber ?? 0}:${parentFile?.columnNumber ?? 0}`;
+}
+/**
+* Throws `duplicate-service` when a started container already has a registration for `name`,
+* or when an open transaction of the container, other than `except`, declares or provides `name`.
+*/
+function assertNoDuplicate(container, name, except) {
+	if (slotOf(container, name)() && container.signals.started()) throw new DuplicateServiceError(`The started container already has a registration for '${name}'.`);
+	if (reservedBy(container.transactions, name, except)) throw new DuplicateServiceError(`An open transaction of the container reserves '${name}'.`);
+}
+/**
+* Publishes `service` as the current registration of its key. Call it inside a batch.
+* Before `start()`, a second provide of the same name replaces the first registration, as in 0.2.
+*/
+function publishRegistration(container, service) {
+	const previous = slotOf(container, service.name)();
+	if (previous) {
+		releaseService(previous);
+		emitRecord(container, {
+			type: "registration-replaced",
+			key: service.name,
+			owner: container.owner,
+			instanceId: previous.signals.instance()?.id,
+			reason: `A second provide of '${service.name}' replaced the registration before start().`
+		});
+	}
+	publishService(service);
+}
+/** Creates the service of one registration. It is not published yet. */
+function serviceOf(container, name, definition, exclusive, extra = {}) {
+	const service = createService({
+		container,
+		kind: "service",
+		name,
+		edges: definition.edges,
+		build: definition.build,
+		metadata: definition.metadata,
+		policy: definition.policy,
+		exclusive,
+		exported: definition.exported,
+		perConsumer: definition.perConsumer,
+		...extra
+	});
+	container.services.add(service);
+	return service;
+}
+/** Makes the service of one `provide` call the current registration of its key. */
+function register(container, name, definition, exclusive) {
+	assertNoDuplicate(container, name);
+	const registration = createRegistration(container, name, exclusive);
+	batch(() => {
+		const service = serviceOf(container, name, definition, exclusive, { registration });
+		publishRegistration(container, service);
+		registration.current = service;
+	});
+	return registration;
+}
+/**
+* Registers a provider. The public `provide` functions call it directly and pass `stackIndex` 3: this function, the auto-name helper, and the public function come before their caller.
+*/
+function provideIn(container, stackIndex, nameOrOption, option) {
+	const node = nodeOf(container);
+	assertActive(node, "provide");
+	const name = typeof nameOrOption === "string" ? nameOrOption : isProvidedKey(nameOrOption) ? normalizeName(nameOrOption) : autoName(stackIndex, nameOrOption, option);
+	if (typeof name !== "string" || name.length === 0) throw new InvalidArgumentError("A provider name must be a non-empty string.");
+	const providerObject = normalizeProvideOption(nameOrOption, option);
+	const definition = readDefinition(name, providerObject);
+	const exclusive = isExclusiveKey(nameOrOption);
+	const registration = untracked(() => register(node, name, definition, exclusive));
+	traceLoggerOf(container)?.provide(name, definition.edges.map((edge) => edge.keyName));
+	return registrationApi(registration);
+}
+function provide$1(container, nameOrOption, option) {
+	return provideIn(container, 3, nameOrOption, option);
+}
+// src/primitives/resolve.ts
+/**
+* Waits until the dependencies are available and returns their values. Before `start()`, it builds and starts them.
+*
+* Rejects when a required dependency fails. With `options.signal`, it rejects when the signal aborts. An aborted signal rejects at once.
+* Each rejection removes the hidden resolver of the call. The values can become stale after a run-time change. Use it for one-time code.
+*/
+function resolve$1(container, dependsOn, options) {
+	const node = nodeOf(container);
+	assertActive(node, "resolve");
+	const edges = readEdges("resolve", dependsOn);
+	const signal = readSignal(options, "resolve");
+	if (signal?.aborted) return Promise.reject(waitAbortError(signal.reason, "resolve() timed out."));
+	const { reconciler } = node.runtime;
+	return new Promise((done, fail) => untracked(() => {
+		let settled = false;
+		let service;
+		let stopListening = () => {};
+		let disarm = () => {};
+		const finish = (outcome) => {
+			if (settled) return;
+			settled = true;
+			stopListening();
+			disarm();
+			batch(() => releaseService(service));
+			outcome();
+		};
+		const build = (context) => finish(() => done({ ...context.dependsOn }));
+		batch(() => {
+			service = createService({
+				container: node,
+				kind: "resolver",
+				name: "resolve",
+				edges,
+				build
+			});
+			node.services.add(service);
+		});
+		stopListening = reconciler.onDrained(() => {
+			const failure = blockingFailure(service);
+			if (failure) finish(() => fail(failure.error));
+		});
+		disarm = onAbort(signal, (reason) => finish(() => fail(waitAbortError(reason, "resolve() timed out."))));
+		service.withdrawal.promise.then(() => finish(() => fail(new BuildAfterDisposeError("The container was disposed before resolve() got its dependencies."))));
+	}));
+}
+// src/primitives/timeout.ts
+function readMilliseconds(ms, action) {
+	if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) throw new InvalidArgumentError(`The milliseconds of ${action} must be a finite number of 0 or more. Got ${String(ms)}.`);
+	return ms;
+}
+/**
+* Returns a signal that aborts after `ms` milliseconds of the clock of `container`.
+*
+* The reason is a `DOMException` with the name `TimeoutError`, as for `AbortSignal.timeout()`. Use it in place of `AbortSignal.timeout()`, because that one does not use the container clock.
+* With the system clock, the timer does not keep a Node process alive.
+*/
+function timeout(container, ms) {
+	const { clock } = nodeOf(container).runtime;
+	const milliseconds = readMilliseconds(ms, "timeout");
+	return timeoutSignal(clock, milliseconds, () => timeoutReason(`The operation timed out after ${milliseconds}ms.`), true).signal;
+}
+/** Returns a signal that aborts when `signal` aborts, or after `ms` milliseconds of the clock of `container`. Without `signal`, it is `timeout(container, ms)`. */
+function withTimeout(signal, ms, container) {
+	return anySignal(readSignal({ signal }, "withTimeout"), timeout(container, ms));
+}
+// src/primitives/transaction.ts
+function readName(key, action) {
+	let name;
+	try {
+		name = normalizeName(key);
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the key of ${action}.`, { cause: error });
+	}
+	if (typeof name !== "string" || name.length === 0) throw new InvalidArgumentError(`The key of ${action} must be a name or a key.`);
+	return name;
+}
+function readDeclareOptions(name, options) {
+	let dependsOn;
+	let optional;
+	try {
+		dependsOn = options?.dependsOn;
+		optional = options?.optional;
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the declare options of '${name}'.`, { cause: error });
+	}
+	if (optional !== void 0 && typeof optional !== "boolean") throw new InvalidArgumentError(`The optional option of '${name}' must be a boolean.`);
+	return {
+		dependsOn,
+		optional: optional === true
+	};
+}
+/** The service that a `tx.replace` names now. A stale registration, or a key without a registration, fails. */
+function replaceTarget(container, entry) {
+	const target = entry.target ? currentService(entry.target) : slotOf(container, entry.name)();
+	if (!target || !target.signals.present()) throw new StaleRegistrationError(`The transaction replaces '${entry.name}', but the container has no current registration for it.`);
+	if (target.signals.phase() === "stopping") throw new ReplaceWhileStoppingError(`The transaction replaces '${entry.name}', but it is stopping.`);
+	return target;
+}
+/** Checks the entries and creates the services of a commit. The services are not published. */
+function createMembers(transaction) {
+	const { container } = transaction;
+	assertActive(container, "commit a transaction");
+	const incomplete = [...transaction.entries.values()].filter((entry) => !entry.definition && !entry.optional);
+	if (incomplete.length > 0) throw new TransactionIncompleteError(`These declared services have no provide: ${incomplete.map((entry) => `'${entry.name}'`).join(", ")}.`);
+	const entries = [...transaction.entries.values()].filter((entry) => entry.definition);
+	const targets = /* @__PURE__ */ new Map();
+	for (const entry of entries) if (entry.replace) targets.set(entry, replaceTarget(container, entry));
+	else assertNoDuplicate(container, entry.name, transaction);
+	const members = [];
+	batch(() => {
+		for (const entry of entries) {
+			const definition = entry.definition;
+			const target = targets.get(entry);
+			const extra = {
+				phase: "declared",
+				transaction
+			};
+			if (!target) {
+				members.push({
+					entry,
+					service: serviceOf(container, entry.name, definition, entry.exclusive, {
+						...extra,
+						registration: entry.registration
+					})
+				});
+				continue;
+			}
+			const registration = target.registration ?? createRegistration(container, entry.name, target.exclusive);
+			const service = target.signals.phase() === "running" && !target.perConsumer ? replaceRunning(registration, target, definition, extra).service : serviceOf(container, entry.name, {
+				...definition,
+				perConsumer: target.perConsumer,
+				exported: target.exported
+			}, target.exclusive, {
+				...extra,
+				registration
+			});
+			members.push({
+				entry,
+				service,
+				target
+			});
+		}
+	});
+	return members;
+}
+/** Publishes the members in one batch. A built member goes to `starting`, the others to `pending`. The reservations end in the same batch. */
+function publishMembers(transaction, members, built) {
+	batch(() => {
+		releaseReservations(transaction);
+		for (const { service, target } of members) {
+			service.transaction = void 0;
+			const registration = service.registration;
+			if (target && registration && service.swap) {
+				cancelPending(registration);
+				registration.pending = service;
+			} else if (target && registration && target.perConsumer) replaceTemplate(registration, target, service);
+			else if (target && registration) takeOver(registration, target, service);
+			else {
+				publishRegistration(service.container, service);
+				if (registration) registration.current = service;
+			}
+			if (service.signals.present()) setPhase(service, built.has(service) ? "starting" : "pending", { reason: built.has(service) ? "The transaction committed." : "The transaction committed. The service waits for its dependencies." });
+		}
+	});
+}
+async function commit(transaction) {
+	const members = untracked(() => createMembers(transaction));
+	const byName = new Map(members.map((member) => [member.service.name, member.service]));
+	const order = orderMembers(byName);
+	const outcome = await buildMembers(transaction, order, byName);
+	if (outcome.kind !== "built") {
+		await untracked(() => rollbackMembers(byName, outcome.built));
+		throw outcome.kind === "failed" ? outcome.error : transaction.abortError;
+	}
+	untracked(() => publishMembers(transaction, members, new Set(outcome.built.keys())));
+	transaction.state = "done";
+	transaction.container.transactions.delete(transaction);
+	startMembers(order, outcome.built);
+}
+/**
+* Commits `transaction`. When `signal` aborts before the publish, the transaction aborts with the reason, and the result rejects at once.
+* The rollback continues: the build in progress gets the abort on its `signal`, and the key reservations end when the rollback settles.
+*/
+function startCommit(transaction, options) {
+	let signal;
+	try {
+		signal = readSignal(options, "commit");
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	if (transaction.state !== "open") return Promise.reject(new InvalidArgumentError(`The transaction is ${transaction.state === "aborted" ? "aborted" : "already committed"}.`));
+	if (signal?.aborted) {
+		abortTransaction(transaction, signal.reason);
+		return Promise.reject(signal.reason);
+	}
+	transaction.state = "committing";
+	const committed = commit(transaction).catch((error) => {
+		if (transaction.state !== "done") {
+			transaction.state = "aborted";
+			transaction.container.transactions.delete(transaction);
+			untracked(() => releaseReservations(transaction));
+		}
+		throw error;
+	});
+	transaction.settled = committed.then(() => {}, () => {});
+	if (!signal) return committed;
+	return new Promise((resolve, reject) => {
+		const removeAbort = onAbort(signal, (reason) => {
+			if (transaction.state !== "committing") return;
+			abortTransaction(transaction, reason);
+			reject(reason);
+		});
+		committed.then((value) => {
+			removeAbort();
+			resolve(value);
+		}, (error) => {
+			removeAbort();
+			reject(error);
+		});
+	});
+}
+/** Throws `duplicate-service` when another open transaction of the container declares or provides `name`. */
+function assertNotReserved(transaction, name) {
+	if (reservedBy(transaction.container.transactions, name, transaction)) throw new DuplicateServiceError(`Another open transaction of the container reserves '${name}'.`);
+}
+function assertOpen(transaction, action) {
+	if (transaction.state !== "open") throw new InvalidArgumentError(`Cannot ${action} after the transaction committed or aborted.`);
+}
+function entryOf$1(transaction, name, exclusive) {
+	let entry = transaction.entries.get(name);
+	if (!entry) {
+		entry = {
+			name,
+			declared: void 0,
+			optional: false,
+			definition: void 0,
+			replace: false,
+			target: void 0,
+			registration: void 0,
+			exclusive,
+			exported: false,
+			reservation: void 0
+		};
+		transaction.entries.set(name, entry);
+	}
+	return entry;
+}
+/**
+* Creates a transaction for `container`.
+*
+* `declare` reserves services. `provide` and `replace` add services. Nothing is visible to consumers before `commit()`.
+* `commit()` builds the services in dependency order and publishes them in one batch. Then the `start` hooks run.
+* A failed build publishes nothing. A disposal of the container during the transaction aborts it.
+*/
+function transaction(container) {
+	const node = nodeOf(container);
+	assertActive(node, "create a transaction");
+	const state = {
+		container: node,
+		state: "open",
+		entries: /* @__PURE__ */ new Map(),
+		abortError: void 0,
+		controllers: /* @__PURE__ */ new Set(),
+		settled: void 0
+	};
+	node.transactions.add(state);
+	const declare = (key, options) => {
+		assertOpen(state, "declare");
+		const name = readName(key, "declare");
+		const { dependsOn, optional } = readDeclareOptions(name, options);
+		assertNotReserved(state, name);
+		const declared = readEdges(name, dependsOn);
+		const entry = entryOf$1(state, name, false);
+		entry.exclusive ||= isExclusiveKey(key);
+		entry.declared = declared;
+		entry.optional = optional;
+		untracked(() => reserveKey(state, entry));
+	};
+	/**
+	* The `withdraw()` of a registration from `tx.provide`. Before the commit, it removes the provide from the transaction and resolves `true`.
+	* A declaration of the key stays, so the commit fails with `transaction-incomplete` unless the declaration is optional.
+	* During the commit, it waits for the commit, then withdraws the published service with `options`.
+	*/
+	const withdrawEntry = async (entry, registration, options) => {
+		if (state.state === "open") {
+			if (entry.registration !== registration) return false;
+			entry.definition = void 0;
+			entry.registration = void 0;
+			entry.exported = false;
+			untracked(() => {
+				if (!entry.declared) {
+					state.entries.delete(entry.name);
+					releaseReservation(entry);
+				} else reserveKey(state, entry);
+			});
+			return true;
+		}
+		if (state.state === "committing") await state.settled;
+		return withdrawRegistration(registration, options);
+	};
+	const provide = ((key, option) => {
+		assertOpen(state, "provide");
+		const name = readName(key, "provide");
+		if (state.entries.get(name)?.definition) throw new DuplicateServiceError(`The transaction already provides '${name}'.`);
+		assertNotReserved(state, name);
+		const read = readDefinition(name, option);
+		const entry = entryOf$1(state, name, false);
+		entry.exclusive ||= isExclusiveKey(key);
+		const definition = read.edges.length === 0 && entry.declared ? {
+			...read,
+			edges: entry.declared
+		} : read;
+		const registration = createRegistration(node, name, entry.exclusive);
+		entry.definition = definition;
+		entry.registration = registration;
+		entry.exported = definition.exported;
+		untracked(() => reserveKey(state, entry));
+		return registrationApi(registration, { withdraw: (options) => withdrawEntry(entry, registration, options) });
+	});
+	const replace = ((key, option) => {
+		assertOpen(state, "replace");
+		const name = readName(key, "replace");
+		if (state.entries.get(name)?.definition) throw new DuplicateServiceError(`The transaction already provides or replaces '${name}'.`);
+		const target = registrationOf(key);
+		const entry = entryOf$1(state, name, target?.exclusive ?? false);
+		entry.definition = readDefinition(name, option, untracked(() => target ? currentService(target) : slotOf(node, name)()));
+		entry.replace = true;
+		entry.target = target;
+		untracked(() => releaseReservation(entry));
+	});
+	return Object.freeze({
+		declare,
+		provide,
+		replace,
+		commit: (options) => untracked(() => startCommit(state, options)),
+		abort: () => untracked(() => abortTransaction(state, new TransactionIncompleteError("The transaction was aborted before the commit completed.")))
+	});
+}
+// src/queries/impact.ts
+const livePhases = /* @__PURE__ */ new Set([
+	"building",
+	"starting",
+	"retrying",
+	"running"
+]);
+/** A service with an instance that a change can stop or rebuild. A new service that waits for its swap does not count. */
+function isLive(service) {
+	return service.kind !== "resolver" && !service.swap && service.signals.instance() !== void 0 && livePhases.has(service.signals.phase());
+}
+function rootOf(container) {
+	let root = container;
+	while (root.parent) root = root.parent;
+	return root;
+}
+/** The services of a `perConsumer` registration, with the registration. */
+function withConsumers(service) {
+	return [service, ...service.signals.consumers().values()];
+}
+/** Lists the services that leave when `container` and its descendants are disposed. */
+function disposedServices(container) {
+	return new Set(subtreeOf(container).flatMap((current) => [...current.services]).flatMap(withConsumers));
+}
+/** Lists the services that leave when `service` is withdrawn. */
+function withdrawnServices(service) {
+	return new Set(withConsumers(service));
+}
+/**
+* Computes what a proposed change does, on a copy of the graph state. It reads the real graph and never writes it.
+*
+* - A dependent that loses a required dependency without an alternative provider stops. Its dependents follow.
+* - A dependent whose dependency gets another instance gets `dependency-change`. With a handler, it is notified. Without one, it rebuilds, and its dependents follow.
+* - An alternative provider is an ancestor registration that serves, or another `firstAvailable` candidate.
+*/
+function computeImpact(scope, change) {
+	const services = subtreeOf(rootOf(scope)).flatMap((container) => [...container.services]).filter(isLive);
+	const stopped = new Set([...change.removed].filter(isLive));
+	const rebuilt = /* @__PURE__ */ new Set();
+	const notified = /* @__PURE__ */ new Set();
+	const gone = (service) => change.removed.has(service) || stopped.has(service);
+	const renewed = (service) => change.renewed.has(service) || rebuilt.has(service);
+	/** Tells whether another candidate of the edge serves after the change. */
+	const alternative = (consumer, keyNames) => keyNames.some((keyName) => candidatesOf(consumer.scope, keyName, consumer).some((registration) => {
+		const provider = serviceFor(registration, consumer.scope);
+		return provider !== void 0 && !gone(provider) && !gone(registration) && provider.signals.serving();
+	}));
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const service of services) {
+			if (stopped.has(service) || change.removed.has(service)) continue;
+			let lost = false;
+			let identity = false;
+			for (const edge of service.edges) {
+				const resolution = resolutionOf(service, edge);
+				if (resolution.kind !== "resolved") continue;
+				const provider = resolution.provider;
+				if (gone(provider)) {
+					if (alternative(service, edge.candidates)) identity = true;
+					else if (edge.optional) identity = true;
+					else lost = true;
+				} else if (renewed(provider)) identity = true;
+			}
+			if (lost) {
+				rebuilt.delete(service);
+				notified.delete(service);
+				stopped.add(service);
+				changed = true;
+			} else if (identity && !rebuilt.has(service) && !notified.has(service)) {
+				const instance = service.signals.instance();
+				if (instance && instance.hooks["dependency-change"].length > 0) notified.add(service);
+				else {
+					rebuilt.add(service);
+					changed = true;
+				}
+			}
+		}
+	}
+	return {
+		stopped,
+		rebuilt,
+		notified
+	};
+}
+// src/queries/graph.ts
+const emptyMetadata = Object.freeze({});
+function readKey(key, action) {
+	let name;
+	try {
+		name = normalizeName(key);
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the key of ${action}.`, { cause: error });
+	}
+	if (typeof name !== "string" || name.length === 0) throw new InvalidArgumentError(`The key of ${action} must be a name or a key.`);
+	return name;
+}
+function entryOf(service) {
+	const status = service.signals.effective();
+	return Object.freeze({
+		key: service.name,
+		kind: service.kind === "invocation" ? "invocation" : "service",
+		owner: service.container.owner,
+		phase: service.signals.phase(),
+		...withoutUndefined({
+			status: status?.status,
+			instanceId: service.signals.instance()?.id,
+			consumer: service.consumer
+		}),
+		metadata: service.metadata,
+		exclusive: service.exclusive,
+		perConsumer: service.perConsumer,
+		exported: service.exported
+	});
+}
+function declaredEntryOf(container, entry) {
+	return Object.freeze({
+		key: entry.name,
+		kind: "service",
+		owner: container.owner,
+		phase: "declared",
+		metadata: entry.definition?.metadata ?? emptyMetadata,
+		exclusive: entry.exclusive,
+		perConsumer: entry.definition?.perConsumer ?? false,
+		exported: entry.exported
+	});
+}
+/** The services and invocations of the scope that are not `withdrawn`, in registration order. */
+function servicesOf(scope) {
+	return subtreeOf(scope).flatMap((container) => [...container.services]).filter((service) => service.kind !== "resolver" && service.signals.phase() !== "withdrawn").sort((a, b) => a.seq - b.seq);
+}
+/** The keys that open transactions declared and did not publish yet. */
+function declaredOf(scope) {
+	return subtreeOf(scope).flatMap((container) => [...container.transactions].filter((transaction) => transaction.state === "open").flatMap((transaction) => [...transaction.entries.values()].map((entry) => ({
+		container,
+		entry
+	}))));
+}
+/** Finds the service of `name`: the provider that a consumer in `scope` sees, then the first service of that name in the scope. */
+function lookup(scope, name) {
+	return findProvider(scope, name) ?? servicesOf(scope).find((service) => service.name === name);
+}
+/** The providers that the edges of `service` select now, served or not. */
+function targetsOf(service) {
+	return service.edges.flatMap((edge) => edge.candidates.flatMap((keyName) => {
+		const provider = findProvider(service.scope, keyName, service);
+		return provider ? [provider] : [];
+	}));
+}
+function resolutionKind(service, edge) {
+	const resolution = resolutionOf(service, edge);
+	return resolution.kind === "missing" ? { kind: "missing" } : {
+		kind: resolution.kind,
+		provider: resolution.provider
+	};
+}
+function dependencyOf(edge, resolution) {
+	return Object.freeze({
+		name: edge.name,
+		keys: edge.candidates,
+		optional: edge.optional,
+		fallback: edge.fallback,
+		conditional: edge.condition !== void 0 || edge.candidateConditions !== void 0,
+		resolution: resolution.kind,
+		...withoutUndefined({ provider: resolution.provider && entryOf(resolution.provider) })
+	});
+}
+/** The resolution of a declared edge, which has no computed resolution yet. */
+function declaredResolution(container, edge) {
+	for (const keyName of edge.candidates) {
+		const selection = selectProvider(container, keyName);
+		if (!selection) continue;
+		const provider = selection.provider ?? selection.registration;
+		return {
+			kind: provider.signals.serving() ? "resolved" : "not-running",
+			provider
+		};
+	}
+	return { kind: "missing" };
+}
+/**
+* Orders `services` so that each provider comes before its dependents. It is Tarjan's algorithm: each cycle comes out as one group.
+* Returns the groups in order.
+*/
+function components(services) {
+	const inScope = new Set(services);
+	const index = /* @__PURE__ */ new Map();
+	const low = /* @__PURE__ */ new Map();
+	const stack = [];
+	const onStack = /* @__PURE__ */ new Set();
+	const groups = [];
+	let counter = 0;
+	const visit = (service) => {
+		index.set(service, counter);
+		low.set(service, counter);
+		counter++;
+		stack.push(service);
+		onStack.add(service);
+		for (const target of targetsOf(service)) {
+			if (!inScope.has(target)) continue;
+			if (!index.has(target)) {
+				visit(target);
+				low.set(service, Math.min(low.get(service), low.get(target)));
+			} else if (onStack.has(target)) low.set(service, Math.min(low.get(service), index.get(target)));
+		}
+		if (low.get(service) === index.get(service)) {
+			const group = [];
+			let member;
+			do {
+				member = stack.pop();
+				onStack.delete(member);
+				group.push(member);
+			} while (member !== service);
+			groups.push(group.sort((a, b) => a.seq - b.seq));
+		}
+	};
+	for (const service of services) if (!index.has(service)) visit(service);
+	return groups;
+}
+/** The services of `roots` and their transitive dependencies. */
+function closure(roots) {
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [...roots];
+	while (queue.length > 0) {
+		const service = queue.shift();
+		if (seen.has(service)) continue;
+		seen.add(service);
+		queue.push(...targetsOf(service));
+	}
+	return [...seen].sort((a, b) => a.seq - b.seq);
+}
+function sorted(services) {
+	return Object.freeze([...services].sort((a, b) => a.seq - b.seq).map(entryOf));
+}
+function proposedChange(scope, change) {
+	let kind;
+	let key;
+	let container;
+	try {
+		kind = change.kind;
+		key = "key" in change ? change.key : void 0;
+		container = "container" in change ? change.container : void 0;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the impact change.", { cause: error });
+	}
+	switch (kind) {
+		case "withdraw":
+		case "replace": {
+			const service = lookup(scope, readKey(key, "impact"));
+			if (!service) return {
+				removed: /* @__PURE__ */ new Set(),
+				renewed: /* @__PURE__ */ new Set()
+			};
+			const registration = service.template ?? service;
+			return kind === "withdraw" ? {
+				removed: withdrawnServices(registration),
+				renewed: /* @__PURE__ */ new Set()
+			} : {
+				removed: /* @__PURE__ */ new Set(),
+				renewed: withdrawnServices(registration)
+			};
+		}
+		case "dispose": return {
+			removed: disposedServices(nodeOf(container)),
+			renewed: /* @__PURE__ */ new Set()
+		};
+		default: throw new InvalidArgumentError(`The impact change kind must be 'withdraw', 'replace', or 'dispose'. Got ${String(kind)}.`);
+	}
+}
+/**
+* Returns the graph queries of `container`. They cover the container and its descendants. Each query is a pure read.
+*
+* A key resolves as for a consumer in the container: from the container and the exports of its children, then from each ancestor and the exports of its children.
+* A key that only a descendant has resolves to the first such service.
+*/
+function graph(container) {
+	const scope = nodeOf(container);
+	return Object.freeze({
+		services: () => untracked(() => Object.freeze([...servicesOf(scope).map(entryOf), ...declaredOf(scope).map(({ container: owner, entry }) => declaredEntryOf(owner, entry))])),
+		dependencies: (key) => untracked(() => {
+			const name = readKey(key, "dependencies");
+			const service = lookup(scope, name);
+			if (service) return Object.freeze(service.edges.map((edge) => dependencyOf(edge, resolutionKind(service, edge))));
+			const declared = declaredOf(scope).find(({ entry }) => entry.name === name);
+			const edges = declared?.entry.definition?.edges ?? declared?.entry.declared ?? [];
+			return Object.freeze(edges.map((edge) => dependencyOf(edge, declaredResolution(declared.container, edge))));
+		}),
+		dependents: (key) => untracked(() => {
+			const target = lookup(scope, readKey(key, "dependents"));
+			if (!target) return Object.freeze([]);
+			const registration = target.template ?? target;
+			return Object.freeze(servicesOf(scope).filter((service) => service.edges.some((edge) => {
+				const resolution = resolutionOf(service, edge);
+				return resolution.kind !== "missing" && (resolution.provider === target || (resolution.provider.template ?? resolution.provider) === registration);
+			})).map(entryOf));
+		}),
+		order: (keys) => untracked(() => {
+			const services = keys === void 0 ? servicesOf(scope) : closure(keys.flatMap((key) => {
+				const service = lookup(scope, readKey(key, "order"));
+				return service ? [service] : [];
+			}));
+			return Object.freeze(components(services).flat().map(entryOf));
+		}),
+		cycles: () => untracked(() => Object.freeze(components(servicesOf(scope)).filter((group) => group.length > 1).map((group) => Object.freeze(group.map(entryOf))))),
+		impact: (change) => untracked(() => {
+			const result = computeImpact(scope, proposedChange(scope, change));
+			return Object.freeze({
+				stopped: sorted(result.stopped),
+				rebuilt: sorted(result.rebuilt),
+				notified: sorted(result.notified)
+			});
+		}),
+		explain: (key) => untracked(() => {
+			const name = readKey(key, "explain");
+			const service = lookup(scope, name);
+			if (service) return explainService(service);
+			const declared = declaredOf(scope).find(({ entry }) => entry.name === name);
+			if (declared) return Object.freeze({
+				name,
+				kind: "service",
+				owner: declared.container.owner,
+				phase: "declared",
+				blockers: Object.freeze([])
+			});
+			return Object.freeze({
+				name,
+				kind: "service",
+				owner: scope.owner,
+				phase: void 0,
+				blockers: Object.freeze([Object.freeze({
+					kind: "missing-provider",
+					dependency: name,
+					key: name
+				})])
+			});
+		})
+	});
+}
+// src/queries/peek.ts
+function resultOf(resolution, fallbackKey) {
+	switch (resolution.kind) {
+		case "missing": return Object.freeze({
+			kind: "missing",
+			key: fallbackKey
+		});
+		case "conflict": return Object.freeze({
+			kind: "conflict",
+			key: resolution.provider.name,
+			owners: ownersOf([resolution.provider, ...resolution.rivals])
+		});
+		case "rejected": return Object.freeze({
+			kind: "rejected",
+			key: resolution.provider.name,
+			owner: resolution.provider.container.owner,
+			metadata: resolution.provider.metadata
+		});
+		case "not-running": {
+			const { provider } = resolution;
+			const phase = provider.signals.phase();
+			const owner = (provider.template ?? provider).container.owner;
+			return Object.freeze({
+				kind: "not-running",
+				key: provider.name,
+				owner,
+				phase,
+				...phase === "failed" ? { error: provider.failure?.error } : {}
+			});
+		}
+		case "resolved": {
+			const { provider, instance } = resolution;
+			const owner = (provider.template ?? provider).container.owner;
+			const status = provider.signals.effective();
+			if (!status || status.status === "unavailable") return Object.freeze({
+				kind: "unavailable",
+				key: provider.name,
+				owner,
+				instanceId: instance.id,
+				...withoutUndefined({
+					reason: status?.reason,
+					cause: status?.cause
+				})
+			});
+			return Object.freeze({
+				kind: "resolved",
+				key: provider.name,
+				owner,
+				value: instance.value,
+				status: status.status,
+				instanceId: instance.id
+			});
+		}
+	}
+}
+/**
+* Reads the value of a dependency now, without a wait. It is a pure read: it does not demand, build, or start a service.
+*
+* The dependency resolves as for a consumer in `container`: a key, `where(key, condition)`, or `firstAvailable(...)`. An `optional` marker has no effect.
+* The result is the value with its status, or the reason why no value is available now. A `perConsumer` key has a value only after something demanded its service for `container`.
+*/
+function peek(container, dependency) {
+	const node = nodeOf(container);
+	const [edge] = readEdges("peek", { dependency });
+	if (!edge) throw new InvalidArgumentError("peek() needs a dependency.");
+	return untracked(() => {
+		const consumer = {
+			container: node,
+			scope: node,
+			name: "peek",
+			template: void 0
+		};
+		return resultOf(edge.fallback ? resolveFallback(consumer, edge) : resolvePlain(consumer, edge), edge.candidates[0] ?? edge.keyName);
+	});
+}
+// src/queries/listeners.ts
+/**
+* Returns the current listeners for `eventKey` in `container` and its descendants, in registration order.
+*
+* Each entry has the handler, the owner record of the container that owns it, and its metadata.
+* `H` is the handler type that the caller expects. injeca does not check it.
+*/
+function listeners(container, eventKey) {
+	const id = readEventId(eventKey);
+	return Object.freeze(subtreeOf(nodeOf(container)).filter((node) => node.state !== "disposed").flatMap((node) => (node.listeners.get(id) ?? []).map((record) => ({
+		record,
+		owner: node.owner
+	}))).sort((a, b) => a.record.seq - b.record.seq).map(({ record, owner }) => Object.freeze({
+		handler: record.handler,
+		owner,
+		metadata: record.metadata
+	})));
+}
+// src/global.ts
+let globalContainer = createContainer();
+function setLogger(logger) {
+	globalContainer.logger = logger;
+}
+/** Returns the root container of the global functions. Pass it as `parent` to make a child container. */
+function getContainer() {
+	return globalContainer;
+}
+/** Replaces the global container with a new one. `getContainer()` then returns the new one. It does not stop or dispose the old container. */
+function resetContainer() {
+	globalContainer = createContainer();
+}
+function provide(nameOrOption, option) {
+	return provideIn(globalContainer, 3, nameOrOption, option);
+}
+function invoke(option) {
+	return invokeIn(globalContainer, option);
+}
+function resolve(dependsOn, options) {
+	return resolve$1(globalContainer, dependsOn, options);
+}
+function start(options) {
+	return start$1(globalContainer, options);
+}
+function stop(options) {
+	return stop$1(globalContainer, options);
+}
+export { createNoopLogger as A, effect$1 as C, systemClock as D, waitAbortError as E, createDefaultLogger as O, dispose as S, readSignal as T, listen as _, resolve as a, invoke$1 as b, stop as c, graph as d, transaction as f, provide$1 as g, resolve$1 as h, resetContainer as i, createLoggLogger as k, listeners as l, withTimeout as m, invoke as n, setLogger as o, timeout as p, provide as r, start as s, getContainer as t, peek as u, start$1 as v, onAbort as w, createContainer as x, stop$1 as y };
+
+//# sourceMappingURL=global-B5N-d-TO.mjs.map