@zudojs/container 0.1.0 → 1.1.0

package/dist/containerResolution/containerResolution.core.js

@@ -1,51 +1,117 @@
 /**
  * Dependency resolver for Zudojs.
+ *
+ * Lifetime semantics:
+ * - SINGLETON instances are always looked up in and stored to the resolver's
+ *   root singleton cache, no matter where the resolution happens (root or
+ *   scope). A scope can therefore never re-create or shadow a singleton.
+ * - SCOPED instances live in the scope cache supplied via
+ *   `ResolutionOptions.cache`. Resolving a SCOPED registration without a
+ *   scope cache throws a ScopedResolutionError; a SCOPED dependency of a
+ *   SINGLETON throws a CaptiveDependencyError.
+ * - TRANSIENT instances are never cached.
+ *
+ * Every freshly created instance (any lifetime, never a cache hit) is
+ * reported through `ResolutionOptions.onInstanceCreated` in creation order,
+ * so owners can track transitively created dependencies for disposal — not
+ * just the top-level result of a `resolve()` call.
+ *
+ * Factories registered as SINGLETON or SCOPED must be synchronous: a Promise
+ * result throws an AsyncProviderError instead of being cached as the instance.
+ *
+ * The resolver subscribes to registry change events: REPLACE/REMOVE evict the
+ * affected token's cached singleton, CLEAR/RESTORE evict all cached
+ * singletons. Each eviction is reported through the `onSingletonEvicted`
+ * callback so the owning container can dispose the instance.
  */
 import { isClassProvider, isExistingProvider, isFactoryProvider, isValueProvider, normalizeProvider, } from "../containerProvider/containerProvider.core.js";
 import { ContainerScope as Scope } from "../containerScope/containerScope.type.js";
-import { getRegistrationToken } from "../containerRegistration/containerRegistration.core.js";
-import { RegistrationNotFoundError } from "@zudojs/errors";
-import { describeRegistryToken } from "../containerRegistry/containerRegistry.error.js";
+import { defineRegistration, getRegistrationToken, } from "../containerRegistration/containerRegistration.core.js";
+import { RegistryOperation } from "../containerRegistry/containerRegistry.type.js";
 import { unwrapToken } from "../containerToken/containerToken.type.js";
-import { CircularDependencyError, ProviderResolutionError, } from "@zudojs/errors";
+import { CircularDependencyError, ProviderResolutionError, RegistrationNotFoundError, } from "@zudojs/errors";
+import { AsyncProviderError, CaptiveDependencyError, DependencyResolutionError, MaxResolutionDepthError, ScopedResolutionError, } from "./containerResolution.error.js";
 import { describeToken } from "../containerToken/containerToken.type.js";
+/**
+ * Scope cache that falls back to its parent scope's cache for lookups while
+ * writing only to its own map. Nested scopes therefore see SCOPED instances
+ * already created by their ancestors, while instances they create themselves
+ * stay private to (and are disposed with) the nested scope.
+ */
+class ChainedResolutionCache {
+    #own = new Map();
+    #parent;
+    constructor(parent) {
+        this.#parent = parent;
+    }
+    has(token) {
+        return this.#own.has(token) || (this.#parent?.has(token) ?? false);
+    }
+    get(token) {
+        if (this.#own.has(token))
+            return this.#own.get(token);
+        return this.#parent?.get(token);
+    }
+    set(token, value) {
+        this.#own.set(token, value);
+    }
+    clear() {
+        this.#own.clear();
+    }
+}
 export class ContainerResolver {
     registry;
-    singletonCache;
-    constructor(registry) {
+    singletonCache = new Map();
+    onSingletonEvicted;
+    constructor(registry, onSingletonEvicted) {
         this.registry = registry;
-        this.singletonCache = new Map();
+        this.onSingletonEvicted = onSingletonEvicted;
+        registry.subscribe((event) => this.handleRegistryChange(event));
     }
     resolve(token, options = {}) {
         return this.resolveDetailed(token, options).value;
     }
     resolveDetailed(token, options = {}) {
         const normalized = unwrapToken(token);
-        const cache = options.cache ?? this.singletonCache;
-        const path = options.path ?? [];
-        return this.resolveInternal(normalized, cache, path, options);
-    }
-    resolveInternal(token, cache, path, options) {
-        if (path.includes(token))
-            throw new CircularDependencyError([...path, token].map((t) => describeToken(t)));
-        const registration = this.registry.get(token);
+        const path = [...(options.path ?? [])];
+        const state = {
+            scopeCache: options.cache,
+            autoRegisterClasses: options.autoRegisterClasses ?? true,
+            allowRegistration: options.allowRegistration ?? true,
+            detectCircularDependencies: options.detectCircularDependencies ?? true,
+            maxResolutionDepth: options.maxResolutionDepth ?? 100,
+            onInstanceCreated: options.onInstanceCreated,
+            path,
+            pathSet: new Set(path),
+        };
+        return this.resolveInternal(normalized, state, undefined);
+    }
+    resolveInternal(token, state, singletonAncestor) {
+        const depth = state.path.length + 1;
+        if (depth > state.maxResolutionDepth)
+            throw new MaxResolutionDepthError(describeToken(token), depth, state.maxResolutionDepth, [...state.path, token].map((t) => describeToken(t)));
+        if (state.detectCircularDependencies && state.pathSet.has(token))
+            throw new CircularDependencyError([...state.path, token].map((t) => describeToken(t)));
+        let registration = this.registry.get(token);
         if (!registration) {
-            if (options.autoRegisterClasses !== false &&
-                typeof token === "function") {
-                this.registry.register(token, { useClass: token }, { scope: Scope.TRANSIENT });
-                return this.resolveInternal(token, cache, path, {
-                    ...options,
-                    autoRegisterClasses: false,
-                });
+            if (state.autoRegisterClasses && typeof token === "function") {
+                if (state.allowRegistration) {
+                    registration = this.registry.register(token, { useClass: token }, { scope: Scope.TRANSIENT });
+                }
+                else {
+                    // Registrations are frozen: instantiate ephemerally, do not register.
+                    registration = defineRegistration(token, { useClass: token }, { scope: Scope.TRANSIENT });
+                }
+            }
+            else {
+                throw new RegistrationNotFoundError(describeToken(token));
             }
-            throw new RegistrationNotFoundError(describeRegistryToken(token));
         }
-        const currentPath = [...path, token];
-        if (registration.scope !== Scope.TRANSIENT) {
-            const cached = cache.get(token);
-            if (cached !== undefined) {
+        const currentPath = [...state.path, token];
+        if (registration.scope === Scope.SINGLETON) {
+            if (this.singletonCache.has(token)) {
                 return {
-                    value: cached,
+                    value: this.singletonCache.get(token),
                     token,
                     registration,
                     scope: registration.scope,
@@ -54,12 +120,39 @@ export class ContainerResolver {
                 };
             }
         }
-        const value = this.createInstance(registration, cache, currentPath, options);
+        else if (registration.scope === Scope.SCOPED) {
+            if (singletonAncestor !== undefined)
+                throw new CaptiveDependencyError(describeToken(singletonAncestor), describeToken(token), currentPath.map((t) => describeToken(t)));
+            if (!state.scopeCache)
+                throw new ScopedResolutionError(describeToken(token), currentPath.map((t) => describeToken(t)));
+            if (state.scopeCache.has(token)) {
+                return {
+                    value: state.scopeCache.get(token),
+                    token,
+                    registration,
+                    scope: registration.scope,
+                    fromCache: true,
+                    path: currentPath,
+                };
+            }
+        }
+        const nextAncestor = registration.scope === Scope.SINGLETON ? token : singletonAncestor;
+        state.path.push(token);
+        state.pathSet.add(token);
+        let value;
+        let owned;
+        try {
+            ({ value, owned } = this.createInstance(registration, state, nextAncestor));
+        }
+        finally {
+            state.path.pop();
+            state.pathSet.delete(token);
+        }
         if (registration.scope === Scope.SINGLETON)
             this.singletonCache.set(token, value);
         else if (registration.scope === Scope.SCOPED)
-            cache.set(token, value);
-        return {
+            state.scopeCache?.set(token, value);
+        const result = {
             value,
             token,
             registration,
@@ -67,59 +160,157 @@ export class ContainerResolver {
             fromCache: false,
             path: currentPath,
         };
+        // A `useExisting` alias of a cached (SINGLETON/SCOPED) target does not
+        // own the instance it hands out — the target's own creation already
+        // reported it. Reporting it again registered a second owner for the same
+        // object: the container disposed it twice, and a SCOPED alias let a
+        // scope dispose a container-owned singleton.
+        if (owned)
+            state.onInstanceCreated?.(result);
+        return result;
     }
-    createInstance(registration, cache, path, options) {
+    createInstance(registration, state, singletonAncestor) {
         const provider = normalizeProvider(registration.provider);
+        const token = getRegistrationToken(registration);
         try {
             if (isValueProvider(provider))
-                return provider.useValue;
-            if (isExistingProvider(provider))
-                return this.resolve(provider.useExisting, { ...options, cache, path });
-            if (isFactoryProvider(provider))
-                return this.createFromFactory(provider, cache, path, options);
-            if (isClassProvider(provider))
-                return this.createFromClass(provider.useClass);
+                return { value: provider.useValue, owned: true };
+            if (isExistingProvider(provider)) {
+                const target = unwrapToken(provider.useExisting);
+                if (!this.registry.has(target) &&
+                    !(state.autoRegisterClasses && typeof target === "function")) {
+                    throw new Error(`useExisting target "${describeToken(target)}" for token ` +
+                        `"${describeToken(token)}" is not registered.`);
+                }
+                const resolved = this.resolveInternal(target, state, singletonAncestor);
+                // Only a TRANSIENT target has no owner of its own; a cached alias
+                // of it is the one place the instance can be tracked.
+                return {
+                    value: resolved.value,
+                    owned: resolved.scope === Scope.TRANSIENT,
+                };
+            }
+            if (isFactoryProvider(provider)) {
+                const deps = provider.inject ?? [];
+                const args = deps.map((d) => this.resolveInternal(unwrapToken(d), state, singletonAncestor)
+                    .value);
+                const produced = provider.useFactory(...args);
+                if (registration.scope !== Scope.TRANSIENT && isPromiseLike(produced))
+                    throw new AsyncProviderError(describeToken(token), registration.scope);
+                return { value: produced, owned: true };
+            }
+            if (isClassProvider(provider)) {
+                const deps = provider.inject ?? [];
+                const args = deps.map((d) => this.resolveInternal(unwrapToken(d), state, singletonAncestor)
+                    .value);
+                const ctor = provider.useClass;
+                return { value: new ctor(...args), owned: true };
+            }
             throw new Error("Unsupported container provider.");
         }
         catch (error) {
+            // Resolution errors created deeper in the chain already carry the full
+            // chain in their message/details — propagate them unchanged.
             if (error instanceof CircularDependencyError ||
-                error instanceof ProviderResolutionError)
+                error instanceof ProviderResolutionError ||
+                error instanceof ScopedResolutionError ||
+                error instanceof CaptiveDependencyError ||
+                error instanceof MaxResolutionDepthError ||
+                error instanceof AsyncProviderError)
                 throw error;
-            const message = error instanceof Error ? error.message : undefined;
-            throw new ProviderResolutionError(describeRegistryToken(getRegistrationToken(registration)), message, error);
+            throw new DependencyResolutionError(describeToken(token), error, state.path.map((t) => describeToken(t)));
         }
     }
-    createFromFactory(provider, cache, path, options) {
-        const deps = provider.inject ?? [];
-        return provider.useFactory(...deps.map((d) => this.resolve(d, { ...options, cache, path })));
-    }
-    createFromClass(constructor) {
-        return new constructor();
+    /**
+     * Creates an empty scope cache for SCOPED instances. When `parent` is
+     * given, lookups fall back to it (nested scope semantics) while writes stay
+     * local to the new cache.
+     */
+    createScope(parent) {
+        return new ChainedResolutionCache(parent);
     }
-    createScope() {
-        return new Map();
+    /** Tokens currently held in the singleton cache. */
+    getCachedSingletonTokens() {
+        return [...this.singletonCache.keys()];
     }
-    clearSingletons() {
+    /**
+     * Clears the singleton cache WITHOUT invoking eviction callbacks.
+     * Callers are responsible for disposing the previously cached instances.
+     */
+    clearSingletonCache() {
         this.singletonCache.clear();
     }
-    hasSingleton(token) {
-        return this.singletonCache.has(unwrapToken(token));
+    resolveMany(tokens, options = {}) {
+        return tokens.map((t) => this.resolve(t, options));
     }
-    getSingleton(token) {
-        return this.singletonCache.get(unwrapToken(token));
+    canResolve(token, autoRegisterClasses = true) {
+        const t = unwrapToken(token);
+        return (this.registry.has(t) || (autoRegisterClasses && typeof t === "function"));
     }
-    removeSingleton(token) {
-        return this.singletonCache.delete(unwrapToken(token));
+    handleRegistryChange(event) {
+        switch (event.operation) {
+            case RegistryOperation.REPLACE:
+            case RegistryOperation.REMOVE: {
+                const token = unwrapToken(event.token);
+                this.evictSingleton(token);
+                this.evictAliasesOf(token);
+                break;
+            }
+            case RegistryOperation.CLEAR:
+            case RegistryOperation.RESTORE: {
+                for (const t of [...this.singletonCache.keys()])
+                    this.evictSingleton(t);
+                break;
+            }
+            default:
+                break;
+        }
     }
-    clearScope(cache) {
-        cache.clear();
+    evictSingleton(token) {
+        if (!this.singletonCache.has(token))
+            return;
+        this.singletonCache.delete(token);
+        this.onSingletonEvicted?.(token);
     }
-    resolveMany(tokens, options = {}) {
-        return tokens.map((t) => this.resolve(t, options));
+    /**
+     * Evicts every cached singleton whose `useExisting` chain ends at `target`.
+     *
+     * A cached alias holds the target's instance under its own token, so
+     * evicting the target alone left the alias serving the old — by now
+     * disposed — instance after `replace()`/`remove()`.
+     */
+    evictAliasesOf(target) {
+        for (const cached of [...this.singletonCache.keys()]) {
+            if (cached === target)
+                continue;
+            if (this.aliasChainReaches(cached, target))
+                this.evictSingleton(cached);
+        }
     }
-    canResolve(token) {
-        const t = unwrapToken(token);
-        return this.registry.has(t) || typeof t === "function";
+    aliasChainReaches(token, target) {
+        const visited = new Set();
+        let current = token;
+        for (;;) {
+            const registration = this.registry.get(current);
+            if (!registration)
+                return false;
+            const provider = normalizeProvider(registration.provider);
+            if (!isExistingProvider(provider))
+                return false;
+            const next = unwrapToken(provider.useExisting);
+            if (next === target)
+                return true;
+            if (visited.has(next))
+                return false;
+            visited.add(next);
+            current = next;
+        }
     }
 }
+function isPromiseLike(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "then" in value &&
+        typeof value.then === "function");
+}
 //# sourceMappingURL=containerResolution.core.js.map

package/dist/containerResolution/containerResolution.error.d.ts

@@ -1,8 +1,73 @@
 /**
  * @zudojs/container/containerResolution/containerResolution.error
  *
- * Error classes re-exported from @zudojs/errors.
- * Token description helpers live in containerToken.type.ts.
+ * Resolution error classes local to this package. They extend the published
+ * `ContainerError` base from @zudojs/errors; the published package does not
+ * yet ship dedicated classes for these failure modes.
  */
-export {};
+import { ContainerError, ProviderResolutionError } from "@zudojs/errors";
+/**
+ * Thrown when a SCOPED registration is resolved without a scope
+ * (i.e. directly from the root container).
+ */
+export declare class ScopedResolutionError extends ContainerError {
+    readonly chain: readonly string[];
+    constructor(token: string, chain?: readonly string[]);
+}
+/**
+ * Thrown when a longer-lived consumer (a SINGLETON) would capture a
+ * shorter-lived SCOPED dependency, freezing it beyond its scope's lifetime.
+ */
+export declare class CaptiveDependencyError extends ContainerError {
+    readonly consumer: string;
+    readonly dependency: string;
+    readonly chain: readonly string[];
+    constructor(consumer: string, dependency: string, chain?: readonly string[]);
+}
+/**
+ * Thrown when a resolution chain exceeds `maxResolutionDepth`.
+ */
+export declare class MaxResolutionDepthError extends ContainerError {
+    readonly depth: number;
+    readonly maxDepth: number;
+    readonly chain: readonly string[];
+    constructor(token: string, depth: number, maxDepth: number, chain?: readonly string[]);
+}
+/**
+ * Thrown when a provider fails while resolving a token. Extends the published
+ * `ProviderResolutionError` with the resolution chain that led to the failing
+ * token (outermost request first) so callers can inspect it programmatically
+ * instead of parsing the message.
+ */
+export declare class DependencyResolutionError extends ProviderResolutionError {
+    readonly chain: readonly string[];
+    constructor(token: string, cause: unknown, chain?: readonly string[]);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        category: import("@zudojs/errors").ErrorCategory;
+        severity: import("@zudojs/errors").ErrorSeverity;
+        statusCode: number;
+        expose: boolean;
+        isOperational: boolean;
+        metadata: Readonly<import("@zudojs/errors").ErrorMetadata>;
+        stack?: string;
+        cause?: import("@zudojs/errors").SerializedBaseError | unknown;
+        token?: string | undefined;
+        chain: readonly string[];
+    };
+}
+/**
+ * Thrown when a factory registered as SINGLETON or SCOPED returns a Promise.
+ *
+ * The container is synchronous: it would otherwise cache the Promise itself
+ * as the instance and the eventual value would never be disposal-tracked.
+ * Await the resource before registering it (e.g. `registerValue`), or use a
+ * TRANSIENT registration whose callers await the result themselves.
+ */
+export declare class AsyncProviderError extends ContainerError {
+    readonly scope: string;
+    constructor(token: string, scope: string);
+}
 //# sourceMappingURL=containerResolution.error.d.ts.map

package/dist/containerResolution/containerResolution.error.js

@@ -1,8 +1,112 @@
 /**
  * @zudojs/container/containerResolution/containerResolution.error
  *
- * Error classes re-exported from @zudojs/errors.
- * Token description helpers live in containerToken.type.ts.
+ * Resolution error classes local to this package. They extend the published
+ * `ContainerError` base from @zudojs/errors; the published package does not
+ * yet ship dedicated classes for these failure modes.
  */
-export {};
+import { ContainerError, ProviderResolutionError } from "@zudojs/errors";
+function formatChain(chain) {
+    return chain.join(" -> ");
+}
+/**
+ * Thrown when a SCOPED registration is resolved without a scope
+ * (i.e. directly from the root container).
+ */
+export class ScopedResolutionError extends ContainerError {
+    chain;
+    constructor(token, chain = []) {
+        const suffix = chain.length > 1 ? ` (chain: ${formatChain(chain)})` : "";
+        super(`Scoped token ${token} cannot be resolved outside a scope. ` +
+            `Create one with container.createScope() and resolve through it.${suffix}`, {
+            code: "CONTAINER_SCOPED_OUTSIDE_SCOPE",
+            token,
+            statusCode: 500,
+            expose: false,
+        });
+        this.chain = chain;
+    }
+}
+/**
+ * Thrown when a longer-lived consumer (a SINGLETON) would capture a
+ * shorter-lived SCOPED dependency, freezing it beyond its scope's lifetime.
+ */
+export class CaptiveDependencyError extends ContainerError {
+    consumer;
+    dependency;
+    chain;
+    constructor(consumer, dependency, chain = []) {
+        const suffix = chain.length > 1 ? ` (chain: ${formatChain(chain)})` : "";
+        super(`Captive dependency: singleton "${consumer}" depends on scoped "${dependency}". ` +
+            `A longer-lived consumer cannot capture a shorter-lived dependency.${suffix}`, {
+            code: "CONTAINER_CAPTIVE_DEPENDENCY",
+            token: dependency,
+            statusCode: 500,
+            expose: false,
+        });
+        this.consumer = consumer;
+        this.dependency = dependency;
+        this.chain = chain;
+    }
+}
+/**
+ * Thrown when a resolution chain exceeds `maxResolutionDepth`.
+ */
+export class MaxResolutionDepthError extends ContainerError {
+    depth;
+    maxDepth;
+    chain;
+    constructor(token, depth, maxDepth, chain = []) {
+        super(`Maximum resolution depth of ${maxDepth} exceeded while resolving ` +
+            `token ${token} at depth ${depth}.`, {
+            code: "CONTAINER_MAX_RESOLUTION_DEPTH",
+            token,
+            statusCode: 500,
+            expose: false,
+        });
+        this.depth = depth;
+        this.maxDepth = maxDepth;
+        this.chain = chain;
+    }
+}
+/**
+ * Thrown when a provider fails while resolving a token. Extends the published
+ * `ProviderResolutionError` with the resolution chain that led to the failing
+ * token (outermost request first) so callers can inspect it programmatically
+ * instead of parsing the message.
+ */
+export class DependencyResolutionError extends ProviderResolutionError {
+    chain;
+    constructor(token, cause, chain = []) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        const suffix = chain.length > 0 ? ` (chain: ${formatChain(chain)})` : "";
+        super(token, `Failed to resolve ${token}: ${detail}${suffix}`, cause);
+        this.chain = Object.freeze([...chain]);
+    }
+    toJSON() {
+        return { ...super.toJSON(), chain: this.chain };
+    }
+}
+/**
+ * Thrown when a factory registered as SINGLETON or SCOPED returns a Promise.
+ *
+ * The container is synchronous: it would otherwise cache the Promise itself
+ * as the instance and the eventual value would never be disposal-tracked.
+ * Await the resource before registering it (e.g. `registerValue`), or use a
+ * TRANSIENT registration whose callers await the result themselves.
+ */
+export class AsyncProviderError extends ContainerError {
+    scope;
+    constructor(token, scope) {
+        super(`Factory for ${scope} token ${token} returned a Promise. Async factories ` +
+            `are not supported for cached (singleton/scoped) registrations: ` +
+            `await the value before registering it, or register it as TRANSIENT.`, {
+            code: "CONTAINER_ASYNC_PROVIDER_UNSUPPORTED",
+            token,
+            statusCode: 500,
+            expose: false,
+        });
+        this.scope = scope;
+    }
+}
 //# sourceMappingURL=containerResolution.error.js.map

package/dist/containerResolution/containerResolution.type.d.ts

@@ -6,8 +6,17 @@ import type { ContainerScope } from "../containerScope/containerScope.type.js";
 import type { Token } from "../containerToken/containerToken.type.js";
 /**
  * A cache containing resolved dependency instances.
+ *
+ * A plain `Map` satisfies this interface; scope caches created by the
+ * resolver additionally fall back to their parent scope's cache for lookups
+ * (see {@link ContainerResolver.createScope}).
  */
-export type ResolutionCache = Map<Token<unknown>, unknown>;
+export interface ResolutionCache {
+    has(token: Token<unknown>): boolean;
+    get(token: Token<unknown>): unknown;
+    set(token: Token<unknown>, value: unknown): void;
+    clear(): void;
+}
 /**
  * Dependency resolution path.
  * Used for diagnostics and circular dependency detection.
@@ -17,12 +26,35 @@ export type ResolutionPath = readonly Token<unknown>[];
  * Options controlling dependency resolution.
  */
 export interface ResolutionOptions {
-    /** Existing cache for the current resolution scope. */
+    /**
+     * Scope cache for SCOPED instances. When absent the resolution is a root
+     * resolution and SCOPED registrations throw. SINGLETON instances always
+     * live in the resolver's own singleton cache, never in this cache.
+     */
     readonly cache?: ResolutionCache;
     /** Current dependency resolution path. Normally managed internally. */
     readonly path?: ResolutionPath;
-    /** Whether to allow resolving unregistered classes directly from their constructors. Defaults to true. */
+    /** Whether unregistered class tokens may be resolved. Defaults to true. */
     readonly autoRegisterClasses?: boolean;
+    /**
+     * Whether auto-resolved class tokens may be added to the registry.
+     * When false (e.g. registrations are frozen) unregistered classes are
+     * instantiated ephemerally without being registered. Defaults to true.
+     */
+    readonly allowRegistration?: boolean;
+    /** Whether circular dependencies are detected. Defaults to true. */
+    readonly detectCircularDependencies?: boolean;
+    /**
+     * Maximum resolution chain depth before resolution aborts with a
+     * MaxResolutionDepthError. Defaults to 100.
+     */
+    readonly maxResolutionDepth?: number;
+    /**
+     * Invoked for every instance the resolver creates during this resolution
+     * (never for cache hits), in creation order — dependencies are reported
+     * before their dependents. Owners use it to track instances for disposal.
+     */
+    readonly onInstanceCreated?: (result: ResolutionResult<unknown>) => void;
 }
 /**
  * Resolution result containing the resolved value and diagnostic information.

package/dist/containerResolution/index.d.ts

@@ -4,5 +4,6 @@
  * Dependency resolution and injection.
  */
 export * from "./containerResolution.type.js";
+export * from "./containerResolution.error.js";
 export * from "./containerResolution.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/containerResolution/index.js

@@ -4,5 +4,6 @@
  * Dependency resolution and injection.
  */
 export * from "./containerResolution.type.js";
+export * from "./containerResolution.error.js";
 export * from "./containerResolution.core.js";
 //# sourceMappingURL=index.js.map