injeca 0.3.0 → 0.4.0

package/dist/{global-C0Nk0pU8.mjs → global-B5N-d-TO.mjs}

@@ -1,6 +1,5 @@
-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 { $ as candidatesOf, A as causeOf, B as withoutUndefined, Dt as StartTimeoutError, E as ensureConsumerService, Et as StaleRegistrationError, F as resolvePlain, G as nodeOf, H as affectedContainers, I as acceptsCandidate, J as releasePresent, K as publishService, L as emitRecord, N as resolveFallback, O as createService, Ot as TransactionIncompleteError, P as resolveKey, Q as buildLost, R as recordAbortedWait, S as normalizeName, St as InvalidArgumentError, U as assertActive, V as createDeferred, W as awaitWithdrawal, X as subtreeOf, Y as releaseService, Z as blockingFailure, _ as timeoutOf, _t as BuildAfterDisposeError, a as releaseReservations, at as resolutionOf, bt as HookTimeoutError, c as cancelPending, ct as serviceFor, d as currentService, dt as removeDeclaration, et as epochOf, f as releaseRegistration, ft as errorFrom, g as timeoutHandlerOf, gt as withOwner, h as readPolicy, ht as untracked, i as releaseReservation, it as requiredWithdrawn, j as sameStatus, k as setPhase, kt as WaitTimeoutError, l as cancelSuccessor, lt as slotOf, m as maxAttemptsOf, mt as batch, n as defaultDecision, nt as requiredAvailable, o as reserveKey, ot as resolvedInstance, p as readDefinition, pt as messageOf, q as registerNode, r as validateDecision, rt as requiredChanged, s as reservedBy, st as selectProvider, t as createDecide, tt as findProvider, u as createRegistration, ut as inConflict, v as readEdges, vt as DuplicateServiceError, wt as ReplaceWhileStoppingError, x as isExclusiveKey, yt as HookOutsideBuildError } from "./decision-BXZu3N1O.mjs";
+import { effectScope, getActiveSub, signal } from "alien-signals";
 import ErrorStackParser from "error-stack-parser";
 import { nanoid } from "nanoid";
 // package.json
@@ -41,6 +40,9 @@ function createDefaultLogger() {
 		},
 		running: () => {
 			console.log(`[${name}] RUNNING`);
+		},
+		warn: (message) => {
+			console.warn(`[${name}] WARN       ${message}`);
 		}
 	};
 }
@@ -74,6 +76,9 @@ function createLoggLogger(logg) {
 		},
 		running: () => {
 			logg.log(`RUNNING`);
+		},
+		warn: (message) => {
+			logg.warn(message);
 		}
 	};
 }
@@ -87,964 +92,180 @@ function createNoopLogger() {
 		hookOnStartComplete: () => {},
 		hookOnStop: () => {},
 		hookOnStopComplete: () => {},
-		running: () => {}
+		running: () => {},
+		warn: () => {}
 	};
 }
-// 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;
+// src/helpers/clock.ts
+const systemClock = Object.freeze({
+	now: () => Date.now(),
+	setTimeout: (callback, ms) => {
+		const handle = globalThis.setTimeout(callback, ms);
+		return () => globalThis.clearTimeout(handle);
 	}
-	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`.
+* Calls `callback` after `ms` milliseconds of `clock`, like `clock.setTimeout`. Returns a function that cancels the call.
 *
-* 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.
+* With `systemClock`, the timer does not keep a Node process alive, as for `AbortSignal.timeout()`. Other clocks get a plain `setTimeout` call.
 */
-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;
+function setWeakTimeout(clock, callback, ms) {
+	if (clock !== systemClock) return clock.setTimeout(callback, ms);
+	const handle = globalThis.setTimeout(callback, ms);
+	if (typeof handle === "object" && handle !== null && typeof handle.unref === "function") handle.unref();
+	return () => globalThis.clearTimeout(handle);
 }
-/** 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);
-	});
+// src/helpers/abort.ts
+/** The reason of a timeout signal: a `DOMException` with the name `TimeoutError`, as for `AbortSignal.timeout()`. */
+function timeoutReason(message) {
+	return new DOMException(message, "TimeoutError");
 }
-/** 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);
+/** Returns `true` when `reason` names itself a timeout: `reason.name === 'TimeoutError'`. The reason of `AbortSignal.timeout()` and of `timeout()` passes. */
+function isTimeoutReason(reason) {
+	return typeof reason === "object" && reason !== null && reason.name === "TimeoutError";
 }
-/** 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("|");
+/** The rejection of a wait for a state that `reason` aborted: `wait-timeout` with the reason as `cause` for a timeout reason, else the reason itself. */
+function waitAbortError(reason, message) {
+	return isTimeoutReason(reason) ? new WaitTimeoutError(message, { cause: reason }) : reason;
 }
 /**
-* Finds the failure that blocks a pending service: a required provider in `failed`, directly or through pending providers.
+* Aborts `controller` when one of `sources` aborts, with the reason of that source.
+* Returns a function that removes the listeners. The listeners also go when the first source aborts.
 */
-function 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;
+function forwardAbort(controller, sources) {
+	const listeners = [];
+	const release = () => {
+		for (const [source, listener] of listeners.splice(0)) source.removeEventListener("abort", listener);
+	};
+	for (const source of sources) {
+		if (source.aborted) {
+			release();
+			controller.abort(source.reason);
+			return release;
 		}
+		const listener = () => {
+			release();
+			controller.abort(source.reason);
+		};
+		source.addEventListener("abort", listener, { once: true });
+		listeners.push([source, listener]);
 	}
+	return release;
 }
-// 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)];
-}
+/** The signals that each combined signal of `anySignal` comes from. A derived signal keeps the origin of its sources. */
+const parents = /* @__PURE__ */ new WeakMap();
 /**
-* 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.
+* Returns a signal that aborts when one of `signals` aborts, with the reason of the first one. `undefined` entries are skipped.
+*
+* It uses `AbortSignal.any` when the runtime has it. Otherwise it forwards the abort, and removes its listeners from all signals when it aborts.
 */
-function 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);
+function anySignal(...signals) {
+	const sources = signals.filter((signal) => signal !== void 0);
+	if (sources.length === 1) return sources[0];
+	let signal;
+	if (typeof AbortSignal.any === "function") signal = AbortSignal.any(sources);
+	else {
+		const controller = new AbortController();
+		forwardAbort(controller, sources);
+		signal = controller.signal;
+	}
+	parents.set(signal, sources);
+	return signal;
+}
+/** Lists `signal` and each signal that it comes from through `anySignal`, `withTimeout` included, nearest first. */
+function signalSources(signal) {
+	const seen = /* @__PURE__ */ new Set([signal]);
+	const queue = [signal];
+	for (let index = 0; index < queue.length; index++) for (const parent of parents.get(queue[index]) ?? []) if (!seen.has(parent)) {
+		seen.add(parent);
+		queue.push(parent);
+	}
+	return queue;
 }
 /**
-* 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.
+* Creates a signal that aborts after `ms` milliseconds of `clock`, with the result of `reason`.
+*
+* With `weak` and the system clock, the timer does not keep a Node process alive, as for `AbortSignal.timeout()`.
 */
-function 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;
+function timeoutSignal(clock, ms, reason, weak = false) {
+	const controller = new AbortController();
+	const abort = () => untracked(() => controller.abort(reason()));
+	const cancel = weak ? setWeakTimeout(clock, abort, ms) : clock.setTimeout(abort, ms);
 	return {
-		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
+		signal: controller.signal,
+		cancel
 	};
-	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;
+/** Reads and checks the `signal` option of `options` once. `action` names the call in errors. */
+function readSignal(options, action) {
+	let signal;
 	try {
-		verdict = untracked(() => condition(providerInfo(registration))) === true;
+		signal = options?.signal;
 	} catch (error) {
-		verdict = false;
-		queueMicrotask(() => reportCallbackError(consumer.container, consumer.name, error, `A resolution condition for '${keyName}' threw. It counts as false.`));
+		throw new InvalidArgumentError(`Cannot read the ${action} options.`, { cause: error });
 	}
-	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
-	};
+	if (signal !== void 0 && !(signal instanceof AbortSignal)) throw new InvalidArgumentError(`The signal option of ${action} must be an AbortSignal.`);
+	return signal;
 }
-/** 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);
+/** Calls `callback` with the reason when `signal` aborts. Returns a function that removes the listener. The callback is an entry point, so it runs untracked. */
+function onAbort(signal, callback) {
+	if (!signal) return () => {};
+	const listener = () => untracked(() => callback(signal.reason));
+	signal.addEventListener("abort", listener, { once: true });
+	return () => signal.removeEventListener("abort", listener);
 }
-// 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.
+* Waits for `promise` until `signal` aborts. At the abort, it rejects with the result of `reasonOf`, and nothing waits for `promise` any more.
+*
+* A rejection of `promise` after the abort is not reported. The listener goes when the wait settles.
 */
-function 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;
+function abortable(promise, signal, reasonOf = (reason) => reason) {
+	if (!signal) return promise;
+	if (signal.aborted) {
+		promise.catch(() => {});
+		return Promise.reject(reasonOf(signal.reason));
 	}
-	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
-			})
+	return new Promise((resolve, reject) => {
+		const remove = onAbort(signal, (reason) => {
+			promise.catch(() => {});
+			reject(reasonOf(reason));
 		});
-	});
-}
-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
+		promise.then((value) => {
+			remove();
+			resolve(value);
+		}, (error) => {
+			remove();
+			reject(error);
 		});
-		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.
+* Waits for `promise` until `signal` aborts. An aborted signal gives `aborted` at once.
 *
-* 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`.
+* A rejection of `promise` before the abort rejects the result. After the abort, nothing waits for `promise`, and its rejection is not reported.
 */
-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);
+function raceAbort(promise, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			promise.catch(() => {});
+			resolve({ kind: "aborted" });
+			return;
 		}
-		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);
+		const remove = onAbort(signal, () => {
+			promise.catch(() => {});
+			resolve({ kind: "aborted" });
+		});
+		promise.then((value) => {
+			remove();
+			resolve({
+				kind: "settled",
+				value
+			});
+		}, (error) => {
+			remove();
+			reject(error);
 		});
-		return current;
 	});
-	if (!service) return false;
-	await awaitWithdrawal(service);
-	return true;
 }
 // src/helpers/cleanup-context.ts
 function activeIn(frame, owner) {
@@ -1070,14 +291,6 @@ function createSynchronousContext() {
 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 = [];
@@ -1248,9 +461,13 @@ function invokeUser(fn) {
 		return Promise.reject(error);
 	}
 }
-/** Only services with a key write to the logger. Invocations and resolvers do not. */
+/** The logger of the lifecycle trace of `container`, or `undefined` when its `logging` option is off. `warn` does not use it. */
+function traceLoggerOf(container) {
+	return container.logging ? container.logger : void 0;
+}
+/** Only services with a key write the lifecycle trace. Invocations and resolvers do not. */
 function loggerOf(service) {
-	return service.kind === "service" ? service.container.api.logger : void 0;
+	return service.kind === "service" ? traceLoggerOf(service.container.api) : void 0;
 }
 function callListeners(listeners, ...args) {
 	for (const listener of [...listeners]) try {
@@ -1261,6 +478,19 @@ function callListeners(listeners, ...args) {
 		});
 	}
 }
+// src/reconciler/demand.ts
+/**
+* An active service makes the providers of its edges converge too, before `start()`. A fallback edge demands each candidate.
+* A `perConsumer` registration gets a service for the scope of `service`. The nearest registration of each key is demanded.
+*
+* A pending service demands its providers before it builds. A running service demands them too, so that an optional or a fallback edge to a key that registers later gets its consumer service.
+*/
+function demandProviders(service) {
+	for (const edge of service.edges) for (const keyName of edge.candidates) {
+		const [nearest] = candidatesOf(service.scope, keyName, service).map((registration) => registration.perConsumer ? ensureConsumerService(registration, service.scope, service) : registration);
+		if (nearest && !nearest.signals.serving() && !nearest.signals.demanded()) nearest.signals.demanded(true);
+	}
+}
 // src/reconciler/holds.ts
 function addHolder(provider, holder) {
 	const holders = provider.signals.holders();
@@ -1286,6 +516,115 @@ function releaseExtraHolds(service, instance) {
 	instance.extraHolds.clear();
 	batch(() => syncHolds(service, instance));
 }
+// src/reconciler/reentry.ts
+/** The instance of each signal that injeca gives to a run: the build signal of an instance, and the signal of each hook run. */
+const signalOrigins = /* @__PURE__ */ new WeakMap();
+/** The service of each cleanup frame of a teardown. */
+const frameServices = /* @__PURE__ */ new WeakMap();
+/** Records that `signal` belongs to the runs of `instance`. A signal from `anySignal` or `withTimeout` on top of it keeps this origin. */
+function recordSignalOrigin(signal, instance) {
+	signalOrigins.set(signal, instance);
+}
+/** Creates the cleanup frame of a teardown of `service`, inside `parent`. The teardown sets `active` to `false` when it ends. */
+function serviceFrame(service, parent) {
+	const frame = {
+		owner: service,
+		parent,
+		active: true
+	};
+	frameServices.set(frame, service);
+	return frame;
+}
+function within(container, ancestor) {
+	for (let current = container; current; current = current.parent) if (current === ancestor) return true;
+	return false;
+}
+/** Finds a cleanup that `covers` names, by the origin of `signal`, then by the synchronous cleanup frames. The instance of a signal counts only while its teardown runs. */
+function findCleanup(context, signal, covers) {
+	if (signal) for (const source of signalSources(signal)) {
+		const instance = signalOrigins.get(source);
+		if (instance && instance.tearingDown && !instance.disposed && covers(instance.service, instance)) return {
+			service: instance.service,
+			instance
+		};
+	}
+	for (let frame = context.current(); frame; frame = frame.parent) {
+		const service = frame.active ? frameServices.get(frame) : void 0;
+		if (service && covers(service, service.signals.instance())) return { service };
+	}
+}
+/**
+* Tells whether the teardown of `instance` is part of a stop that waits for each service that `stops` names.
+* It is when the service of `instance` is such a service, or when `instance` holds an instance of one, directly or through other instances.
+* The teardown of a held instance waits until its holders release it, so it waits for `instance` too.
+*/
+function waitedFor(instance, stops) {
+	const seen = /* @__PURE__ */ new Set([instance]);
+	const queue = [instance];
+	for (let index = 0; index < queue.length; index++) {
+		const current = queue[index];
+		if (stops(current.service)) return true;
+		for (const provider of current.held) if (!seen.has(provider)) {
+			seen.add(provider);
+			queue.push(provider);
+		}
+	}
+	return false;
+}
+/** Finds a cleanup whose teardown the wait for the services that `stops` names includes. */
+function findWaitedCleanup(context, signal, stops) {
+	return findCleanup(context, signal, (service, instance) => stops(service) || instance !== void 0 && waitedFor(instance, stops));
+}
+/**
+* Finds out whether a `stop()` or `dispose()` of `target` comes from a cleanup that the call waits for. Such a call cannot wait, because the wait includes the caller.
+*
+* - The cleanup is of a service of the subtree, or of a container effect of the subtree.
+* - Or the cleanup is of a service outside the subtree that holds a service that the call stops, directly or through other instances. That service waits for its holders.
+*   `dispose()` also withdraws the consumer services of each `perConsumer` registration of the subtree, so they count for it.
+* - With `signal`: the signal, or a signal that it comes from, belongs to such an instance whose teardown runs.
+*   The check uses the instance, not the phase of its service. So the teardown of a successor whose build failed, or of an old instance during a rebuild, counts too.
+* - Without it: the synchronous part of such a teardown makes the call.
+*
+* A call without a signal after an `await` is not found. A configured `stop` timeout ends that cleanup.
+*/
+function findReentry(target, call, signal) {
+	const { context } = target.runtime;
+	const found = findWaitedCleanup(context, signal, call === "dispose" ? (service) => within(service.container, target) || service.template !== void 0 && within(service.template.container, target) : (service) => within(service.container, target));
+	if (found) return found;
+	return context.isActive(target) ? { service: void 0 } : void 0;
+}
+/**
+* Finds out whether a `withdraw()` of `target` comes from a cleanup that the withdrawal waits for: of `target`, of a consumer service of it, or of a service that holds one of them, directly or through other instances.
+* The rules are the same as for `findReentry`.
+*/
+function findWithdrawReentry(target, signal) {
+	return findWaitedCleanup(target.container.runtime.context, signal, (service) => service === target || service.template === target);
+}
+function describeOwner(container) {
+	return JSON.stringify(container.owner);
+}
+const actions = {
+	stop: "stop",
+	dispose: "disposal",
+	withdraw: "withdrawal"
+};
+/**
+* Warns on the logger of `target` and sends a `reentrant-call` record. The call then resolves at once.
+* `subject` names the target of the call. It defaults to the owner of `target`.
+*/
+function reportReentry(target, call, reentry, subject = describeOwner(target)) {
+	const { service } = reentry;
+	const reason = `${service ? `The cleanup of '${service.name}' in ${describeOwner(service.container)}` : `A container effect in ${describeOwner(target)}`} called ${call}() of ${subject}, and the wait includes that cleanup. injeca resolved the call at once. The ${actions[call]} continues.`;
+	target.api.logger.warn(reason);
+	emitRecord(service?.container ?? target, {
+		type: "reentrant-call",
+		key: service?.name ?? "",
+		owner: (service?.container ?? target).owner,
+		instanceId: reentry.instance?.id ?? service?.signals.instance()?.id,
+		call,
+		reason
+	});
+}
 // src/reconciler/snapshot.ts
 /** The current snapshot of all dependencies. */
 function currentSnapshot(service) {
@@ -1342,37 +681,6 @@ function acceptSnapshot(service, instance, snapshot) {
 	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);
@@ -1404,19 +712,34 @@ function recordDecision(service, instance, decision, 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) {
+/**
+* Reports a failure of a callback that injeca stopped waiting for, after a timeout or a newer target. Nothing else gets the error, so injeca writes it with `logger.warn`.
+*
+* A failure with the reason of one of `signals` is not reported, because the callback only followed its abort.
+*/
+function reportLateFailure(service, source, error, signals) {
+	if (signals.some((signal) => signal?.aborted && signal.reason === error)) return;
+	const callback = source === "effect" ? `An effect disposer of '${service.name}'` : `The '${source}' hook of '${service.name}'`;
+	service.container.api.logger.warn(`${callback} failed after injeca stopped waiting for it: ${messageOf(error)}`);
+}
+/** Records the late decision of a hook run that injeca stopped waiting for. A late `fail` is reported with `reportLateFailure`. */
+function recordLateDecision(service, instance, decision, signals) {
+	recordDecision(service, instance, decision, true);
+	if (decision.kind === "fail") reportLateFailure(service, decision.hook, decision.error, signals);
+}
+/**
+* Starts a hook run. Its signal aborts when a newer target supersedes it, when the instance is disposed, or when `timeout` aborts.
+* The signal has the reason of the first one. `end` removes the listeners.
+*/
+function beginHookRun(instance, timeout) {
 	const controller = new AbortController();
-	const parent = instance.controller.signal;
-	const forward = () => controller.abort(parent.reason);
-	if (parent.aborted) forward();
-	else parent.addEventListener("abort", forward, { once: true });
+	const release = forwardAbort(controller, timeout ? [instance.controller.signal, timeout] : [instance.controller.signal]);
+	recordSignalOrigin(controller.signal, instance);
 	instance.hookRun = controller;
 	return {
 		signal: controller.signal,
-		abort: (reason) => controller.abort(reason),
 		end: () => {
-			parent.removeEventListener("abort", forward);
+			release();
 			if (instance.hookRun === controller) instance.hookRun = void 0;
 		}
 	};
@@ -1461,7 +784,8 @@ async function runHandlers(service, instance, hook, runSignal, extras, options =
 /**
 * 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`.
+* The handler runs synchronously. For `start`, a value that is not a decision of this hook, a promise, or no handler gives `fail` with `hook-timeout`.
+* For `stop`, they give `handled` with the timeout as the reason, so that the stop continues and its callers do not fail. A throw gives `fail` for both hooks.
 */
 function decideTimeout(service, instance, hook, timeoutMs) {
 	const state = hookStateOf(instance, hook);
@@ -1484,8 +808,9 @@ function decideTimeout(service, instance, hook, timeoutMs) {
 		attempt: state.attempt,
 		reason: error.message
 	});
+	const fallback = () => hook === "stop" ? decide.handled({ reason: error.message }) : decide.fail(error, { reason: error.message });
 	const handler = timeoutHandlerOf(service);
-	if (!handler) return decide.fail(error, { reason: error.message });
+	if (!handler) return fallback();
 	try {
 		const value = untracked(() => handler(Object.freeze({
 			hook,
@@ -1494,7 +819,7 @@ function decideTimeout(service, instance, hook, timeoutMs) {
 			previous: state.previous,
 			decide
 		})));
-		return validateDecision(run, value) ?? decide.fail(error, { reason: error.message });
+		return validateDecision(run, value) ?? fallback();
 	} catch (handlerError) {
 		return decide.fail(handlerError, { reason: `The onTimeout handler of '${service.name}' threw.` });
 	}
@@ -1572,29 +897,45 @@ function reconcileStopping(service) {
 	if (instance.signals.holders().size > 0) return;
 	teardown(service, instance, true);
 }
+/** The warning of a `stop` timeout. During a stop or a disposal of the container, it tells the most common cause. */
+function stopTimeoutWarning(service, timeoutMs) {
+	const warning = `The cleanups of '${service.name}' did not settle within the stop timeout of ${timeoutMs}ms. injeca stopped waiting for them, and the stop continues.`;
+	const { container } = service;
+	const action = container.state === "disposing" ? "disposing" : container.signals.started() ? void 0 : "stopping";
+	if (!action) return warning;
+	return `${warning} The container is ${action}. A cleanup can be waiting for its own container. It must pass its signal to stop() or dispose().`;
+}
 /**
 * Runs the `stop` hooks in reverse order, then the effect disposers in reverse order.
 *
-* A configured `stop` timeout covers all of them. 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.
+* A configured `stop` timeout covers all of them. It is a timeout signal on the container clock. The `stop` handlers get it in their `signal`.
+* When it aborts, injeca records it, warns, applies the `onTimeout` decision, and stops waiting. Without `onTimeout`, the timeout counts as `handled`, so the callers of `stop()` and `dispose()` do not fail.
+* The callback in progress is abandoned. The remaining callbacks still run, but injeca does not wait for them. So a cleanup that awaits the disposal of its own container without its signal cannot block that disposal.
+* The late decisions of the abandoned `stop` handlers are recorded as ignored. A late failure of an abandoned callback goes to `logger.warn`, unless it is the abort reason of its signal.
 */
 async function runTeardownCallbacks(service, instance, stopHooks, frame) {
 	const errors = [];
 	const { clock, context } = service.container.runtime;
 	const call = (fn) => context.run(frame, () => invokeUser(fn));
 	const timeoutMs = timeoutOf(service, "stop");
-	const deadline = timeoutMs === void 0 ? void 0 : clock.now() + timeoutMs;
+	const deadline = timeoutMs === void 0 ? void 0 : timeoutSignal(clock, timeoutMs, () => new HookTimeoutError(`The 'stop' hook of '${service.name}' timed out.`, "stop", timeoutMs));
+	const hookSignal = anySignal(instance.controller.signal, deadline?.signal);
 	let timedOut = false;
-	/** Waits for one callback until the deadline. `undefined` means that the deadline passed. */
-	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()));
+	/**
+	* Waits for one callback until the deadline. `undefined` means that the deadline passed.
+	* After the deadline, `late` gets the value of the callback, and a rejection is reported with `logger.warn`.
+	*/
+	const settle = async (promise, source, late) => {
+		const abandon = () => {
+			promise.then((value) => late?.(value), (error) => reportLateFailure(service, source, error, [hookSignal, instance.controller.signal]));
+		};
+		if (!deadline) return { value: await promise };
+		if (timedOut) return abandon();
+		const result = await raceAbort(promise, deadline.signal);
 		if (result.kind === "settled") return { value: result.value };
+		abandon();
 		timedOut = true;
+		service.container.api.logger.warn(stopTimeoutWarning(service, timeoutMs));
 		const decision = decideTimeout(service, instance, "stop", timeoutMs);
 		recordDecision(service, instance, decision, false);
 		finishRun(instance, "stop", decision);
@@ -1605,7 +946,7 @@ async function runTeardownCallbacks(service, instance, stopHooks, frame) {
 		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));
+			const settled = await settle(callHandler(service, instance, "stop", handler, hookSignal, {}, call), "stop", (late) => recordLateDecision(service, instance, late, [hookSignal, instance.controller.signal]));
 			if (!settled) continue;
 			const decision = settled.value;
 			recordDecision(service, instance, decision, false);
@@ -1616,19 +957,22 @@ async function runTeardownCallbacks(service, instance, stopHooks, frame) {
 	}
 	const effects = instance.effects.splice(0).reverse();
 	for (const disposer of effects) try {
-		await settle(call(disposer));
+		await settle(call(disposer), "effect");
 	} catch (error) {
 		errors.push(error);
 	}
+	deadline?.cancel();
 	return errors;
 }
 async function teardown(service, instance, stopHooks, phase) {
 	service.busy = true;
+	instance.tearingDown = true;
 	cancelRequeueWait(instance);
 	instance.extraHolds.clear();
 	if (phase) setPhase(service, phase, { reason: service.stopIntent.reason });
-	const frame = service.container.frame;
+	const frame = serviceFrame(service, service.container.frame);
 	const errors = await service.container.runtime.context.run(frame, () => runTeardownCallbacks(service, instance, stopHooks, frame));
+	frame.active = false;
 	instance.disposed = true;
 	instance.controller.abort(/* @__PURE__ */ new Error(`The instance '${instance.id}' of '${service.name}' was disposed.`));
 	service.busy = false;
@@ -1697,11 +1041,59 @@ function finalize(service) {
 		}
 		setPhase(service, "withdrawn");
 	});
-	service.withdrawal.resolve([...service.teardownErrors]);
-	if (template) service.container.runtime.reconciler.markDirty(template);
-	service.container.runtime.reconciler.requestDrain();
+	service.withdrawal.resolve([...service.teardownErrors]);
+	if (template) service.container.runtime.reconciler.markDirty(template);
+	service.container.runtime.reconciler.requestDrain();
+}
+// src/reconciler/swap.ts
+/**
+* Creates a new service that replaces `target` after it completes `start`. It is not published before the swap.
+* `target.successor` names it until the replacement ends. It gets the demand of `target`, so that it converges as `target` does.
+*/
+function createSuccessor(target, definition, options) {
+	const outcome = createDeferred();
+	let settled = false;
+	let service;
+	batch(() => {
+		service = createService({
+			container: target.container,
+			kind: "service",
+			name: target.name,
+			edges: definition.edges,
+			build: definition.build,
+			metadata: definition.metadata,
+			policy: definition.policy,
+			exclusive: target.exclusive,
+			exported: target.exported,
+			template: options.template,
+			consumer: target.consumer,
+			registration: target.registration,
+			...options.rebuild ? { seq: target.seq } : {},
+			...options.extra,
+			swap: {
+				target,
+				ready: options.ready,
+				held: false,
+				...options.rebuild ? { rebuild: true } : {},
+				settle: (result) => {
+					if (settled) return;
+					settled = true;
+					if (target.successor === service) target.successor = void 0;
+					options.onSettle(service, result);
+					outcome.resolve(result);
+				}
+			}
+		});
+		service.signals.demanded(target.signals.demanded());
+		service.signals.subscribers(target.signals.subscribers());
+		target.container.services.add(service);
+		target.successor = service;
+	});
+	return {
+		service,
+		outcome: outcome.promise
+	};
 }
-// 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.
@@ -1739,34 +1131,43 @@ function completeSwap(service) {
 // 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.
+*
+* The run signal includes a timeout signal on the container clock. At the timeout, the run signal aborts with `hook-timeout`, later handlers do not run, and the `onTimeout` decision replaces the result.
+* When a newer target aborts the run, for example `stop()` or `dispose()`, injeca does not wait for the handler in progress. The service stops at once.
+* Late decisions are recorded as ignored.
 */
 async function runAttempt(service, instance) {
-	const run = beginHookRun(instance);
+	const timeoutMs = timeoutOf(service, "start");
+	const timer = timeoutMs === void 0 ? void 0 : timeoutSignal(service.container.runtime.clock, timeoutMs, () => new HookTimeoutError(`The 'start' hook of '${service.name}' timed out.`, "start", timeoutMs));
+	const run = beginHookRun(instance, timer?.signal);
 	const progress = { index: instance.startFrom };
-	let timedOut = false;
+	let abandoned = false;
 	const running = runHandlers(service, instance, "start", run.signal, {}, {
 		from: instance.startFrom,
 		progress,
-		stopped: () => timedOut
+		stopped: () => abandoned
 	});
-	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));
+	const result = await raceAbort(running, run.signal);
+	timer?.cancel();
+	const timedOut = timer !== void 0 && timer.signal.aborted && run.signal.reason === timer.signal.reason;
 	run.end();
+	instance.startFrom = progress.index;
+	if (result.kind === "settled") return {
+		decisions: result.value,
+		superseded: false
+	};
+	abandoned = true;
 	running.then((late) => {
-		for (const decision of late) recordDecision(service, instance, decision, true);
+		for (const decision of late) recordLateDecision(service, instance, decision, [run.signal]);
 	});
-	return [decideTimeout(service, instance, "start", timeoutMs)];
+	if (!timedOut) return {
+		decisions: [],
+		superseded: true
+	};
+	return {
+		decisions: [decideTimeout(service, instance, "start", timeoutMs)],
+		superseded: false
+	};
 }
 /**
 * Runs the `start` hooks of a built instance. The service moves to `running`, waits in `retrying` for a requeue, or stops.
@@ -1779,9 +1180,13 @@ async function runStart(service, instance) {
 	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) : [];
+	const attempt = handlers.length > instance.startFrom ? await runAttempt(service, instance) : {
+		decisions: [],
+		superseded: false
+	};
+	const { decisions } = attempt;
 	service.busy = false;
-	const ignored = service.signals.targetLost();
+	const ignored = attempt.superseded || service.signals.targetLost();
 	for (const decision of decisions) recordDecision(service, instance, decision, ignored);
 	if (ignored) {
 		enterStopping(service, { reason: "A newer target superseded the start." });
@@ -1789,9 +1194,13 @@ async function runStart(service, instance) {
 	}
 	const decision = decisions.at(-1);
 	if (!decision || decision.kind === "handled") {
+		service.demanders.clear();
 		if (decision) finishRun(instance, "start", decision);
 		logger?.hookOnStartComplete(service.name, performance.now() - startTime);
-		if (service.swap) completeSwap(service);
+		if (service.swap?.ready) {
+			service.swap.held = true;
+			service.swap.ready(service);
+		} else if (service.swap) completeSwap(service);
 		else setPhase(service, "running");
 		return;
 	}
@@ -1827,16 +1236,6 @@ async function runStart(service, instance) {
 }
 // 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.
 */
@@ -1903,8 +1302,10 @@ function prepareInstance(service, snapshot) {
 		startFrom: 0,
 		value: void 0,
 		building: true,
+		tearingDown: false,
 		disposed: false
 	};
+	recordSignalOrigin(instance.controller.signal, instance);
 	service.busy = true;
 	batch(() => {
 		syncHolds(service, instance);
@@ -1989,13 +1390,13 @@ function memberEntry(member, built) {
 	};
 }
 /** Resolves one key inside a transaction: a built member first, then the published providers. */
-function resolveInTransaction(service, keyName, condition, members, built) {
+function resolveInTransaction(service, keyName, edge, members, built) {
 	const member = members.get(keyName);
 	if (member && member !== service) {
-		if (inConflict(member) || condition && !acceptsProvider(service, keyName, condition, member)) return void 0;
+		if (inConflict(member) || !acceptsCandidate(service, edge, keyName, member)) return void 0;
 		return memberEntry(member, built);
 	}
-	const resolution = resolveKey(service, keyName, condition);
+	const resolution = resolveKey(service, keyName, edge);
 	if (resolution.kind !== "resolved") return void 0;
 	return {
 		state: Object.freeze({
@@ -2010,7 +1411,7 @@ function resolveInTransaction(service, keyName, condition, members, built) {
 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 entries = edge.candidates.map((keyName) => resolveInTransaction(service, keyName, edge, members, built));
 		const entry = entries.find((candidate) => candidate !== void 0 && candidate.state.status !== "unavailable") ?? entries.find((candidate) => candidate !== void 0);
 		if (!edge.optional && (!entry || entry.state.status === "unavailable")) return void 0;
 		snapshot.set(edge.name, entry);
@@ -2091,6 +1492,7 @@ function abortTransaction(transaction, error) {
 	if (!committing) {
 		transaction.container.transactions.delete(transaction);
 		transaction.settled = Promise.resolve();
+		releaseReservations(transaction);
 	}
 	return transaction.settled ?? Promise.resolve();
 }
@@ -2105,6 +1507,54 @@ function reconcileConflict(service) {
 	setPhase(service, "pending", { reason: `Only one declaration of the exclusive key '${service.name}' remains.` });
 	service.container.runtime.reconciler.markDirty(service);
 }
+// src/reconciler/rebuild.ts
+/**
+* Tells whether the old instance of a running service can keep serving while its successor builds and starts.
+*
+* - Only a service with a key rebuilds make-before-break. An invocation has no dependents, so it stops, then runs again.
+* - Each edge that the old instance is bound to still resolves, maybe to a new instance. An edge without a provider has nothing to build against, so the service stops first.
+* - The container is not in disposal.
+*
+* A bound provider instance stays usable until its last holder releases it, so the old instance keeps working with its bindings.
+*/
+function keepsServing(service, instance) {
+	if (service.kind !== "service" || service.container.state !== "active") return false;
+	return service.edges.every((edge) => !instance.bindings.has(edge.name) || resolvedInstance(service, edge) !== void 0);
+}
+/**
+* Rebuilds a running service, for a changed dependency without a handler, or for a `rebuild` decision.
+*
+* When the old instance can keep serving, the rebuild is make-before-break: a successor with the same options builds and starts against the current dependencies.
+* The old instance serves until the successor completes `start`. Then one batch swaps them, as for `replace()`. The dependents get `dependency-change`, not a withdrawal.
+* If the successor fails, the old instance stops and the service goes to `failed`.
+* Otherwise the service stops first and builds again from `pending`.
+*
+* A replacement in progress, from `replace()` or a transaction, takes precedence. The old instance serves until it ends, and the service reconciles again then.
+*/
+function rebuild(service, instance, intent) {
+	if (service.successor) return;
+	if (!keepsServing(service, instance)) {
+		enterStopping(service, intent);
+		return;
+	}
+	const { registration } = service;
+	const { service: successor } = createSuccessor(service, service, {
+		template: service.template,
+		rebuild: true,
+		onSettle: (next, outcome) => {
+			if (registration?.pending === next) registration.pending = void 0;
+			if (outcome.kind === "swapped" && registration) registration.current = next;
+			if (outcome.kind === "swapped" && service.signals.phase() === "running") enterStopping(service, intent);
+			if (outcome.kind === "failed" && service.signals.present()) enterStopping(service, {
+				failure: { error: outcome.error },
+				reason: "The rebuild failed. The old instance stops.",
+				decision: intent.decision
+			});
+			service.container.runtime.reconciler.markDirty(service);
+		}
+	});
+	if (registration) registration.pending = successor;
+}
 // src/reconciler/dependency-hooks.ts
 /** Handles a running service: it stops it, or it runs a dependency hook for the changes since the last handled snapshot. */
 function reconcileRunning(service) {
@@ -2123,6 +1573,7 @@ function reconcileRunning(service) {
 		enterStopping(service, { reason: `The exclusive key '${service.name}' got another declaration.` });
 		return;
 	}
+	demandProviders(service);
 	const snapshot = currentSnapshot(service);
 	if (requiredWithdrawn(service)) {
 		cancelRequeueWait(instance);
@@ -2130,12 +1581,13 @@ function reconcileRunning(service) {
 		else enterStopping(service, { reason: "A required dependency was withdrawn." });
 		return;
 	}
+	if (service.successor?.swap?.rebuild) return;
 	const changes = diffSnapshot(service, instance.handled, snapshot);
 	if (changes.length === 0 || instance.requeueWait) return;
 	const identity = changes.some(isIdentityChange);
 	const hook = identity ? "dependency-change" : "dependency-status-change";
 	if (instance.hooks[hook].length === 0) {
-		if (identity) enterStopping(service, {
+		if (identity) rebuild(service, instance, {
 			reason: `A dependency changed without a handler: ${describeChanges(changes)}.`,
 			decision: "rebuild"
 		});
@@ -2199,7 +1651,7 @@ async function runDependencyHook(service, instance, hook, snapshot, changes) {
 		}
 		case "rebuild":
 			releaseExtraHolds(service, instance);
-			enterStopping(service, {
+			rebuild(service, instance, {
 				reason: decision.reason,
 				decision: "rebuild"
 			});
@@ -2329,6 +1781,9 @@ function createReconciler(options) {
 			case "failed":
 				if (!service.signals.present()) finalize(service);
 				return;
+			case "starting":
+				if (service.swap?.held && service.signals.targetLost()) enterStopping(service, { reason: "The replacement was cancelled before the swap." });
+				return;
 			case "running":
 				reconcileRunning(service);
 				return;
@@ -2414,6 +1869,16 @@ function readRandom(options) {
 	if (random !== void 0 && typeof random !== "function") throw new InvalidArgumentError("The random option must be a function.");
 	return random ?? Math.random;
 }
+function readLogging(options, parent) {
+	let logging;
+	try {
+		logging = options.logging;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the logging option.", { cause: error });
+	}
+	if (logging !== void 0 && typeof logging !== "boolean") throw new InvalidArgumentError("The logging option must be a boolean.");
+	return logging ?? parent?.api.logging ?? false;
+}
 function createRuntime(options) {
 	let seq = 0;
 	let instanceSeq = 0;
@@ -2441,7 +1906,8 @@ function createContainer(options = {}) {
 	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 logging = readLogging(options, parent);
+	const logger = options.logger ?? parent?.api.logger ?? createDefaultLogger();
 	const runtime = parent?.runtime ?? createRuntime(options);
 	let reactiveOwner;
 	const stopReactive = withOwner(parent?.reactiveOwner, () => effectScope(() => {
@@ -2449,6 +1915,7 @@ function createContainer(options = {}) {
 	}));
 	const api = {
 		logger,
+		logging,
 		owner,
 		parent: parent?.api
 	};
@@ -2462,7 +1929,8 @@ function createContainer(options = {}) {
 		services: /* @__PURE__ */ new Set(),
 		signals: {
 			started: signal(false),
-			slots: /* @__PURE__ */ new Map()
+			slots: /* @__PURE__ */ new Map(),
+			exports: /* @__PURE__ */ new Map()
 		},
 		isolated,
 		policy,
@@ -2483,20 +1951,31 @@ function createContainer(options = {}) {
 }
 /**
 * Runs `setup` and stores the returned disposer on the container. `dispose(container)` runs the disposers in reverse order.
+*
+* When the disposal of the container started or ended, the disposer runs at once after `setup`, so that the resource does not leak.
+* A disposer that throws throws to the caller. A disposer promise that rejects is reported outside the call, as an unhandled error.
 */
 function effect$1(container, setup) {
 	const node = nodeOf(container);
-	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);
+	if (typeof disposer !== "function") return;
+	if (node.state === "active") {
+		node.effects.push(disposer);
+		return;
+	}
+	const result = untracked(disposer);
+	if (result instanceof Promise) result.catch((error) => queueMicrotask(() => {
+		throw error;
+	}));
 }
 /**
-* Starts the disposal of `container` and of its descendants.
+* Starts the disposal of `container` and of its descendants. The whole subtree enters `disposing` at once, so nothing new registers in it.
 *
-* The synchronous part withdraws all services of the subtree in the caller's batch, so that dependents stop without a rebuild.
+* The child containers dispose first, one after the other, in reverse creation order. Then the services of the container withdraw in one batch, so that dependents stop without a rebuild.
+* Then the effects of the container run in reverse order. `after` delays the work until an earlier sibling completed its disposal.
 */
-function beginDisposal(container, parentFrame) {
+function beginDisposal(container, parentFrame, after) {
 	if (container.disposal) return container.disposal;
 	const { context } = container.runtime;
 	const frame = {
@@ -2507,27 +1986,35 @@ function beginDisposal(container, parentFrame) {
 	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);
-	}
+	let previous = after;
 	const children = [...container.children].reverse().map((child) => {
-		const disposal = beginDisposal(child, frame);
+		const disposal = beginDisposal(child, frame, previous);
 		disposal.catch(() => {});
+		previous = disposal.then(() => {}, () => {});
 		return disposal;
 	});
+	const withdrawn = /* @__PURE__ */ new Set();
+	const withdrawServices = () => untracked(() => batch(() => {
+		for (const service of container.services) if (service.signals.present()) {
+			releaseService(service);
+			withdrawn.add(service);
+		}
+	}));
+	const immediate = after === void 0 && children.length === 0;
+	if (immediate) withdrawServices();
 	container.disposal = context.run(frame, async () => {
 		const errors = [];
-		for (const service of [...container.services]) {
-			const serviceErrors = await service.withdrawal.promise;
-			if (withdrawn.has(service)) errors.push(...serviceErrors);
-		}
+		if (after) await after;
 		for (const child of children) try {
 			await child;
 		} catch (error) {
 			errors.push(error);
 		}
+		if (!immediate) withdrawServices();
+		for (const service of [...container.services]) {
+			const serviceErrors = await service.withdrawal.promise;
+			if (withdrawn.has(service)) errors.push(...serviceErrors);
+		}
 		for (const disposer of container.effects.splice(0).reverse()) try {
 			await context.run(frame, () => untracked(disposer));
 		} catch (error) {
@@ -2551,25 +2038,81 @@ function beginDisposal(container, parentFrame) {
 	});
 	return container.disposal;
 }
+/** The services of `container` and of its descendants that did not finish their withdrawal. */
+function unfinishedServices(container) {
+	return [...[...container.services].filter((service) => service.kind !== "resolver" && service.signals.phase() !== "withdrawn"), ...[...container.children].flatMap(unfinishedServices)];
+}
 /**
 * Withdraws the registrations and invocations of the container, disposes the child containers, and runs the container effects in reverse order.
 *
-* One error keeps its identity. More than one error becomes an `AggregateError`.
-* A call from the cleanup chain of the same container rejects with `reentrant-dispose`. A second call from outside gets the same promise.
+* One error keeps its identity. More than one error becomes an `AggregateError`. A second call from outside without a signal gets the same promise.
+*
+* A call from the cleanup chain of the container or of a descendant cannot wait, because the disposal waits for that cleanup.
+* The same is true for a cleanup of a service that holds a service of the subtree, directly or through other instances, or a consumer service of a `perConsumer` registration of it.
+* injeca finds such a call by the signal of the cleanup, or by the synchronous part of the cleanup. It warns, sends a `reentrant-call` record, and resolves at once. The disposal continues.
+*
+* When `options.signal` aborts, the call rejects with the reason and stops waiting. The disposal continues: the container stays in `disposing`, and calls on it fail with `build-after-dispose`.
+* A later `dispose()` waits for the same disposal and gets its result. An aborted signal starts the disposal, then rejects at once.
 */
-function dispose(container) {
+function dispose(container, options) {
 	const node = nodeOf(container);
+	const abortSignal = readSignal(options, "dispose");
 	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;
+	const reentry = untracked(() => findReentry(node, "dispose", abortSignal));
+	const disposal = node.disposal ?? untracked(() => {
+		let started;
 		batch(() => {
-			disposal = beginDisposal(node, context.current());
+			started = beginDisposal(node, context.current());
 		});
-		return disposal;
+		return started;
+	});
+	if (reentry) {
+		untracked(() => reportReentry(node, "dispose", reentry));
+		disposal.catch(() => {});
+		return Promise.resolve();
+	}
+	return abortable(disposal, abortSignal, (reason) => {
+		recordAbortedWait(unfinishedServices(node), "dispose", reason);
+		return reason;
+	});
+}
+// src/primitives/withdraw.ts
+/**
+* Runs a `withdraw()` call. `release` releases the service and returns it, or `undefined` when there is nothing to withdraw.
+*
+* - Resolves `true` after the withdrawal, and rejects with the teardown errors.
+* - When `options.signal` aborts, it rejects with the reason and stops waiting. The withdrawal continues. An aborted signal still starts it.
+* - A call from a cleanup that the withdrawal waits for warns, sends a `reentrant-call` record, and resolves `true` at once.
+*/
+function withdrawWith(release, options) {
+	let signal;
+	try {
+		signal = readSignal(options, "withdraw");
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	const service = release();
+	if (!service) return Promise.resolve(false);
+	const withdrawal = awaitWithdrawal(service).then(() => true);
+	const reentry = untracked(() => findWithdrawReentry(service, signal));
+	if (reentry) {
+		untracked(() => reportReentry(service.container, "withdraw", reentry, `'${service.name}' in ${JSON.stringify(service.container.owner)}`));
+		withdrawal.catch(() => {});
+		return Promise.resolve(true);
+	}
+	return abortable(withdrawal, signal, (reason) => {
+		recordAbortedWait(untracked(() => service.signals.phase()) === "withdrawn" ? [] : [service], "withdraw", reason);
+		return reason;
 	});
 }
+/** The `withdraw()` of a registration. Resolves `false` for a stale registration. */
+function withdrawRegistration(registration, options) {
+	return withdrawWith(() => releaseRegistration(registration), options);
+}
+/** The `withdraw()` of an invocation. Resolves `false` when it is already withdrawn. */
+function withdrawInvocation(service, options) {
+	return withdrawWith(() => releasePresent(service) ? service : void 0, options);
+}
 // src/primitives/invoke.ts
 function invoke$1(container, option) {
 	return invokeIn(container, option);
@@ -2610,8 +2153,11 @@ function invokeIn(container, option) {
 		});
 		return service;
 	});
-	container.logger.invoke(edges.map((edge) => edge.keyName));
-	return Object.freeze({ withdraw: () => withdrawService(registered) });
+	traceLoggerOf(container)?.invoke(edges.map((edge) => edge.keyName));
+	return Object.freeze({
+		key: name,
+		withdraw: (options) => withdrawInvocation(registered, options)
+	});
 }
 // src/diagnostics/explain.ts
 /** The owners of conflicting declarations, in container order. The order of the registrations has no effect. */
@@ -2647,6 +2193,19 @@ function explainService(service) {
 	for (const edge of service.edges) {
 		if (edge.optional) continue;
 		const resolution = resolutionOf(service, edge);
+		if (edge.fallback && resolution.kind !== "resolved") {
+			for (const keyName of edge.candidates) {
+				const candidate = resolveKey(service, keyName, edge);
+				if (candidate.kind === "rejected") blockers.push({
+					kind: "rejected-provider",
+					dependency: edge.name,
+					key: candidate.provider.name,
+					owner: candidate.provider.container.owner,
+					metadata: candidate.provider.metadata
+				});
+			}
+			if (resolution.kind === "rejected") continue;
+		}
 		switch (resolution.kind) {
 			case "missing":
 				blockers.push({
@@ -2699,6 +2258,7 @@ function explainService(service) {
 		}
 	}
 	const status = service.signals.effective();
+	const successor = service.successor;
 	return Object.freeze({
 		name: service.name,
 		kind: service.kind === "invocation" ? "invocation" : "service",
@@ -2709,7 +2269,8 @@ function explainService(service) {
 			reason: status?.reason,
 			cause: status?.cause
 		}),
-		blockers: Object.freeze(blockers)
+		blockers: Object.freeze(blockers),
+		...withoutUndefined({ replacement: successor?.signals.present() ? explainService(successor) : void 0 })
 	});
 }
 /** Formats a cause chain, for example `'airi.llm' is unavailable (reason), because 'gateway/store' is unavailable`. */
@@ -2740,6 +2301,11 @@ function describeExplanations(explanations) {
 	return explanations.map((explanation) => {
 		const reasons = explanation.blockers.map(describeBlocker);
 		if (explanation.cause) reasons.push(`it is ${explanation.status ?? "unavailable"}, because ${describeCause(explanation.cause)}`);
+		const { replacement } = explanation;
+		if (replacement) {
+			const blockers = replacement.blockers.map(describeBlocker);
+			reasons.push(`its replacement is ${replacement.phase ?? "missing"}${blockers.length > 0 ? ` (${blockers.join(", ")})` : ""}`);
+		}
 		return `- ${explanation.name} is ${explanation.phase}${reasons.length > 0 ? `: ${reasons.join(", ")}` : ""}`;
 	}).join("\n");
 }
@@ -2757,49 +2323,42 @@ function presentServices(containers) {
 }
 /**
 * 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`.
+* When `signal` aborts first, it stops checking and rejects with the result of `onAborted`. An aborted signal rejects at once.
 */
-function waitUntilSettled(containers, check, timeoutMs) {
-	const { clock, reconciler } = containers[0].runtime;
+function waitUntilSettled(containers, check, signal, onAborted) {
+	const { reconciler } = containers[0].runtime;
 	return new Promise((done, fail) => {
-		let cancelTimeout = () => {};
+		if (signal?.aborted) {
+			fail(onAborted(signal.reason));
+			return;
+		}
+		let removeAbort = () => {};
 		const stopListening = reconciler.onDrained(() => {
 			const result = check(presentServices(containers));
 			if (result === "waiting") return;
 			stopListening();
-			cancelTimeout();
+			removeAbort();
 			if (result.kind === "done") done();
 			else fail(errorFrom(result.errors, "Start failed."));
 		});
-		if (timeoutMs !== void 0) cancelTimeout = clock.setTimeout(() => untracked(() => {
+		removeAbort = onAbort(signal, (reason) => {
 			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);
+			fail(onAborted(reason));
+		});
 		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 service in `failed` tries again. A required key without a provider keeps the promise pending, unless `options.signal` aborts.
 * A child container that was never started does not start. Call `start(child)` for it.
 */
 function start$1(container, options) {
 	const node = nodeOf(container);
 	assertActive(node, "start");
-	const timeoutMs = readTimeout(options);
+	const signal = readSignal(options, "start");
 	node.enrolled = true;
 	const containers = affectedContainers(node);
 	return untracked(() => {
@@ -2818,17 +2377,42 @@ function start$1(container, options) {
 				kind: "failed",
 				errors
 			} : "waiting";
-		}, timeoutMs);
-	}).then(() => container.logger.running());
+		}, signal, (reason) => {
+			if (!isTimeoutReason(reason)) return reason;
+			const explanations = presentServices(containers).filter((service) => service.signals.phase() !== "running").map(explainService);
+			return new StartTimeoutError(`start() timed out. These services are not running:\n${describeExplanations(explanations)}`, explanations, { cause: reason });
+		});
+	}).then(() => traceLoggerOf(container)?.running());
 }
 /**
 * Stops all instances of the container and of each child container that was started. Dependents stop before their providers.
 *
 * The registrations stay. The container stays usable, and a later `start()` builds them again. `dispose()` clears the container.
 * Rejects with the teardown errors.
+*
+* When `options.signal` aborts, it rejects with the reason and stops waiting. The container stays stopped: a later `start()` builds again.
+* The services that did not stop yet stay in `stopping` until their cleanups settle.
+*
+* A call from the cleanup chain of the container or of a descendant cannot wait, because the stop waits for that cleanup.
+* The same is true for a cleanup of a service that holds a service of the subtree, directly or through other instances.
+* injeca finds such a call by the signal of the cleanup, or by the synchronous part of the cleanup. It warns, sends a `reentrant-call` record, and resolves at once. The stop continues.
 */
-async function stop$1(container) {
-	const node = nodeOf(container);
+function stop$1(container, options) {
+	let node;
+	let signal;
+	try {
+		node = nodeOf(container);
+		signal = readSignal(options, "stop");
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	const reentry = untracked(() => findReentry(node, "stop", signal));
+	if (!reentry) return stopAndWait(node, signal);
+	untracked(() => reportReentry(node, "stop", reentry));
+	stopAndWait(node, void 0).catch(() => {});
+	return Promise.resolve();
+}
+async function stopAndWait(node, signal) {
 	const containers = affectedContainers(node);
 	const affected = new Set(containers);
 	node.enrolled = false;
@@ -2839,9 +2423,16 @@ async function stop$1(container) {
 	const settled = untracked(() => {
 		batch(() => {
 			for (const current of containers) current.signals.started(false);
-			for (const service of presentServices(containers)) service.signals.demanded(false);
+			for (const service of presentServices(containers)) {
+				service.signals.demanded(false);
+				service.signals.subscribers(/* @__PURE__ */ new Set());
+			}
+		});
+		const stopped = (service) => service.signals.instance() === void 0 && !transitionalPhases.has(service.signals.phase());
+		return waitUntilSettled(containers, (services) => services.every(stopped) ? { kind: "done" } : "waiting", signal, (reason) => {
+			recordAbortedWait(presentServices(containers).filter((service) => !stopped(service)), "stop", reason);
+			return reason;
 		});
-		return waitUntilSettled(containers, (services) => services.every((service) => service.signals.instance() === void 0 && !transitionalPhases.has(service.signals.phase())) ? { kind: "done" } : "waiting");
 	});
 	try {
 		await settled;
@@ -2898,46 +2489,6 @@ function listen(container, eventKey, handler, metadata) {
 	};
 }
 // 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;
@@ -2967,6 +2518,7 @@ function replaceAtOnce(registration, target, definition) {
 			metadata: definition.metadata,
 			policy: definition.policy,
 			exclusive: target.exclusive,
+			exported: target.exported,
 			perConsumer: target.perConsumer,
 			registration
 		});
@@ -2977,45 +2529,84 @@ function replaceAtOnce(registration, target, definition) {
 	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.
+* Replaces the `perConsumer` registration `target` with the unpublished registration `template`. Resolves with the outcome.
+*
+* Each running consumer service gets a successor that builds and starts from `definition`. A successor that completes `start` waits.
+* When every successor waits, one batch publishes `template` and swaps in all successors. The other consumer services leave and build again on demand.
+* When one successor fails, all successors leave, `template` leaves, and the old registration and its consumer services do not change.
+* A consumer service that leaves during the replacement, for example with its container, drops out of the batch.
+* A newer `replace` or a withdrawal cancels the replacement.
 */
-function 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
+function replaceTemplate(registration, target, template) {
+	const definition = {
+		edges: template.edges,
+		build: template.build,
+		metadata: template.metadata,
+		perConsumer: true,
+		exported: false,
+		policy: template.policy
+	};
+	const outcome = createDeferred();
+	const waiting = /* @__PURE__ */ new Set();
+	const held = /* @__PURE__ */ new Set();
+	let settled = false;
+	const finish = (result) => {
+		settled = true;
+		template.swap = void 0;
+		if (target.successor === template) target.successor = void 0;
+		if (registration.pending === template) registration.pending = void 0;
+		outcome.resolve(result);
+	};
+	const abandon = (result) => {
+		if (settled) return;
+		batch(() => {
+			finish(result);
+			for (const successor of [...waiting, ...held]) {
+				successor.signals.present(false);
+				successor.container.runtime.reconciler.markDirty(successor);
+			}
+			releaseService(template);
+		});
+	};
+	const commitIfReady = () => {
+		if (settled || waiting.size > 0) return;
+		batch(() => {
+			finish({ kind: "swapped" });
+			takeOver(registration, target, template);
+			for (const successor of held) completeSwap(successor);
 		});
-		target.container.services.add(template);
-		swaps = moveConsumers(registration, target, template, definition);
+	};
+	batch(() => {
+		cancelPending(registration);
+		template.swap = {
+			target,
+			held: false,
+			settle: abandon
+		};
+		registration.pending = template;
+		target.successor = template;
+		for (const consumer of target.signals.consumers().values()) {
+			if (!consumer.signals.serving()) continue;
+			cancelSuccessor(consumer);
+			const { service } = createSuccessor(consumer, definition, {
+				template,
+				onSettle: (successor, result) => {
+					waiting.delete(successor);
+					held.delete(successor);
+					if (result.kind === "failed") abandon(result);
+					else if (result.kind !== "swapped") commitIfReady();
+				},
+				ready: (successor) => {
+					waiting.delete(successor);
+					held.add(successor);
+					commitIfReady();
+				}
+			});
+			waiting.add(service);
+		}
 	});
-	return swaps;
+	commitIfReady();
+	return outcome.promise;
 }
 /** Settles a replacement for its registration. */
 function settleRegistration(registration) {
@@ -3029,44 +2620,81 @@ function settleRegistration(registration) {
 * 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);
+	const pending = createSuccessor(target, definition, {
+		onSettle: settleRegistration(registration),
+		extra
+	});
 	if (!extra?.transaction) {
 		cancelPending(registration);
 		registration.pending = pending.service;
 	}
 	return pending;
 }
+/**
+* Waits for the outcome of the pending replacement `pending`. When `signal` aborts first, it cancels the replacement, as a newer `replace` does.
+* The cancel settles the outcome as `cancelled`. The listener goes when the outcome settles.
+*/
+async function awaitOutcome(registration, pending, outcome, signal) {
+	const removeAbort = onAbort(signal, () => {
+		if (registration.pending === pending) batch(() => cancelPending(registration));
+	});
+	try {
+		return outcomeResult(await outcome, registration.name);
+	} finally {
+		removeAbort();
+	}
+}
 /** The `replace()` of a registration. */
-async function replace(registration, option) {
+async function replace(registration, option, options) {
+	const signal = readSignal(options, "replace");
 	const target = untracked(() => currentService(registration));
 	if (!target) return false;
 	const definition = readDefinition(registration.name, option, target);
+	if (signal?.aborted) return false;
 	const phase = untracked(() => target.signals.phase());
 	if (phase === "stopping") throw new ReplaceWhileStoppingError(`'${registration.name}' is stopping. Wait until it stops, then call provide.`);
 	if (target.perConsumer) {
-		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;
+		let template;
+		const outcome = untracked(() => {
+			batch(() => {
+				template = createService({
+					container: target.container,
+					kind: "service",
+					name: target.name,
+					edges: definition.edges,
+					build: definition.build,
+					metadata: definition.metadata,
+					policy: definition.policy,
+					exclusive: target.exclusive,
+					exported: target.exported,
+					perConsumer: true,
+					registration
+				});
+				target.container.services.add(template);
+			});
+			return replaceTemplate(registration, target, template);
+		});
+		return awaitOutcome(registration, template, outcome, signal);
 	}
 	if (phase !== "running") {
 		untracked(() => replaceAtOnce(registration, target, definition));
 		return true;
 	}
-	return outcomeResult(await untracked(() => replaceRunning(registration, target, definition)).outcome, registration.name);
+	const pending = untracked(() => replaceRunning(registration, target, definition));
+	return awaitOutcome(registration, pending.service, pending.outcome, signal);
 }
 const registrations = /* @__PURE__ */ new WeakMap();
 /** The registration behind a result of `provide`, or `undefined` for any other value. */
 function registrationOf(key) {
 	return typeof key === "object" && key !== null ? registrations.get(key) : void 0;
 }
-/** Creates the public result of `provide`: the typed key with `withdraw()` and `replace()`. */
-function registrationApi(registration) {
+/** Creates the public result of `provide`: the typed key with `withdraw()` and `replace()`. A transaction passes its own `withdraw`. */
+function registrationApi(registration, overrides = {}) {
 	const api = Object.freeze({
 		key: registration.name,
 		...registration.exclusive ? { exclusive: true } : {},
-		withdraw: () => withdrawRegistration(registration),
-		replace: ((option) => replace(registration, option))
+		withdraw: overrides.withdraw ?? ((options) => withdrawRegistration(registration, options)),
+		replace: ((option, options) => replace(registration, option, options))
 	});
 	registrations.set(api, registration);
 	return api;
@@ -3096,9 +2724,13 @@ function autoName(stackIndex, nameOrOption, option) {
 	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) {
+/**
+* Throws `duplicate-service` when a started container already has a registration for `name`,
+* or when an open transaction of the container, other than `except`, declares or provides `name`.
+*/
+function assertNoDuplicate(container, name, except) {
 	if (slotOf(container, name)() && container.signals.started()) throw new DuplicateServiceError(`The started container already has a registration for '${name}'.`);
+	if (reservedBy(container.transactions, name, except)) throw new DuplicateServiceError(`An open transaction of the container reserves '${name}'.`);
 }
 /**
 * Publishes `service` as the current registration of its key. Call it inside a batch.
@@ -3129,6 +2761,7 @@ function serviceOf(container, name, definition, exclusive, extra = {}) {
 		metadata: definition.metadata,
 		policy: definition.policy,
 		exclusive,
+		exported: definition.exported,
 		perConsumer: definition.perConsumer,
 		...extra
 	});
@@ -3154,10 +2787,11 @@ function provideIn(container, stackIndex, nameOrOption, option) {
 	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 providerObject = normalizeProvideOption(nameOrOption, option);
+	const definition = readDefinition(name, providerObject);
 	const exclusive = isExclusiveKey(nameOrOption);
 	const registration = untracked(() => register(node, name, definition, exclusive));
-	container.logger.provide(name, definition.edges.map((edge) => edge.keyName));
+	traceLoggerOf(container)?.provide(name, definition.edges.map((edge) => edge.keyName));
 	return registrationApi(registration);
 }
 function provide$1(container, nameOrOption, option) {
@@ -3167,21 +2801,26 @@ function provide$1(container, nameOrOption, option) {
 /**
 * 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.
+* Rejects when a required dependency fails. With `options.signal`, it rejects when the signal aborts. An aborted signal rejects at once.
+* Each rejection removes the hidden resolver of the call. The values can become stale after a run-time change. Use it for one-time code.
 */
-function resolve$1(container, dependsOn) {
+function resolve$1(container, dependsOn, options) {
 	const node = nodeOf(container);
 	assertActive(node, "resolve");
 	const edges = readEdges("resolve", dependsOn);
+	const signal = readSignal(options, "resolve");
+	if (signal?.aborted) return Promise.reject(waitAbortError(signal.reason, "resolve() timed out."));
 	const { reconciler } = node.runtime;
 	return new Promise((done, fail) => untracked(() => {
 		let settled = false;
 		let service;
 		let stopListening = () => {};
+		let disarm = () => {};
 		const finish = (outcome) => {
 			if (settled) return;
 			settled = true;
 			stopListening();
+			disarm();
 			batch(() => releaseService(service));
 			outcome();
 		};
@@ -3200,9 +2839,30 @@ function resolve$1(container, dependsOn) {
 			const failure = blockingFailure(service);
 			if (failure) finish(() => fail(failure.error));
 		});
+		disarm = onAbort(signal, (reason) => finish(() => fail(waitAbortError(reason, "resolve() timed out."))));
 		service.withdrawal.promise.then(() => finish(() => fail(new BuildAfterDisposeError("The container was disposed before resolve() got its dependencies."))));
 	}));
 }
+// src/primitives/timeout.ts
+function readMilliseconds(ms, action) {
+	if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) throw new InvalidArgumentError(`The milliseconds of ${action} must be a finite number of 0 or more. Got ${String(ms)}.`);
+	return ms;
+}
+/**
+* Returns a signal that aborts after `ms` milliseconds of the clock of `container`.
+*
+* The reason is a `DOMException` with the name `TimeoutError`, as for `AbortSignal.timeout()`. Use it in place of `AbortSignal.timeout()`, because that one does not use the container clock.
+* With the system clock, the timer does not keep a Node process alive.
+*/
+function timeout(container, ms) {
+	const { clock } = nodeOf(container).runtime;
+	const milliseconds = readMilliseconds(ms, "timeout");
+	return timeoutSignal(clock, milliseconds, () => timeoutReason(`The operation timed out after ${milliseconds}ms.`), true).signal;
+}
+/** Returns a signal that aborts when `signal` aborts, or after `ms` milliseconds of the clock of `container`. Without `signal`, it is `timeout(container, ms)`. */
+function withTimeout(signal, ms, container) {
+	return anySignal(readSignal({ signal }, "withTimeout"), timeout(container, ms));
+}
 // src/primitives/transaction.ts
 function readName(key, action) {
 	let name;
@@ -3245,7 +2905,7 @@ function createMembers(transaction) {
 	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);
+	else assertNoDuplicate(container, entry.name, transaction);
 	const members = [];
 	batch(() => {
 		for (const entry of entries) {
@@ -3268,7 +2928,8 @@ function createMembers(transaction) {
 			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
+				perConsumer: target.perConsumer,
+				exported: target.exported
 			}, target.exclusive, {
 				...extra,
 				registration
@@ -3282,22 +2943,17 @@ function createMembers(transaction) {
 	});
 	return members;
 }
-/** Publishes the members in one batch. A built member goes to `starting`, the others to `pending`. */
-function publishMembers(members, built) {
+/** Publishes the members in one batch. A built member goes to `starting`, the others to `pending`. The reservations end in the same batch. */
+function publishMembers(transaction, members, built) {
 	batch(() => {
+		releaseReservations(transaction);
 		for (const { service, target } of members) {
 			service.transaction = void 0;
 			const registration = service.registration;
 			if (target && registration && service.swap) {
 				cancelPending(registration);
 				registration.pending = service;
-			} else if (target && registration && target.perConsumer) moveConsumers(registration, target, service, {
-				edges: service.edges,
-				build: service.build,
-				metadata: service.metadata,
-				perConsumer: true,
-				policy: service.policy
-			});
+			} else if (target && registration && target.perConsumer) replaceTemplate(registration, target, service);
 			else if (target && registration) takeOver(registration, target, service);
 			else {
 				publishRegistration(service.container, service);
@@ -3316,23 +2972,56 @@ async function commit(transaction) {
 		await untracked(() => rollbackMembers(byName, outcome.built));
 		throw outcome.kind === "failed" ? outcome.error : transaction.abortError;
 	}
-	untracked(() => publishMembers(members, new Set(outcome.built.keys())));
+	untracked(() => publishMembers(transaction, members, new Set(outcome.built.keys())));
 	transaction.state = "done";
 	transaction.container.transactions.delete(transaction);
 	startMembers(order, outcome.built);
 }
-function startCommit(transaction) {
+/**
+* Commits `transaction`. When `signal` aborts before the publish, the transaction aborts with the reason, and the result rejects at once.
+* The rollback continues: the build in progress gets the abort on its `signal`, and the key reservations end when the rollback settles.
+*/
+function startCommit(transaction, options) {
+	let signal;
+	try {
+		signal = readSignal(options, "commit");
+	} catch (error) {
+		return Promise.reject(error);
+	}
 	if (transaction.state !== "open") return Promise.reject(new InvalidArgumentError(`The transaction is ${transaction.state === "aborted" ? "aborted" : "already committed"}.`));
+	if (signal?.aborted) {
+		abortTransaction(transaction, signal.reason);
+		return Promise.reject(signal.reason);
+	}
 	transaction.state = "committing";
-	const result = commit(transaction).catch((error) => {
+	const committed = commit(transaction).catch((error) => {
 		if (transaction.state !== "done") {
 			transaction.state = "aborted";
 			transaction.container.transactions.delete(transaction);
+			untracked(() => releaseReservations(transaction));
 		}
 		throw error;
 	});
-	transaction.settled = result.then(() => {}, () => {});
-	return result;
+	transaction.settled = committed.then(() => {}, () => {});
+	if (!signal) return committed;
+	return new Promise((resolve, reject) => {
+		const removeAbort = onAbort(signal, (reason) => {
+			if (transaction.state !== "committing") return;
+			abortTransaction(transaction, reason);
+			reject(reason);
+		});
+		committed.then((value) => {
+			removeAbort();
+			resolve(value);
+		}, (error) => {
+			removeAbort();
+			reject(error);
+		});
+	});
+}
+/** Throws `duplicate-service` when another open transaction of the container declares or provides `name`. */
+function assertNotReserved(transaction, name) {
+	if (reservedBy(transaction.container.transactions, name, transaction)) throw new DuplicateServiceError(`Another open transaction of the container reserves '${name}'.`);
 }
 function assertOpen(transaction, action) {
 	if (transaction.state !== "open") throw new InvalidArgumentError(`Cannot ${action} after the transaction committed or aborted.`);
@@ -3348,7 +3037,9 @@ function entryOf$1(transaction, name, exclusive) {
 			replace: false,
 			target: void 0,
 			registration: void 0,
-			exclusive
+			exclusive,
+			exported: false,
+			reservation: void 0
 		};
 		transaction.entries.set(name, entry);
 	}
@@ -3377,17 +3068,44 @@ function transaction(container) {
 		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);
+		assertNotReserved(state, name);
+		const declared = readEdges(name, dependsOn);
+		const entry = entryOf$1(state, name, false);
+		entry.exclusive ||= isExclusiveKey(key);
+		entry.declared = declared;
 		entry.optional = optional;
+		untracked(() => reserveKey(state, entry));
+	};
+	/**
+	* The `withdraw()` of a registration from `tx.provide`. Before the commit, it removes the provide from the transaction and resolves `true`.
+	* A declaration of the key stays, so the commit fails with `transaction-incomplete` unless the declaration is optional.
+	* During the commit, it waits for the commit, then withdraws the published service with `options`.
+	*/
+	const withdrawEntry = async (entry, registration, options) => {
+		if (state.state === "open") {
+			if (entry.registration !== registration) return false;
+			entry.definition = void 0;
+			entry.registration = void 0;
+			entry.exported = false;
+			untracked(() => {
+				if (!entry.declared) {
+					state.entries.delete(entry.name);
+					releaseReservation(entry);
+				} else reserveKey(state, entry);
+			});
+			return true;
+		}
+		if (state.state === "committing") await state.settled;
+		return withdrawRegistration(registration, options);
 	};
 	const provide = ((key, option) => {
 		assertOpen(state, "provide");
 		const name = readName(key, "provide");
-		const existing = state.entries.get(name);
-		if (existing?.definition) throw new DuplicateServiceError(`The transaction already provides '${name}'.`);
+		if (state.entries.get(name)?.definition) throw new DuplicateServiceError(`The transaction already provides '${name}'.`);
+		assertNotReserved(state, name);
 		const read = readDefinition(name, option);
-		const entry = entryOf$1(state, name, isExclusiveKey(key) || existing?.exclusive === true);
+		const entry = entryOf$1(state, name, false);
+		entry.exclusive ||= isExclusiveKey(key);
 		const definition = read.edges.length === 0 && entry.declared ? {
 			...read,
 			edges: entry.declared
@@ -3395,7 +3113,9 @@ function transaction(container) {
 		const registration = createRegistration(node, name, entry.exclusive);
 		entry.definition = definition;
 		entry.registration = registration;
-		return registrationApi(registration);
+		entry.exported = definition.exported;
+		untracked(() => reserveKey(state, entry));
+		return registrationApi(registration, { withdraw: (options) => withdrawEntry(entry, registration, options) });
 	});
 	const replace = ((key, option) => {
 		assertOpen(state, "replace");
@@ -3406,12 +3126,13 @@ function transaction(container) {
 		entry.definition = readDefinition(name, option, untracked(() => target ? currentService(target) : slotOf(node, name)()));
 		entry.replace = true;
 		entry.target = target;
+		untracked(() => releaseReservation(entry));
 	});
 	return Object.freeze({
 		declare,
 		provide,
 		replace,
-		commit: () => untracked(() => startCommit(state)),
+		commit: (options) => untracked(() => startCommit(state, options)),
 		abort: () => untracked(() => abortTransaction(state, new TransactionIncompleteError("The transaction was aborted before the commit completed.")))
 	});
 }
@@ -3458,8 +3179,8 @@ function computeImpact(scope, change) {
 	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);
+	const alternative = (consumer, keyNames) => keyNames.some((keyName) => candidatesOf(consumer.scope, keyName, consumer).some((registration) => {
+		const provider = serviceFor(registration, consumer.scope);
 		return provider !== void 0 && !gone(provider) && !gone(registration) && provider.signals.serving();
 	}));
 	let changed = true;
@@ -3526,7 +3247,8 @@ function entryOf(service) {
 		}),
 		metadata: service.metadata,
 		exclusive: service.exclusive,
-		perConsumer: service.perConsumer
+		perConsumer: service.perConsumer,
+		exported: service.exported
 	});
 }
 function declaredEntryOf(container, entry) {
@@ -3537,7 +3259,8 @@ function declaredEntryOf(container, entry) {
 		phase: "declared",
 		metadata: entry.definition?.metadata ?? emptyMetadata,
 		exclusive: entry.exclusive,
-		perConsumer: entry.definition?.perConsumer ?? false
+		perConsumer: entry.definition?.perConsumer ?? false,
+		exported: entry.exported
 	});
 }
 /** The services and invocations of the scope that are not `withdrawn`, in registration order. */
@@ -3558,7 +3281,7 @@ function lookup(scope, 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);
+		const provider = findProvider(service.scope, keyName, service);
 		return provider ? [provider] : [];
 	}));
 }
@@ -3575,7 +3298,7 @@ function dependencyOf(edge, resolution) {
 		keys: edge.candidates,
 		optional: edge.optional,
 		fallback: edge.fallback,
-		conditional: edge.condition !== void 0,
+		conditional: edge.condition !== void 0 || edge.candidateConditions !== void 0,
 		resolution: resolution.kind,
 		...withoutUndefined({ provider: resolution.provider && entryOf(resolution.provider) })
 	});
@@ -3685,7 +3408,8 @@ function proposedChange(scope, change) {
 /**
 * 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.
+* A key resolves as for a consumer in the container: from the container and the exports of its children, then from each ancestor and the exports of its children.
+* A key that only a descendant has resolves to the first such service.
 */
 function graph(container) {
 	const scope = nodeOf(container);
@@ -3729,16 +3453,102 @@ function graph(container) {
 			const service = lookup(scope, name);
 			if (service) return explainService(service);
 			const declared = declaredOf(scope).find(({ entry }) => entry.name === name);
-			return declared && Object.freeze({
+			if (declared) return Object.freeze({
 				name,
 				kind: "service",
 				owner: declared.container.owner,
 				phase: "declared",
 				blockers: Object.freeze([])
 			});
+			return Object.freeze({
+				name,
+				kind: "service",
+				owner: scope.owner,
+				phase: void 0,
+				blockers: Object.freeze([Object.freeze({
+					kind: "missing-provider",
+					dependency: name,
+					key: name
+				})])
+			});
 		})
 	});
 }
+// src/queries/peek.ts
+function resultOf(resolution, fallbackKey) {
+	switch (resolution.kind) {
+		case "missing": return Object.freeze({
+			kind: "missing",
+			key: fallbackKey
+		});
+		case "conflict": return Object.freeze({
+			kind: "conflict",
+			key: resolution.provider.name,
+			owners: ownersOf([resolution.provider, ...resolution.rivals])
+		});
+		case "rejected": return Object.freeze({
+			kind: "rejected",
+			key: resolution.provider.name,
+			owner: resolution.provider.container.owner,
+			metadata: resolution.provider.metadata
+		});
+		case "not-running": {
+			const { provider } = resolution;
+			const phase = provider.signals.phase();
+			const owner = (provider.template ?? provider).container.owner;
+			return Object.freeze({
+				kind: "not-running",
+				key: provider.name,
+				owner,
+				phase,
+				...phase === "failed" ? { error: provider.failure?.error } : {}
+			});
+		}
+		case "resolved": {
+			const { provider, instance } = resolution;
+			const owner = (provider.template ?? provider).container.owner;
+			const status = provider.signals.effective();
+			if (!status || status.status === "unavailable") return Object.freeze({
+				kind: "unavailable",
+				key: provider.name,
+				owner,
+				instanceId: instance.id,
+				...withoutUndefined({
+					reason: status?.reason,
+					cause: status?.cause
+				})
+			});
+			return Object.freeze({
+				kind: "resolved",
+				key: provider.name,
+				owner,
+				value: instance.value,
+				status: status.status,
+				instanceId: instance.id
+			});
+		}
+	}
+}
+/**
+* Reads the value of a dependency now, without a wait. It is a pure read: it does not demand, build, or start a service.
+*
+* The dependency resolves as for a consumer in `container`: a key, `where(key, condition)`, or `firstAvailable(...)`. An `optional` marker has no effect.
+* The result is the value with its status, or the reason why no value is available now. A `perConsumer` key has a value only after something demanded its service for `container`.
+*/
+function peek(container, dependency) {
+	const node = nodeOf(container);
+	const [edge] = readEdges("peek", { dependency });
+	if (!edge) throw new InvalidArgumentError("peek() needs a dependency.");
+	return untracked(() => {
+		const consumer = {
+			container: node,
+			scope: node,
+			name: "peek",
+			template: void 0
+		};
+		return resultOf(edge.fallback ? resolveFallback(consumer, edge) : resolvePlain(consumer, edge), edge.candidates[0] ?? edge.keyName);
+	});
+}
 // src/queries/listeners.ts
 /**
 * Returns the current listeners for `eventKey` in `container` and its descendants, in registration order.
@@ -3776,15 +3586,15 @@ function provide(nameOrOption, option) {
 function invoke(option) {
 	return invokeIn(globalContainer, option);
 }
-function resolve(dependsOn) {
-	return resolve$1(globalContainer, dependsOn);
+function resolve(dependsOn, options) {
+	return resolve$1(globalContainer, dependsOn, options);
 }
 function start(options) {
 	return start$1(globalContainer, options);
 }
-function stop() {
-	return stop$1(globalContainer);
+function stop(options) {
+	return stop$1(globalContainer, options);
 }
-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 };
+export { createNoopLogger as A, effect$1 as C, systemClock as D, waitAbortError as E, createDefaultLogger as O, dispose as S, readSignal as T, listen as _, resolve as a, invoke$1 as b, stop as c, graph as d, transaction as f, provide$1 as g, resolve$1 as h, resetContainer as i, createLoggLogger as k, listeners as l, withTimeout as m, invoke as n, setLogger as o, timeout as p, provide as r, start as s, getContainer as t, peek as u, start$1 as v, onAbort as w, createContainer as x, stop$1 as y };
 
-//# sourceMappingURL=global-C0Nk0pU8.mjs.map
+//# sourceMappingURL=global-B5N-d-TO.mjs.map