@zudojs/container 0.1.0 → 1.1.0

package/dist/containerCore/containerCore.scope.js

@@ -1,42 +1,63 @@
 /**
- * ContainerScopeContext — child dependency scope with
- * its own scoped-instance cache.
- */
-import { ContainerLifecycle, ContainerLifecycleOwner, } from "../containerLifecycle/containerLifecycle.core.js";
-/**
- * Represents a child dependency scope.
+ * ContainerScopeContext — a dependency scope with its own scoped-instance
+ * cache and its own lifecycle for SCOPED instances.
+ *
+ * Ownership model:
+ * - SCOPED instances created through this scope — including those created
+ *   transitively as dependencies — are owned by the scope and disposed when
+ *   the scope is disposed.
+ * - SINGLETON instances resolved through a scope stay owned by the parent
+ *   container — a scope's disposal never touches them.
+ * - TRANSIENT instances are not tracked anywhere; callers own their disposal.
  *
- * A scope has its own scoped-instance cache while sharing
- * registrations and singleton instances with its parent.
+ * Nesting: `scope.createScope()` creates a true child scope. A child sees
+ * SCOPED instances already created by its ancestors (lookups chain upward),
+ * while instances it creates itself are private to the child. Disposing a
+ * scope disposes its children first, and a child refuses to resolve once any
+ * ancestor (scope or container) is disposed.
  */
+import { ContainerLifecycle, ContainerLifecycleOwner, } from "../containerLifecycle/containerLifecycle.core.js";
+import { ContainerScope } from "../containerScope/containerScope.type.js";
 export class ContainerScopeContext {
-    parent;
     disposed = false;
+    disposing;
     cache;
     lifecycle;
+    container;
+    parentScope;
+    children = new Set();
     name;
     metadata;
-    constructor(parent, options = {}) {
-        this.parent = parent;
-        this.name = options.name ?? `${parent.name}:scope`;
+    /**
+     * @param container The container that owns the scope tree.
+     * @param options Scope name / metadata.
+     * @param parentScope When given, the new scope is a nested child of it.
+     *   Application code should use `container.createScope()` /
+     *   `scope.createScope()` rather than constructing scopes directly.
+     */
+    constructor(container, options = {}, parentScope) {
+        this.container = container;
+        this.parentScope = parentScope;
+        this.name = options.name ?? `${(parentScope ?? container).name}:scope`;
         this.metadata = Object.freeze({ ...(options.metadata ?? {}) });
-        this.cache = parent.resolver.createScope();
+        this.cache = container.createScopeCache(parentScope?.cache);
         this.lifecycle = new ContainerLifecycle();
     }
     /**
      * Resolves a dependency within this scope.
+     *
+     * SCOPED instances are cached per scope (visible to child scopes) and
+     * tracked for disposal with the scope that created them. SINGLETON
+     * instances come from (and are tracked by) the container. TRANSIENT
+     * instances are created fresh and never tracked.
      */
     resolve(token) {
         this.ensureActive();
-        const result = this.parent.resolver.resolveDetailed(token, {
-            ...this.parent.resolutionOptions,
-            cache: this.cache,
-        });
-        this.lifecycle.track(result.token, result.value, ContainerLifecycleOwner.SCOPE);
+        const result = this.container.resolveInScope(token, this.cache, (created) => this.trackCreated(created));
         return result.value;
     }
     /**
-     * Resolves multiple dependencies within this scope.
+     * Resolves multiple dependencies within this scope, typed per token.
      */
     resolveMany(tokens) {
         return tokens.map((token) => this.resolve(token));
@@ -46,35 +67,75 @@ export class ContainerScopeContext {
      */
     canResolve(token) {
         this.ensureActive();
-        return this.parent.resolver.canResolve(token);
+        return this.container.canResolve(token);
     }
     /**
      * Checks whether a registration exists.
      */
     has(token) {
         this.ensureActive();
-        return this.parent.has(token);
+        return this.container.has(token);
     }
     /**
-     * Creates another nested scope.
+     * Creates a nested child scope.
+     *
+     * The child inherits this scope's cached SCOPED instances for lookups,
+     * caches the SCOPED instances it creates itself, and is disposed
+     * automatically when this scope is disposed.
      */
     createScope(options = {}) {
         this.ensureActive();
-        return this.parent.createScope(options);
+        const child = new ContainerScopeContext(this.container, options, this);
+        this.children.add(child);
+        return child;
     }
     /**
-     * Disposes all instances belonging to this scope.
+     * Disposes child scopes (most recent first), then all SCOPED instances
+     * belonging to this scope in reverse creation order, and detaches the scope
+     * from its parent. Container-owned singletons are not touched. Idempotent.
+     *
+     * Every failure is collected; the scope is marked disposed regardless and
+     * an AggregateError listing the failures is thrown afterwards. Concurrent
+     * callers share the in-flight disposal rather than returning early.
      */
-    async dispose() {
+    dispose() {
+        if (this.disposing)
+            return this.disposing;
         if (this.disposed)
-            return;
+            return Promise.resolve();
+        this.disposed = true;
+        this.disposing = this.runDispose().finally(() => {
+            this.disposing = undefined;
+        });
+        return this.disposing;
+    }
+    async runDispose() {
+        const failures = [];
+        for (const child of [...this.children].reverse()) {
+            try {
+                await child.dispose();
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        this.children.clear();
         try {
-            await this.lifecycle.disposeScope();
+            await this.lifecycle.dispose();
+        }
+        catch (error) {
+            failures.push(error);
         }
         finally {
+            this.lifecycle.shutdown();
             this.cache.clear();
-            this.disposed = true;
+            if (this.parentScope)
+                this.parentScope.releaseChild(this);
+            else
+                this.container.releaseScope(this);
         }
+        if (failures.length > 0)
+            throw new AggregateError(failures, `Container scope "${this.name}" was disposed, but ${failures.length} cleanup step(s) failed.`);
     }
     /**
      * Returns whether the scope has been disposed.
@@ -83,18 +144,46 @@ export class ContainerScopeContext {
         return this.disposed;
     }
     /**
-     * Returns the parent container.
+     * Returns the direct parent: the container for a top-level scope, or the
+     * parent scope for a nested one.
      */
     getParent() {
-        return this.parent;
+        return this.parentScope ?? this.container;
+    }
+    /**
+     * Returns the container that owns the whole scope tree.
+     */
+    getContainer() {
+        return this.container;
+    }
+    /** @internal Detaches a disposed child scope. */
+    releaseChild(scope) {
+        this.children.delete(scope);
+    }
+    /**
+     * Tracks SCOPED instances created during a resolution through this scope
+     * (top-level result or transitively created dependency). Instances served
+     * from an ancestor's cache are cache hits and never reach here.
+     */
+    trackCreated(result) {
+        if (result.scope !== ContainerScope.SCOPED)
+            return;
+        this.lifecycle.track(result.token, result.value, ContainerLifecycleOwner.SCOPE);
     }
     /**
-     * Throws when the scope is no longer active.
+     * Throws when the scope — or any ancestor scope, or the container that
+     * owns it — is no longer active.
      */
     ensureActive() {
         if (this.disposed) {
             throw new Error(`Container scope "${this.name}" has already been disposed.`);
         }
+        if (this.parentScope?.isDisposed()) {
+            throw new Error(`Parent scope "${this.parentScope.name}" of scope "${this.name}" has been disposed.`);
+        }
+        if (this.container.isDisposed()) {
+            throw new Error(`Container "${this.container.name}" owning scope "${this.name}" has been disposed.`);
+        }
     }
 }
 //# sourceMappingURL=containerCore.scope.js.map

package/dist/containerCore/containerCore.type.d.ts

@@ -2,6 +2,8 @@
  * Types for the core container.
  */
 import type { RegistrationToken } from "../containerRegistration/containerRegistration.core.js";
+import type { ResolutionCache, ResolutionResult } from "../containerResolution/containerResolution.type.js";
+import type { ContainerScopeContext } from "./containerCore.scope.js";
 /**
  * Options used when creating a child container scope.
  */
@@ -16,25 +18,29 @@ export interface ContainerScopeOptions {
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
 /**
- * Full Container interface including mixin methods.
- * Used by ContainerScopeContext to reference the parent container.
+ * The surface a ContainerScopeContext needs from its owning container.
+ * Implemented by Container; the `resolveInScope` / `createScopeCache` /
+ * `releaseScope` members are internal plumbing for scopes and should not be
+ * called by application code.
  */
 export interface ContainerLike {
     readonly name: string;
-    readonly resolver: {
-        createScope(): import("../containerResolution/containerResolution.type.js").ResolutionCache;
-        resolveDetailed(token: unknown, options: unknown): {
-            token: unknown;
-            value: unknown;
-        };
-        canResolve(token: unknown): boolean;
-    };
-    readonly resolutionOptions: {
-        autoRegisterClasses: boolean;
-        detectCircularDependencies: boolean;
-        maxResolutionDepth: number;
-    };
     has<T>(token: RegistrationToken<T>): boolean;
-    createScope(options?: ContainerScopeOptions): import("./containerCore.scope.js").ContainerScopeContext;
+    canResolve<T>(token: RegistrationToken<T>): boolean;
+    isDisposed(): boolean;
+    createScope(options?: ContainerScopeOptions): ContainerScopeContext;
+    /**
+     * @internal Creates a fresh scoped-instance cache, optionally chained to a
+     * parent scope's cache (nested scopes).
+     */
+    createScopeCache(parent?: ResolutionCache): ResolutionCache;
+    /**
+     * @internal Resolves a token using the given scope cache. `onInstanceCreated`
+     * is invoked for every instance created during the resolution (including
+     * transitively created dependencies) so the scope can track SCOPED ones.
+     */
+    resolveInScope<T>(token: RegistrationToken<T>, cache: ResolutionCache, onInstanceCreated?: (result: ResolutionResult<unknown>) => void): ResolutionResult<T>;
+    /** @internal Unregisters a top-level scope from the container's live-scope set. */
+    releaseScope(scope: ContainerScopeContext): void;
 }
 //# sourceMappingURL=containerCore.type.d.ts.map

package/dist/containerLifecycle/containerLifecycle.core.d.ts

@@ -1,16 +1,41 @@
 /**
  * Lifecycle management for resolved container instances.
- * Tracks instances that need cleanup and disposes them when a container or scope is destroyed.
+ *
+ * Tracks SINGLETON instances (container-owned) and SCOPED instances
+ * (scope-owned) that need cleanup and disposes them when their owner is
+ * destroyed, in reverse creation order.
+ *
+ * TRANSIENT instances are deliberately NOT tracked: the container creates a
+ * new transient per resolution, so tracking them per token would either leak
+ * (unbounded growth) or silently drop all but the last instance. Callers own
+ * the disposal of transient instances they resolve.
  */
 import type { Token } from "../containerToken/containerToken.type.js";
 import { ContainerLifecycleError } from "@zudojs/errors";
-export interface Disposable {
-    dispose(): void;
+/**
+ * An object disposable via a `dispose()` method (sync or async).
+ * Named `DisposableLike` to avoid shadowing the ES2023 `Disposable` built-in.
+ */
+export interface DisposableLike {
+    dispose(): void | Promise<void>;
+}
+/** An object disposable via the ES2023 `Symbol.dispose` protocol. */
+export interface SymbolDisposableLike {
+    [Symbol.dispose](): void;
 }
-export interface AsyncDisposable {
-    [Symbol.asyncDispose]?: () => Promise<void>;
+/**
+ * An object disposable via the ES2023 `Symbol.asyncDispose` protocol.
+ * Named `AsyncDisposableLike` to avoid shadowing the `AsyncDisposable`
+ * built-in.
+ */
+export interface AsyncDisposableLike {
+    [Symbol.asyncDispose](): Promise<void> | void;
 }
-export type DisposableInstance = Disposable | AsyncDisposable;
+/** @deprecated Use {@link DisposableLike} instead. */
+export type Disposable = DisposableLike;
+/** @deprecated Use {@link AsyncDisposableLike} instead. */
+export type AsyncDisposable = AsyncDisposableLike;
+export type DisposableInstance = DisposableLike | SymbolDisposableLike | AsyncDisposableLike;
 export declare enum ContainerLifecycleOwner {
     CONTAINER = "container",
     SCOPE = "scope"
@@ -30,26 +55,51 @@ export declare class ContainerDisposalError extends ContainerLifecycleError {
     readonly tokens: readonly Token<unknown>[];
     constructor(errors: readonly unknown[], tokens: readonly Token<unknown>[]);
 }
-export declare function isDisposable(value: unknown): value is Disposable;
-export declare function isAsyncDisposable(value: unknown): value is AsyncDisposable;
+export declare function isDisposable(value: unknown): value is DisposableLike;
+export declare function isSymbolDisposable(value: unknown): value is SymbolDisposableLike;
+export declare function isAsyncDisposable(value: unknown): value is AsyncDisposableLike;
 export declare function isDisposableInstance(value: unknown): value is DisposableInstance;
 export declare class ContainerLifecycle {
     private readonly instances;
     private readonly options;
     private disposed;
     constructor(options?: ContainerLifecycleOptions);
+    /**
+     * Tracks a disposable instance for later cleanup.
+     *
+     * Re-tracking a token removes the previous entry and re-inserts it at the
+     * end of the map, so reverse-creation disposal order stays sound.
+     * Non-disposable instances are ignored.
+     */
     track<T>(token: Token<T>, instance: T, owner?: ContainerLifecycleOwner): void;
     has<T>(token: Token<T>): boolean;
     get<T>(token: Token<T>): TrackedInstance<T> | undefined;
     getAll(): readonly TrackedInstance[];
     get size(): number;
     untrack<T>(token: Token<T>): boolean;
+    /**
+     * Disposes a single tracked instance and untracks it. Untracking happens
+     * even when disposal fails — a failed disposal is terminal for the entry.
+     */
     disposeInstance<T>(token: Token<T>): Promise<void>;
+    /**
+     * Disposes tracked instances in reverse creation order.
+     *
+     * Entries are untracked even when their disposal fails (terminal). When
+     * `owner` is omitted the whole lifecycle is marked disposed — this happens
+     * even on failure — and every failure is reported in the thrown
+     * ContainerDisposalError.
+     */
     dispose(owner?: ContainerLifecycleOwner): Promise<void>;
     disposeScope(): Promise<void>;
     disposeContainer(): Promise<void>;
+    /**
+     * Releases all tracked references WITHOUT disposing them and marks the
+     * lifecycle disposed so further `track()` calls are refused. Used when a
+     * container is disposed with `autoDispose: false`.
+     */
+    shutdown(): void;
     isDisposed(): boolean;
-    reset(): void;
     getTrackedTokens(): readonly Token<unknown>[];
 }
 export declare function createContainerLifecycle(options?: ContainerLifecycleOptions): ContainerLifecycle;

package/dist/containerLifecycle/containerLifecycle.core.js

@@ -1,6 +1,14 @@
 /**
  * Lifecycle management for resolved container instances.
- * Tracks instances that need cleanup and disposes them when a container or scope is destroyed.
+ *
+ * Tracks SINGLETON instances (container-owned) and SCOPED instances
+ * (scope-owned) that need cleanup and disposes them when their owner is
+ * destroyed, in reverse creation order.
+ *
+ * TRANSIENT instances are deliberately NOT tracked: the container creates a
+ * new transient per resolution, so tracking them per token would either leak
+ * (unbounded growth) or silently drop all but the last instance. Callers own
+ * the disposal of transient instances they resolve.
  */
 import { describeToken } from "../containerToken/containerToken.type.js";
 import { ContainerLifecycleError } from "@zudojs/errors";
@@ -24,6 +32,12 @@ export function isDisposable(value) {
         "dispose" in value &&
         typeof value.dispose === "function");
 }
+export function isSymbolDisposable(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Symbol.dispose in value &&
+        typeof value[Symbol.dispose] === "function");
+}
 export function isAsyncDisposable(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -31,7 +45,7 @@ export function isAsyncDisposable(value) {
         typeof value[Symbol.asyncDispose] === "function");
 }
 export function isDisposableInstance(value) {
-    return isDisposable(value) || isAsyncDisposable(value);
+    return (isDisposable(value) || isSymbolDisposable(value) || isAsyncDisposable(value));
 }
 export class ContainerLifecycle {
     instances = new Map();
@@ -40,11 +54,19 @@ export class ContainerLifecycle {
     constructor(options = {}) {
         this.options = { failFast: options.failFast ?? false };
     }
+    /**
+     * Tracks a disposable instance for later cleanup.
+     *
+     * Re-tracking a token removes the previous entry and re-inserts it at the
+     * end of the map, so reverse-creation disposal order stays sound.
+     * Non-disposable instances are ignored.
+     */
     track(token, instance, owner = ContainerLifecycleOwner.CONTAINER) {
         if (this.disposed)
-            throw new Error("Cannot track an instance after the container lifecycle has been disposed.");
+            throw new ContainerLifecycleError("track", "Cannot track an instance after the container lifecycle has been disposed.");
         if (!isDisposableInstance(instance))
             return;
+        this.instances.delete(token);
         this.instances.set(token, {
             token,
             instance,
@@ -68,14 +90,18 @@ export class ContainerLifecycle {
     untrack(token) {
         return this.instances.delete(token);
     }
+    /**
+     * Disposes a single tracked instance and untracks it. Untracking happens
+     * even when disposal fails — a failed disposal is terminal for the entry.
+     */
     async disposeInstance(token) {
-        const tracked = this.get(token);
+        const tracked = this.instances.get(token);
         if (!tracked || tracked.disposed)
             return;
+        tracked.disposed = true;
+        this.instances.delete(token);
         try {
             await disposeValue(tracked.instance);
-            tracked.disposed = true;
-            this.instances.delete(token);
         }
         catch (error) {
             if (this.options.failFast)
@@ -83,9 +109,21 @@ export class ContainerLifecycle {
             throw new ContainerDisposalError([error], [token]);
         }
     }
+    /**
+     * Disposes tracked instances in reverse creation order.
+     *
+     * Entries are untracked even when their disposal fails (terminal). When
+     * `owner` is omitted the whole lifecycle is marked disposed — this happens
+     * even on failure — and every failure is reported in the thrown
+     * ContainerDisposalError.
+     */
     async dispose(owner) {
         if (this.disposed)
             return;
+        // Mark before the first await: an instance tracked while disposal is in
+        // flight would be dropped by `shutdown()` without ever being disposed.
+        if (owner === undefined)
+            this.disposed = true;
         const tracked = [...this.instances.values()].reverse();
         const selected = owner
             ? tracked.filter((entry) => entry.owner === owner)
@@ -95,10 +133,10 @@ export class ContainerLifecycle {
         for (const entry of selected) {
             if (entry.disposed)
                 continue;
+            entry.disposed = true;
+            this.instances.delete(entry.token);
             try {
                 await disposeValue(entry.instance);
-                entry.disposed = true;
-                this.instances.delete(entry.token);
             }
             catch (error) {
                 errors.push(error);
@@ -109,8 +147,6 @@ export class ContainerLifecycle {
         }
         if (errors.length > 0)
             throw new ContainerDisposalError(errors, failedTokens);
-        if (owner === undefined)
-            this.disposed = true;
     }
     async disposeScope() {
         await this.dispose(ContainerLifecycleOwner.SCOPE);
@@ -118,13 +154,18 @@ export class ContainerLifecycle {
     async disposeContainer() {
         await this.dispose(ContainerLifecycleOwner.CONTAINER);
     }
+    /**
+     * Releases all tracked references WITHOUT disposing them and marks the
+     * lifecycle disposed so further `track()` calls are refused. Used when a
+     * container is disposed with `autoDispose: false`.
+     */
+    shutdown() {
+        this.instances.clear();
+        this.disposed = true;
+    }
     isDisposed() {
         return this.disposed;
     }
-    reset() {
-        this.instances.clear();
-        this.disposed = false;
-    }
     getTrackedTokens() {
         return [...this.instances.keys()];
     }
@@ -134,8 +175,12 @@ async function disposeValue(value) {
         await value[Symbol.asyncDispose]();
         return;
     }
+    if (isSymbolDisposable(value)) {
+        value[Symbol.dispose]();
+        return;
+    }
     if (isDisposable(value)) {
-        value.dispose();
+        await value.dispose();
         return;
     }
 }

package/dist/containerOptions/containerOptions.type.d.ts

@@ -4,26 +4,18 @@
 import type { ContainerLifecycleOptions } from "../containerLifecycle/containerLifecycle.core.js";
 import type { ContainerRegistryOptions } from "../containerRegistry/containerRegistry.type.js";
 import type { ResolutionOptions } from "../containerResolution/containerResolution.type.js";
-export declare enum ContainerLogLevel {
-    NONE = "none",
-    ERROR = "error",
-    WARN = "warn",
-    INFO = "info",
-    DEBUG = "debug",
-    TRACE = "trace"
-}
-export declare const DEFAULT_CONTAINER_LOG_LEVEL: ContainerLogLevel;
-export interface ContainerResolutionOptions extends ResolutionOptions {
-    readonly autoRegisterClasses?: boolean;
-    readonly detectCircularDependencies?: boolean;
-    readonly maxResolutionDepth?: number;
-}
+/**
+ * The subset of {@link ResolutionOptions} a container accepts at
+ * construction time. Per-call plumbing (`cache`, `path`,
+ * `allowRegistration`, `onInstanceCreated`) is managed by the container
+ * itself and deliberately not configurable here.
+ */
+export type ContainerResolutionOptions = Pick<ResolutionOptions, "autoRegisterClasses" | "detectCircularDependencies" | "maxResolutionDepth">;
 export interface ContainerOptions {
     readonly name?: string;
     readonly registry?: ContainerRegistryOptions;
     readonly lifecycle?: ContainerLifecycleOptions;
     readonly resolution?: ContainerResolutionOptions;
-    readonly logLevel?: ContainerLogLevel;
     readonly autoDispose?: boolean;
     readonly allowScopes?: boolean;
     readonly freezeRegistrations?: boolean;
@@ -34,7 +26,6 @@ export interface ResolvedContainerOptions {
     readonly registry: ContainerRegistryOptions;
     readonly lifecycle: ContainerLifecycleOptions;
     readonly resolution: ContainerResolutionOptions;
-    readonly logLevel: ContainerLogLevel;
     readonly autoDispose: boolean;
     readonly allowScopes: boolean;
     readonly freezeRegistrations: boolean;
@@ -47,7 +38,6 @@ export declare const DEFAULT_FREEZE_REGISTRATIONS = false;
 export declare const DEFAULT_RESOLUTION_OPTIONS: Required<Pick<ContainerResolutionOptions, "autoRegisterClasses" | "detectCircularDependencies" | "maxResolutionDepth">>;
 export declare function resolveContainerOptions(options?: ContainerOptions): ResolvedContainerOptions;
 export declare function validateResolutionOptions(options: ContainerResolutionOptions): void;
-export declare function isContainerLogLevel(value: unknown): value is ContainerLogLevel;
 export declare function allowsContainerScopes(options: ResolvedContainerOptions): boolean;
 export declare function shouldAutoDisposeContainer(options: ResolvedContainerOptions): boolean;
 export declare function canModifyRegistrations(options: ResolvedContainerOptions): boolean;

package/dist/containerOptions/containerOptions.type.js

@@ -1,16 +1,6 @@
 /**
  * Configuration options for the Zudojs dependency injection container.
  */
-export var ContainerLogLevel;
-(function (ContainerLogLevel) {
-    ContainerLogLevel["NONE"] = "none";
-    ContainerLogLevel["ERROR"] = "error";
-    ContainerLogLevel["WARN"] = "warn";
-    ContainerLogLevel["INFO"] = "info";
-    ContainerLogLevel["DEBUG"] = "debug";
-    ContainerLogLevel["TRACE"] = "trace";
-})(ContainerLogLevel || (ContainerLogLevel = {}));
-export const DEFAULT_CONTAINER_LOG_LEVEL = ContainerLogLevel.WARN;
 export const DEFAULT_CONTAINER_NAME = "zudojs-container";
 export const DEFAULT_AUTO_DISPOSE = true;
 export const DEFAULT_ALLOW_SCOPES = true;
@@ -39,7 +29,6 @@ export function resolveContainerOptions(options = {}) {
         registry: Object.freeze({ ...(options.registry ?? {}) }),
         lifecycle: Object.freeze({ ...(options.lifecycle ?? {}) }),
         resolution: Object.freeze({ ...resolution }),
-        logLevel: options.logLevel ?? DEFAULT_CONTAINER_LOG_LEVEL,
         autoDispose: options.autoDispose ?? DEFAULT_AUTO_DISPOSE,
         allowScopes: options.allowScopes ?? DEFAULT_ALLOW_SCOPES,
         freezeRegistrations: options.freezeRegistrations ?? DEFAULT_FREEZE_REGISTRATIONS,
@@ -53,14 +42,6 @@ export function validateResolutionOptions(options) {
         throw new RangeError("Container maxResolutionDepth must be a positive integer.");
     }
 }
-export function isContainerLogLevel(value) {
-    return (value === ContainerLogLevel.NONE ||
-        value === ContainerLogLevel.ERROR ||
-        value === ContainerLogLevel.WARN ||
-        value === ContainerLogLevel.INFO ||
-        value === ContainerLogLevel.DEBUG ||
-        value === ContainerLogLevel.TRACE);
-}
 export function allowsContainerScopes(options) {
     return options.allowScopes;
 }

package/dist/containerProvider/containerProvider.core.d.ts

@@ -6,6 +6,11 @@ import type { Constructor, InjectionToken, Token } from "../containerToken/conta
 export type ProviderToken<T = unknown> = Token<T> | InjectionToken<T>;
 export interface ClassProvider<T> {
     readonly useClass: Constructor<T>;
+    /**
+     * Tokens resolved and passed to the constructor, in order.
+     * Omit (or leave empty) for zero-argument constructors.
+     */
+    readonly inject?: readonly ProviderToken[];
 }
 export interface FactoryProvider<T> {
     readonly useFactory: (...dependencies: unknown[]) => T;
@@ -25,6 +30,7 @@ export interface TokenProvider<T = unknown> {
 export interface ClassRegistration<T = unknown> {
     readonly provide: ProviderToken<T>;
     readonly useClass: Constructor<T>;
+    readonly inject?: readonly ProviderToken[];
 }
 export interface FactoryRegistration<T = unknown> {
     readonly provide: ProviderToken<T>;
@@ -45,12 +51,14 @@ export declare function isFactoryProvider<T = unknown>(provider: Provider<T>): p
 export declare function isValueProvider<T = unknown>(provider: Provider<T>): provider is ValueProvider<T>;
 export declare function isExistingProvider<T = unknown>(provider: Provider<T>): provider is ExistingProvider<T>;
 export declare function isTokenProvider<T = unknown>(provider: ContainerProvider<T>): provider is TokenProvider<T>;
-export declare function hasInjectedDependencies<T = unknown>(provider: Provider<T>): provider is FactoryProvider<T>;
-export declare function classProvider<T>(useClass: Constructor<T>): ClassProvider<T>;
+export declare function hasInjectedDependencies<T = unknown>(provider: Provider<T>): provider is (FactoryProvider<T> | ClassProvider<T>) & {
+    readonly inject: readonly ProviderToken[];
+};
+export declare function classProvider<T>(useClass: Constructor<T>, inject?: readonly ProviderToken[]): ClassProvider<T>;
 export declare function factoryProvider<T>(useFactory: (...dependencies: unknown[]) => T, inject?: readonly ProviderToken[]): FactoryProvider<T>;
 export declare function valueProvider<T>(useValue: T): ValueProvider<T>;
 export declare function existingProvider<T>(useExisting: ProviderToken<T>): ExistingProvider<T>;
-export declare function provideClass<T>(provide: ProviderToken<T>, useClass: Constructor<T>): ClassRegistration<T>;
+export declare function provideClass<T>(provide: ProviderToken<T>, useClass: Constructor<T>, inject?: readonly ProviderToken[]): ClassRegistration<T>;
 export declare function provideFactory<T>(provide: ProviderToken<T>, useFactory: (...dependencies: unknown[]) => T, inject?: readonly ProviderToken[]): FactoryRegistration<T>;
 export declare function provideValue<T>(provide: ProviderToken<T>, useValue: T): ValueRegistration<T>;
 export declare function provideExisting<T>(provide: ProviderToken<T>, useExisting: ProviderToken<T>): ExistingRegistration<T>;