injeca 0.3.0 → 0.4.0

package/dist/{global-B9Bk2EG2.d.mts → global-DPfe26g5.d.mts}

@@ -1,4 +1,4 @@
-import { F as Container, Ft as Logger, I as ContainerOptions, O as EffectSetup, a as InvocationHandle, at as ConditionalDependency, ct as DependencyMap, d as ProvideOption, dt as KeyOptions, g as Registration, gt as ProvidedKey, h as ProvideOptionWithKeys, ht as ProvidedBy, lt as FallbackDependency, n as Transaction, o as InvokeOption, pt as OptionalDependency, st as DependencyDeclarations, u as InvokeOptionWithKeys, ut as InferProvided, vt as ResolutionCondition, wt as OwnerRecord, y as Graph, yt as ResolveDependencyDeclaration } from "./index-DXguNx2M.mjs";
+import { A as PeekValue, At as OwnerRecord, H as ContainerOptions, O as PeekDependency, P as EffectSetup, S as Graph, St as ProvidedKey, Tt as ResolveDependencyDeclaration, V as Container, Vt as Logger, _ as Registration, _t as KeyOptions, d as InvokeOptionWithKeys, dt as ConditionalDependency, f as ProvideOption, g as ProvideOptionWithKeys, gt as InferProvided, ht as FallbackDependency, k as PeekResult, mt as DependencyMap, n as Transaction, o as InvocationHandle, pt as DependencyDeclarations, s as InvokeOption, wt as ResolutionCondition, xt as ProvidedBy, yt as OptionalDependency } from "./index-DTYp044J.mjs";
 import { setActiveSub } from "alien-signals";
 /** The identity of an event. Any object with a string `id` is an event key, for example an eventa definition. */
 interface EventKey {
@@ -21,15 +21,31 @@ interface ListenerEntry<H> {
 declare function createContainer(options?: ContainerOptions): Container;
 /**
  * Runs `setup` and stores the returned disposer on the container. `dispose(container)` runs the disposers in reverse order.
+ *
+ * When the disposal of the container started or ended, the disposer runs at once after `setup`, so that the resource does not leak.
+ * A disposer that throws throws to the caller. A disposer promise that rejects is reported outside the call, as an unhandled error.
  */
 declare function effect$1(container: Container, setup: EffectSetup): void;
+interface DisposeOptions {
+  /**
+   * Ends the wait when the signal aborts, and rejects with the reason. The disposal continues in the background. There is no default.
+   * Each service that did not stop yet gets a `wait-aborted` record in the observe stream.
+   */
+  signal?: AbortSignal;
+}
 /**
  * Withdraws the registrations and invocations of the container, disposes the child containers, and runs the container effects in reverse order.
  *
- * One error keeps its identity. More than one error becomes an `AggregateError`.
- * A call from the cleanup chain of the same container rejects with `reentrant-dispose`. A second call from outside gets the same promise.
+ * One error keeps its identity. More than one error becomes an `AggregateError`. A second call from outside without a signal gets the same promise.
+ *
+ * A call from the cleanup chain of the container or of a descendant cannot wait, because the disposal waits for that cleanup.
+ * The same is true for a cleanup of a service that holds a service of the subtree, directly or through other instances, or a consumer service of a `perConsumer` registration of it.
+ * injeca finds such a call by the signal of the cleanup, or by the synchronous part of the cleanup. It warns, sends a `reentrant-call` record, and resolves at once. The disposal continues.
+ *
+ * When `options.signal` aborts, the call rejects with the reason and stops waiting. The disposal continues: the container stays in `disposing`, and calls on it fail with `build-after-dispose`.
+ * A later `dispose()` waits for the same disposal and gets its result. An aborted signal starts the disposal, then rejects at once.
  */
-declare function dispose(container: Container): Promise<void>;
+declare function dispose(container: Container, options?: DisposeOptions): Promise<void>;
 /**
  * Registers an invocation: a service without a value. The callback runs when the required dependencies are available.
  * Before `start()`, it waits for `start()`.
@@ -48,11 +64,13 @@ declare function defineKey<T>(name: string, options?: KeyOptions): ProvidedKey<s
  *
  * 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.
  */
-declare function firstAvailable<const Keys extends readonly KeyLike[]>(...keys: Keys): FallbackDependency<InferProvided<Keys[number]>>;
+declare function firstAvailable<const Keys extends readonly (KeyLike | ConditionalDependency<unknown>)[]>(...keys: Keys): FallbackDependency<InferProvided<Keys[number]>>;
 /**
  * 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.
+ * It also accepts a `firstAvailable` marker and a `where` marker, with their conditions.
  */
 declare function optional<T>(dependency: KeyLike<T> | FallbackDependency<T> | ConditionalDependency<T>): OptionalDependency<T>;
 /**
@@ -61,18 +79,32 @@ declare function optional<T>(dependency: KeyLike<T> | FallbackDependency<T> | Co
  * If it returns `false`, the dependency does not resolve. A required dependency keeps the dependent `pending`. An optional one is `undefined`.
  * The condition must be pure and synchronous. A thrown error counts as `false` and goes to the observe stream.
  * Wrap the result in `optional()`, or pass an `optional()` marker, to combine the two.
+ *
+ * For a `firstAvailable` marker, the condition filters each candidate. The selection is the first available candidate that passes.
+ * A candidate that `firstAvailable(where(key, other), ...)` filters must pass both conditions.
  */
 declare function where<T>(dependency: OptionalDependency<T>, condition: ResolutionCondition): OptionalDependency<T>;
+declare function where<T>(dependency: FallbackDependency<T>, condition: ResolutionCondition): FallbackDependency<T>;
 declare function where<T>(dependency: KeyLike<T>, condition: ResolutionCondition): ConditionalDependency<T>;
 interface StartOptions {
-  /** Rejects with `start-timeout` when not every service runs after this many milliseconds. There is no default. */
-  timeoutMs?: number;
+  /**
+   * Ends the wait when the signal aborts. The services keep converging.
+   * A timeout reason (`name === 'TimeoutError'`) rejects with `start-timeout` and the explanations. Another reason rejects as it is. There is no default.
+   */
+  signal?: AbortSignal;
+}
+interface StopOptions {
+  /**
+   * Ends the wait when the signal aborts, and rejects with the reason. The cleanups that did not settle keep running.
+   * Each service that did not stop yet gets a `wait-aborted` record in the observe stream. There is no default.
+   */
+  signal?: AbortSignal;
 }
 /**
  * Begins convergence of the container and of each child container that was started.
  *
  * Resolves when all their services and invocations are `running`. Rejects with the build and start errors.
- * A service in `failed` tries again. A required key without a provider keeps the promise pending, unless `timeoutMs` is set.
+ * A service in `failed` tries again. A required key without a provider keeps the promise pending, unless `options.signal` aborts.
  * A child container that was never started does not start. Call `start(child)` for it.
  */
 declare function start$1(container: Container, options?: StartOptions): Promise<void>;
@@ -81,8 +113,15 @@ declare function start$1(container: Container, options?: StartOptions): Promise<
  *
  * The registrations stay. The container stays usable, and a later `start()` builds them again. `dispose()` clears the container.
  * Rejects with the teardown errors.
+ *
+ * When `options.signal` aborts, it rejects with the reason and stops waiting. The container stays stopped: a later `start()` builds again.
+ * The services that did not stop yet stay in `stopping` until their cleanups settle.
+ *
+ * A call from the cleanup chain of the container or of a descendant cannot wait, because the stop waits for that cleanup.
+ * The same is true for a cleanup of a service that holds a service of the subtree, directly or through other instances.
+ * injeca finds such a call by the signal of the cleanup, or by the synchronous part of the cleanup. It warns, sends a `reentrant-call` record, and resolves at once. The stop continues.
  */
-declare function stop$1(container: Container): Promise<void>;
+declare function stop$1(container: Container, options?: StopOptions): Promise<void>;
 /**
  * Stores a listener for `eventKey`. The container owns it: `dispose(container)` removes it.
  *
@@ -106,12 +145,29 @@ declare function provide$1<D extends DependencyMap | undefined, T = any, Key ext
 }): Registration<Key, T, D>;
 declare function provide$1<T, Key extends string, Deps extends DependencyDeclarations>(container: Container, key: ProvidedKey<Key, T, DependencyMap | undefined>, option: ProvideOptionWithKeys<NoInfer<T>, Deps>): Registration<Key, T, ResolveDependencyDeclaration<Deps>>;
 declare function provide$1<T, Key extends string>(container: Container, key: ProvidedKey<Key, T, DependencyMap | undefined>, option: ProvideOption<NoInfer<T>, undefined>): Registration<Key, T, undefined>;
+interface ResolveOptions {
+  /**
+   * 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;
+}
 /**
  * Waits until the dependencies are available and returns their values. Before `start()`, it builds and starts them.
  *
- * Rejects when a required dependency fails. The values can become stale after a run-time change. Use it for one-time code.
+ * Rejects when a required dependency fails. With `options.signal`, it rejects when the signal aborts. An aborted signal rejects at once.
+ * Each rejection removes the hidden resolver of the call. The values can become stale after a run-time change. Use it for one-time code.
+ */
+declare function resolve$1<Deps extends DependencyDeclarations>(container: Container, dependsOn: Deps, options?: ResolveOptions): Promise<ResolveDependencyDeclaration<Deps>>;
+/**
+ * Returns a signal that aborts after `ms` milliseconds of the clock of `container`.
+ *
+ * The reason is a `DOMException` with the name `TimeoutError`, as for `AbortSignal.timeout()`. Use it in place of `AbortSignal.timeout()`, because that one does not use the container clock.
+ * With the system clock, the timer does not keep a Node process alive.
  */
-declare function resolve$1<Deps extends DependencyDeclarations>(container: Container, dependsOn: Deps): Promise<ResolveDependencyDeclaration<Deps>>;
+declare function timeout(container: Container, ms: number): AbortSignal;
+/** Returns a signal that aborts when `signal` aborts, or after `ms` milliseconds of the clock of `container`. Without `signal`, it is `timeout(container, ms)`. */
+declare function withTimeout(signal: AbortSignal | undefined, ms: number, container: Container): AbortSignal;
 /**
  * Creates a transaction for `container`.
  *
@@ -123,9 +179,17 @@ declare function transaction(container: Container): Transaction;
 /**
  * Returns the graph queries of `container`. They cover the container and its descendants. Each query is a pure read.
  *
- * A key resolves as for a consumer in the container: from the container, then from its ancestors. A key that only a descendant has resolves to the first such service.
+ * A key resolves as for a consumer in the container: from the container and the exports of its children, then from each ancestor and the exports of its children.
+ * A key that only a descendant has resolves to the first such service.
  */
 declare function graph(container: Container): Graph;
+/**
+ * Reads the value of a dependency now, without a wait. It is a pure read: it does not demand, build, or start a service.
+ *
+ * The dependency resolves as for a consumer in `container`: a key, `where(key, condition)`, or `firstAvailable(...)`. An `optional` marker has no effect.
+ * The result is the value with its status, or the reason why no value is available now. A `perConsumer` key has a value only after something demanded its service for `container`.
+ */
+declare function peek<D extends PeekDependency>(container: Container, dependency: D): PeekResult<PeekValue<D>>;
 /**
  * Returns the current listeners for `eventKey` in `container` and its descendants, in registration order.
  *
@@ -146,8 +210,8 @@ declare function provide<T, Key extends string, Deps extends DependencyDeclarati
 declare function provide<T, Key extends string>(key: ProvidedKey<Key, T, DependencyMap | undefined>, option: ProvideOption<NoInfer<T>, undefined>): Registration<Key, T, undefined>;
 declare function invoke<Deps extends DependencyDeclarations>(option: InvokeOptionWithKeys<Deps>): InvocationHandle;
 declare function invoke<D extends DependencyMap>(option: InvokeOption<D>): InvocationHandle;
-declare function resolve<Deps extends DependencyDeclarations>(dependsOn: Deps): Promise<ResolveDependencyDeclaration<Deps>>;
+declare function resolve<Deps extends DependencyDeclarations>(dependsOn: Deps, options?: ResolveOptions): Promise<ResolveDependencyDeclaration<Deps>>;
 declare function start(options?: StartOptions): Promise<void>;
-declare function stop(): Promise<void>;
-export { createContainer as C, ListenerEntry as D, EventKey as E, ListenerMetadata as O, invoke$1 as S, effect$1 as T, stop$1 as _, resolve as a, optional as b, stop as c, transaction as d, resolve$1 as f, start$1 as g, StartOptions as h, resetContainer as i, listeners as l, listen as m, invoke as n, setLogger as o, provide$1 as p, provide as r, start as s, getContainer as t, graph as u, defineKey as v, dispose as w, where as x, firstAvailable as y };
-//# sourceMappingURL=global-B9Bk2EG2.d.mts.map
+declare function stop(options?: StopOptions): Promise<void>;
+export { dispose as A, defineKey as C, invoke$1 as D, where as E, EventKey as M, ListenerEntry as N, DisposeOptions as O, ListenerMetadata as P, stop$1 as S, optional as T, provide$1 as _, resolve as a, StopOptions as b, stop as c, graph as d, transaction as f, resolve$1 as g, ResolveOptions as h, resetContainer as i, effect$1 as j, createContainer as k, listeners as l, withTimeout as m, invoke as n, setLogger as o, timeout as p, provide as r, start as s, getContainer as t, peek as u, listen as v, firstAvailable as w, start$1 as x, StartOptions as y };
+//# sourceMappingURL=global-DPfe26g5.d.mts.map

package/dist/global.d.mts

@@ -1,2 +1,2 @@
-import { a as resolve, c as stop, i as resetContainer, n as invoke, o as setLogger, r as provide, s as start, t as getContainer } from "./global-B9Bk2EG2.mjs";
+import { a as resolve, c as stop, i as resetContainer, n as invoke, o as setLogger, r as provide, s as start, t as getContainer } from "./global-DPfe26g5.mjs";
 export { getContainer, invoke, provide, resetContainer, resolve, setLogger, start, stop };

package/dist/global.mjs

@@ -1 +1 @@
-export { t as getContainer, n as invoke, r as provide, i as resetContainer, a as resolve, o as setLogger, s as start, c as stop } from "./global-C0Nk0pU8.mjs";
+export { t as getContainer, n as invoke, r as provide, i as resetContainer, a as resolve, o as setLogger, s as start, c as stop } from "./global-B5N-d-TO.mjs";

package/dist/{index-DXguNx2M.d.mts → index-DTYp044J.d.mts}

@@ -1,4 +1,7 @@
 import { Logg } from "@guiiai/logg";
+/**
+ * The logger of a container. `warn` always writes. The other methods write the lifecycle trace, and injeca calls them only when the `logging` option of the container is `true`.
+ */
 interface Logger {
   provide: (name: string, dependencies: string[]) => void;
   invoke: (dependencies: string[]) => void;
@@ -9,9 +12,19 @@ interface Logger {
   hookOnStop: (name: string) => void;
   hookOnStopComplete: (name: string, duration: number) => void;
   running: () => void;
+  /** A call that injeca handled in another way than the caller asked, for example a re-entrant `dispose()` that resolved at once. */
+  warn: (message: string) => void;
 }
 interface LoggerOptions {
-  enabled?: boolean;
+  /**
+   * Writes the lifecycle trace: `provide`, `invoke`, builds, `start` and `stop` hooks, and `running`. It defaults to `false`.
+   * A child container uses the value of its parent, unless it sets its own. `warn` does not depend on it.
+   */
+  logging?: boolean;
+  /**
+   * The logger. It defaults to the logger of the parent container, then to `createDefaultLogger()`.
+   * To also silence the warnings, for example in tests, pass `createNoopLogger()`.
+   */
   logger?: Logger;
 }
 declare function createDefaultLogger(): Logger;
@@ -20,7 +33,7 @@ declare function createNoopLogger(): Logger;
 /**
  * The time source of a container. Pass a custom clock to control time in tests.
  *
- * The reconciler uses it for requeue delays and hook timeouts. The work queue does not use it. It drains on microtasks.
+ * The reconciler uses it for requeue delays and hook timeouts, and `timeout()` uses it for its signal. The work queue does not use it. It drains on microtasks.
  */
 interface Clock {
   now: () => number;
@@ -161,13 +174,19 @@ interface ServiceExplanation {
   readonly name: string;
   readonly kind: 'service' | 'invocation';
   readonly owner: OwnerRecord;
-  readonly phase: ServicePhase;
+  /** The phase of the service. It is `undefined` for a key without a service. Then `owner` is the owner of the container of the query. */
+  readonly phase: ServicePhase | undefined;
   /** The effective status of a running service. */
   readonly status?: ServiceStatus;
   readonly reason?: string;
   /** The cause chain of the effective status. */
   readonly cause?: StatusCause;
   readonly blockers: readonly ServiceBlocker[];
+  /**
+   * The new instance of a replacement in progress, from `replace()`, a transaction, or a make-before-break rebuild.
+   * The old instance serves until the new one completes `start`. Its phase and blockers tell why the swap did not happen yet.
+   */
+  readonly replacement?: ServiceExplanation;
 }
 declare const providedType: unique symbol;
 declare const optionalType: unique symbol;
@@ -213,8 +232,10 @@ interface OptionalDependency<T> {
   readonly [optionalBrand]: true;
   /** The names of the keys, in order. More than one name comes from `optional(firstAvailable(...))`. */
   readonly dependencies: readonly string[];
-  /** The resolution condition from `where`, when the marker has one. */
+  /** The resolution condition from `where`, when the marker has one. It filters each candidate. */
   readonly condition?: ResolutionCondition;
+  /** The resolution conditions of single candidates, from `firstAvailable(where(key, condition), ...)`, by key name. */
+  readonly candidateConditions?: Readonly<Record<string, ResolutionCondition>>;
   /** Carries the value type. It has no value at run time. */
   readonly [optionalType]?: T;
 }
@@ -227,11 +248,18 @@ interface ConditionalDependency<T> {
   /** Carries the value type. It has no value at run time. */
   readonly [conditionalType]?: T;
 }
-/** A fallback dependency marker from `firstAvailable(...keys)`. It resolves to the first available provider in the list. */
+/**
+ * A fallback dependency marker from `firstAvailable(...keys)`. It resolves to the first available provider in the list.
+ * A resolution condition filters the candidates. The selection is the first available candidate that passes.
+ */
 interface FallbackDependency<T> {
   readonly [fallbackBrand]: true;
   /** The names of the keys, in order of preference. */
   readonly dependencies: readonly string[];
+  /** The resolution condition from `where(firstAvailable(...), condition)`. It filters each candidate. */
+  readonly condition?: ResolutionCondition;
+  /** The resolution conditions of single candidates, from `firstAvailable(where(key, condition), ...)`, by key name. */
+  readonly candidateConditions?: Readonly<Record<string, ResolutionCondition>>;
   /** Carries the value type. It has no value at run time. */
   readonly [fallbackType]?: T;
 }
@@ -243,7 +271,7 @@ interface OptionalValue<T> {
   readonly value: T;
   readonly status: ServiceStatus;
 }
-type InferProvided<T> = T extends ProvidedKey<any, infer P, any> ? P : T extends ProvidedBy<infer P> ? P : never;
+type InferProvided<T> = T extends ProvidedKey<any, infer P, any> ? P : T extends ProvidedBy<infer P> ? P : T extends ConditionalDependency<infer P> ? P : never;
 /** A required dependency is its value. An optional dependency is `{ value, status }` or `undefined`. */
 type ResolveDependencyDeclaration<Deps extends DependencyDeclarations> = { [K in keyof Deps]: Deps[K] extends OptionalDependency<infer T> ? OptionalValue<T> | undefined : Deps[K] extends FallbackDependency<infer T> ? T : Deps[K] extends ConditionalDependency<infer T> ? T : Deps[K] extends ProvidedKey<any, infer T, any> ? T : Deps[K] extends ProvidedBy<infer T> ? T : any; };
 /** The hooks that `on` registers in `build` and in an invocation callback. */
@@ -334,7 +362,8 @@ type TimeoutContext = { readonly [H in 'start' | 'stop']: {
 /**
  * Decides what happens when a `start` or `stop` hook times out. It runs synchronously.
  *
- * A value that is not a decision, a promise, or a throw gives `fail` with `hook-timeout`.
+ * For a `start` timeout, a value that is not a decision or a promise gives `fail` with `hook-timeout`.
+ * For a `stop` timeout, it gives `handled`, so that the stop continues. A throw gives `fail` for both hooks.
  */
 type TimeoutHandler = (context: TimeoutContext) => unknown;
 /** The timeouts of the `start` and `stop` hooks in milliseconds. A missing value means no timeout. */
@@ -357,11 +386,13 @@ interface PolicyOptions {
   maxAttempts?: number;
   /** The timeouts of the `start` and `stop` hooks. Each field overrides the same field of the container. */
   timeouts?: HookTimeouts;
-  /** Decides what happens when a hook times out. Without it, the result is `fail` with `hook-timeout`. */
+  /** Decides what happens when a hook times out. Without it, a `start` timeout gives `fail` with `hook-timeout`, and a `stop` timeout counts as `handled`. */
   onTimeout?: TimeoutHandler;
 }
 interface Container {
   logger: Logger;
+  /** `true` when the container writes the lifecycle trace to `logger`. A child container reads it when it is created. */
+  logging: boolean;
   readonly owner: OwnerRecord;
   readonly parent: Container | undefined;
 }
@@ -450,6 +481,8 @@ interface GraphService {
   readonly metadata: ServiceMetadata;
   readonly exclusive: boolean;
   readonly perConsumer: boolean;
+  /** `true` for a registration that `provide(..., { export: true })` exports to the resolution area of the parent container. */
+  readonly exported: boolean;
   /** The owner record of the consumer container of a `perConsumer` instance. */
   readonly consumer?: OwnerRecord;
 }
@@ -524,9 +557,61 @@ interface Graph {
   readonly cycles: () => readonly (readonly GraphService[])[];
   /** The services that a proposed change stops, rebuilds, or notifies. It runs on a copy of the graph. */
   readonly impact: (change: ImpactChange) => ImpactResult;
-  /** Why the service of `key` is not `running`: missing, conflicting, rejected, failed, or unavailable dependencies. */
-  readonly explain: (key: KeyReference) => ServiceExplanation | undefined;
+  /**
+   * Why the service of `key` is not `running`: missing, conflicting, rejected, failed, or unavailable dependencies.
+   * A key without a service gives `phase: undefined` and one `missing-provider` blocker.
+   */
+  readonly explain: (key: KeyReference) => ServiceExplanation;
 }
+/** The value type of a dependency declaration for `peek`. */
+type PeekValue<D> = D extends OptionalDependency<infer T> ? T : D extends FallbackDependency<infer T> ? T : D extends ConditionalDependency<infer T> ? T : D extends ProvidedKey<string, infer T, DependencyMap | undefined> ? T : D extends ProvidedBy<infer T> ? T : unknown;
+/**
+ * The result of `peek`: the value now, or the reason why no value is available now.
+ *
+ * - `resolved`: a running provider serves the key with the status `ready` or `degraded`.
+ * - `unavailable`: a running provider has the effective status `unavailable`. `reason` and `cause` tell why.
+ * - `not-running`: a provider exists, but it does not run. `phase` is its phase. A `failed` provider has `error`.
+ * - `rejected`: a resolution condition rejected the provider.
+ * - `conflict`: the key is exclusive and has more than one declaration. `owners` lists them.
+ * - `missing`: no provider exists.
+ *
+ * `key` is the key name of the provider. For `firstAvailable`, it is the selected key, or the first key when no key has a provider.
+ */
+type PeekResult<T> = {
+  readonly kind: 'resolved';
+  readonly key: string;
+  readonly owner: OwnerRecord;
+  readonly value: T;
+  readonly status: Exclude<ServiceStatus, 'unavailable'>;
+  readonly instanceId: string;
+} | {
+  readonly kind: 'unavailable';
+  readonly key: string;
+  readonly owner: OwnerRecord;
+  readonly instanceId: string;
+  readonly reason?: string;
+  readonly cause?: StatusCause;
+} | {
+  readonly kind: 'not-running';
+  readonly key: string;
+  readonly owner: OwnerRecord;
+  readonly phase: ServicePhase;
+  readonly error?: unknown;
+} | {
+  readonly kind: 'rejected';
+  readonly key: string;
+  readonly owner: OwnerRecord;
+  readonly metadata: ServiceMetadata;
+} | {
+  readonly kind: 'conflict';
+  readonly key: string;
+  readonly owners: readonly OwnerRecord[];
+} | {
+  readonly kind: 'missing';
+  readonly key: string;
+};
+/** A dependency declaration that `peek` reads. An `optional` marker has no effect. */
+type PeekDependency = DependencyDeclaration;
 /** The registration options that each object form of `provide` accepts. */
 interface RegistrationOptions extends PolicyOptions {
   /** A record that resolution conditions and graph queries read. injeca freezes a copy. */
@@ -536,6 +621,12 @@ interface RegistrationOptions extends PolicyOptions {
    * Each instance disposes with its consumer container.
    */
   perConsumer?: boolean;
+  /**
+   * Exports the registration one level up. The registration stays in its container: its owner, its disposal, its dependencies, and its phases.
+   * It is also a candidate for consumers in the resolution area of the parent container: the parent and each descendant of the parent.
+   * For an exclusive key, it counts as a declaration in that area. On a root container, it has no effect.
+   */
+  export?: boolean;
 }
 type ProvideOptionObject<T, D extends DependencyMap | undefined = undefined> = {
   build: (context: BuildContext<D>) => T | Promise<T>;
@@ -570,8 +661,24 @@ type InvokeOptionWithKeys<Deps extends DependencyDeclarations> = InvokeOptionObj
  * An option without `metadata`, `maxAttempts`, `timeouts`, or `onTimeout` keeps that value of the registration. `perConsumer` does not change.
  */
 interface ReplaceFunction<T> {
-  <Deps extends DependencyDeclarations>(option: ProvideOptionWithKeys<T, Deps>): Promise<boolean>;
-  (option: ProvideOption<T, undefined>): Promise<boolean>;
+  <Deps extends DependencyDeclarations>(option: ProvideOptionWithKeys<T, Deps>, options?: ReplaceOptions): Promise<boolean>;
+  (option: ProvideOption<T, undefined>, options?: ReplaceOptions): Promise<boolean>;
+}
+/** The options of `replace()`. */
+interface ReplaceOptions {
+  /**
+   * Cancels the pending replacement when the signal aborts, as a newer `replace` does. The old instance stays, and `replace()` resolves `false`.
+   * An aborted signal resolves `false` at once and changes nothing. After the swap, the signal has no effect.
+   */
+  signal?: AbortSignal;
+}
+/** The options of `withdraw()` of a registration or an invocation. */
+interface WithdrawOptions {
+  /**
+   * Ends the wait when the signal aborts, and rejects with the reason. The withdrawal continues. There is no default.
+   * The service gets a `wait-aborted` record in the observe stream when it did not finish its withdrawal. An aborted signal still starts the withdrawal.
+   */
+  signal?: AbortSignal;
 }
 /**
  * The result of `provide`: the typed key of the service, with `withdraw()` and `replace()`.
@@ -581,13 +688,16 @@ interface Registration<Key, T, D extends DependencyMap | undefined> extends Prov
    * Withdraws the service. Dependents stop first. Then the service runs its `stop` hooks and effect disposers.
    *
    * Resolves `false` for a stale registration and does not change any service. Rejects with the teardown errors.
+   *
+   * A call from a cleanup that the withdrawal waits for cannot wait: of the service, of a consumer service of it, or of a service that holds it.
+   * injeca finds such a call by the signal of the cleanup, or by the synchronous part of the cleanup. It warns, sends a `reentrant-call` record, and resolves `true` at once. The withdrawal continues.
    */
-  readonly withdraw: () => Promise<boolean>;
+  readonly withdraw: (options?: WithdrawOptions) => Promise<boolean>;
   /**
    * Replaces the instance of the service without a gap.
    *
    * The old instance keeps serving with its status while the new instance runs `build` and `start`. The swap is one batch.
-   * Resolves `true` after the swap. Resolves `false` for a stale registration, or when a newer `replace` or a withdrawal supersedes this call.
+   * Resolves `true` after the swap. Resolves `false` for a stale registration, when a newer `replace` or a withdrawal supersedes this call, or when `options.signal` aborts before the swap.
    * Rejects with the build or start error of the new instance, and the old instance does not change.
    * Rejects with `replace-while-stopping` when the service is in `stopping`.
    */
@@ -595,8 +705,10 @@ interface Registration<Key, T, D extends DependencyMap | undefined> extends Prov
 }
 /** The result of `invoke`. */
 interface InvocationHandle {
-  /** Withdraws the invocation. Resolves `false` when it is already withdrawn. Rejects with the teardown errors. */
-  readonly withdraw: () => Promise<boolean>;
+  /** The name of the invocation. Graph queries, for example `graph(container).dependencies(key)` and `explain(key)`, accept it. */
+  readonly key: string;
+  /** Withdraws the invocation. Resolves `false` when it is already withdrawn. Rejects with the teardown errors. `options` work as for `withdraw()` of a registration. */
+  readonly withdraw: (options?: WithdrawOptions) => Promise<boolean>;
 }
 interface DeclareOptions {
   /** The declared edges. A later `tx.provide` without `dependsOn` uses them. */
@@ -616,6 +728,11 @@ interface TransactionReplace {
   <T, Deps extends DependencyDeclarations>(key: ProvidedKey<string, T, DependencyMap | undefined> | string, option: ProvideOptionWithKeys<NoInfer<T>, Deps>): void;
   <T>(key: ProvidedKey<string, T, DependencyMap | undefined> | string, option: ProvideOption<NoInfer<T>, undefined>): void;
 }
+/** The options of `tx.commit()`. */
+interface TransactionCommitOptions {
+  /** Aborts the transaction when the signal aborts before the publish. */
+  signal?: AbortSignal;
+}
 /**
  * A set of registrations that publish together. `transaction(container)` creates it.
  *
@@ -634,10 +751,13 @@ interface Transaction {
    * A service whose required dependencies are not available goes to `pending`. That is not a failure.
    * If one build fails, nothing publishes, no `start` hook runs, and the promise rejects with the build error.
    * Resolves after the publish. It does not wait for the `start` hooks.
+   *
+   * When `options.signal` aborts before the publish, the transaction aborts and rolls back, and the commit rejects at once with the reason.
+   * An aborted signal rejects at once and builds nothing. After the publish, the signal has no effect.
    */
-  readonly commit: () => Promise<void>;
+  readonly commit: (options?: TransactionCommitOptions) => Promise<void>;
   /** Removes all declared and built services of the transaction. A build that settles later cannot publish. */
   readonly abort: () => Promise<void>;
 }
-export { HookResult as $, HookContextFor as A, ServiceStatus as At, TimeoutHandler as B, ImpactChange as C, DependencyState as Ct, Disposer as D, ServiceExplanation as Dt, DependencyHookContext as E, ServiceBlocker as Et, Container as F, Logger as Ft, DecisionKind as G, DecideFor as H, ContainerOptions as I, LoggerOptions as It, DependencyHook as J, DecisionOptions as K, HookTimeouts as L, createDefaultLogger as Lt, HookHandler as M, StatusCause as Mt, InvocationContext as N, Clock as Nt, EffectSetup as O, ServicePhase as Ot, LifecycleContext as P, systemClock as Pt, HookDecisionKind as Q, PolicyOptions as R, createLoggLogger as Rt, GraphService as S, DependencySnapshot as St, BuildContext as T, OwnerValue as Tt, Decision as U, Decide as V, DecisionFor as W, FailDecision as X, ExponentialBackoff as Y, HandledDecision as Z, RegistrationOptions as _, ProviderInfo as _t, InvocationHandle as a, ConditionalDependency as at, GraphDependency as b, ServiceMetadata as bt, InvokeOptionObject as c, DependencyMap as ct, ProvideOption as d, KeyOptions as dt, RebuildDecision as et, ProvideOptionFunc as f, KeyReference as ft, Registration as g, ProvidedKey as gt, ProvideOptionWithKeys as h, ProvidedBy as ht, TransactionReplace as i, StopDecision as it, HookDependencies as j, SetStatusOptions as jt, HookContext as k, ServiceState as kt, InvokeOptionObjectWithKeys as l, FallbackDependency as lt, ProvideOptionObjectWithKeys as m, OptionalValue as mt, Transaction as n, RequeueOptions as nt, InvokeOption as o, DependencyDeclaration as ot, ProvideOptionObject as p, OptionalDependency as pt, DecisionSource as q, TransactionProvide as r, ServiceHook as rt, InvokeOptionFunc as s, DependencyDeclarations as st, DeclareOptions as t, RequeueDecision as tt, InvokeOptionWithKeys as u, InferProvided as ut, ReplaceFunction as v, ResolutionCondition as vt, ImpactResult as w, OwnerRecord as wt, GraphResolution as x, DependencyChange as xt, Graph as y, ResolveDependencyDeclaration as yt, TimeoutContext as z, createNoopLogger as zt };
-//# sourceMappingURL=index-DXguNx2M.d.mts.map
+export { DecisionSource as $, PeekValue as A, OwnerRecord as At, LifecycleContext as B, systemClock as Bt, GraphDependency as C, ProviderInfo as Ct, ImpactResult as D, DependencyChange as Dt, ImpactChange as E, ServiceMetadata as Et, HookContext as F, ServiceState as Ft, TimeoutContext as G, createNoopLogger as Gt, ContainerOptions as H, LoggerOptions as Ht, HookContextFor as I, ServiceStatus as It, DecideFor as J, TimeoutHandler as K, HookDependencies as L, SetStatusOptions as Lt, DependencyHookContext as M, ServiceBlocker as Mt, Disposer as N, ServiceExplanation as Nt, PeekDependency as O, DependencySnapshot as Ot, EffectSetup as P, ServicePhase as Pt, DecisionOptions as Q, HookHandler as R, StatusCause as Rt, Graph as S, ProvidedKey as St, GraphService as T, ResolveDependencyDeclaration as Tt, HookTimeouts as U, createDefaultLogger as Ut, Container as V, Logger as Vt, PolicyOptions as W, createLoggLogger as Wt, DecisionFor as X, Decision as Y, DecisionKind as Z, Registration as _, KeyOptions as _t, TransactionReplace as a, HookResult as at, ReplaceOptions as b, OptionalValue as bt, InvokeOptionFunc as c, RequeueOptions as ct, InvokeOptionWithKeys as d, ConditionalDependency as dt, DependencyHook as et, ProvideOption as f, DependencyDeclaration as ft, ProvideOptionWithKeys as g, InferProvided as gt, ProvideOptionObjectWithKeys as h, FallbackDependency as ht, TransactionProvide as i, HookDecisionKind as it, BuildContext as j, OwnerValue as jt, PeekResult as k, DependencyState as kt, InvokeOptionObject as l, ServiceHook as lt, ProvideOptionObject as m, DependencyMap as mt, Transaction as n, FailDecision as nt, InvocationHandle as o, RebuildDecision as ot, ProvideOptionFunc as p, DependencyDeclarations as pt, Decide as q, TransactionCommitOptions as r, HandledDecision as rt, InvokeOption as s, RequeueDecision as st, DeclareOptions as t, ExponentialBackoff as tt, InvokeOptionObjectWithKeys as u, StopDecision as ut, RegistrationOptions as v, KeyReference as vt, GraphResolution as w, ResolutionCondition as wt, WithdrawOptions as x, ProvidedBy as xt, ReplaceFunction as y, OptionalDependency as yt, InvocationContext as z, Clock as zt };
+//# sourceMappingURL=index-DTYp044J.d.mts.map

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { $ as HookResult, A as HookContextFor, At as ServiceStatus, B as TimeoutHandler, C as ImpactChange, Ct as DependencyState, D as Disposer, Dt as ServiceExplanation, E as DependencyHookContext, Et as ServiceBlocker, F as Container, Ft as Logger, G as DecisionKind, H as DecideFor, I as ContainerOptions, It as LoggerOptions, J as DependencyHook, K as DecisionOptions, L as HookTimeouts, Lt as createDefaultLogger, M as HookHandler, Mt as StatusCause, N as InvocationContext, Nt as Clock, O as EffectSetup, Ot as ServicePhase, P as LifecycleContext, Pt as systemClock, Q as HookDecisionKind, R as PolicyOptions, Rt as createLoggLogger, S as GraphService, St as DependencySnapshot, T as BuildContext, Tt as OwnerValue, U as Decision, V as Decide, W as DecisionFor, X as FailDecision, Y as ExponentialBackoff, Z as HandledDecision, _ as RegistrationOptions, _t as ProviderInfo, a as InvocationHandle, at as ConditionalDependency, b as GraphDependency, bt as ServiceMetadata, c as InvokeOptionObject, ct as DependencyMap, d as ProvideOption, dt as KeyOptions, et as RebuildDecision, f as ProvideOptionFunc, ft as KeyReference, g as Registration, gt as ProvidedKey, h as ProvideOptionWithKeys, ht as ProvidedBy, i as TransactionReplace, it as StopDecision, j as HookDependencies, jt as SetStatusOptions, k as HookContext, kt as ServiceState, l as InvokeOptionObjectWithKeys, lt as FallbackDependency, m as ProvideOptionObjectWithKeys, mt as OptionalValue, n as Transaction, nt as RequeueOptions, o as InvokeOption, ot as DependencyDeclaration, p as ProvideOptionObject, pt as OptionalDependency, q as DecisionSource, r as TransactionProvide, rt as ServiceHook, s as InvokeOptionFunc, st as DependencyDeclarations, t as DeclareOptions, tt as RequeueDecision, u as InvokeOptionWithKeys, ut as InferProvided, v as ReplaceFunction, vt as ResolutionCondition, w as ImpactResult, wt as OwnerRecord, x as GraphResolution, xt as DependencyChange, y as Graph, yt as ResolveDependencyDeclaration, z as TimeoutContext, zt as createNoopLogger } from "./index-DXguNx2M.mjs";
-import { C as createContainer, D as ListenerEntry, E as EventKey, O as ListenerMetadata, S as invoke, T as effect, _ as stop, a as resolve$1, b as optional, c as stop$1, d as transaction, f as resolve, g as start, h as StartOptions, l as listeners, m as listen, n as invoke$1, o as setLogger, p as provide, r as provide$1, s as start$1, t as getContainer, u as graph, v as defineKey, w as dispose, x as where, y as firstAvailable } from "./global-B9Bk2EG2.mjs";
+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;
@@ -53,9 +53,30 @@ 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;
-type InjecaErrorCode = 'build-after-dispose' | 'duplicate-service' | 'hook-outside-build' | 'hook-timeout' | 'invalid-argument' | 'invalid-decision' | 'reentrant-dispose' | 'replace-while-stopping' | 'stale-registration' | 'start-timeout' | 'transaction-incomplete' | 'wait-timeout';
+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;
 }
@@ -96,11 +117,6 @@ export declare class TransactionIncompleteError extends InjecaError {
   readonly code: 'transaction-incomplete';
   constructor(message: string, options?: InjecaErrorOptions);
 }
-/** `dispose()` was called from the cleanup chain of the same container. */
-export declare class ReentrantDisposeError extends InjecaError {
-  readonly code: 'reentrant-dispose';
-  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';
@@ -120,7 +136,14 @@ export declare class StartTimeoutError extends InjecaError {
   readonly explanations: readonly ServiceExplanation[];
   constructor(message: string, explanations: readonly ServiceExplanation[], options?: InjecaErrorOptions);
 }
-/** `waitFor()` did not match before its configured timeout. */
+/** `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);
@@ -150,15 +173,17 @@ export declare function watch(container: Container, key: WatchKey, callback: (st
 interface WaitForOptions {
   /** Waits for this effective status. Without it, `waitFor` waits until the key is available: `ready` or `degraded`. */
   status?: ServiceStatus;
-  /** Rejects with `wait-timeout` after this many milliseconds of the container clock. There is no default. */
-  timeoutMs?: number;
-  /** Rejects with the abort reason when the signal aborts. */
+  /**
+   * 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 on a timeout or an abort, and when the container is disposed. It has no built-in timeout.
+ * 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: {
@@ -170,5 +195,5 @@ export declare const injeca: {
   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 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 PhaseObserveRecord, type PolicyOptions, type ProvideOption, type ProvideOptionFunc, type ProvideOptionObject, type ProvideOptionObjectWithKeys, type ProvideOptionWithKeys, type ProvidedBy, type ProvidedKey, type ProviderInfo, type RebuildDecision, type Registration, type RegistrationOptions, type RegistrationReplacedObserveRecord, type ReplaceFunction, type RequeueDecision, type RequeueOptions, type ResolutionCondition, type ResolveDependencyDeclaration, 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 TimeoutContext, type TimeoutHandler, type TimeoutObserveRecord, type Transaction, type TransactionProvide, type TransactionReplace, type WaitForOptions, type WatchKey, createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, defineKey, dispose, effect, firstAvailable, graph, invoke, listen, listeners, optional, provide, resolve, start, stop, systemClock, transaction, where };
+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