injeca 0.3.0 → 0.4.0

package/dist/decision-BXZu3N1O.mjs

@@ -0,0 +1,1356 @@
+import { computed, effect, endBatch, setActiveSub, signal, startBatch } from "alien-signals";
+import { isUndefined, omitBy } from "es-toolkit";
+// src/diagnostics/errors.ts
+/**
+* The base class of all injeca errors. Use `code` to identify an error. The message text is not stable.
+*/
+var InjecaError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "InjecaError";
+		this.code = code;
+	}
+};
+/** A started container already has a current registration for the key. */
+var DuplicateServiceError = class extends InjecaError {
+	constructor(message, options) {
+		super("duplicate-service", message, options);
+		this.name = "DuplicateServiceError";
+	}
+};
+/** A registration is no longer the current registration of its service. */
+var StaleRegistrationError = class extends InjecaError {
+	constructor(message, options) {
+		super("stale-registration", message, options);
+		this.name = "StaleRegistrationError";
+	}
+};
+/** A hook returned a decision from another run, or a kind that the hook does not accept. */
+var InvalidDecisionError = class extends InjecaError {
+	constructor(message, options) {
+		super("invalid-decision", message, options);
+		this.name = "InvalidDecisionError";
+	}
+};
+/** A caller used a container or an instance after its disposal started. */
+var BuildAfterDisposeError = class extends InjecaError {
+	constructor(message, options) {
+		super("build-after-dispose", message, options);
+		this.name = "BuildAfterDisposeError";
+	}
+};
+/** `on` was called after `build` settled. */
+var HookOutsideBuildError = class extends InjecaError {
+	constructor(message, options) {
+		super("hook-outside-build", message, options);
+		this.name = "HookOutsideBuildError";
+	}
+};
+/** A transaction commit found a declared service without `provide`. */
+var TransactionIncompleteError = class extends InjecaError {
+	constructor(message, options) {
+		super("transaction-incomplete", message, options);
+		this.name = "TransactionIncompleteError";
+	}
+};
+/** A `start` or `stop` hook did not settle before its configured timeout. */
+var HookTimeoutError = class extends InjecaError {
+	hook;
+	timeoutMs;
+	constructor(message, hook, timeoutMs, options) {
+		super("hook-timeout", message, options);
+		this.name = "HookTimeoutError";
+		this.hook = hook;
+		this.timeoutMs = timeoutMs;
+	}
+};
+/** `replace` was called on a service in `stopping`. */
+var ReplaceWhileStoppingError = class extends InjecaError {
+	constructor(message, options) {
+		super("replace-while-stopping", message, options);
+		this.name = "ReplaceWhileStoppingError";
+	}
+};
+/** `start()` did not reach `running` for every service before its configured timeout. */
+var StartTimeoutError = class extends InjecaError {
+	/** One entry for each service or invocation that is not `running`. */
+	explanations;
+	constructor(message, explanations, options) {
+		super("start-timeout", message, options);
+		this.name = "StartTimeoutError";
+		this.explanations = explanations;
+	}
+};
+/** `waitFor()` found the service in `failed`, or waiting for a required provider in `failed`. `cause` is the failure. */
+var ServiceFailedError = class extends InjecaError {
+	/** The key name that the caller waited for. */
+	key;
+	constructor(message, key, options) {
+		super("service-failed", message, options);
+		this.name = "ServiceFailedError";
+		this.key = key;
+	}
+};
+/** `waitFor()` or `resolve()` did not match before its configured timeout. */
+var WaitTimeoutError = class extends InjecaError {
+	constructor(message, options) {
+		super("wait-timeout", message, options);
+		this.name = "WaitTimeoutError";
+	}
+};
+/** A caller passed a value with the wrong shape, or reading a caller-owned property failed. */
+var InvalidArgumentError = class extends InjecaError {
+	constructor(message, options) {
+		super("invalid-argument", message, options);
+		this.name = "InvalidArgumentError";
+	}
+};
+// 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);
+}
+/** The message of a thrown value: `message` of an `Error` or a `DOMException`, else `String(value)`. */
+function messageOf(value) {
+	if (typeof value === "object" && value !== null && typeof value.message === "string") return value.message;
+	return String(value);
+}
+// src/graph/resolvers/exports.ts
+/** Returns the signal of the exported services of `keyName` that the child containers of `container` publish. It creates the signal on first read, so that resolution can track it. */
+function exportsOf(container, keyName) {
+	let exports = container.signals.exports.get(keyName);
+	if (!exports) {
+		exports = signal(Object.freeze([]));
+		container.signals.exports.set(keyName, exports);
+	}
+	return exports;
+}
+/**
+* The container whose resolution area a registration belongs to.
+* An exported registration belongs to the area of its parent container. A registration of a root container has no parent, so `export` has no effect there.
+*/
+function areaOf(service) {
+	return service.exported && service.container.parent || service.container;
+}
+// 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.
+* For an exported registration, the caller passes the parent container. See `areaOf`.
+*/
+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.
+* An exported registration counts in the resolution area of its parent container. So two sibling exports of one exclusive key conflict, and an export conflicts with a registration of the parent.
+* 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(areaOf(service), areaOf(other), 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.
+*
+* At each level, from `container` up through its ancestors, the candidates are the registration of that container, then the exports of its child containers in creation order.
+* The walk ends at a container that isolates the key. So an isolated key also hides the exports of the siblings.
+* A service does not resolve itself. A consumer service of a `perConsumer` registration does not resolve its registration.
+*/
+function candidatesOf(container, keyName, consumer) {
+	const candidates = [];
+	const add = (candidate) => {
+		if (candidate && candidate !== consumer && candidate !== consumer?.template && !candidates.includes(candidate)) candidates.push(candidate);
+	};
+	for (let current = container; current; current = current.parent) {
+		add(slotOf(current, keyName)());
+		for (const exported of exportsOf(current, keyName)()) add(exported);
+		if (current.isolated.has(keyName)) break;
+	}
+	return candidates;
+}
+/** The service that serves `registration` for a consumer in `container`. A `perConsumer` registration has one for each consumer container, or none yet. */
+function serviceFor(registration, container) {
+	return registration.perConsumer ? registration.signals.consumers().get(container) : registration;
+}
+/**
+* Selects the provider of `keyName` for a consumer in `container`.
+*
+* A nearer registration shadows an ancestor only while it is `running`. Until then, the first serving registration wins.
+* If no registration serves, the nearest one is selected. So shadowing never leaves a gap.
+*/
+function selectProvider(container, keyName, consumer) {
+	const candidates = candidatesOf(container, keyName, consumer);
+	for (const registration of candidates) {
+		const provider = serviceFor(registration, container);
+		if (provider?.signals.serving()) return {
+			registration,
+			provider
+		};
+	}
+	const [nearest] = candidates;
+	return nearest ? {
+		registration: nearest,
+		provider: serviceFor(nearest, container)
+	} : void 0;
+}
+/** Finds the service for `keyName` that a consumer in `container` sees. A `perConsumer` registration without a service for the container gives the registration. */
+function findProvider(container, keyName, consumer) {
+	const selection = selectProvider(container, keyName, consumer);
+	return selection && (selection.provider ?? selection.registration);
+}
+/** `ready` and `degraded` count as available. A provider outside `running` has no status and is not available. */
+function isAvailable(provider) {
+	const status = provider.signals.effective();
+	return status !== void 0 && status.status !== "unavailable";
+}
+/** The current resolution of the edge. */
+function resolutionOf(service, edge) {
+	return service.signals.resolutions.get(edge.name)?.() ?? { kind: "missing" };
+}
+/** The instance of the edge, when it resolves. */
+function resolvedInstance(service, edge) {
+	const resolution = resolutionOf(service, edge);
+	return resolution.kind === "resolved" ? resolution.instance : void 0;
+}
+/** Tells whether each required edge resolves to an available provider. A pending service builds only then. */
+function requiredAvailable(service) {
+	return service.edges.every((edge) => {
+		if (edge.optional) return true;
+		const resolution = resolutionOf(service, edge);
+		return resolution.kind === "resolved" && isAvailable(resolution.provider);
+	});
+}
+/** Tells whether a required edge no longer resolves: its provider was withdrawn, or it does not run. */
+function requiredWithdrawn(service) {
+	return service.edges.some((edge) => !edge.optional && resolvedInstance(service, edge) === void 0);
+}
+/** Tells whether the current resolution of a required edge differs from the bindings of `instance`. */
+function requiredChanged(service, instance) {
+	return service.edges.some((edge) => !edge.optional && resolvedInstance(service, edge) !== instance.bindings.get(edge.name));
+}
+/** A build is discarded when its target is lost, a required dependency changed during the build, or the key went into conflict. */
+function buildLost(service, instance) {
+	return !service.signals.present() || !service.signals.active() || service.signals.rivals().length > 0 || requiredChanged(service, instance);
+}
+/** The identity of the dependency set: the revision and the instance id of each resolved required dependency. */
+function epochOf(service, pick) {
+	const ids = service.edges.filter((edge) => !edge.optional).map((edge) => `${edge.name}=${pick(edge)?.id ?? ""}`);
+	return [String(service.revision), ...ids].join("|");
+}
+/**
+* Finds the failure that blocks a pending service: a required provider in `failed`, directly or through pending providers.
+*/
+function blockingFailure(service, visited = /* @__PURE__ */ new Set()) {
+	visited.add(service);
+	for (const edge of service.edges) {
+		if (edge.optional) continue;
+		const resolution = resolutionOf(service, edge);
+		if (resolution.kind !== "not-running" || visited.has(resolution.provider)) continue;
+		const provider = resolution.provider;
+		const phase = provider.signals.phase();
+		if (phase === "failed") return provider.failure;
+		if (phase === "pending") {
+			const failure = blockingFailure(provider, visited);
+			if (failure) return failure;
+		}
+	}
+}
+// src/graph/nodes/container.ts
+const nodes = /* @__PURE__ */ new WeakMap();
+/** Connects the public container object to its node. `createContainer` calls it once. */
+function registerNode(container, node) {
+	nodes.set(container, node);
+}
+/** Returns the internal node of a container from `createContainer`. */
+function nodeOf(container) {
+	const node = typeof container === "object" && container !== null ? nodes.get(container) : void 0;
+	if (!node) throw new InvalidArgumentError("The value is not a container from createContainer.");
+	return node;
+}
+function assertActive(container, action) {
+	if (container.state !== "active") throw new BuildAfterDisposeError(`Cannot ${action} after the container disposal started.`);
+}
+/** Lists `container` and its descendants that were started, through started containers only. `start()` and `stop()` apply to them. */
+function affectedContainers(container) {
+	const result = [container];
+	for (const child of container.children) if (child.enrolled) result.push(...affectedContainers(child));
+	return result;
+}
+/** Lists `container` and all its descendants. */
+function subtreeOf(container) {
+	return [container, ...[...container.children].flatMap(subtreeOf)];
+}
+/**
+* Adds an exported service to the exports of its parent container, in container creation order.
+* It takes the place of an earlier service of the same container, for example at the swap of a replacement.
+*/
+function addExport(service) {
+	const parent = service.container.parent;
+	if (!service.exported || !parent) return;
+	const exports = exportsOf(parent, service.name);
+	const current = exports();
+	if (current.includes(service)) return;
+	exports(Object.freeze([...current.filter((other) => other.container !== service.container), service].sort((a, b) => a.container.seq - b.container.seq)));
+}
+function removeExport(service) {
+	const parent = service.container.parent;
+	if (!service.exported || !parent) return;
+	const exports = exportsOf(parent, service.name);
+	if (exports().includes(service)) exports(Object.freeze(exports().filter((other) => other !== service)));
+}
+/**
+* Makes `service` visible to consumers: the slot of its key, or the consumer map of its `perConsumer` registration.
+* An exported service is also visible in the resolution area of the parent container.
+* An exclusive conflict counts each published service with a key.
+*/
+function publishService(service) {
+	const { template } = service;
+	if (template) {
+		const consumers = template.signals.consumers();
+		if (consumers.get(service.container) !== service) template.signals.consumers(new Map([...consumers, [service.container, service]]));
+		return;
+	}
+	slotOf(service.container, service.name)(service);
+	addExport(service);
+	addDeclaration(service);
+}
+/**
+* Clears the slot and marks the service absent. The reconciler stops it after its holders release it.
+* A `perConsumer` registration also releases the service of each consumer container.
+*/
+function releaseService(service) {
+	service.signals.present(false);
+	if (service.kind !== "service" || service.template) return;
+	for (const consumer of service.signals.consumers().values()) consumer.signals.present(false);
+	const slot = slotOf(service.container, service.name);
+	if (slot() === service) slot(void 0);
+	removeExport(service);
+}
+/** 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.`);
+}
+/** Releases a service or an invocation. Returns `false` when it is already withdrawn. */
+function releasePresent(service) {
+	return untracked(() => {
+		if (!service.signals.present()) return false;
+		batch(() => releaseService(service));
+		return true;
+	});
+}
+// src/helpers/deferred.ts
+function createDeferred() {
+	let resolve;
+	return {
+		promise: new Promise((done) => {
+			resolve = done;
+		}),
+		resolve
+	};
+}
+// src/helpers/without-undefined.ts
+/** Copies `fields` without the fields that are `undefined`. Spread the result to add optional fields to a record. */
+function withoutUndefined(fields) {
+	return omitBy(fields, isUndefined);
+}
+// src/graph/observers.ts
+function within(container, ancestor) {
+	for (let current = container; current; current = current.parent) if (current === ancestor) return true;
+	return false;
+}
+/** The active observers of `container`: the observers of the container and of its ancestors. */
+function targetsOf(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(container);
+	if (targets.length === 0) return;
+	send(container, targets, Object.freeze(record));
+}
+/** Reports a callback error as an `error` record. An error from an observe callback does not go back to that callback. */
+function reportCallbackError(container, key, error, reason, source) {
+	const record = {
+		type: "error",
+		key,
+		owner: container.owner,
+		instanceId: void 0,
+		reason,
+		error
+	};
+	send(container, targetsOf(container, source), record);
+}
+/** Sends a `wait-aborted` record for each service of `services`: the `signal` of `call` aborted before the service stopped. */
+function recordAbortedWait(services, call, reason) {
+	const message = messageOf(reason);
+	for (const service of services) emitRecord(service.container, {
+		type: "wait-aborted",
+		key: service.name,
+		owner: service.container.owner,
+		instanceId: service.signals.instance()?.id,
+		call,
+		phase: service.signals.phase(),
+		reason: message,
+		abortReason: reason
+	});
+}
+// src/graph/resolvers/condition.ts
+/**
+* The verdict of each condition for each provider registration.
+* The input of a condition is frozen, and a condition must be pure. So each pair runs once, and a throw is reported once.
+*/
+const verdicts = /* @__PURE__ */ new WeakMap();
+/** The read-only information about a provider registration that a condition gets. */
+function providerInfo(registration) {
+	return Object.freeze({
+		key: registration.name,
+		owner: registration.container.owner,
+		metadata: registration.metadata
+	});
+}
+/**
+* Tells whether `condition` accepts the provider registration.
+* A thrown error counts as `false` and goes to the observe stream of the consumer.
+*/
+function acceptsProvider(consumer, keyName, condition, registration) {
+	let byProvider = verdicts.get(condition);
+	if (!byProvider) {
+		byProvider = /* @__PURE__ */ new WeakMap();
+		verdicts.set(condition, byProvider);
+	}
+	const known = byProvider.get(registration);
+	if (known !== void 0) return known;
+	let verdict;
+	try {
+		verdict = untracked(() => condition(providerInfo(registration))) === true;
+	} catch (error) {
+		verdict = false;
+		queueMicrotask(() => reportCallbackError(consumer.container, consumer.name, error, `A resolution condition for '${keyName}' threw. It counts as false.`));
+	}
+	byProvider.set(registration, verdict);
+	return verdict;
+}
+/** The resolution conditions that a candidate of `edge` must pass: the condition of the edge, then the condition of the candidate. */
+function conditionsOf(edge, keyName) {
+	const conditions = [];
+	if (edge?.condition) conditions.push(edge.condition);
+	const own = edge?.candidateConditions?.[keyName];
+	if (own) conditions.push(own);
+	return conditions;
+}
+/** Tells whether the provider registration passes each condition of the candidate `keyName` of `edge`. */
+function acceptsCandidate(consumer, edge, keyName, registration) {
+	return conditionsOf(edge, keyName).every((condition) => acceptsProvider(consumer, keyName, condition, registration));
+}
+// 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 a condition of `edge` for `keyName` rejects, does not resolve.
+*/
+function resolveKey(consumer, keyName, edge) {
+	const selection = selectProvider(consumer.scope, 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 (!acceptsCandidate(consumer, edge, keyName, registration)) return {
+		kind: "rejected",
+		provider: registration
+	};
+	if (!provider) return {
+		kind: "not-running",
+		provider: registration
+	};
+	const instance = provider.signals.instance();
+	if (!provider.signals.serving() || !instance) return {
+		kind: "not-running",
+		provider
+	};
+	return {
+		kind: "resolved",
+		provider,
+		instance
+	};
+}
+/** Resolves a plain or an optional edge. It has one candidate key. */
+function resolvePlain(consumer, edge) {
+	const [keyName] = edge.candidates;
+	return keyName === void 0 ? { kind: "missing" } : resolveKey(consumer, keyName, edge);
+}
+// src/graph/resolvers/fallback.ts
+/**
+* Resolves a `firstAvailable` edge. The first serving and available candidate that passes its conditions wins. A rejected candidate is skipped.
+* If no serving candidate is available, the first serving candidate stays selected, so that a running dependent does not lose it.
+* Without a serving candidate, the edge reports the first candidate that exists.
+*/
+function resolveFallback(consumer, edge) {
+	let firstUnresolved;
+	let firstServing;
+	for (const keyName of edge.candidates) {
+		const resolution = resolveKey(consumer, keyName, edge);
+		if (resolution.kind === "missing") continue;
+		if (resolution.kind !== "resolved") {
+			firstUnresolved ??= resolution;
+			continue;
+		}
+		if (isAvailable(resolution.provider)) return resolution;
+		firstServing ??= resolution;
+	}
+	return firstServing ?? firstUnresolved ?? { kind: "missing" };
+}
+// src/graph/status.ts
+const statusRank = {
+	ready: 0,
+	degraded: 1,
+	unavailable: 2
+};
+/** Tells whether `a` is worse than `b`. The order is `ready`, then `degraded`, then `unavailable`. */
+function worseThan(a, b) {
+	return statusRank[a] > statusRank[b];
+}
+function sameCause(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.key === b.key && a.owner === b.owner && a.status === b.status && a.reason === b.reason && sameCause(a.cause, b.cause);
+}
+/** Tells whether two status values have the same status, reason, and cause. */
+function sameStatus(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.status === b.status && a.reason === b.reason && sameCause(a.cause, b.cause);
+}
+function statusFields(status) {
+	return withoutUndefined({
+		reason: status.reason,
+		cause: status.cause
+	});
+}
+/** The cause that a dependent reports when `provider` makes its effective status worse. */
+function causeOf(provider, status) {
+	return Object.freeze({
+		key: provider.name,
+		owner: provider.container.owner,
+		status: status.status,
+		...withoutUndefined({
+			reason: status.reason,
+			cause: status.cause
+		})
+	});
+}
+/**
+* Creates the effective status of a service: the worst of the own status and the effective status of each required dependency.
+* An optional dependency does not count. It is `undefined` outside `running`.
+*/
+function createEffectiveStatus(input) {
+	const { phase, instance, edges, resolutions } = input;
+	return computed((previous) => {
+		const current = instance();
+		if (phase() !== "running" || !current) return void 0;
+		let result = current.signals.own();
+		for (const edge of edges) {
+			if (edge.optional) continue;
+			const resolution = resolutions.get(edge.name)?.();
+			if (resolution?.kind !== "resolved") continue;
+			const dependency = resolution.provider.signals.effective();
+			if (dependency && worseThan(dependency.status, result.status)) result = {
+				status: dependency.status,
+				cause: causeOf(resolution.provider, dependency)
+			};
+		}
+		return previous && sameStatus(previous, result) ? previous : result;
+	});
+}
+/** Reports a change of the effective status. The status effect of each service calls it. */
+function reportStatus(service, next) {
+	const previous = service.reportedStatus;
+	service.reportedStatus = next;
+	if (!next || sameStatus(previous, next)) return;
+	emitRecord(service.container, {
+		type: "status",
+		key: service.name,
+		owner: service.container.owner,
+		instanceId: service.signals.instance()?.id,
+		from: previous?.status,
+		to: next.status,
+		...statusFields(next)
+	});
+}
+// src/graph/nodes/service.ts
+/** Writes the phase and sends the change to the observe stream. */
+function setPhase(service, to, details = {}) {
+	const from = service.signals.phase();
+	if (from === to) return;
+	batch(() => {
+		service.signals.phase(to);
+		if (service.kind === "resolver") return;
+		emitRecord(service.container, {
+			type: "phase",
+			key: service.name,
+			owner: service.container.owner,
+			instanceId: service.signals.instance()?.id,
+			from,
+			to,
+			...withoutUndefined({
+				reason: details.reason,
+				decision: details.decision
+			})
+		});
+	});
+}
+function sameResolution(a, b) {
+	if (a.kind !== b.kind) return false;
+	switch (a.kind) {
+		case "missing": return true;
+		case "not-running":
+		case "rejected": return "provider" in b && a.provider === b.provider;
+		case "conflict": return b.kind === "conflict" && a.provider === b.provider && a.rivals === b.rivals;
+		case "resolved": return b.kind === "resolved" && a.provider === b.provider && a.instance === b.instance;
+	}
+}
+/** Creates the resolution of one declared edge. It keeps the previous value when nothing changed. */
+function resolveEdge(consumer, edge) {
+	return computed((previous) => {
+		const next = edge.fallback ? resolveFallback(consumer, edge) : resolvePlain(consumer, edge);
+		return previous && sameResolution(previous, next) ? previous : next;
+	});
+}
+const emptyMetadata$1 = 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 subscribers = signal(/* @__PURE__ */ new Set());
+	const resolutions = /* @__PURE__ */ new Map();
+	const effective = createEffectiveStatus({
+		phase,
+		instance,
+		edges: input.edges,
+		resolutions
+	});
+	let rivals = () => [];
+	const service = {
+		seq: input.seq ?? runtime.nextSeq(),
+		kind: input.kind,
+		name: input.name,
+		container,
+		scope: input.template?.container ?? container,
+		edges: input.edges,
+		build: input.build,
+		metadata: input.metadata ?? emptyMetadata$1,
+		policy: input.policy ?? emptyPolicy$1,
+		exclusive: input.exclusive ?? false,
+		exported: input.template === void 0 && (input.exported ?? false),
+		perConsumer: input.perConsumer ?? false,
+		template: input.template,
+		consumer: input.consumer,
+		registration: input.registration,
+		swap: input.swap,
+		replacedBy: void 0,
+		successor: void 0,
+		transaction: input.transaction,
+		revision: 0,
+		signals: {
+			present,
+			phase,
+			instance,
+			demanded,
+			subscribers,
+			active: computed(() => container.signals.started() || input.kind !== "invocation" && (demanded() || subscribers().size > 0)),
+			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,
+		demanders: /* @__PURE__ */ new Set(),
+		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
+/** The phases of a consumer service that lead to a build outcome. */
+const waitingPhases = /* @__PURE__ */ new Set([
+	"pending",
+	"building",
+	"starting",
+	"retrying"
+]);
+/**
+* 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.
+*
+* `demander` is the dependent, the `resolve` call, or the subscription that needs the service.
+* A failed service builds again for a demander that did not get a build since the service last ran. So a new demand retries a failed consumer service.
+*/
+function ensureConsumerService(registration, container, demander) {
+	const existing = registration.signals.consumers().get(container);
+	if (existing) {
+		if (existing.signals.phase() === "failed" && existing.signals.present() && !existing.demanders.has(demander)) {
+			existing.demanders.add(demander);
+			existing.failure = void 0;
+			setPhase(existing, "pending", { reason: "A new demand tries the failed consumer service again." });
+			existing.container.runtime.reconciler.markDirty(existing);
+		} else if (waitingPhases.has(existing.signals.phase())) existing.demanders.add(demander);
+		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
+		});
+		service.demanders.add(demander);
+		container.services.add(service);
+		publishService(service);
+	});
+	return service;
+}
+/**
+* Makes `subscription` demand the consumer service of `registration` for `container`, so that it builds also before `start()`.
+* Returns the service, or `undefined` when it cannot exist. `releaseConsumerDemand` ends the demand.
+*/
+function demandConsumerService(registration, container, subscription) {
+	const service = ensureConsumerService(registration, container, subscription);
+	if (service && !service.signals.subscribers().has(subscription)) service.signals.subscribers(/* @__PURE__ */ new Set([...service.signals.subscribers(), subscription]));
+	return service;
+}
+/** Ends the demand of `subscription` on `service`. */
+function releaseConsumerDemand(service, subscription) {
+	const subscribers = service.signals.subscribers();
+	if (subscribers.has(subscription)) service.signals.subscribers(new Set([...subscribers].filter((other) => other !== subscription)));
+}
+// 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);
+}
+/** The candidate conditions of a marker, without empty records. */
+function withCandidateConditions(candidateConditions) {
+	return candidateConditions && Object.keys(candidateConditions).length > 0 ? { candidateConditions } : {};
+}
+/**
+* Marks a fallback dependency. It resolves to the first provider in the list whose effective status is available.
+*
+* A change of the selection is a change of identity: the dependent gets `dependency-change`.
+* It is required, unless it is wrapped in `optional()`.
+* A `where(key, condition)` marker in the list filters that candidate only. `where(firstAvailable(...), condition)` filters each candidate.
+* The selection is the first available candidate that passes its conditions.
+*/
+function firstAvailable(...keys) {
+	if (keys.length === 0) throw new InvalidArgumentError("firstAvailable() needs at least one key.");
+	const candidateConditions = {};
+	const dependencies = keys.map((key) => {
+		if (isConditionalDependency(key)) {
+			const [name] = key.dependencies;
+			candidateConditions[name] = key.condition;
+			return name;
+		}
+		if (isFallbackDependency(key) || isOptionalDependency(key)) throw new InvalidArgumentError("firstAvailable() accepts keys, names, and where() markers.");
+		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(", ")}.`);
+	return fallbackMarker(Object.freeze(dependencies), void 0, Object.freeze(candidateConditions));
+}
+function fallbackMarker(dependencies, condition, candidateConditions) {
+	const marker = Object.freeze({
+		[fallbackBrand]: true,
+		dependencies,
+		...condition ? { condition } : {},
+		...withCandidateConditions(candidateConditions)
+	});
+	fallbackMarkers.add(marker);
+	return marker;
+}
+function optionalMarker(dependencies, condition, candidateConditions) {
+	const marker = Object.freeze({
+		[optionalBrand]: true,
+		dependencies,
+		...condition ? { condition } : {},
+		...withCandidateConditions(candidateConditions)
+	});
+	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, with their conditions.
+*/
+function optional(dependency) {
+	if (isFallbackDependency(dependency)) return optionalMarker(dependency.dependencies, dependency.condition, dependency.candidateConditions);
+	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, dependency.candidateConditions);
+	}
+	if (isFallbackDependency(dependency)) {
+		if (dependency.condition) throw new InvalidArgumentError("The fallback dependency already has a condition.");
+		return fallbackMarker(dependency.dependencies, condition, dependency.candidateConditions);
+	}
+	if (isConditionalDependency(dependency)) throw new InvalidArgumentError("where() accepts a key, a name, an optional() marker, or a firstAvailable() 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, candidateConditions) {
+	return Object.freeze({
+		name,
+		keyName: candidates.join(" | "),
+		candidates,
+		optional,
+		fallback,
+		...condition ? { condition } : {},
+		...candidateConditions ? { candidateConditions } : {}
+	});
+}
+/**
+* Reads a `dependsOn` declaration into edges. Reading a caller-owned property happens once, inside a narrow `try`.
+*/
+function readEdges(owner, dependsOn) {
+	if (dependsOn === void 0 || dependsOn === null) return Object.freeze([]);
+	if (typeof dependsOn !== "object") throw new InvalidArgumentError(`The dependsOn option of '${owner}' is not an object.`);
+	let entries;
+	try {
+		entries = Object.entries(dependsOn);
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the dependsOn option of '${owner}'.`, { cause: error });
+	}
+	return Object.freeze(entries.map(([name, dependency]) => {
+		if (isOptionalDependency(dependency)) return edgeOf(name, dependency.dependencies, true, dependency.dependencies.length > 1, dependency.condition, dependency.candidateConditions);
+		if (isConditionalDependency(dependency)) return edgeOf(name, dependency.dependencies, false, false, dependency.condition);
+		if (isFallbackDependency(dependency)) return edgeOf(name, dependency.dependencies, false, true, dependency.condition, dependency.candidateConditions);
+		if (typeof dependency === "string" || typeof dependency === "object" && dependency !== null && "key" in dependency) {
+			const keyName = normalizeName(dependency);
+			if (typeof keyName === "string" && keyName.length > 0) return edgeOf(name, Object.freeze([keyName]), false, false);
+		}
+		throw new InvalidArgumentError(`The dependency '${name}' of '${owner}' is not a name, a key, an optional marker, a fallback marker, or a condition marker.`);
+	}));
+}
+// src/graph/nodes/policy.ts
+const emptyPolicy = Object.freeze({});
+function readMaxAttempts(owner, value) {
+	if (value !== void 0 && (typeof value !== "number" || !Number.isInteger(value) || value < 1)) throw new InvalidArgumentError(`The maxAttempts option of ${owner} must be an integer of 1 or more. Got ${String(value)}.`);
+	return value;
+}
+function readTimeout(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(owner, "start", fields.start);
+	const stop = readTimeout(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 = Object.freeze({});
+function readMetadata(name, metadata, fallback) {
+	if (metadata === void 0) return fallback ?? emptyMetadata;
+	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.
+* A replacement keeps `perConsumer` and `export` of its registration, so it ignores these fields of the definition.
+*/
+function readDefinition(name, option, inherit) {
+	let build;
+	let dependsOn;
+	let metadata;
+	let perConsumer;
+	let exported;
+	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;
+		exported = object.export;
+		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.`);
+	if (exported !== void 0 && typeof exported !== "boolean") throw new InvalidArgumentError(`The export option of '${name}' must be a boolean.`);
+	return {
+		edges: readEdges(name, dependsOn),
+		build,
+		metadata: readMetadata(name, metadata, inherit?.metadata),
+		perConsumer: perConsumer === true,
+		exported: exported === 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);
+}
+/** Cancels the successor that waits to replace `service`, for example a make-before-break rebuild. `service` does not change. */
+function cancelSuccessor(service) {
+	const successor = service.successor;
+	if (!successor) return;
+	service.successor = void 0;
+	successor.swap?.settle({ kind: "cancelled" });
+	releaseService(successor);
+}
+/** Releases the current service of a registration and cancels its pending replacement. Returns the service, or `undefined` for a stale registration. */
+function releaseRegistration(registration) {
+	return untracked(() => {
+		const current = currentService(registration);
+		if (current) batch(() => {
+			cancelPending(registration);
+			releaseService(current);
+		});
+		return current;
+	});
+}
+// src/graph/nodes/reservation.ts
+/**
+* Reserves the exclusive key of a transaction entry until the commit or the abort.
+*
+* The reservation is a declaration without a slot. Consumers cannot resolve it. An exclusive conflict counts it, so a provider of the key in another container of the resolution area goes to `conflict`.
+* The reservation of an exported key counts in the resolution area of the parent container, as the published service does.
+* A plain key needs no reservation. In the same container, `provide` checks the open transactions and fails with `duplicate-service`.
+*/
+function reserveKey(transaction, entry) {
+	if (!entry.exclusive || entry.replace) return;
+	if (entry.reservation?.exported === entry.exported) return;
+	releaseReservation(entry);
+	batch(() => {
+		const reservation = createService({
+			container: transaction.container,
+			kind: "service",
+			name: entry.name,
+			edges: [],
+			build: () => void 0,
+			exclusive: true,
+			exported: entry.exported,
+			phase: "declared",
+			transaction
+		});
+		entry.reservation = reservation;
+		addDeclaration(reservation);
+	});
+}
+/** Removes the reservation of a transaction entry. The commit calls it in the batch of its publish. */
+function releaseReservation(entry) {
+	const reservation = entry.reservation;
+	if (!reservation) return;
+	entry.reservation = void 0;
+	batch(() => {
+		reservation.signals.present(false);
+		removeDeclaration(reservation);
+	});
+	reservation.disposeEffects();
+}
+/** Removes the reservations of all entries of a transaction. */
+function releaseReservations(transaction) {
+	batch(() => {
+		for (const entry of transaction.entries.values()) releaseReservation(entry);
+	});
+}
+/** Tells whether an open or committing transaction of the container, other than `except`, has an entry that reserves `name`. */
+function reservedBy(transactions, name, except) {
+	for (const transaction of transactions) {
+		if (transaction === except || transaction.state !== "open" && transaction.state !== "committing") continue;
+		const entry = transaction.entries.get(name);
+		if (entry && !entry.replace) return transaction;
+	}
+}
+// src/primitives/decision.ts
+const issued = /* @__PURE__ */ new WeakMap();
+function reasonFrom(options) {
+	return options?.reason === void 0 ? {} : { reason: options.reason };
+}
+/** Creates the `decide` object of one run. */
+function createDecide(run) {
+	function issue(fields) {
+		const decision = Object.freeze({
+			...fields,
+			service: run.service,
+			instanceId: run.instanceId,
+			hook: run.hook,
+			attempt: run.attempt,
+			issuedAt: run.now()
+		});
+		issued.set(decision, run);
+		return decision;
+	}
+	return Object.freeze({
+		handled: (options) => issue({
+			kind: "handled",
+			...reasonFrom(options)
+		}),
+		rebuild: (options) => issue({
+			kind: "rebuild",
+			...reasonFrom(options)
+		}),
+		requeue: (options) => issue({
+			kind: "requeue",
+			...reasonFrom(options),
+			...options?.after === void 0 ? {} : { after: options.after },
+			...options?.backoff === void 0 ? {} : { backoff: Object.freeze({ ...options.backoff }) },
+			...options?.maxAttempts === void 0 ? {} : { maxAttempts: options.maxAttempts }
+		}),
+		stop: (options) => issue({
+			kind: "stop",
+			...reasonFrom(options)
+		}),
+		fail: (error, options) => issue({
+			kind: "fail",
+			error,
+			...reasonFrom(options)
+		})
+	});
+}
+const validKinds = {
+	"start": /* @__PURE__ */ new Set([
+		"handled",
+		"requeue",
+		"stop",
+		"fail"
+	]),
+	"stop": /* @__PURE__ */ new Set(["handled", "fail"]),
+	"dependency-change": /* @__PURE__ */ new Set([
+		"handled",
+		"rebuild",
+		"requeue",
+		"stop",
+		"fail"
+	]),
+	"dependency-status-change": /* @__PURE__ */ new Set([
+		"handled",
+		"rebuild",
+		"requeue",
+		"stop",
+		"fail"
+	])
+};
+/** The decision for `undefined`. A `dependency-change` handler without a decision gets the default: rebuild. */
+function defaultDecision(run) {
+	const decide = createDecide(run);
+	return run.hook === "dependency-change" ? decide.rebuild() : decide.handled();
+}
+/**
+* Checks the value that a hook handler returned. It gives `undefined` for a value that `decide` did not create, so that the caller applies the default.
+* This keeps a shorthand such as `on('start', () => app.listen(port))` valid.
+*
+* @throws {InvalidDecisionError} when another run created the decision, or when the hook does not accept its kind.
+*/
+function validateDecision(run, value) {
+	const owner = typeof value === "object" && value !== null ? issued.get(value) : void 0;
+	if (!owner) return void 0;
+	if (owner !== run) throw new InvalidDecisionError(`The '${run.hook}' hook of '${run.service}' returned a decision from another run: the '${owner.hook}' hook of '${owner.service}', instance '${owner.instanceId}', attempt ${owner.attempt}.`);
+	const decision = value;
+	if (!validKinds[run.hook].has(decision.kind)) throw new InvalidDecisionError(`The '${run.hook}' hook cannot return a '${decision.kind}' decision.`);
+	return decision;
+}
+export { candidatesOf as $, causeOf as A, withoutUndefined as B, optional as C, InvalidDecisionError as Ct, releaseConsumerDemand as D, StartTimeoutError as Dt, ensureConsumerService as E, StaleRegistrationError as Et, resolvePlain as F, nodeOf as G, affectedContainers as H, acceptsCandidate as I, releasePresent as J, publishService as K, emitRecord as L, statusFields as M, resolveFallback as N, createService as O, TransactionIncompleteError as Ot, resolveKey as P, buildLost as Q, recordAbortedWait as R, normalizeName as S, InvalidArgumentError as St, demandConsumerService as T, ServiceFailedError as Tt, assertActive as U, createDeferred as V, awaitWithdrawal as W, subtreeOf as X, releaseService as Y, blockingFailure as Z, timeoutOf as _, BuildAfterDisposeError as _t, releaseReservations as a, resolutionOf as at, firstAvailable as b, HookTimeoutError as bt, cancelPending as c, serviceFor as ct, currentService as d, removeDeclaration as dt, epochOf as et, releaseRegistration as f, errorFrom as ft, timeoutHandlerOf as g, withOwner as gt, readPolicy as h, untracked as ht, releaseReservation as i, requiredWithdrawn as it, sameStatus as j, setPhase as k, WaitTimeoutError as kt, cancelSuccessor as l, slotOf as lt, maxAttemptsOf as m, batch as mt, defaultDecision as n, requiredAvailable as nt, reserveKey as o, resolvedInstance as ot, readDefinition as p, messageOf as pt, registerNode as q, validateDecision as r, requiredChanged as rt, reservedBy as s, selectProvider as st, createDecide as t, findProvider as tt, createRegistration as u, inConflict as ut, readEdges as v, DuplicateServiceError as vt, where as w, ReplaceWhileStoppingError as wt, isExclusiveKey as x, InjecaError as xt, defineKey as y, HookOutsideBuildError as yt, reportCallbackError as z };
+
+//# sourceMappingURL=decision-BXZu3N1O.mjs.map