injeca 0.2.0 → 0.4.0

package/dist/index.d.mts

@@ -1,2 +1,199 @@
-import { A as resolve, C as ProvidedBy, D as invoke, E as createContainer, F as createDefaultLogger, I as createLoggLogger, L as createNoopLogger, M as stop, N as Logger, O as lifecycle, P as LoggerOptions, R as Lifecycle, S as ProvideOptionWithKeys, T as ResolveDependencyDeclaration, _ as InvokeOptionWithKeys, b as ProvideOptionObject, c as injeca, d as DependencyMap, f as InferProvided, g as InvokeOptionObjectWithKeys, h as InvokeOptionObject, j as start, k as provide, l as BuildContext, m as InvokeOptionFunc, p as InvokeOption, u as Container, v as ProvideOption, w as ProvidedKey, x as ProvideOptionObjectWithKeys, y as ProvideOptionFunc } from "./global-BLY6_SI_.mjs";
-export { BuildContext, Container, DependencyMap, InferProvided, InvokeOption, InvokeOptionFunc, InvokeOptionObject, InvokeOptionObjectWithKeys, InvokeOptionWithKeys, Lifecycle, Logger, LoggerOptions, ProvideOption, ProvideOptionFunc, ProvideOptionObject, ProvideOptionObjectWithKeys, ProvideOptionWithKeys, ProvidedBy, ProvidedKey, ResolveDependencyDeclaration, createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, injeca, invoke, lifecycle, provide, resolve, start, stop };
+import { $ as DecisionSource, A as PeekValue, At as OwnerRecord, B as LifecycleContext, Bt as systemClock, C as GraphDependency, Ct as ProviderInfo, D as ImpactResult, Dt as DependencyChange, E as ImpactChange, Et as ServiceMetadata, F as HookContext, Ft as ServiceState, G as TimeoutContext, Gt as createNoopLogger, H as ContainerOptions, Ht as LoggerOptions, I as HookContextFor, It as ServiceStatus, J as DecideFor, K as TimeoutHandler, L as HookDependencies, Lt as SetStatusOptions, M as DependencyHookContext, Mt as ServiceBlocker, N as Disposer, Nt as ServiceExplanation, O as PeekDependency, Ot as DependencySnapshot, P as EffectSetup, Pt as ServicePhase, Q as DecisionOptions, R as HookHandler, Rt as StatusCause, S as Graph, St as ProvidedKey, T as GraphService, Tt as ResolveDependencyDeclaration, U as HookTimeouts, Ut as createDefaultLogger, V as Container, Vt as Logger, W as PolicyOptions, Wt as createLoggLogger, X as DecisionFor, Y as Decision, Z as DecisionKind, _ as Registration, _t as KeyOptions, a as TransactionReplace, at as HookResult, b as ReplaceOptions, bt as OptionalValue, c as InvokeOptionFunc, ct as RequeueOptions, d as InvokeOptionWithKeys, dt as ConditionalDependency, et as DependencyHook, f as ProvideOption, ft as DependencyDeclaration, g as ProvideOptionWithKeys, gt as InferProvided, h as ProvideOptionObjectWithKeys, ht as FallbackDependency, i as TransactionProvide, it as HookDecisionKind, j as BuildContext, jt as OwnerValue, k as PeekResult, kt as DependencyState, l as InvokeOptionObject, lt as ServiceHook, m as ProvideOptionObject, mt as DependencyMap, n as Transaction, nt as FailDecision, o as InvocationHandle, ot as RebuildDecision, p as ProvideOptionFunc, pt as DependencyDeclarations, q as Decide, r as TransactionCommitOptions, rt as HandledDecision, s as InvokeOption, st as RequeueDecision, t as DeclareOptions, tt as ExponentialBackoff, u as InvokeOptionObjectWithKeys, ut as StopDecision, v as RegistrationOptions, vt as KeyReference, w as GraphResolution, wt as ResolutionCondition, x as WithdrawOptions, xt as ProvidedBy, y as ReplaceFunction, yt as OptionalDependency, z as InvocationContext, zt as Clock } from "./index-DTYp044J.mjs";
+import { A as dispose, C as defineKey, D as invoke, E as where, M as EventKey, N as ListenerEntry, O as DisposeOptions, P as ListenerMetadata, S as stop, T as optional, _ as provide, a as resolve$1, b as StopOptions, c as stop$1, d as graph, f as transaction, g as resolve, h as ResolveOptions, j as effect, k as createContainer, l as listeners, m as withTimeout, n as invoke$1, o as setLogger, p as timeout, r as provide$1, s as start$1, t as getContainer, u as peek, v as listen, w as firstAvailable, x as start, y as StartOptions } from "./global-DPfe26g5.mjs";
+interface ObserveRecordBase {
+  /** The key name of the service, or the name of the invocation. */
+  readonly key: string;
+  /** The owner record of the container of the service. */
+  readonly owner: OwnerRecord;
+  readonly instanceId: string | undefined;
+  readonly reason?: string;
+}
+/** A service moved to another phase. A replayed record has no `from`. */
+interface PhaseObserveRecord extends ObserveRecordBase {
+  readonly type: 'phase';
+  readonly from: ServicePhase | undefined;
+  readonly to: ServicePhase;
+  /** The decision that caused the move, when a decision caused it. */
+  readonly decision?: DecisionKind;
+}
+/** The effective status of a running instance changed. A replayed record, or the first status of an instance, has no `from`. */
+interface StatusObserveRecord extends ObserveRecordBase {
+  readonly type: 'status';
+  readonly from: ServiceStatus | undefined;
+  readonly to: ServiceStatus;
+  readonly cause?: StatusCause;
+}
+/** A hook returned a decision. `ignored` is `true` when injeca did not apply it. */
+interface DecisionObserveRecord extends ObserveRecordBase {
+  readonly type: 'decision';
+  readonly hook: ServiceHook;
+  readonly decision: DecisionKind;
+  readonly attempt: number;
+  readonly ignored: boolean;
+}
+/** A call that had no effect, for example `setStatus` after the instance was disposed. */
+interface IgnoredObserveRecord extends ObserveRecordBase {
+  readonly type: 'ignored';
+  readonly call: 'setStatus';
+}
+/** A `start` or `stop` hook did not settle before its configured timeout. The `onTimeout` decision follows as a `decision` record. */
+interface TimeoutObserveRecord extends ObserveRecordBase {
+  readonly type: 'timeout';
+  readonly hook: 'start' | 'stop';
+  readonly timeoutMs: number;
+  readonly attempt: number;
+}
+/** A second `provide` of the same key before `start()` replaced the current registration. No hook runs for it. */
+interface RegistrationReplacedObserveRecord extends ObserveRecordBase {
+  readonly type: 'registration-replaced';
+  readonly reason: string;
+}
+/** A `watch` or `observe` callback threw. The error did not stop a transition or the other callbacks. */
+interface ErrorObserveRecord extends ObserveRecordBase {
+  readonly type: 'error';
+  readonly error: unknown;
+}
+/**
+ * The `signal` of `stop()`, `dispose()`, or `withdraw()` aborted before this service stopped. The call stopped waiting. The cleanups of the service keep running.
+ * `phase` is the phase at the abort. `abortReason` is the reason of the signal.
+ */
+interface WaitAbortedObserveRecord extends ObserveRecordBase {
+  readonly type: 'wait-aborted';
+  readonly call: 'stop' | 'dispose' | 'withdraw';
+  readonly phase: ServicePhase;
+  readonly reason: string;
+  readonly abortReason: unknown;
+}
+/**
+ * A cleanup called `stop()` or `dispose()` of its own container, or of an ancestor, or `withdraw()` of a registration that waits for that cleanup.
+ * The wait includes that cleanup, so injeca resolved the call at once. The action continues.
+ * `key` is the service of the cleanup, or `''` for a container effect.
+ */
+interface ReentrantCallObserveRecord extends ObserveRecordBase {
+  readonly type: 'reentrant-call';
+  readonly call: 'stop' | 'dispose' | 'withdraw';
+  readonly reason: string;
+}
+/** One record of the observe stream. */
+type ObserveRecord = PhaseObserveRecord | StatusObserveRecord | DecisionObserveRecord | IgnoredObserveRecord | TimeoutObserveRecord | RegistrationReplacedObserveRecord | ErrorObserveRecord | WaitAbortedObserveRecord | ReentrantCallObserveRecord;
+type InjecaErrorCode = 'build-after-dispose' | 'duplicate-service' | 'hook-outside-build' | 'hook-timeout' | 'invalid-argument' | 'invalid-decision' | 'service-failed' | 'replace-while-stopping' | 'stale-registration' | 'start-timeout' | 'transaction-incomplete' | 'wait-timeout';
+interface InjecaErrorOptions {
+  cause?: unknown;
+}
+/**
+ * The base class of all injeca errors. Use `code` to identify an error. The message text is not stable.
+ */
+export declare class InjecaError extends Error {
+  readonly code: InjecaErrorCode;
+  constructor(code: InjecaErrorCode, message: string, options?: InjecaErrorOptions);
+}
+/** A started container already has a current registration for the key. */
+export declare class DuplicateServiceError extends InjecaError {
+  readonly code: 'duplicate-service';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A registration is no longer the current registration of its service. */
+export declare class StaleRegistrationError extends InjecaError {
+  readonly code: 'stale-registration';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A hook returned a decision from another run, or a kind that the hook does not accept. */
+export declare class InvalidDecisionError extends InjecaError {
+  readonly code: 'invalid-decision';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A caller used a container or an instance after its disposal started. */
+export declare class BuildAfterDisposeError extends InjecaError {
+  readonly code: 'build-after-dispose';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** `on` was called after `build` settled. */
+export declare class HookOutsideBuildError extends InjecaError {
+  readonly code: 'hook-outside-build';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A transaction commit found a declared service without `provide`. */
+export declare class TransactionIncompleteError extends InjecaError {
+  readonly code: 'transaction-incomplete';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A `start` or `stop` hook did not settle before its configured timeout. */
+export declare class HookTimeoutError extends InjecaError {
+  readonly code: 'hook-timeout';
+  readonly hook: 'start' | 'stop';
+  readonly timeoutMs: number;
+  constructor(message: string, hook: 'start' | 'stop', timeoutMs: number, options?: InjecaErrorOptions);
+}
+/** `replace` was called on a service in `stopping`. */
+export declare class ReplaceWhileStoppingError extends InjecaError {
+  readonly code: 'replace-while-stopping';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** `start()` did not reach `running` for every service before its configured timeout. */
+export declare class StartTimeoutError extends InjecaError {
+  readonly code: 'start-timeout';
+  /** One entry for each service or invocation that is not `running`. */
+  readonly explanations: readonly ServiceExplanation[];
+  constructor(message: string, explanations: readonly ServiceExplanation[], options?: InjecaErrorOptions);
+}
+/** `waitFor()` found the service in `failed`, or waiting for a required provider in `failed`. `cause` is the failure. */
+export declare class ServiceFailedError extends InjecaError {
+  readonly code: 'service-failed';
+  /** The key name that the caller waited for. */
+  readonly key: string;
+  constructor(message: string, key: string, options?: InjecaErrorOptions);
+}
+/** `waitFor()` or `resolve()` did not match before its configured timeout. */
+export declare class WaitTimeoutError extends InjecaError {
+  readonly code: 'wait-timeout';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A caller passed a value with the wrong shape, or reading a caller-owned property failed. */
+export declare class InvalidArgumentError extends InjecaError {
+  readonly code: 'invalid-argument';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/**
+ * Subscribes to all transitions of the services in `container` and in its child containers.
+ *
+ * It replays the current state of each service at once, then sends each change in order.
+ * A callback error goes to the other observers as an `error` record. No call follows the disposal of the container.
+ * Returns a disposer.
+ */
+export declare function observe(container: Container, callback: (record: ObserveRecord) => void): () => void;
+/** A key name, a key from `defineKey`, or the result of `provide`. */
+type WatchKey = KeyReference;
+/**
+ * Sends the current phase and effective status of `key` at once, then each change, in order.
+ *
+ * The key resolves from `container` and its ancestors. After a withdrawal, the callback sees the old service until it is `withdrawn`, or until a new provider appears.
+ * A callback error goes to the observe stream. The container owns the subscription: no call follows its disposal. Returns a disposer.
+ */
+export declare function watch(container: Container, key: WatchKey, callback: (state: ServiceState) => void): () => void;
+interface WaitForOptions {
+  /** Waits for this effective status. Without it, `waitFor` waits until the key is available: `ready` or `degraded`. */
+  status?: ServiceStatus;
+  /**
+   * Ends the wait when the signal aborts. A timeout reason (`name === 'TimeoutError'`) rejects with `wait-timeout`, with the reason as `cause`.
+   * Another reason rejects as it is. Use `timeout(container, ms)` for a timeout on the container clock. There is no default.
+   */
+  signal?: AbortSignal;
+}
+/**
+ * Resolves with the state of `key` when it is available, or when it has `options.status`.
+ *
+ * It rejects with `service-failed` when the service is in `failed`, or when it waits for a required provider in `failed`, as `resolve` does.
+ * It rejects when `options.signal` aborts, at once for an aborted signal, and when the container is disposed. It has no built-in timeout.
+ */
+export declare function waitFor(container: Container, key: WatchKey, options?: WaitForOptions): Promise<ServiceState>;
+export declare const injeca: {
+  provide: typeof provide$1;
+  invoke: typeof invoke$1;
+  resolve: typeof resolve$1;
+  start: typeof start$1;
+  stop: typeof stop$1;
+  setLogger: typeof setLogger;
+  getContainer: typeof getContainer;
+};
+export { type BuildContext, type Clock, type ConditionalDependency, type Container, type ContainerOptions, type Decide, type DecideFor, type Decision, type DecisionFor, type DecisionKind, type DecisionObserveRecord, type DecisionOptions, type DecisionSource, type DeclareOptions, type DependencyChange, type DependencyDeclaration, type DependencyDeclarations, type DependencyHook, type DependencyHookContext, type DependencyMap, type DependencySnapshot, type DependencyState, type DisposeOptions, type Disposer, type EffectSetup, type ErrorObserveRecord, type EventKey, type ExponentialBackoff, type FailDecision, type FallbackDependency, type Graph, type GraphDependency, type GraphResolution, type GraphService, type HandledDecision, type HookContext, type HookContextFor, type HookDecisionKind, type HookDependencies, type HookHandler, type HookResult, type HookTimeouts, type IgnoredObserveRecord, type ImpactChange, type ImpactResult, type InferProvided, type InjecaErrorCode, type InjecaErrorOptions, type InvocationContext, type InvocationHandle, type InvokeOption, type InvokeOptionFunc, type InvokeOptionObject, type InvokeOptionObjectWithKeys, type InvokeOptionWithKeys, type KeyOptions, type KeyReference, type LifecycleContext, type ListenerEntry, type ListenerMetadata, type Logger, type LoggerOptions, type ObserveRecord, type ObserveRecordBase, type OptionalDependency, type OptionalValue, type OwnerRecord, type OwnerValue, type PeekDependency, type PeekResult, type PeekValue, type PhaseObserveRecord, type PolicyOptions, type ProvideOption, type ProvideOptionFunc, type ProvideOptionObject, type ProvideOptionObjectWithKeys, type ProvideOptionWithKeys, type ProvidedBy, type ProvidedKey, type ProviderInfo, type RebuildDecision, type ReentrantCallObserveRecord, type Registration, type RegistrationOptions, type RegistrationReplacedObserveRecord, type ReplaceFunction, type ReplaceOptions, type RequeueDecision, type RequeueOptions, type ResolutionCondition, type ResolveDependencyDeclaration, type ResolveOptions, type ServiceBlocker, type ServiceExplanation, type ServiceHook, type ServiceMetadata, type ServicePhase, type ServiceState, type ServiceStatus, type SetStatusOptions, type StartOptions, type StatusCause, type StatusObserveRecord, type StopDecision, type StopOptions, type TimeoutContext, type TimeoutHandler, type TimeoutObserveRecord, type Transaction, type TransactionCommitOptions, type TransactionProvide, type TransactionReplace, type WaitAbortedObserveRecord, type WaitForOptions, type WatchKey, type WithdrawOptions, createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, defineKey, dispose, effect, firstAvailable, graph, invoke, listen, listeners, optional, peek, provide, resolve, start, stop, systemClock, timeout, transaction, where, withTimeout };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,3 +1,243 @@
-import { a as provide, c as stop, d as createNoopLogger, i as lifecycle, l as createDefaultLogger, n as createContainer, o as resolve, r as invoke, s as start, t as injeca, u as createLoggLogger } from "./src-UXkTj4Np.mjs";
+import { B as withoutUndefined, C as optional, Ct as InvalidDecisionError, D as releaseConsumerDemand, Dt as StartTimeoutError, Et as StaleRegistrationError, G as nodeOf, M as statusFields, Ot as TransactionIncompleteError, S as normalizeName, St as InvalidArgumentError, T as demandConsumerService, Tt as ServiceFailedError, U as assertActive, Z as blockingFailure, _t as BuildAfterDisposeError, b as firstAvailable, bt as HookTimeoutError, gt as withOwner, ht as untracked, kt as WaitTimeoutError, mt as batch, st as selectProvider, tt as findProvider, vt as DuplicateServiceError, w as where, wt as ReplaceWhileStoppingError, xt as InjecaError, y as defineKey, yt as HookOutsideBuildError, z as reportCallbackError } from "./decision-BXZu3N1O.mjs";
+import { A as createNoopLogger, C as effect, D as systemClock, E as waitAbortError, O as createDefaultLogger, S as dispose, T as readSignal, _ as listen, a as resolve$1, b as invoke, c as stop$1, d as graph, f as transaction, g as provide, h as resolve, k as createLoggLogger, l as listeners, m as withTimeout, n as invoke$1, o as setLogger, p as timeout, r as provide$1, s as start$1, t as getContainer, u as peek, v as start, w as onAbort, x as createContainer, y as stop } from "./global-B5N-d-TO.mjs";
+import { effect as effect$1 } from "alien-signals";
+// src/queries/observe.ts
+function replayOf(service) {
+	const owner = service.container.owner;
+	const instanceId = service.signals.instance()?.id;
+	const records = [{
+		type: "phase",
+		key: service.name,
+		owner,
+		instanceId,
+		from: void 0,
+		to: service.signals.phase()
+	}];
+	const status = service.signals.effective();
+	if (status) records.push({
+		type: "status",
+		key: service.name,
+		owner,
+		instanceId,
+		from: void 0,
+		to: status.status,
+		...statusFields(status)
+	});
+	return records;
+}
+function subtree(container) {
+	return [container, ...[...container.children].flatMap(subtree)];
+}
+/**
+* Subscribes to all transitions of the services in `container` and in its child containers.
+*
+* It replays the current state of each service at once, then sends each change in order.
+* A callback error goes to the other observers as an `error` record. No call follows the disposal of the container.
+* Returns a disposer.
+*/
+function observe(container, callback) {
+	const node = nodeOf(container);
+	assertActive(node, "observe");
+	if (typeof callback !== "function") throw new InvalidArgumentError("The observe callback is not a function.");
+	const { deliveries, observers } = node.runtime;
+	const observer = {
+		container: node,
+		callback,
+		active: true
+	};
+	const replay = untracked(() => subtree(node).flatMap((current) => [...current.services]).filter((service) => service.kind !== "resolver" && service.signals.present()).flatMap(replayOf));
+	observers.add(observer);
+	const stop = () => {
+		observer.active = false;
+		observers.delete(observer);
+		node.disposedListeners.delete(stop);
+	};
+	node.disposedListeners.add(stop);
+	deliveries.deliver(replay.map((entry) => ({
+		run: () => {
+			if (observer.active) callback(Object.freeze(entry));
+		},
+		onError: (error) => reportCallbackError(node, entry.key, error, "An observe callback threw.", observer)
+	})));
+	return stop;
+}
+// src/queries/watch.ts
+const statuses = /* @__PURE__ */ new Set([
+	"ready",
+	"degraded",
+	"unavailable"
+]);
+function readKey(key, action) {
+	let name;
+	try {
+		name = normalizeName(key);
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the key of ${action}.`, { cause: error });
+	}
+	if (typeof name !== "string" || name.length === 0) throw new InvalidArgumentError(`The key of ${action} must be a name or a key.`);
+	return name;
+}
+function stateOf(service) {
+	if (!service) return Object.freeze({
+		phase: void 0,
+		status: void 0,
+		instanceId: void 0
+	});
+	const status = service.signals.effective();
+	return Object.freeze({
+		phase: service.signals.phase(),
+		status: status?.status,
+		instanceId: service.signals.instance()?.id,
+		...withoutUndefined({
+			reason: status?.reason,
+			cause: status?.cause
+		})
+	});
+}
+function sameState(a, b) {
+	return a.phase === b.phase && a.status === b.status && a.instanceId === b.instanceId && a.reason === b.reason && a.cause === b.cause;
+}
+/**
+* Sends the current phase and effective status of `key` at once, then each change, in order.
+*
+* The key resolves from `container` and its ancestors. After a withdrawal, the callback sees the old service until it is `withdrawn`, or until a new provider appears.
+* A callback error goes to the observe stream. The container owns the subscription: no call follows its disposal. Returns a disposer.
+*/
+function watch(container, key, callback) {
+	const node = nodeOf(container);
+	assertActive(node, "watch");
+	const name = readKey(key, "watch");
+	if (typeof callback !== "function") throw new InvalidArgumentError("The watch callback is not a function.");
+	return untracked(() => subscribe(node, name, callback));
+}
+/**
+* The effect of one `watch` call. It tracks the provider of `name` and its state. The delivery queue calls the callback untracked.
+*
+* For a `perConsumer` registration, the subscription demands the consumer service of `node`, as `resolve` does. So the state is the real availability for `node`.
+* The demand ends with the subscription.
+*/
+function subscribe(node, name, callback) {
+	const { deliveries } = node.runtime;
+	const subscription = {};
+	let active = true;
+	let last;
+	let delivered;
+	let demand;
+	let demandQueued = false;
+	const syncDemand = () => {
+		if (!active) return;
+		const registration = selectProvider(node, name)?.registration;
+		const next = registration?.perConsumer ? demandConsumerService(registration, node, subscription) : void 0;
+		if (demand && demand !== next) releaseConsumerDemand(demand, subscription);
+		demand = next;
+	};
+	batch(syncDemand);
+	const stopEffect = withOwner(node.reactiveOwner, () => effect$1(() => {
+		const current = findProvider(node, name);
+		const moved = demand !== void 0 && current?.template !== void 0 && current !== demand;
+		if ((current?.perConsumer || moved) && !demandQueued) {
+			demandQueued = true;
+			queueMicrotask(() => untracked(() => {
+				demandQueued = false;
+				batch(syncDemand);
+			}));
+		}
+		if (current) last = current;
+		const state = stateOf(current ?? last);
+		if (delivered && sameState(delivered, state)) return;
+		delivered = state;
+		deliveries.deliver([{
+			run: () => {
+				if (active && node.state !== "disposed") callback(state);
+			},
+			onError: (error) => reportCallbackError(node, name, error, "A watch callback threw.")
+		}]);
+	}));
+	const stop = () => {
+		if (!active) return;
+		active = false;
+		stopEffect();
+		if (demand) untracked(() => batch(() => releaseConsumerDemand(demand, subscription)));
+		node.disposedListeners.delete(stop);
+	};
+	node.disposedListeners.add(stop);
+	return stop;
+}
+function readWaitOptions(options) {
+	let status;
+	try {
+		status = options?.status;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the waitFor options.", { cause: error });
+	}
+	if (status !== void 0 && (typeof status !== "string" || !statuses.has(status))) throw new InvalidArgumentError(`The status option of waitFor must be 'ready', 'degraded', or 'unavailable'. Got ${String(status)}.`);
+	return {
+		status,
+		signal: readSignal(options, "waitFor")
+	};
+}
+/** The failure that ends a wait for `name`: its service is in `failed`, or it waits for a required provider in `failed`. */
+function failureOf(node, name) {
+	const provider = findProvider(node, name);
+	if (!provider) return void 0;
+	const phase = provider.signals.phase();
+	if (phase === "failed") return provider.failure ?? { error: void 0 };
+	return phase === "pending" ? blockingFailure(provider) : void 0;
+}
+/**
+* Resolves with the state of `key` when it is available, or when it has `options.status`.
+*
+* It rejects with `service-failed` when the service is in `failed`, or when it waits for a required provider in `failed`, as `resolve` does.
+* It rejects when `options.signal` aborts, at once for an aborted signal, and when the container is disposed. It has no built-in timeout.
+*/
+function waitFor(container, key, options) {
+	const node = nodeOf(container);
+	assertActive(node, "waitFor");
+	const name = readKey(key, "waitFor");
+	const { status, signal } = readWaitOptions(options);
+	const abortError = (reason) => waitAbortError(reason, `waitFor('${name}') timed out.`);
+	if (signal?.aborted) return Promise.reject(abortError(signal.reason));
+	const matches = (state) => state.phase === "running" && (status === void 0 ? state.status !== void 0 && state.status !== "unavailable" : state.status === status);
+	return new Promise((resolve, reject) => untracked(() => {
+		let done = false;
+		let stopWatch;
+		let disarm = () => {};
+		let stopListening = () => {};
+		const onDisposed = () => finish(() => reject(new BuildAfterDisposeError(`The container was disposed before waitFor('${name}') matched.`)));
+		function finish(outcome) {
+			if (done) return;
+			done = true;
+			stopWatch?.();
+			stopListening();
+			disarm();
+			node.disposedListeners.delete(onDisposed);
+			outcome();
+		}
+		node.disposedListeners.add(onDisposed);
+		disarm = onAbort(signal, (reason) => finish(() => reject(abortError(reason))));
+		const checkFailure = () => {
+			const failure = failureOf(node, name);
+			if (failure) finish(() => reject(new ServiceFailedError(`waitFor('${name}') found a failed service.`, name, { cause: failure.error })));
+		};
+		stopListening = node.runtime.reconciler.onDrained(checkFailure);
+		stopWatch = subscribe(node, name, (state) => {
+			if (matches(state)) finish(() => resolve(state));
+			else if (state.phase === "failed") checkFailure();
+		});
+		node.runtime.reconciler.requestDrain();
+		if (done) stopWatch();
+	}));
+}
+// src/index.ts
+const injeca = {
+	provide: provide$1,
+	invoke: invoke$1,
+	resolve: resolve$1,
+	start: start$1,
+	stop: stop$1,
+	setLogger,
+	getContainer
+};
+export { BuildAfterDisposeError, DuplicateServiceError, HookOutsideBuildError, HookTimeoutError, InjecaError, InvalidArgumentError, InvalidDecisionError, ReplaceWhileStoppingError, ServiceFailedError, StaleRegistrationError, StartTimeoutError, TransactionIncompleteError, WaitTimeoutError, createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, defineKey, dispose, effect, firstAvailable, graph, injeca, invoke, listen, listeners, observe, optional, peek, provide, resolve, start, stop, systemClock, timeout, transaction, waitFor, watch, where, withTimeout };
 
-export { createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, injeca, invoke, lifecycle, provide, resolve, start, stop };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["effect","globalProvide","globalInvoke","globalResolve","globalStart","globalStop","globalSetLogger","globalGetContainer"],"sources":["../src/queries/observe.ts","../src/queries/watch.ts","../src/index.ts"],"sourcesContent":["import type { ContainerNode, Observer, ServiceNode } from '../graph/graph'\nimport type { Container, ObserveRecord } from '../types'\n\nimport { InvalidArgumentError } from '../diagnostics/errors'\nimport { assertActive, nodeOf } from '../graph/nodes'\nimport { reportCallbackError } from '../graph/observers'\nimport { statusFields } from '../graph/status'\nimport { untracked } from '../helpers/signals'\n\nfunction replayOf(service: ServiceNode): ObserveRecord[] {\n  const owner = service.container.owner\n  const instanceId = service.signals.instance()?.id\n  const records: ObserveRecord[] = [{ type: 'phase', key: service.name, owner, instanceId, from: undefined, to: service.signals.phase() }]\n  const status = service.signals.effective()\n  if (status)\n    records.push({ type: 'status', key: service.name, owner, instanceId, from: undefined, to: status.status, ...statusFields(status) })\n\n  return records\n}\n\nfunction subtree(container: ContainerNode): ContainerNode[] {\n  return [container, ...[...container.children].flatMap(subtree)]\n}\n\n/**\n * Subscribes to all transitions of the services in `container` and in its child containers.\n *\n * It replays the current state of each service at once, then sends each change in order.\n * A callback error goes to the other observers as an `error` record. No call follows the disposal of the container.\n * Returns a disposer.\n */\nexport function observe(container: Container, callback: (record: ObserveRecord) => void): () => void {\n  const node = nodeOf(container)\n  assertActive(node, 'observe')\n  if (typeof callback !== 'function')\n    throw new InvalidArgumentError('The observe callback is not a function.')\n\n  const { deliveries, observers } = node.runtime\n  const observer: Observer = { container: node, callback, active: true }\n  const replay = untracked(() => subtree(node)\n    .flatMap(current => [...current.services])\n    .filter(service => service.kind !== 'resolver' && service.signals.present())\n    .flatMap(replayOf))\n\n  observers.add(observer)\n  const stop = (): void => {\n    observer.active = false\n    observers.delete(observer)\n    node.disposedListeners.delete(stop)\n  }\n  node.disposedListeners.add(stop)\n\n  deliveries.deliver(replay.map(entry => ({\n    run: () => {\n      if (observer.active)\n        callback(Object.freeze(entry))\n    },\n    onError: (error: unknown) => reportCallbackError(node, entry.key, error, 'An observe callback threw.', observer),\n  })))\n\n  return stop\n}\n","import type { ContainerNode, ServiceNode } from '../graph/graph'\nimport type { Container, KeyReference, ServiceState, ServiceStatus } from '../types'\n\nimport { effect } from 'alien-signals'\n\nimport { BuildAfterDisposeError, InvalidArgumentError, ServiceFailedError } from '../diagnostics/errors'\nimport { assertActive, demandConsumerService, nodeOf, releaseConsumerDemand } from '../graph/nodes'\nimport { reportCallbackError } from '../graph/observers'\nimport { blockingFailure, findProvider, selectProvider } from '../graph/resolvers/resolvers'\nimport { onAbort, readSignal, waitAbortError } from '../helpers/abort'\nimport { batch, untracked, withOwner } from '../helpers/signals'\nimport { withoutUndefined } from '../helpers/without-undefined'\nimport { normalizeName } from '../primitives/keys'\n\n/** A key name, a key from `defineKey`, or the result of `provide`. */\nexport type WatchKey = KeyReference\n\nconst statuses: ReadonlySet<string> = new Set<ServiceStatus>(['ready', 'degraded', 'unavailable'])\n\nfunction readKey(key: unknown, action: string): string {\n  let name: unknown\n  try {\n    name = normalizeName(key as string)\n  }\n  catch (error) {\n    throw new InvalidArgumentError(`Cannot read the key of ${action}.`, { cause: error })\n  }\n  if (typeof name !== 'string' || name.length === 0)\n    throw new InvalidArgumentError(`The key of ${action} must be a name or a key.`)\n\n  return name\n}\n\nfunction stateOf(service: ServiceNode | undefined): ServiceState {\n  if (!service)\n    return Object.freeze({ phase: undefined, status: undefined, instanceId: undefined })\n\n  const status = service.signals.effective()\n  return Object.freeze({\n    phase: service.signals.phase(),\n    status: status?.status,\n    instanceId: service.signals.instance()?.id,\n    ...withoutUndefined({ reason: status?.reason, cause: status?.cause }),\n  })\n}\n\nfunction sameState(a: ServiceState, b: ServiceState): boolean {\n  return a.phase === b.phase && a.status === b.status && a.instanceId === b.instanceId && a.reason === b.reason && a.cause === b.cause\n}\n\n/**\n * Sends the current phase and effective status of `key` at once, then each change, in order.\n *\n * The key resolves from `container` and its ancestors. After a withdrawal, the callback sees the old service until it is `withdrawn`, or until a new provider appears.\n * A callback error goes to the observe stream. The container owns the subscription: no call follows its disposal. Returns a disposer.\n */\nexport function watch(container: Container, key: WatchKey, callback: (state: ServiceState) => void): () => void {\n  const node = nodeOf(container)\n  assertActive(node, 'watch')\n  const name = readKey(key, 'watch')\n  if (typeof callback !== 'function')\n    throw new InvalidArgumentError('The watch callback is not a function.')\n\n  return untracked(() => subscribe(node, name, callback))\n}\n\n/**\n * The effect of one `watch` call. It tracks the provider of `name` and its state. The delivery queue calls the callback untracked.\n *\n * For a `perConsumer` registration, the subscription demands the consumer service of `node`, as `resolve` does. So the state is the real availability for `node`.\n * The demand ends with the subscription.\n */\nfunction subscribe(node: ContainerNode, name: string, callback: (state: ServiceState) => void): () => void {\n  const { deliveries } = node.runtime\n  const subscription = {}\n  let active = true\n  let last: ServiceNode | undefined\n  let delivered: ServiceState | undefined\n  let demand: ServiceNode | undefined\n  let demandQueued = false\n\n  const syncDemand = (): void => {\n    if (!active)\n      return\n\n    const registration = selectProvider(node, name)?.registration\n    const next = registration?.perConsumer ? demandConsumerService(registration, node, subscription) : undefined\n    if (demand && demand !== next)\n      releaseConsumerDemand(demand, subscription)\n    demand = next\n  }\n  batch(syncDemand)\n\n  const stopEffect = withOwner(node.reactiveOwner, () => effect(() => {\n    const current = findProvider(node, name)\n    // A `perConsumer` registration has no service for this container yet, for example after a replacement. Demand it after this run, outside the effect.\n    // A new consumer service, for example after a rebuild, takes over the demand too.\n    const moved = demand !== undefined && current?.template !== undefined && current !== demand\n    if ((current?.perConsumer || moved) && !demandQueued) {\n      demandQueued = true\n      queueMicrotask(() => untracked(() => {\n        demandQueued = false\n        batch(syncDemand)\n      }))\n    }\n    if (current)\n      last = current\n    const state = stateOf(current ?? last)\n    if (delivered && sameState(delivered, state))\n      return\n\n    delivered = state\n    deliveries.deliver([{\n      run: () => {\n        if (active && node.state !== 'disposed')\n          callback(state)\n      },\n      onError: error => reportCallbackError(node, name, error, 'A watch callback threw.'),\n    }])\n  }))\n\n  const stop = (): void => {\n    if (!active)\n      return\n\n    active = false\n    stopEffect()\n    if (demand)\n      untracked(() => batch(() => releaseConsumerDemand(demand!, subscription)))\n    node.disposedListeners.delete(stop)\n  }\n  node.disposedListeners.add(stop)\n\n  return stop\n}\n\nexport interface WaitForOptions {\n  /** Waits for this effective status. Without it, `waitFor` waits until the key is available: `ready` or `degraded`. */\n  status?: ServiceStatus\n  /**\n   * Ends the wait when the signal aborts. A timeout reason (`name === 'TimeoutError'`) rejects with `wait-timeout`, with the reason as `cause`.\n   * Another reason rejects as it is. Use `timeout(container, ms)` for a timeout on the container clock. There is no default.\n   */\n  signal?: AbortSignal\n}\n\nfunction readWaitOptions(options: WaitForOptions | undefined): { readonly status: ServiceStatus | undefined, readonly signal: AbortSignal | undefined } {\n  let status: unknown\n  try {\n    status = options?.status\n  }\n  catch (error) {\n    throw new InvalidArgumentError('Cannot read the waitFor options.', { cause: error })\n  }\n  if (status !== undefined && (typeof status !== 'string' || !statuses.has(status)))\n    throw new InvalidArgumentError(`The status option of waitFor must be 'ready', 'degraded', or 'unavailable'. Got ${String(status)}.`)\n\n  return { status: status as ServiceStatus | undefined, signal: readSignal(options, 'waitFor') }\n}\n\n/** The failure that ends a wait for `name`: its service is in `failed`, or it waits for a required provider in `failed`. */\nfunction failureOf(node: ContainerNode, name: string): { readonly error: unknown } | undefined {\n  const provider = findProvider(node, name)\n  if (!provider)\n    return undefined\n\n  const phase = provider.signals.phase()\n  if (phase === 'failed')\n    return provider.failure ?? { error: undefined }\n  return phase === 'pending' ? blockingFailure(provider) : undefined\n}\n\n/**\n * Resolves with the state of `key` when it is available, or when it has `options.status`.\n *\n * It rejects with `service-failed` when the service is in `failed`, or when it waits for a required provider in `failed`, as `resolve` does.\n * It rejects when `options.signal` aborts, at once for an aborted signal, and when the container is disposed. It has no built-in timeout.\n */\nexport function waitFor(container: Container, key: WatchKey, options?: WaitForOptions): Promise<ServiceState> {\n  const node = nodeOf(container)\n  assertActive(node, 'waitFor')\n  const name = readKey(key, 'waitFor')\n  const { status, signal } = readWaitOptions(options)\n  const abortError = (reason: unknown): unknown => waitAbortError(reason, `waitFor('${name}') timed out.`)\n  if (signal?.aborted)\n    return Promise.reject(abortError(signal.reason))\n\n  const matches = (state: ServiceState): boolean => state.phase === 'running'\n    && (status === undefined ? state.status !== undefined && state.status !== 'unavailable' : state.status === status)\n\n  return new Promise((resolve, reject) => untracked(() => {\n    let done = false\n    let stopWatch: (() => void) | undefined\n    let disarm = () => {}\n    let stopListening = () => {}\n\n    const onDisposed = (): void => finish(() => reject(new BuildAfterDisposeError(`The container was disposed before waitFor('${name}') matched.`)))\n\n    function finish(outcome: () => void): void {\n      if (done)\n        return\n\n      done = true\n      stopWatch?.()\n      stopListening()\n      disarm()\n      node.disposedListeners.delete(onDisposed)\n      outcome()\n    }\n\n    node.disposedListeners.add(onDisposed)\n    disarm = onAbort(signal, reason => finish(() => reject(abortError(reason))))\n\n    const checkFailure = (): void => {\n      const failure = failureOf(node, name)\n      if (failure)\n        finish(() => reject(new ServiceFailedError(`waitFor('${name}') found a failed service.`, name, { cause: failure.error })))\n    }\n\n    // A failure of a dependency does not change the state of `key`. The check runs after each drain, as for `resolve`.\n    stopListening = node.runtime.reconciler.onDrained(checkFailure)\n    stopWatch = subscribe(node, name, (state) => {\n      if (matches(state))\n        finish(() => resolve(state))\n      else if (state.phase === 'failed')\n        checkFailure()\n    })\n    node.runtime.reconciler.requestDrain()\n    // The first state can match at once, before `stopWatch` was assigned.\n    if (done)\n      stopWatch()\n  }))\n}\n","import {\n  getContainer as globalGetContainer,\n  invoke as globalInvoke,\n  provide as globalProvide,\n  resolve as globalResolve,\n  setLogger as globalSetLogger,\n  start as globalStart,\n  stop as globalStop,\n} from './global'\n\nexport type { InjecaErrorCode, InjecaErrorOptions } from './diagnostics/errors'\nexport {\n  BuildAfterDisposeError,\n  DuplicateServiceError,\n  HookOutsideBuildError,\n  HookTimeoutError,\n  InjecaError,\n  InvalidArgumentError,\n  InvalidDecisionError,\n  ReplaceWhileStoppingError,\n  ServiceFailedError,\n  StaleRegistrationError,\n  StartTimeoutError,\n  TransactionIncompleteError,\n  WaitTimeoutError,\n} from './diagnostics/errors'\n\nexport type { Logger, LoggerOptions } from './diagnostics/logger'\n\nexport {\n  createDefaultLogger,\n  createLoggLogger,\n  createNoopLogger,\n} from './diagnostics/logger'\nexport type { Clock } from './helpers/clock'\n\nexport { systemClock } from './helpers/clock'\nexport type {\n  Decide,\n  DecideFor,\n  Decision,\n  DecisionFor,\n  DecisionKind,\n  DecisionOptions,\n  DecisionSource,\n  DependencyHook,\n  ExponentialBackoff,\n  FailDecision,\n  HandledDecision,\n  HookDecisionKind,\n  HookResult,\n  RebuildDecision,\n  RequeueDecision,\n  RequeueOptions,\n  ServiceHook,\n  StopDecision,\n} from './primitives/decision'\n\nexport { observe } from './queries/observe'\n\nexport { waitFor, watch } from './queries/watch'\nexport type { WaitForOptions, WatchKey } from './queries/watch'\n\nexport {\n  createContainer,\n  defineKey,\n  dispose,\n  effect,\n  firstAvailable,\n  graph,\n  invoke,\n  listen,\n  listeners,\n  optional,\n  peek,\n  provide,\n  resolve,\n  start,\n  stop,\n  timeout,\n  transaction,\n  where,\n  withTimeout,\n} from './scoped'\n\nexport type { DisposeOptions, ResolveOptions, StartOptions, StopOptions } from './scoped'\nexport type {\n  BuildContext,\n  ConditionalDependency,\n  Container,\n  ContainerOptions,\n  DeclareOptions,\n  DecisionObserveRecord,\n  DependencyChange,\n  DependencyDeclaration,\n  DependencyDeclarations,\n  DependencyHookContext,\n  DependencyMap,\n  DependencySnapshot,\n  DependencyState,\n  Disposer,\n  EffectSetup,\n  ErrorObserveRecord,\n  EventKey,\n  FallbackDependency,\n  Graph,\n  GraphDependency,\n  GraphResolution,\n  GraphService,\n  HookTimeouts,\n  HookContext,\n  HookContextFor,\n  HookDependencies,\n  HookHandler,\n  IgnoredObserveRecord,\n  ImpactChange,\n  ImpactResult,\n  InferProvided,\n  InvocationContext,\n  InvocationHandle,\n  InvokeOption,\n  InvokeOptionFunc,\n  InvokeOptionObject,\n  InvokeOptionObjectWithKeys,\n  InvokeOptionWithKeys,\n  KeyOptions,\n  KeyReference,\n  LifecycleContext,\n  ListenerEntry,\n  ListenerMetadata,\n  ObserveRecord,\n  ObserveRecordBase,\n  OptionalDependency,\n  OptionalValue,\n  OwnerRecord,\n  OwnerValue,\n  PeekDependency,\n  PeekResult,\n  PeekValue,\n  PhaseObserveRecord,\n  PolicyOptions,\n  ProviderInfo,\n  ProvidedBy,\n  ProvidedKey,\n  ProvideOption,\n  ProvideOptionFunc,\n  ProvideOptionObject,\n  ProvideOptionObjectWithKeys,\n  ProvideOptionWithKeys,\n  Registration,\n  RegistrationOptions,\n  ReentrantCallObserveRecord,\n  RegistrationReplacedObserveRecord,\n  ReplaceFunction,\n  ReplaceOptions,\n  ResolutionCondition,\n  ResolveDependencyDeclaration,\n  ServiceBlocker,\n  ServiceExplanation,\n  ServiceMetadata,\n  ServicePhase,\n  ServiceState,\n  ServiceStatus,\n  SetStatusOptions,\n  StatusCause,\n  StatusObserveRecord,\n  TimeoutContext,\n  TimeoutHandler,\n  TimeoutObserveRecord,\n  Transaction,\n  TransactionCommitOptions,\n  TransactionProvide,\n  TransactionReplace,\n  WaitAbortedObserveRecord,\n  WithdrawOptions,\n} from './types'\n\nexport const injeca = {\n  provide: globalProvide,\n  invoke: globalInvoke,\n  resolve: globalResolve,\n  start: globalStart,\n  stop: globalStop,\n  setLogger: globalSetLogger,\n  getContainer: globalGetContainer,\n}\n"],"mappings":"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"}

package/dist/testing.d.mts

@@ -0,0 +1,61 @@
+import { Dt as DependencyChange, I as HookContextFor, L as HookDependencies, V as Container, Y as Decision, lt as ServiceHook, zt as Clock } from "./index-DTYp044J.mjs";
+/**
+ * Resolves when the work queue of `container` has drained and stays drained.
+ *
+ * A build or a hook that settles on a microtask can queue more work after a drain.
+ * So it waits one macrotask after each drain, and starts again when another drain happens.
+ * The macrotask is a real `setTimeout(0)`, so it does not resolve while the fake timers of a test runner hold `setTimeout`.
+ * A `manualClock` does not change `setTimeout`, so the two work together.
+ *
+ * It does not wait for work that a timer starts later, for example a requeue delay or a policy timeout. Move the clock first, then await `drained` again.
+ */
+export declare function drained(container: Container): Promise<void>;
+/** A clock that moves only when a test calls `advance`. Pass `clock` to `createContainer`. */
+interface ManualClock {
+  /** The clock for `createContainer({ clock })`. Its time starts at 0. */
+  readonly clock: Clock;
+  /**
+   * Moves the time forward by `ms`, and runs each timer that is due, in the order of its time.
+   * A timer that a callback sets during the call runs at a later call, also when it is due now.
+   */
+  readonly advance: (ms: number) => void;
+  /** The number of timers that wait. A timer that was cancelled or that ran does not count. */
+  readonly pending: () => number;
+}
+/**
+ * Creates a manual clock for tests. It drives `timeout()`, `withTimeout()`, requeue delays, and the `start` and `stop` policy timeouts without real time.
+ *
+ * `advance` runs the timer callbacks synchronously. Await `drained(container)` after it, so that the work that the callbacks start settles.
+ */
+export declare function manualClock(): ManualClock;
+export interface HookContextOptions<D = undefined> {
+  /** The service name that the decisions carry. It defaults to `'test'`. */
+  service?: string;
+  /** The instance id that the decisions carry. It defaults to `'test-instance'`. */
+  instanceId?: string;
+  /** It defaults to `1`. */
+  attempt?: number;
+  previous?: Decision;
+  /** It defaults to a signal that does not abort. */
+  signal?: AbortSignal;
+  /** The snapshot of a dependency hook. It defaults to an empty record. */
+  dependsOn?: HookDependencies<D>;
+  /** The changes of a dependency hook. It defaults to an empty list. */
+  changes?: readonly DependencyChange[];
+  /** The clock for `issuedAt`. It defaults to `Date.now`. */
+  now?: () => number;
+}
+/**
+ * Creates a hook context for a unit test of a hook handler, or of a helper that gets `decide`.
+ *
+ * Its decisions are bound to this context, as in a real run. Use `checkDecision` to check a result as injeca does.
+ */
+export declare function createHookContext<H extends ServiceHook, D = undefined>(hook: H, options?: HookContextOptions<D>): HookContextFor<H, D>;
+/**
+ * Checks the value that a handler returned for `context`, as injeca does. `undefined` gives `undefined`: the default of the hook.
+ *
+ * @throws {InvalidDecisionError} for a decision from another context, or a kind that the hook does not accept. A value that is not a decision gives `undefined`.
+ */
+export declare function checkDecision(context: object, value: unknown): Decision | undefined;
+export type { ManualClock };
+//# sourceMappingURL=testing.d.mts.map