injeca 0.2.0 → 0.3.0

package/dist/global-C0Nk0pU8.mjs

@@ -0,0 +1,3790 @@
+import { a as DuplicateServiceError, d as ReentrantDisposeError, f as ReplaceWhileStoppingError, h as TransactionIncompleteError, i as BuildAfterDisposeError, l as InvalidArgumentError, m as StartTimeoutError, n as defaultDecision, o as HookOutsideBuildError, p as StaleRegistrationError, r as validateDecision, s as HookTimeoutError, t as createDecide } from "./decision-odiPb2Au.mjs";
+import { computed, effect, effectScope, endBatch, getActiveSub, setActiveSub, signal, startBatch } from "alien-signals";
+import { isUndefined, omitBy } from "es-toolkit";
+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`);
+		}
+	};
+}
+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`);
+		}
+	};
+}
+function createNoopLogger() {
+	return {
+		provide: () => {},
+		invoke: () => {},
+		beforeRun: () => {},
+		run: () => {},
+		hookOnStart: () => {},
+		hookOnStartComplete: () => {},
+		hookOnStop: () => {},
+		hookOnStopComplete: () => {},
+		running: () => {}
+	};
+}
+// src/helpers/signals.ts
+/**
+* Runs `fn` with tracking paused.
+*
+* The tracking rule: each entry point pauses tracking once. The entry points are the public API calls, the reconciler drain, timer callbacks, and the calls of user callbacks.
+* Code inside an entry point reads signals directly. Only the bodies of `computed` and `effect` track.
+* A promise continuation starts with no active subscriber, so it needs no extra pause.
+*/
+function untracked(fn) {
+	const previous = setActiveSub(void 0);
+	try {
+		return fn();
+	} finally {
+		setActiveSub(previous);
+	}
+}
+/** Writes signals in one batch. Effects see one consistent change. */
+function batch(fn) {
+	startBatch();
+	try {
+		fn();
+	} finally {
+		endBatch();
+	}
+}
+/** Runs `fn` with `owner` as the active subscriber, so effects that `fn` creates belong to `owner`. */
+function withOwner(owner, fn) {
+	const previous = setActiveSub(owner);
+	try {
+		return fn();
+	} finally {
+		setActiveSub(previous);
+	}
+}
+// src/helpers/error-from.ts
+/**
+* Makes one error from collected errors. One error keeps its identity. More than one error becomes an `AggregateError`.
+*
+* The result is `unknown`, because a thrown value is not always an `Error`.
+*/
+function errorFrom(errors, message) {
+	return errors.length === 1 ? errors[0] : new AggregateError(errors, message);
+}
+// src/graph/resolvers/exclusive.ts
+/** Tells whether `ancestor` is `container` or an ancestor of it, with no container in between that isolates `keyName`. */
+function reaches(container, ancestor, keyName) {
+	for (let current = container; current; current = current.parent) {
+		if (current === ancestor) return true;
+		if (current.isolated.has(keyName)) return false;
+	}
+	return false;
+}
+/**
+* Tells whether two containers share a resolution area of `keyName`.
+* A resolution area is the container that has the key, with its descendants that do not isolate the key.
+*/
+function sameArea(a, b, keyName) {
+	return reaches(a, b, keyName) || reaches(b, a, keyName);
+}
+/** The published services of `keyName` in all containers of the runtime. */
+function declarationsOf(runtime, keyName) {
+	let declarations = runtime.declarations.get(keyName);
+	if (!declarations) {
+		declarations = signal(/* @__PURE__ */ new Set());
+		runtime.declarations.set(keyName, declarations);
+	}
+	return declarations;
+}
+function addDeclaration(service) {
+	const declarations = declarationsOf(service.container.runtime, service.name);
+	if (!declarations().has(service)) declarations(/* @__PURE__ */ new Set([...declarations(), service]));
+}
+function removeDeclaration(service) {
+	const declarations = declarationsOf(service.container.runtime, service.name);
+	if (declarations().has(service)) declarations(new Set([...declarations()].filter((other) => other !== service)));
+}
+function sameList(a, b) {
+	return a.length === b.length && a.every((service, index) => service === b[index]);
+}
+const none = Object.freeze([]);
+/**
+* Creates the conflict of a service: the other present declarations of its key in the same resolution area, when the key is exclusive.
+*
+* The result depends only on the set of declarations. The order of the registrations has no effect.
+* Only one registration of a key exists in one container, so a rival is always in another container.
+* A service of a `perConsumer` registration has no conflict of its own. It follows the conflict of its registration.
+*/
+function createRivals(service) {
+	if (service.template) return () => service.template?.signals.rivals() ?? none;
+	if (service.kind !== "service") return () => none;
+	return computed((previous) => {
+		const rivals = [...declarationsOf(service.container.runtime, service.name)()].filter((other) => other.container !== service.container && other.signals.present() && (service.exclusive || other.exclusive) && sameArea(service.container, other.container, service.name)).sort((a, b) => a.seq - b.seq);
+		return previous && sameList(previous, rivals) ? previous : rivals;
+	});
+}
+/** Tells whether the key of the service has more than one declaration in its resolution area. */
+function inConflict(service) {
+	return service.signals.rivals().length > 0;
+}
+// src/graph/resolvers/resolvers.ts
+/** Returns the slot signal of `keyName` in `container`. It creates the slot on first read, so that resolution can track it. */
+function slotOf(container, keyName) {
+	let slot = container.signals.slots.get(keyName);
+	if (!slot) {
+		slot = signal(void 0);
+		container.signals.slots.set(keyName, slot);
+	}
+	return slot;
+}
+/**
+* Lists the registrations of `keyName` that a consumer in `container` can see, nearest first.
+* The walk ends at a container that isolates the key. A service does not resolve itself.
+*/
+function candidatesOf(container, keyName, consumer) {
+	const candidates = [];
+	for (let current = container; current; current = current.parent) {
+		const candidate = slotOf(current, keyName)();
+		if (candidate && candidate !== consumer) candidates.push(candidate);
+		if (current.isolated.has(keyName)) break;
+	}
+	return candidates;
+}
+/** The service that serves `registration` for a consumer in `container`. A `perConsumer` registration has one for each consumer container, or none yet. */
+function serviceFor(registration, container) {
+	return registration.perConsumer ? registration.signals.consumers().get(container) : registration;
+}
+/**
+* Selects the provider of `keyName` for a consumer in `container`.
+*
+* A nearer registration shadows an ancestor only while it is `running`. Until then, the first serving registration wins.
+* If no registration serves, the nearest one is selected. So shadowing never leaves a gap.
+*/
+function selectProvider(container, keyName, consumer) {
+	const candidates = candidatesOf(container, keyName, consumer);
+	for (const registration of candidates) {
+		const provider = serviceFor(registration, container);
+		if (provider?.signals.serving()) return {
+			registration,
+			provider
+		};
+	}
+	const [nearest] = candidates;
+	return nearest ? {
+		registration: nearest,
+		provider: serviceFor(nearest, container)
+	} : void 0;
+}
+/** Finds the service for `keyName` that a consumer in `container` sees. A `perConsumer` registration without a service for the container gives the registration. */
+function findProvider(container, keyName, consumer) {
+	const selection = selectProvider(container, keyName, consumer);
+	return selection && (selection.provider ?? selection.registration);
+}
+/** `ready` and `degraded` count as available. A provider outside `running` has no status and is not available. */
+function isAvailable(provider) {
+	const status = provider.signals.effective();
+	return status !== void 0 && status.status !== "unavailable";
+}
+/** The current resolution of the edge. */
+function resolutionOf(service, edge) {
+	return service.signals.resolutions.get(edge.name)?.() ?? { kind: "missing" };
+}
+/** The instance of the edge, when it resolves. */
+function resolvedInstance(service, edge) {
+	const resolution = resolutionOf(service, edge);
+	return resolution.kind === "resolved" ? resolution.instance : void 0;
+}
+/** Tells whether each required edge resolves to an available provider. A pending service builds only then. */
+function requiredAvailable(service) {
+	return service.edges.every((edge) => {
+		if (edge.optional) return true;
+		const resolution = resolutionOf(service, edge);
+		return resolution.kind === "resolved" && isAvailable(resolution.provider);
+	});
+}
+/** Tells whether a required edge no longer resolves: its provider was withdrawn, or it does not run. */
+function requiredWithdrawn(service) {
+	return service.edges.some((edge) => !edge.optional && resolvedInstance(service, edge) === void 0);
+}
+/** Tells whether the current resolution of a required edge differs from the bindings of `instance`. */
+function requiredChanged(service, instance) {
+	return service.edges.some((edge) => !edge.optional && resolvedInstance(service, edge) !== instance.bindings.get(edge.name));
+}
+/** A build is discarded when its target is lost, a required dependency changed during the build, or the key went into conflict. */
+function buildLost(service, instance) {
+	return !service.signals.present() || !service.signals.active() || service.signals.rivals().length > 0 || requiredChanged(service, instance);
+}
+/** The identity of the dependency set: the revision and the instance id of each resolved required dependency. */
+function epochOf(service, pick) {
+	const ids = service.edges.filter((edge) => !edge.optional).map((edge) => `${edge.name}=${pick(edge)?.id ?? ""}`);
+	return [String(service.revision), ...ids].join("|");
+}
+/**
+* Finds the failure that blocks a pending service: a required provider in `failed`, directly or through pending providers.
+*/
+function blockingFailure(service, visited = /* @__PURE__ */ new Set()) {
+	visited.add(service);
+	for (const edge of service.edges) {
+		if (edge.optional) continue;
+		const resolution = resolutionOf(service, edge);
+		if (resolution.kind !== "not-running" || visited.has(resolution.provider)) continue;
+		const provider = resolution.provider;
+		const phase = provider.signals.phase();
+		if (phase === "failed") return provider.failure;
+		if (phase === "pending") {
+			const failure = blockingFailure(provider, visited);
+			if (failure) return failure;
+		}
+	}
+}
+// src/graph/nodes/container.ts
+const nodes = /* @__PURE__ */ new WeakMap();
+/** Connects the public container object to its node. `createContainer` calls it once. */
+function registerNode(container, node) {
+	nodes.set(container, node);
+}
+/** Returns the internal node of a container from `createContainer`. */
+function nodeOf(container) {
+	const node = typeof container === "object" && container !== null ? nodes.get(container) : void 0;
+	if (!node) throw new InvalidArgumentError("The value is not a container from createContainer.");
+	return node;
+}
+function assertActive(container, action) {
+	if (container.state !== "active") throw new BuildAfterDisposeError(`Cannot ${action} after the container disposal started.`);
+}
+/** Lists `container` and its descendants that were started, through started containers only. `start()` and `stop()` apply to them. */
+function affectedContainers(container) {
+	const result = [container];
+	for (const child of container.children) if (child.enrolled) result.push(...affectedContainers(child));
+	return result;
+}
+/** Lists `container` and all its descendants. */
+function subtreeOf(container) {
+	return [container, ...[...container.children].flatMap(subtreeOf)];
+}
+/**
+* Makes `service` visible to consumers: the slot of its key, or the consumer map of its `perConsumer` registration.
+* An exclusive conflict counts each published service with a key.
+*/
+function publishService(service) {
+	const { template } = service;
+	if (template) {
+		const consumers = template.signals.consumers();
+		if (consumers.get(service.container) !== service) template.signals.consumers(new Map([...consumers, [service.container, service]]));
+		return;
+	}
+	slotOf(service.container, service.name)(service);
+	addDeclaration(service);
+}
+/**
+* Clears the slot and marks the service absent. The reconciler stops it after its holders release it.
+* A `perConsumer` registration also releases the service of each consumer container.
+*/
+function releaseService(service) {
+	service.signals.present(false);
+	if (service.kind !== "service" || service.template) return;
+	for (const consumer of service.signals.consumers().values()) consumer.signals.present(false);
+	const slot = slotOf(service.container, service.name);
+	if (slot() === service) slot(void 0);
+}
+/** Waits until `service` is `withdrawn`. Rejects with its teardown errors. */
+async function awaitWithdrawal(service) {
+	const errors = await service.withdrawal.promise;
+	if (errors.length > 0) throw errorFrom(errors, `Withdrawal of '${service.name}' failed.`);
+}
+/** Withdraws a service or an invocation. Resolves `false` when it is already withdrawn. It is the `withdraw()` entry point. */
+async function withdrawService(service) {
+	if (!untracked(() => {
+		if (!service.signals.present()) return false;
+		batch(() => releaseService(service));
+		return true;
+	})) return false;
+	await awaitWithdrawal(service);
+	return true;
+}
+// src/helpers/deferred.ts
+function createDeferred() {
+	let resolve;
+	return {
+		promise: new Promise((done) => {
+			resolve = done;
+		}),
+		resolve
+	};
+}
+// src/helpers/without-undefined.ts
+/** Copies `fields` without the fields that are `undefined`. Spread the result to add optional fields to a record. */
+function withoutUndefined(fields) {
+	return omitBy(fields, isUndefined);
+}
+// src/graph/observers.ts
+function within(container, ancestor) {
+	for (let current = container; current; current = current.parent) if (current === ancestor) return true;
+	return false;
+}
+/** The active observers of `container`: the observers of the container and of its ancestors. */
+function targetsOf$1(container, source) {
+	return [...container.runtime.observers].filter((observer) => observer !== source && observer.active && within(container, observer.container));
+}
+function send(container, targets, record) {
+	container.runtime.deliveries.deliver(targets.map((observer) => ({
+		run: () => {
+			if (observer.active && observer.container.state !== "disposed") observer.callback(record);
+		},
+		onError: (error) => {
+			if (record.type !== "error") reportCallbackError(observer.container, record.key, error, "An observe callback threw.", observer);
+		}
+	})));
+}
+/** Sends `record` to the observers of `container`. */
+function emitRecord(container, record) {
+	const targets = targetsOf$1(container);
+	if (targets.length === 0) return;
+	send(container, targets, Object.freeze(record));
+}
+/** Reports a callback error as an `error` record. An error from an observe callback does not go back to that callback. */
+function reportCallbackError(container, key, error, reason, source) {
+	const record = {
+		type: "error",
+		key,
+		owner: container.owner,
+		instanceId: void 0,
+		reason,
+		error
+	};
+	send(container, targetsOf$1(container, source), record);
+}
+// src/graph/resolvers/condition.ts
+/**
+* The verdict of each condition for each provider registration.
+* The input of a condition is frozen, and a condition must be pure. So each pair runs once, and a throw is reported once.
+*/
+const verdicts = /* @__PURE__ */ new WeakMap();
+/** The read-only information about a provider registration that a condition gets. */
+function providerInfo(registration) {
+	return Object.freeze({
+		key: registration.name,
+		owner: registration.container.owner,
+		metadata: registration.metadata
+	});
+}
+/**
+* Tells whether `condition` accepts the provider registration.
+* A thrown error counts as `false` and goes to the observe stream of the consumer.
+*/
+function acceptsProvider(consumer, keyName, condition, registration) {
+	let byProvider = verdicts.get(condition);
+	if (!byProvider) {
+		byProvider = /* @__PURE__ */ new WeakMap();
+		verdicts.set(condition, byProvider);
+	}
+	const known = byProvider.get(registration);
+	if (known !== void 0) return known;
+	let verdict;
+	try {
+		verdict = untracked(() => condition(providerInfo(registration))) === true;
+	} catch (error) {
+		verdict = false;
+		queueMicrotask(() => reportCallbackError(consumer.container, consumer.name, error, `A resolution condition for '${keyName}' threw. It counts as false.`));
+	}
+	byProvider.set(registration, verdict);
+	return verdict;
+}
+// src/graph/resolvers/plain.ts
+/**
+* Resolves one key name: the selected provider, and its instance when the provider serves.
+* A provider in conflict, or one that `condition` rejects, does not resolve.
+*/
+function resolveKey(consumer, keyName, condition) {
+	const selection = selectProvider(consumer.container, keyName, consumer);
+	if (!selection) return { kind: "missing" };
+	const { registration, provider } = selection;
+	const rivals = registration.signals.rivals();
+	if (rivals.length > 0) return {
+		kind: "conflict",
+		provider: registration,
+		rivals
+	};
+	if (condition && !acceptsProvider(consumer, keyName, condition, registration)) return {
+		kind: "rejected",
+		provider: registration
+	};
+	if (!provider) return {
+		kind: "not-running",
+		provider: registration
+	};
+	const instance = provider.signals.instance();
+	if (!provider.signals.serving() || !instance) return {
+		kind: "not-running",
+		provider
+	};
+	return {
+		kind: "resolved",
+		provider,
+		instance
+	};
+}
+/** Resolves a plain or an optional edge. It has one candidate key. */
+function resolvePlain(consumer, edge) {
+	const [keyName] = edge.candidates;
+	return keyName === void 0 ? { kind: "missing" } : resolveKey(consumer, keyName, edge.condition);
+}
+// src/graph/resolvers/fallback.ts
+/**
+* Resolves a `firstAvailable` edge. The first serving and available candidate wins.
+* If no serving candidate is available, the first serving candidate stays selected, so that a running dependent does not lose it.
+* Without a serving candidate, the edge reports the first candidate that exists.
+*/
+function resolveFallback(consumer, edge) {
+	let firstUnresolved;
+	let firstServing;
+	for (const keyName of edge.candidates) {
+		const resolution = resolveKey(consumer, keyName, edge.condition);
+		if (resolution.kind === "missing") continue;
+		if (resolution.kind !== "resolved") {
+			firstUnresolved ??= resolution;
+			continue;
+		}
+		if (isAvailable(resolution.provider)) return resolution;
+		firstServing ??= resolution;
+	}
+	return firstServing ?? firstUnresolved ?? { kind: "missing" };
+}
+// src/graph/status.ts
+const statusRank = {
+	ready: 0,
+	degraded: 1,
+	unavailable: 2
+};
+/** Tells whether `a` is worse than `b`. The order is `ready`, then `degraded`, then `unavailable`. */
+function worseThan(a, b) {
+	return statusRank[a] > statusRank[b];
+}
+function sameCause(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.key === b.key && a.owner === b.owner && a.status === b.status && a.reason === b.reason && sameCause(a.cause, b.cause);
+}
+/** Tells whether two status values have the same status, reason, and cause. */
+function sameStatus(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.status === b.status && a.reason === b.reason && sameCause(a.cause, b.cause);
+}
+function statusFields(status) {
+	return withoutUndefined({
+		reason: status.reason,
+		cause: status.cause
+	});
+}
+/** The cause that a dependent reports when `provider` makes its effective status worse. */
+function causeOf(provider, status) {
+	return Object.freeze({
+		key: provider.name,
+		owner: provider.container.owner,
+		status: status.status,
+		...withoutUndefined({
+			reason: status.reason,
+			cause: status.cause
+		})
+	});
+}
+/**
+* Creates the effective status of a service: the worst of the own status and the effective status of each required dependency.
+* An optional dependency does not count. It is `undefined` outside `running`.
+*/
+function createEffectiveStatus(input) {
+	const { phase, instance, edges, resolutions } = input;
+	return computed((previous) => {
+		const current = instance();
+		if (phase() !== "running" || !current) return void 0;
+		let result = current.signals.own();
+		for (const edge of edges) {
+			if (edge.optional) continue;
+			const resolution = resolutions.get(edge.name)?.();
+			if (resolution?.kind !== "resolved") continue;
+			const dependency = resolution.provider.signals.effective();
+			if (dependency && worseThan(dependency.status, result.status)) result = {
+				status: dependency.status,
+				cause: causeOf(resolution.provider, dependency)
+			};
+		}
+		return previous && sameStatus(previous, result) ? previous : result;
+	});
+}
+/** Reports a change of the effective status. The status effect of each service calls it. */
+function reportStatus(service, next) {
+	const previous = service.reportedStatus;
+	service.reportedStatus = next;
+	if (!next || sameStatus(previous, next)) return;
+	emitRecord(service.container, {
+		type: "status",
+		key: service.name,
+		owner: service.container.owner,
+		instanceId: service.signals.instance()?.id,
+		from: previous?.status,
+		to: next.status,
+		...statusFields(next)
+	});
+}
+// src/graph/nodes/service.ts
+/** Writes the phase and sends the change to the observe stream. */
+function setPhase(service, to, details = {}) {
+	const from = service.signals.phase();
+	if (from === to) return;
+	batch(() => {
+		service.signals.phase(to);
+		if (service.kind === "resolver") return;
+		emitRecord(service.container, {
+			type: "phase",
+			key: service.name,
+			owner: service.container.owner,
+			instanceId: service.signals.instance()?.id,
+			from,
+			to,
+			...withoutUndefined({
+				reason: details.reason,
+				decision: details.decision
+			})
+		});
+	});
+}
+function sameResolution(a, b) {
+	if (a.kind !== b.kind) return false;
+	switch (a.kind) {
+		case "missing": return true;
+		case "not-running":
+		case "rejected": return "provider" in b && a.provider === b.provider;
+		case "conflict": return b.kind === "conflict" && a.provider === b.provider && a.rivals === b.rivals;
+		case "resolved": return b.kind === "resolved" && a.provider === b.provider && a.instance === b.instance;
+	}
+}
+/** Creates the resolution of one declared edge. It keeps the previous value when nothing changed. */
+function resolveEdge(consumer, edge) {
+	return computed((previous) => {
+		const next = edge.fallback ? resolveFallback(consumer, edge) : resolvePlain(consumer, edge);
+		return previous && sameResolution(previous, next) ? previous : next;
+	});
+}
+const emptyMetadata$2 = Object.freeze({});
+const emptyPolicy$1 = Object.freeze({});
+/**
+* Creates a service with its signals, its derived values, and its effects.
+*
+* The main effect reads the derived values of the service and only marks the service dirty.
+* The status effect sends each change of the effective status to the observe stream.
+*/
+function createService(input) {
+	const { container } = input;
+	const { runtime } = container;
+	const present = signal(true);
+	const phase = signal(input.phase ?? "pending");
+	const instance = signal(void 0);
+	const demanded = signal(input.kind === "resolver");
+	const resolutions = /* @__PURE__ */ new Map();
+	const effective = createEffectiveStatus({
+		phase,
+		instance,
+		edges: input.edges,
+		resolutions
+	});
+	let rivals = () => [];
+	const service = {
+		seq: runtime.nextSeq(),
+		kind: input.kind,
+		name: input.name,
+		container,
+		edges: input.edges,
+		build: input.build,
+		metadata: input.metadata ?? emptyMetadata$2,
+		policy: input.policy ?? emptyPolicy$1,
+		exclusive: input.exclusive ?? false,
+		perConsumer: input.perConsumer ?? false,
+		template: input.template,
+		consumer: input.consumer,
+		registration: input.registration,
+		swap: input.swap,
+		replacedBy: void 0,
+		transaction: input.transaction,
+		revision: 0,
+		signals: {
+			present,
+			phase,
+			instance,
+			demanded,
+			active: computed(() => container.signals.started() || input.kind !== "invocation" && demanded()),
+			serving: computed(() => present() && phase() === "running"),
+			resolutions,
+			effective,
+			rivals: () => rivals(),
+			consumers: signal(/* @__PURE__ */ new Map()),
+			targetLost: computed(() => !present() || !service.signals.active() || service.signals.rivals().length > 0 || requiredWithdrawn(service))
+		},
+		busy: false,
+		stopIntent: {},
+		parkedEpoch: void 0,
+		failure: void 0,
+		teardownErrors: [],
+		withdrawal: createDeferred(),
+		reportedStatus: void 0,
+		disposeEffects: () => {}
+	};
+	for (const edge of input.edges) resolutions.set(edge.name, resolveEdge(service, edge));
+	rivals = createRivals(service);
+	const stopMain = withOwner(container.reactiveOwner, () => effect(() => {
+		present();
+		phase();
+		service.signals.active();
+		service.signals.rivals();
+		instance()?.signals.holders();
+		service.swap?.target.signals.present();
+		for (const resolution of resolutions.values()) {
+			const current = resolution();
+			if (current.kind === "not-running") current.provider.signals.phase();
+			if (current.kind === "resolved") current.provider.signals.effective();
+		}
+		runtime.reconciler.markDirty(service);
+	}));
+	const stopStatus = input.kind === "resolver" ? () => {} : withOwner(container.reactiveOwner, () => effect(() => {
+		const status = effective();
+		untracked(() => reportStatus(service, status));
+	}));
+	service.disposeEffects = () => {
+		stopMain();
+		stopStatus();
+	};
+	return service;
+}
+// src/graph/nodes/consumer.ts
+/**
+* Returns the service of a `perConsumer` registration for one consumer container. It creates the service on first use.
+*
+* The service lives in the consumer container, so it disposes with that container. Its build context has the owner of the container as `consumer`.
+* It returns `undefined` when the registration is withdrawn or the container disposal started.
+*/
+function ensureConsumerService(registration, container) {
+	const existing = registration.signals.consumers().get(container);
+	if (existing) return existing;
+	if (!registration.signals.present() || container.state !== "active") return void 0;
+	let service;
+	batch(() => {
+		service = createService({
+			container,
+			kind: "service",
+			name: registration.name,
+			edges: registration.edges,
+			build: registration.build,
+			metadata: registration.metadata,
+			policy: registration.policy,
+			exclusive: registration.exclusive,
+			template: registration,
+			consumer: container.owner
+		});
+		container.services.add(service);
+		publishService(service);
+	});
+	return service;
+}
+// src/types/keys.ts
+const optionalBrand = Symbol("injeca.optional");
+const fallbackBrand = Symbol("injeca.fallback");
+const conditionBrand = Symbol("injeca.condition");
+// src/primitives/keys.ts
+function assertName(name) {
+	if (typeof name !== "string" || name.length === 0 || name.trim() !== name) throw new InvalidArgumentError(`A key name must be a non-empty string without outer whitespace. Got ${JSON.stringify(name)}.`);
+}
+function readKeyOptions(options) {
+	if (options === void 0) return false;
+	if (typeof options !== "object" || options === null) throw new InvalidArgumentError("The options of defineKey must be an object.");
+	let exclusive;
+	try {
+		exclusive = options.exclusive;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the options of defineKey.", { cause: error });
+	}
+	if (exclusive !== void 0 && typeof exclusive !== "boolean") throw new InvalidArgumentError("The exclusive option of defineKey must be a boolean.");
+	return exclusive === true;
+}
+/**
+* Creates a typed key without a provider. A consumer can depend on it now. `provide(key, ...)` registers a provider later.
+*
+* With `options.exclusive`, the key can have only one provider in its resolution area. Two or more providers all go to `conflict`.
+*/
+function defineKey(name, options) {
+	assertName(name);
+	return readKeyOptions(options) ? Object.freeze({
+		key: name,
+		exclusive: true
+	}) : Object.freeze({ key: name });
+}
+/** Tells whether a key from `provide` or `defineKey` is exclusive. A name is not. Reading a caller-owned property happens once, inside a narrow `try`. */
+function isExclusiveKey(key) {
+	if (typeof key !== "object" || key === null) return false;
+	try {
+		return key.exclusive === true;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the exclusive property of the key.", { cause: error });
+	}
+}
+function normalizeName(nameOrProvidedKey) {
+	if (typeof nameOrProvidedKey === "object" && nameOrProvidedKey !== null && "key" in nameOrProvidedKey) return nameOrProvidedKey.key;
+	return nameOrProvidedKey;
+}
+const optionalMarkers = /* @__PURE__ */ new WeakSet();
+const fallbackMarkers = /* @__PURE__ */ new WeakSet();
+const conditionMarkers = /* @__PURE__ */ new WeakSet();
+function isConditionalDependency(value) {
+	return typeof value === "object" && value !== null && conditionMarkers.has(value);
+}
+function isFallbackDependency(value) {
+	return typeof value === "object" && value !== null && fallbackMarkers.has(value);
+}
+/**
+* Marks a fallback dependency. It resolves to the first provider in the list whose effective status is available.
+*
+* A change of the selection is a change of identity: the dependent gets `dependency-change`.
+* It is required, unless it is wrapped in `optional()`.
+*/
+function firstAvailable(...keys) {
+	if (keys.length === 0) throw new InvalidArgumentError("firstAvailable() needs at least one key.");
+	const dependencies = keys.map((key) => {
+		const name = normalizeName(key);
+		assertName(name);
+		return name;
+	});
+	if (new Set(dependencies).size !== dependencies.length) throw new InvalidArgumentError(`firstAvailable() got the same key more than once: ${dependencies.join(", ")}.`);
+	const marker = Object.freeze({
+		[fallbackBrand]: true,
+		dependencies: Object.freeze(dependencies)
+	});
+	fallbackMarkers.add(marker);
+	return marker;
+}
+function optionalMarker(dependencies, condition) {
+	const marker = Object.freeze({
+		[optionalBrand]: true,
+		dependencies,
+		...condition ? { condition } : {}
+	});
+	optionalMarkers.add(marker);
+	return marker;
+}
+/**
+* Marks an optional dependency. The dependent gets `{ value, status }`, or `undefined` when no provider runs.
+* It also accepts a `firstAvailable` marker and a `where` marker.
+*/
+function optional(dependency) {
+	if (isFallbackDependency(dependency)) return optionalMarker(dependency.dependencies, void 0);
+	if (isConditionalDependency(dependency)) return optionalMarker(dependency.dependencies, dependency.condition);
+	const name = normalizeName(dependency);
+	assertName(name);
+	return optionalMarker(Object.freeze([name]), void 0);
+}
+function where(dependency, condition) {
+	if (typeof condition !== "function") throw new InvalidArgumentError("The condition of where() is not a function.");
+	if (isOptionalDependency(dependency)) {
+		if (dependency.condition) throw new InvalidArgumentError("The optional dependency already has a condition.");
+		return optionalMarker(dependency.dependencies, condition);
+	}
+	if (isFallbackDependency(dependency) || isConditionalDependency(dependency)) throw new InvalidArgumentError("where() accepts a key, a name, or an optional() marker.");
+	const name = normalizeName(dependency);
+	assertName(name);
+	const marker = Object.freeze({
+		[conditionBrand]: true,
+		dependencies: Object.freeze([name]),
+		condition
+	});
+	conditionMarkers.add(marker);
+	return marker;
+}
+function isOptionalDependency(value) {
+	return typeof value === "object" && value !== null && optionalMarkers.has(value);
+}
+// src/graph/nodes/edge.ts
+function edgeOf(name, candidates, optional, fallback, condition) {
+	return Object.freeze({
+		name,
+		keyName: candidates.join(" | "),
+		candidates,
+		optional,
+		fallback,
+		...condition ? { condition } : {}
+	});
+}
+/**
+* Reads a `dependsOn` declaration into edges. Reading a caller-owned property happens once, inside a narrow `try`.
+*/
+function readEdges(owner, dependsOn) {
+	if (dependsOn === void 0 || dependsOn === null) return Object.freeze([]);
+	if (typeof dependsOn !== "object") throw new InvalidArgumentError(`The dependsOn option of '${owner}' is not an object.`);
+	let entries;
+	try {
+		entries = Object.entries(dependsOn);
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the dependsOn option of '${owner}'.`, { cause: error });
+	}
+	return Object.freeze(entries.map(([name, dependency]) => {
+		if (isOptionalDependency(dependency)) return edgeOf(name, dependency.dependencies, true, dependency.dependencies.length > 1, dependency.condition);
+		if (isConditionalDependency(dependency)) return edgeOf(name, dependency.dependencies, false, false, dependency.condition);
+		if (isFallbackDependency(dependency)) return edgeOf(name, dependency.dependencies, false, true);
+		if (typeof dependency === "string" || typeof dependency === "object" && dependency !== null && "key" in dependency) {
+			const keyName = normalizeName(dependency);
+			if (typeof keyName === "string" && keyName.length > 0) return edgeOf(name, Object.freeze([keyName]), false, false);
+		}
+		throw new InvalidArgumentError(`The dependency '${name}' of '${owner}' is not a name, a key, an optional marker, a fallback marker, or a condition marker.`);
+	}));
+}
+// src/graph/nodes/policy.ts
+const emptyPolicy = Object.freeze({});
+function readMaxAttempts(owner, value) {
+	if (value !== void 0 && (typeof value !== "number" || !Number.isInteger(value) || value < 1)) throw new InvalidArgumentError(`The maxAttempts option of ${owner} must be an integer of 1 or more. Got ${String(value)}.`);
+	return value;
+}
+function readTimeout$1(owner, hook, value) {
+	if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < 0)) throw new InvalidArgumentError(`The timeouts.${hook} option of ${owner} must be a finite number of 0 or more. Got ${String(value)}.`);
+	return value;
+}
+function readTimeouts(owner, value) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "object" || value === null) throw new InvalidArgumentError(`The timeouts option of ${owner} must be an object.`);
+	let fields;
+	try {
+		const source = value;
+		fields = {
+			start: source.start,
+			stop: source.stop
+		};
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the timeouts option of ${owner}.`, { cause: error });
+	}
+	const start = readTimeout$1(owner, "start", fields.start);
+	const stop = readTimeout$1(owner, "stop", fields.stop);
+	return Object.freeze({
+		...start === void 0 ? {} : { start },
+		...stop === void 0 ? {} : { stop }
+	});
+}
+/**
+* Checks the retry and timeout options that a caller gave. `owner` names the caller in the messages, for example `'voice.speech'`.
+* A field that is `undefined` takes the value of `inherit`, so that a replacement keeps it.
+*/
+function readPolicy(owner, fields, inherit) {
+	const maxAttempts = readMaxAttempts(owner, fields.maxAttempts) ?? inherit?.maxAttempts;
+	const timeouts = readTimeouts(owner, fields.timeouts) ?? inherit?.timeouts;
+	if (fields.onTimeout !== void 0 && typeof fields.onTimeout !== "function") throw new InvalidArgumentError(`The onTimeout option of ${owner} must be a function.`);
+	const onTimeout = fields.onTimeout ?? inherit?.onTimeout;
+	if (maxAttempts === void 0 && timeouts === void 0 && onTimeout === void 0) return emptyPolicy;
+	return Object.freeze({
+		...maxAttempts === void 0 ? {} : { maxAttempts },
+		...timeouts === void 0 ? {} : { timeouts },
+		...onTimeout === void 0 ? {} : { onTimeout }
+	});
+}
+/** The value of the nearest container, from `container` up to the root, that sets it. */
+function fromContainers(container, pick) {
+	for (let current = container; current; current = current.parent) {
+		const value = pick(current.policy);
+		if (value !== void 0) return value;
+	}
+}
+/** The attempt limit of a requeue: the decision, then the service, then the containers. `undefined` means no limit. */
+function maxAttemptsOf(service, fromDecision) {
+	return fromDecision ?? service.policy.maxAttempts ?? fromContainers(service.container, (policy) => policy.maxAttempts);
+}
+/** The timeout of a hook: the service, then the containers. `undefined` means no timeout. */
+function timeoutOf(service, hook) {
+	return service.policy.timeouts?.[hook] ?? fromContainers(service.container, (policy) => policy.timeouts?.[hook]);
+}
+/** The `onTimeout` handler: the service, then the containers. */
+function timeoutHandlerOf(service) {
+	return service.policy.onTimeout ?? fromContainers(service.container, (policy) => policy.onTimeout);
+}
+// src/graph/nodes/definition.ts
+const emptyMetadata$1 = Object.freeze({});
+function readMetadata(name, metadata, fallback) {
+	if (metadata === void 0) return fallback ?? emptyMetadata$1;
+	if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) throw new InvalidArgumentError(`The metadata option of '${name}' must be a record.`);
+	try {
+		return Object.freeze({ ...metadata });
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the metadata option of '${name}'.`, { cause: error });
+	}
+}
+/**
+* Reads the options of one registration once: the function shorthand, or the object form.
+* Reading caller-owned properties happens inside a narrow `try`. `inherit` gives the metadata and each policy field when the options have none.
+*/
+function readDefinition(name, option, inherit) {
+	let build;
+	let dependsOn;
+	let metadata;
+	let perConsumer;
+	let policy;
+	try {
+		const object = typeof option === "function" ? { build: option } : typeof option === "object" && option !== null ? option : {};
+		build = object.build;
+		dependsOn = object.dependsOn;
+		metadata = object.metadata;
+		perConsumer = object.perConsumer;
+		policy = {
+			maxAttempts: object.maxAttempts,
+			timeouts: object.timeouts,
+			onTimeout: object.onTimeout
+		};
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the provide options of '${name}'.`, { cause: error });
+	}
+	if (typeof build !== "function") throw new InvalidArgumentError(`The build option of '${name}' is not a function.`);
+	if (perConsumer !== void 0 && typeof perConsumer !== "boolean") throw new InvalidArgumentError(`The perConsumer option of '${name}' must be a boolean.`);
+	return {
+		edges: readEdges(name, dependsOn),
+		build,
+		metadata: readMetadata(name, metadata, inherit?.metadata),
+		perConsumer: perConsumer === true,
+		policy: readPolicy(`'${name}'`, policy, inherit?.policy)
+	};
+}
+// src/graph/nodes/registration.ts
+function createRegistration(container, name, exclusive) {
+	return {
+		container,
+		name,
+		exclusive,
+		current: void 0,
+		pending: void 0
+	};
+}
+/**
+* The published service of a registration that is still current, or `undefined` for a stale registration.
+* A registration is stale after its own withdrawal, or after a newer `provide` of the same key in the same container.
+*/
+function currentService(registration) {
+	const service = registration.current;
+	return service?.signals.present() ? service : void 0;
+}
+/** Cancels the replacement that waits for its swap. The old service does not change. */
+function cancelPending(registration) {
+	const pending = registration.pending;
+	if (!pending) return;
+	registration.pending = void 0;
+	pending.swap?.settle({ kind: "cancelled" });
+	releaseService(pending);
+}
+/** The `withdraw()` of a registration. Resolves `false` for a stale registration. Rejects with the teardown errors. */
+async function withdrawRegistration(registration) {
+	const service = untracked(() => {
+		const current = currentService(registration);
+		if (current) batch(() => {
+			cancelPending(registration);
+			releaseService(current);
+		});
+		return current;
+	});
+	if (!service) return false;
+	await awaitWithdrawal(service);
+	return true;
+}
+// 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/clock.ts
+const systemClock = Object.freeze({
+	now: () => Date.now(),
+	setTimeout: (callback, ms) => {
+		const handle = globalThis.setTimeout(callback, ms);
+		return () => globalThis.clearTimeout(handle);
+	}
+});
+// 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);
+	}
+}
+/** Only services with a key write to the logger. Invocations and resolvers do not. */
+function loggerOf(service) {
+	return service.kind === "service" ? service.container.api.logger : void 0;
+}
+function callListeners(listeners, ...args) {
+	for (const listener of [...listeners]) try {
+		listener(...args);
+	} catch (error) {
+		queueMicrotask(() => {
+			throw error;
+		});
+	}
+}
+// 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/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/helpers/timeout.ts
+/**
+* Waits for `promise` until `ms` milliseconds of `clock` pass.
+*
+* A rejection of `promise` before the timeout rejects the result. After the timeout, nothing waits for `promise`, and its rejection is not reported.
+*/
+function raceTimeout(clock, promise, ms) {
+	return new Promise((resolve, reject) => {
+		let done = false;
+		const cancel = clock.setTimeout(() => untracked(() => {
+			if (done) return;
+			done = true;
+			promise.catch(() => {});
+			resolve({ kind: "timeout" });
+		}), ms);
+		promise.then((value) => {
+			if (done) return;
+			done = true;
+			cancel();
+			resolve({
+				kind: "settled",
+				value
+			});
+		}, (error) => {
+			if (done) return;
+			done = true;
+			cancel();
+			reject(error);
+		});
+	});
+}
+// 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 })
+	});
+}
+/** Starts a hook run. Its signal aborts when a newer target supersedes it, when it times out, or when the instance is disposed. */
+function beginHookRun(instance) {
+	const controller = new AbortController();
+	const parent = instance.controller.signal;
+	const forward = () => controller.abort(parent.reason);
+	if (parent.aborted) forward();
+	else parent.addEventListener("abort", forward, { once: true });
+	instance.hookRun = controller;
+	return {
+		signal: controller.signal,
+		abort: (reason) => controller.abort(reason),
+		end: () => {
+			parent.removeEventListener("abort", forward);
+			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. A value that is not a decision of this hook, a promise, a throw, or no handler gives `fail` with `hook-timeout`.
+*/
+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 handler = timeoutHandlerOf(service);
+	if (!handler) return decide.fail(error, { reason: error.message });
+	try {
+		const value = untracked(() => handler(Object.freeze({
+			hook,
+			timeoutMs,
+			attempt: state.attempt,
+			previous: state.previous,
+			decide
+		})));
+		return validateDecision(run, value) ?? decide.fail(error, { reason: error.message });
+	} 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);
+}
+/**
+* Runs the `stop` hooks in reverse order, then the effect disposers in reverse order.
+*
+* A configured `stop` timeout covers all of them. When it passes, injeca records it, applies the `onTimeout` decision, and stops waiting.
+* 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 cannot block that disposal.
+*/
+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 : clock.now() + timeoutMs;
+	let timedOut = false;
+	/** Waits for one callback until the deadline. `undefined` means that the deadline passed. */
+	const settle = async (promise) => {
+		if (deadline === void 0) return { value: await promise };
+		if (timedOut) {
+			promise.catch(() => {});
+			return;
+		}
+		const result = await raceTimeout(clock, promise, Math.max(0, deadline - clock.now()));
+		if (result.kind === "settled") return { value: result.value };
+		timedOut = true;
+		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, instance.controller.signal, {}, call));
+			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));
+	} catch (error) {
+		errors.push(error);
+	}
+	return errors;
+}
+async function teardown(service, instance, stopHooks, phase) {
+	service.busy = true;
+	cancelRequeueWait(instance);
+	instance.extraHolds.clear();
+	if (phase) setPhase(service, phase, { reason: service.stopIntent.reason });
+	const frame = service.container.frame;
+	const errors = await service.container.runtime.context.run(frame, () => runTeardownCallbacks(service, instance, stopHooks, frame));
+	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
+/**
+* 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.
+* At the timeout, the run aborts, later handlers do not run, and the `onTimeout` decision replaces the result. Late decisions are recorded as ignored.
+*/
+async function runAttempt(service, instance) {
+	const run = beginHookRun(instance);
+	const progress = { index: instance.startFrom };
+	let timedOut = false;
+	const running = runHandlers(service, instance, "start", run.signal, {}, {
+		from: instance.startFrom,
+		progress,
+		stopped: () => timedOut
+	});
+	const timeoutMs = timeoutOf(service, "start");
+	const result = timeoutMs === void 0 ? {
+		kind: "settled",
+		value: await running
+	} : await raceTimeout(service.container.runtime.clock, running, timeoutMs);
+	instance.startFrom = progress.index;
+	if (result.kind === "settled") {
+		run.end();
+		return result.value;
+	}
+	timedOut = true;
+	run.abort(new HookTimeoutError(`The 'start' hook of '${service.name}' timed out.`, "start", timeoutMs));
+	run.end();
+	running.then((late) => {
+		for (const decision of late) recordDecision(service, instance, decision, true);
+	});
+	return [decideTimeout(service, instance, "start", timeoutMs)];
+}
+/**
+* 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 decisions = handlers.length > instance.startFrom ? await runAttempt(service, instance) : [];
+	service.busy = false;
+	const ignored = 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") {
+		if (decision) finishRun(instance, "start", decision);
+		logger?.hookOnStartComplete(service.name, performance.now() - startTime);
+		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
+/**
+* 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 container of `service`. The nearest registration of each key is demanded.
+*/
+function demandProviders(service) {
+	for (const edge of service.edges) for (const keyName of edge.candidates) {
+		const [nearest] = candidatesOf(service.container, keyName, service).map((registration) => registration.perConsumer ? ensureConsumerService(registration, service.container) : registration);
+		if (nearest && !nearest.signals.serving() && !nearest.signals.demanded()) nearest.signals.demanded(true);
+	}
+}
+/**
+* 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,
+		disposed: false
+	};
+	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, condition, members, built) {
+	const member = members.get(keyName);
+	if (member && member !== service) {
+		if (inConflict(member) || condition && !acceptsProvider(service, keyName, condition, member)) return void 0;
+		return memberEntry(member, built);
+	}
+	const resolution = resolveKey(service, keyName, condition);
+	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.condition, 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();
+	}
+	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/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;
+	}
+	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;
+	}
+	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) enterStopping(service, {
+			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);
+			enterStopping(service, {
+				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 "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 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 logger = options.enabled === false ? createNoopLogger() : 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,
+		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()
+		},
+		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.
+*/
+function effect$1(container, setup) {
+	const node = nodeOf(container);
+	assertActive(node, "add an effect");
+	if (typeof setup !== "function") throw new InvalidArgumentError("The effect setup is not a function.");
+	const disposer = untracked(setup);
+	if (typeof disposer === "function") node.effects.push(disposer);
+}
+/**
+* Starts the disposal of `container` and of its descendants.
+*
+* The synchronous part withdraws all services of the subtree in the caller's batch, so that dependents stop without a rebuild.
+*/
+function beginDisposal(container, parentFrame) {
+	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."));
+	const withdrawn = /* @__PURE__ */ new Set();
+	for (const service of container.services) if (service.signals.present()) {
+		releaseService(service);
+		withdrawn.add(service);
+	}
+	const children = [...container.children].reverse().map((child) => {
+		const disposal = beginDisposal(child, frame);
+		disposal.catch(() => {});
+		return disposal;
+	});
+	container.disposal = context.run(frame, async () => {
+		const errors = [];
+		for (const service of [...container.services]) {
+			const serviceErrors = await service.withdrawal.promise;
+			if (withdrawn.has(service)) errors.push(...serviceErrors);
+		}
+		for (const child of children) try {
+			await child;
+		} catch (error) {
+			errors.push(error);
+		}
+		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;
+}
+/**
+* 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 call from the cleanup chain of the same container rejects with `reentrant-dispose`. A second call from outside gets the same promise.
+*/
+function dispose(container) {
+	const node = nodeOf(container);
+	const { context } = node.runtime;
+	if (context.isActive(node)) return Promise.reject(new ReentrantDisposeError("dispose() was called from the cleanup chain of the same container."));
+	if (node.disposal) return node.disposal;
+	return untracked(() => {
+		let disposal;
+		batch(() => {
+			disposal = beginDisposal(node, context.current());
+		});
+		return disposal;
+	});
+}
+// 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;
+	});
+	container.logger.invoke(edges.map((edge) => edge.keyName));
+	return Object.freeze({ withdraw: () => withdrawService(registered) });
+}
+// 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);
+		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();
+	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)
+	});
+}
+/** 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)}`);
+		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'`.
+* With `timeoutMs`, it rejects with `start-timeout` and the explanation of each service that is not `running`.
+*/
+function waitUntilSettled(containers, check, timeoutMs) {
+	const { clock, reconciler } = containers[0].runtime;
+	return new Promise((done, fail) => {
+		let cancelTimeout = () => {};
+		const stopListening = reconciler.onDrained(() => {
+			const result = check(presentServices(containers));
+			if (result === "waiting") return;
+			stopListening();
+			cancelTimeout();
+			if (result.kind === "done") done();
+			else fail(errorFrom(result.errors, "Start failed."));
+		});
+		if (timeoutMs !== void 0) cancelTimeout = clock.setTimeout(() => untracked(() => {
+			stopListening();
+			const explanations = presentServices(containers).filter((service) => service.signals.phase() !== "running").map(explainService);
+			fail(new StartTimeoutError(`start() timed out after ${timeoutMs}ms. These services are not running:\n${describeExplanations(explanations)}`, explanations));
+		}), timeoutMs);
+		reconciler.requestDrain();
+	});
+}
+function readTimeout(options) {
+	let timeoutMs;
+	try {
+		timeoutMs = options?.timeoutMs;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the start options.", { cause: error });
+	}
+	if (timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs < 0)) throw new InvalidArgumentError(`The timeoutMs option of start must be a finite number of 0 or more. Got ${String(timeoutMs)}.`);
+	return timeoutMs;
+}
+/**
+* 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 `timeoutMs` is set.
+* 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 timeoutMs = readTimeout(options);
+	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";
+		}, timeoutMs);
+	}).then(() => container.logger.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.
+*/
+async function stop$1(container) {
+	const node = nodeOf(container);
+	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);
+		});
+		return waitUntilSettled(containers, (services) => services.every((service) => service.signals.instance() === void 0 && !transitionalPhases.has(service.signals.phase())) ? { kind: "done" } : "waiting");
+	});
+	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
+/**
+* Creates a new service that replaces `target` after it completes `start`. It is not published before the swap.
+* `onSwap` runs at the swap, before the outcome settles.
+*/
+function createSuccessor(target, definition, template, onSettle, extra = {}) {
+	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,
+			template,
+			consumer: target.consumer,
+			registration: target.registration,
+			...extra,
+			swap: {
+				target,
+				settle: (result) => {
+					if (settled) return;
+					settled = true;
+					onSettle(service, result);
+					outcome.resolve(result);
+				}
+			}
+		});
+		service.signals.demanded(target.signals.demanded());
+		target.container.services.add(service);
+	});
+	return {
+		service,
+		outcome: outcome.promise
+	};
+}
+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,
+			perConsumer: target.perConsumer,
+			registration
+		});
+		service.signals.demanded(target.signals.demanded());
+		target.container.services.add(service);
+		takeOver(registration, target, service);
+	});
+	return service;
+}
+/**
+* Moves the consumer services of the `perConsumer` registration `target` to `template`, in the caller's batch.
+* Each running consumer service gets a new service that swaps in after it completes `start`. The others leave and build again on demand.
+*/
+function moveConsumers(registration, target, template, definition) {
+	const consumers = target.signals.consumers();
+	target.signals.consumers(/* @__PURE__ */ new Map());
+	takeOver(registration, target, template);
+	const swaps = [];
+	const kept = /* @__PURE__ */ new Map();
+	for (const [container, consumer] of consumers) {
+		consumer.template = template;
+		if (consumer.signals.serving()) {
+			kept.set(container, consumer);
+			swaps.push(createSuccessor(consumer, definition, template, () => {}));
+		} else consumer.signals.present(false);
+	}
+	template.signals.consumers(kept);
+	return swaps;
+}
+/** Replaces a `perConsumer` registration. The new registration takes the slot at once. Its consumer services swap in one by one. */
+function replaceRegistrationTemplate(registration, target, definition) {
+	let swaps = [];
+	batch(() => {
+		const 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,
+			perConsumer: true,
+			registration
+		});
+		target.container.services.add(template);
+		swaps = moveConsumers(registration, target, template, definition);
+	});
+	return swaps;
+}
+/** 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, void 0, settleRegistration(registration), extra);
+	if (!extra?.transaction) {
+		cancelPending(registration);
+		registration.pending = pending.service;
+	}
+	return pending;
+}
+/** The `replace()` of a registration. */
+async function replace(registration, option) {
+	const target = untracked(() => currentService(registration));
+	if (!target) return false;
+	const definition = readDefinition(registration.name, option, target);
+	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) {
+		const swaps = untracked(() => replaceRegistrationTemplate(registration, target, definition));
+		const errors = (await Promise.all(swaps.map((swap) => swap.outcome))).flatMap((outcome) => outcome.kind === "failed" ? [outcome.error] : []);
+		if (errors.length > 0) throw errorFrom(errors, `The replacement of '${registration.name}' failed for some consumers.`);
+		return true;
+	}
+	if (phase !== "running") {
+		untracked(() => replaceAtOnce(registration, target, definition));
+		return true;
+	}
+	return outcomeResult(await untracked(() => replaceRunning(registration, target, definition)).outcome, registration.name);
+}
+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()`. */
+function registrationApi(registration) {
+	const api = Object.freeze({
+		key: registration.name,
+		...registration.exclusive ? { exclusive: true } : {},
+		withdraw: () => withdrawRegistration(registration),
+		replace: ((option) => replace(registration, option))
+	});
+	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`. */
+function assertNoDuplicate(container, name) {
+	if (slotOf(container, name)() && container.signals.started()) throw new DuplicateServiceError(`The started container already has a registration for '${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,
+		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 definition = readDefinition(name, normalizeProvideOption(nameOrOption, option));
+	const exclusive = isExclusiveKey(nameOrOption);
+	const registration = untracked(() => register(node, name, definition, exclusive));
+	container.logger.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. The values can become stale after a run-time change. Use it for one-time code.
+*/
+function resolve$1(container, dependsOn) {
+	const node = nodeOf(container);
+	assertActive(node, "resolve");
+	const edges = readEdges("resolve", dependsOn);
+	const { reconciler } = node.runtime;
+	return new Promise((done, fail) => untracked(() => {
+		let settled = false;
+		let service;
+		let stopListening = () => {};
+		const finish = (outcome) => {
+			if (settled) return;
+			settled = true;
+			stopListening();
+			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));
+		});
+		service.withdrawal.promise.then(() => finish(() => fail(new BuildAfterDisposeError("The container was disposed before resolve() got its dependencies."))));
+	}));
+}
+// 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);
+	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
+			}, 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`. */
+function publishMembers(members, built) {
+	batch(() => {
+		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) moveConsumers(registration, target, service, {
+				edges: service.edges,
+				build: service.build,
+				metadata: service.metadata,
+				perConsumer: true,
+				policy: service.policy
+			});
+			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(members, new Set(outcome.built.keys())));
+	transaction.state = "done";
+	transaction.container.transactions.delete(transaction);
+	startMembers(order, outcome.built);
+}
+function startCommit(transaction) {
+	if (transaction.state !== "open") return Promise.reject(new InvalidArgumentError(`The transaction is ${transaction.state === "aborted" ? "aborted" : "already committed"}.`));
+	transaction.state = "committing";
+	const result = commit(transaction).catch((error) => {
+		if (transaction.state !== "done") {
+			transaction.state = "aborted";
+			transaction.container.transactions.delete(transaction);
+		}
+		throw error;
+	});
+	transaction.settled = result.then(() => {}, () => {});
+	return result;
+}
+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
+		};
+		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);
+		const entry = entryOf$1(state, name, isExclusiveKey(key));
+		entry.declared = readEdges(name, dependsOn);
+		entry.optional = optional;
+	};
+	const provide = ((key, option) => {
+		assertOpen(state, "provide");
+		const name = readName(key, "provide");
+		const existing = state.entries.get(name);
+		if (existing?.definition) throw new DuplicateServiceError(`The transaction already provides '${name}'.`);
+		const read = readDefinition(name, option);
+		const entry = entryOf$1(state, name, isExclusiveKey(key) || existing?.exclusive === true);
+		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;
+		return registrationApi(registration);
+	});
+	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;
+	});
+	return Object.freeze({
+		declare,
+		provide,
+		replace,
+		commit: () => untracked(() => startCommit(state)),
+		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.container, keyName, consumer).some((registration) => {
+		const provider = serviceFor(registration, consumer.container);
+		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
+	});
+}
+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
+	});
+}
+/** 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.container, 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,
+		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, then from its ancestors. 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);
+			return declared && Object.freeze({
+				name,
+				kind: "service",
+				owner: declared.container.owner,
+				phase: "declared",
+				blockers: Object.freeze([])
+			});
+		})
+	});
+}
+// 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) {
+	return resolve$1(globalContainer, dependsOn);
+}
+function start(options) {
+	return start$1(globalContainer, options);
+}
+function stop() {
+	return stop$1(globalContainer);
+}
+export { assertActive as A, firstAvailable as C, statusFields as D, where as E, createDefaultLogger as F, createLoggLogger as I, createNoopLogger as L, findProvider as M, untracked as N, reportCallbackError as O, withOwner as P, defineKey as S, optional as T, invoke$1 as _, resolve as a, effect$1 as b, stop as c, transaction as d, resolve$1 as f, stop$1 as g, start$1 as h, resetContainer as i, nodeOf as j, withoutUndefined as k, listeners as l, listen as m, invoke as n, setLogger as o, provide$1 as p, provide as r, start as s, getContainer as t, graph as u, createContainer as v, normalizeName as w, systemClock as x, dispose as y };
+
+//# sourceMappingURL=global-C0Nk0pU8.mjs.map