@zudojs/container 1.2.3 → 1.3.0

package/README.md

@@ -47,6 +47,12 @@ container.registerFactory(API, (db) => new Api(db), [DB]); // deps via inject li
 container.registerExisting("db-alias", DB); // alias to another token
 ```
 
+Every `register*` call except `registerValue` defaults to
+**`ContainerScope.TRANSIENT`**: the class or factory runs again on every
+`resolve()`. Pass `{ scope: ContainerScope.SINGLETON }` (the fourth argument
+of `registerFactory`) for a pool, a client or anything else that must be
+shared.
+
 A factory's parameters are typed from its `inject` list, in order: with
 `DB = createToken<Db>("Db")`, `(db) => new Api(db)` receives `db: Db`, and a
 factory whose parameters do not match the tokens is a compile error. Class
@@ -54,6 +60,14 @@ tokens type the same way; plain string and symbol tokens give `unknown`.
 `factoryProvider(factory, inject)` and `provideFactory(token, factory,
 inject)` infer the same way.
 
+`registerClass(token, Class, { inject })`, `classProvider(Class, inject)` and
+`provideClass(token, Class, inject)` check the constructor the same way:
+`inject: [CLOCK, DB]` against `constructor(db: Db, clock: Clock)` is a compile
+error, and so is omitting `inject` for a constructor with required
+parameters. Untyped string/symbol tokens check nothing for classes, a
+non-tuple `ProviderToken[]` built at runtime accepts any constructor, and
+defaulted parameters beyond the list are fine.
+
 ```typescript
 container.registerFactory(
   REPORT,
@@ -164,10 +178,11 @@ container.register(API, {
 
 Classes without an `inject` list are constructed with zero arguments, so
 only a constructor that declares no parameters may omit it (parameters with
-a default value do not count). Registering such a class without `inject`
-is allowed, but resolving it throws a `ProviderResolutionError` naming the
-class and the `inject: [...]` fix, instead of building it with `undefined`
-dependencies. There is no reflection/decorator magic — dependencies are
+a default value do not count). In TypeScript, registering such a class
+without `inject` is a compile error; at runtime (JavaScript callers, casts)
+registering is allowed but resolving throws a `ProviderResolutionError`
+naming the class and the `inject: [...]` fix, instead of building it with
+`undefined` dependencies. There is no reflection/decorator magic — dependencies are
 exactly the tokens you list, resolved in order.
 
 ## Duplicate registrations
@@ -212,8 +227,12 @@ const container = createContainer({
   has no inject list, so `resolve(NeedsDep)` for
   `constructor(dep: Dep)` throws `RegistrationNotFoundError` naming the
   class and telling you to register it with an `inject` list, instead of
-  building it with `dep = undefined`. Parameters with defaults do not
-  count.
+  building it with `dep = undefined`. Parameters with defaults and rest
+  parameters do not count: `constructor(deps: Deps = {})` has
+  `length === 0`, so it _is_ auto-registered and built with no arguments —
+  the default applies and nothing is injected. Register such a class with
+  an `inject` list when the container should supply those values; the
+  container cannot tell "optional" from "please inject" at runtime.
 - `detectCircularDependencies` — circular chains throw
   `CircularDependencyError` with the full chain. When disabled,
   `maxResolutionDepth` still stops runaway recursion.

package/dist/containerCore/containerCore.core.d.ts

@@ -12,20 +12,23 @@
  * - TRANSIENT instances are never cached and never tracked — callers own
  *   their disposal.
  */
-import type { ContainerProvider, InjectedFactory, ProviderToken } from "../containerProvider/containerProvider.core.js";
+import type { ContainerProvider, InjectedConstructor, InjectedFactory, ProviderToken } from "../containerProvider/containerProvider.core.js";
 import type { ContainerRegistration, CreateRegistrationOptions, RegistrationToken, ResolvedTokens } from "../containerRegistration/containerRegistration.core.js";
 import type { ResolutionCache, ResolutionResult } from "../containerResolution/containerResolution.type.js";
 import type { ContainerOptions, ResolvedContainerOptions } from "../containerOptions/containerOptions.type.js";
-import type { Constructor, Token } from "../containerToken/containerToken.type.js";
+import type { Token } from "../containerToken/containerToken.type.js";
 import type { ContainerLike, ContainerScopeOptions } from "./containerCore.type.js";
 import { ContainerScopeContext } from "./containerCore.scope.js";
-/** Options accepted by {@link Container.registerClass}. */
-export interface RegisterClassOptions extends CreateRegistrationOptions {
+/**
+ * Options accepted by {@link Container.registerClass}. `Deps` is inferred
+ * from the `inject` tuple and checked against the class's constructor.
+ */
+export interface RegisterClassOptions<Deps extends readonly ProviderToken[] = readonly ProviderToken[]> extends CreateRegistrationOptions {
     /**
      * Tokens resolved and passed to the constructor, in order.
      * Omit for zero-argument constructors.
      */
-    readonly inject?: readonly ProviderToken[];
+    readonly inject?: Deps;
 }
 export declare class Container implements ContainerLike {
     #private;
@@ -41,8 +44,26 @@ export declare class Container implements ContainerLike {
      * performed by the first `resolve()` — freezes the registration set.
      */
     start(): this;
+    /**
+     * Registers a provider under a token.
+     *
+     * The default `scope` is **`ContainerScope.TRANSIENT`**: the provider
+     * runs on every `resolve()`. Pass `{ scope: ContainerScope.SINGLETON }`
+     * for anything that must be shared (a pool, a client, a cache).
+     */
     register<T>(token: RegistrationToken<T>, provider: ContainerProvider<T>, options?: CreateRegistrationOptions): ContainerRegistration<T>;
-    registerClass<T>(token: RegistrationToken<T>, ctor: Constructor<T>, options?: RegisterClassOptions): ContainerRegistration<T>;
+    /**
+     * Registers a class. Its constructor parameters are checked against the
+     * `inject` tokens, in order: `registerClass(API, Api, { inject: [DB] })`
+     * requires `Api`'s constructor to accept a `Db` when `DB` is a
+     * `createToken<Db>()` or class token, and swapping two typed tokens is a
+     * compile error. String/symbol tokens are untyped and check nothing.
+     * Without `inject` the class must be constructible with no arguments.
+     *
+     * Defaults to **`ContainerScope.TRANSIENT`** (a new instance per
+     * resolution) unless `options.scope` says otherwise.
+     */
+    registerClass<T, const Deps extends readonly ProviderToken[] = readonly []>(token: RegistrationToken<T>, ctor: InjectedConstructor<T, NoInfer<Deps>>, options?: RegisterClassOptions<Deps>): ContainerRegistration<T>;
     /**
      * Registers a pre-built value.
      *
@@ -57,6 +78,11 @@ export declare class Container implements ContainerLike {
      * as `Db` when `DB` is a `createToken<Db>()` or class token, and rejects a
      * factory whose parameters do not match. String/symbol tokens give
      * `unknown`.
+     *
+     * **The default scope is `ContainerScope.TRANSIENT`: the factory runs on
+     * every `resolve()`.** A database pool or HTTP client registered this way
+     * is rebuilt for each consumer unless you pass
+     * `{ scope: ContainerScope.SINGLETON }` as the fourth argument.
      */
     registerFactory<T, const Deps extends readonly ProviderToken[] = readonly []>(token: RegistrationToken<T>, factory: InjectedFactory<T, Deps>, inject?: Deps, options?: CreateRegistrationOptions): ContainerRegistration<T>;
     registerExisting<T>(token: RegistrationToken<T>, existing: ProviderToken<T>, options?: CreateRegistrationOptions): ContainerRegistration<T>;
@@ -159,4 +185,3 @@ export declare class Container implements ContainerLike {
 }
 export declare function createContainer(options?: ContainerOptions): Container;
 export declare function createStartedContainer(options?: ContainerOptions): Container;
-//# sourceMappingURL=containerCore.core.d.ts.map

package/dist/containerCore/containerCore.core.js

@@ -66,10 +66,28 @@ export class Container {
         this.#started = true;
         return this;
     }
+    /**
+     * Registers a provider under a token.
+     *
+     * The default `scope` is **`ContainerScope.TRANSIENT`**: the provider
+     * runs on every `resolve()`. Pass `{ scope: ContainerScope.SINGLETON }`
+     * for anything that must be shared (a pool, a client, a cache).
+     */
     register(token, provider, options = {}) {
         this.ensureMutable();
         return this.#registry.register(token, provider, options);
     }
+    /**
+     * Registers a class. Its constructor parameters are checked against the
+     * `inject` tokens, in order: `registerClass(API, Api, { inject: [DB] })`
+     * requires `Api`'s constructor to accept a `Db` when `DB` is a
+     * `createToken<Db>()` or class token, and swapping two typed tokens is a
+     * compile error. String/symbol tokens are untyped and check nothing.
+     * Without `inject` the class must be constructible with no arguments.
+     *
+     * Defaults to **`ContainerScope.TRANSIENT`** (a new instance per
+     * resolution) unless `options.scope` says otherwise.
+     */
     registerClass(token, ctor, options = {}) {
         const { inject, ...rest } = options;
         return this.register(token, classProvider(ctor, inject ?? []), rest);
@@ -93,6 +111,11 @@ export class Container {
      * as `Db` when `DB` is a `createToken<Db>()` or class token, and rejects a
      * factory whose parameters do not match. String/symbol tokens give
      * `unknown`.
+     *
+     * **The default scope is `ContainerScope.TRANSIENT`: the factory runs on
+     * every `resolve()`.** A database pool or HTTP client registered this way
+     * is rebuilt for each consumer unless you pass
+     * `{ scope: ContainerScope.SINGLETON }` as the fourth argument.
      */
     registerFactory(token, factory, inject = [], options = {}) {
         return this.register(token, factoryProvider(factory, inject), options);
@@ -346,4 +369,3 @@ export function createContainer(options = {}) {
 export function createStartedContainer(options = {}) {
     return new Container(options).start();
 }
-//# sourceMappingURL=containerCore.core.js.map

package/dist/containerCore/containerCore.scope.d.ts

@@ -110,4 +110,3 @@ export declare class ContainerScopeContext {
      */
     private ensureActive;
 }
-//# sourceMappingURL=containerCore.scope.d.ts.map

package/dist/containerCore/containerCore.scope.js

@@ -200,4 +200,3 @@ export class ContainerScopeContext {
         }
     }
 }
-//# sourceMappingURL=containerCore.scope.js.map

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

@@ -43,4 +43,3 @@ export interface ContainerLike {
     /** @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/containerCore/containerCore.type.js

@@ -2,4 +2,3 @@
  * Types for the core container.
  */
 export {};
-//# sourceMappingURL=containerCore.type.js.map

package/dist/containerCore/index.d.ts

@@ -6,4 +6,3 @@
 export * from "./containerCore.type.js";
 export * from "./containerCore.scope.js";
 export * from "./containerCore.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/containerCore/index.js

@@ -6,4 +6,3 @@
 export * from "./containerCore.type.js";
 export * from "./containerCore.scope.js";
 export * from "./containerCore.core.js";
-//# sourceMappingURL=index.js.map

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

@@ -103,4 +103,3 @@ export declare class ContainerLifecycle {
     getTrackedTokens(): readonly Token<unknown>[];
 }
 export declare function createContainerLifecycle(options?: ContainerLifecycleOptions): ContainerLifecycle;
-//# sourceMappingURL=containerLifecycle.core.d.ts.map

package/dist/containerLifecycle/containerLifecycle.core.js

@@ -187,4 +187,3 @@ async function disposeValue(value) {
 export function createContainerLifecycle(options = {}) {
     return new ContainerLifecycle(options);
 }
-//# sourceMappingURL=containerLifecycle.core.js.map

package/dist/containerLifecycle/index.d.ts

@@ -4,4 +4,3 @@
  * Container lifecycle management and scoping.
  */
 export * from "./containerLifecycle.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/containerLifecycle/index.js

@@ -4,4 +4,3 @@
  * Container lifecycle management and scoping.
  */
 export * from "./containerLifecycle.core.js";
-//# sourceMappingURL=index.js.map

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

@@ -41,4 +41,3 @@ export declare function validateResolutionOptions(options: ContainerResolutionOp
 export declare function allowsContainerScopes(options: ResolvedContainerOptions): boolean;
 export declare function shouldAutoDisposeContainer(options: ResolvedContainerOptions): boolean;
 export declare function canModifyRegistrations(options: ResolvedContainerOptions): boolean;
-//# sourceMappingURL=containerOptions.type.d.ts.map

package/dist/containerOptions/containerOptions.type.js

@@ -51,4 +51,3 @@ export function shouldAutoDisposeContainer(options) {
 export function canModifyRegistrations(options) {
     return !options.freezeRegistrations;
 }
-//# sourceMappingURL=containerOptions.type.js.map

package/dist/containerOptions/index.d.ts

@@ -4,4 +4,3 @@
  * Container configuration options and types.
  */
 export * from "./containerOptions.type.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/containerOptions/index.js

@@ -4,4 +4,3 @@
  * Container configuration options and types.
  */
 export * from "./containerOptions.type.js";
-//# sourceMappingURL=index.js.map

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

@@ -15,6 +15,24 @@ export type InjectedDependencies<Deps extends readonly ProviderToken[]> = {
 };
 /** A factory whose parameters are typed from its `inject` list. */
 export type InjectedFactory<T, Deps extends readonly ProviderToken[]> = (...dependencies: InjectedDependencies<Deps>) => T;
+/**
+ * The constructor parameter list an `inject` list must satisfy. A typed
+ * token (`createToken<Db>()`, a class) contributes its type; an untyped
+ * string/symbol token contributes `any`, because a class declares its own
+ * parameter types and an untyped token carries nothing to check them
+ * against. A non-tuple `readonly ProviderToken[]` (a list built at runtime)
+ * has no positions to check and accepts any constructor.
+ */
+export type InjectedConstructorArgs<Deps extends readonly ProviderToken[]> = number extends Deps["length"] ? any[] : {
+    -readonly [K in keyof Deps]: Deps[K] extends ProviderToken<infer U> ? unknown extends U ? any : U : never;
+};
+/**
+ * A class whose constructor parameters are typed from its `inject` list, in
+ * order: `[DB, Clock]` requires `new (db: Db, clock: Clock)`. Swapping two
+ * typed tokens, or omitting the list for a constructor with required
+ * parameters, is a compile error instead of a runtime `undefined`.
+ */
+export type InjectedConstructor<T, Deps extends readonly ProviderToken[]> = new (...args: InjectedConstructorArgs<Deps>) => T;
 export interface ClassProvider<T> {
     readonly useClass: Constructor<T>;
     /**
@@ -65,7 +83,12 @@ export declare function isTokenProvider<T = unknown>(provider: ContainerProvider
 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>;
+/**
+ * Builds a class provider. The constructor's parameters are checked against
+ * the `inject` tokens, in order (see {@link InjectedConstructor}); with no
+ * list the class must be constructible with no arguments.
+ */
+export declare function classProvider<T, const Deps extends readonly ProviderToken[] = readonly []>(useClass: InjectedConstructor<T, NoInfer<Deps>>, inject?: Deps): ClassProvider<T>;
 /**
  * Builds a factory provider. The factory's parameters are inferred from the
  * `inject` tokens, in order.
@@ -73,7 +96,11 @@ export declare function classProvider<T>(useClass: Constructor<T>, inject?: read
 export declare function factoryProvider<T, const Deps extends readonly ProviderToken[] = readonly []>(useFactory: InjectedFactory<T, Deps>, inject?: Deps): 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>, inject?: readonly ProviderToken[]): ClassRegistration<T>;
+/**
+ * Builds a class registration. The constructor's parameters are checked
+ * against the `inject` tokens, in order (see {@link InjectedConstructor}).
+ */
+export declare function provideClass<T, const Deps extends readonly ProviderToken[] = readonly []>(provide: ProviderToken<T>, useClass: InjectedConstructor<T, NoInfer<Deps>>, inject?: Deps): ClassRegistration<T>;
 /**
  * Builds a factory registration. The factory's parameters are inferred from
  * the `inject` tokens, in order.
@@ -83,4 +110,3 @@ export declare function provideValue<T>(provide: ProviderToken<T>, useValue: T):
 export declare function provideExisting<T>(provide: ProviderToken<T>, useExisting: ProviderToken<T>): ExistingRegistration<T>;
 export declare function getProviderToken<T>(provider: ContainerProvider<T>): ProviderToken<T> | undefined;
 export declare function normalizeProvider<T>(provider: ContainerProvider<T>): Provider<T>;
-//# sourceMappingURL=containerProvider.core.d.ts.map

package/dist/containerProvider/containerProvider.core.js

@@ -22,8 +22,16 @@ export function hasInjectedDependencies(provider) {
         Array.isArray(provider.inject) &&
         provider.inject.length > 0);
 }
+/**
+ * Builds a class provider. The constructor's parameters are checked against
+ * the `inject` tokens, in order (see {@link InjectedConstructor}); with no
+ * list the class must be constructible with no arguments.
+ */
 export function classProvider(useClass, inject = []) {
-    return Object.freeze({ useClass, inject: Object.freeze([...inject]) });
+    return Object.freeze({
+        useClass: useClass,
+        inject: Object.freeze([...inject]),
+    });
 }
 /**
  * Builds a factory provider. The factory's parameters are inferred from the
@@ -41,10 +49,14 @@ export function valueProvider(useValue) {
 export function existingProvider(useExisting) {
     return Object.freeze({ useExisting });
 }
+/**
+ * Builds a class registration. The constructor's parameters are checked
+ * against the `inject` tokens, in order (see {@link InjectedConstructor}).
+ */
 export function provideClass(provide, useClass, inject = []) {
     return Object.freeze({
         provide,
-        useClass,
+        useClass: useClass,
         inject: Object.freeze([...inject]),
     });
 }
@@ -75,4 +87,3 @@ export function normalizeProvider(provider) {
         return provider.provider;
     return provider;
 }
-//# sourceMappingURL=containerProvider.core.js.map

package/dist/containerProvider/index.d.ts

@@ -4,4 +4,3 @@
  * Dependency provider implementations and factories.
  */
 export * from "./containerProvider.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/containerProvider/index.js

@@ -4,4 +4,3 @@
  * Dependency provider implementations and factories.
  */
 export * from "./containerProvider.core.js";
-//# sourceMappingURL=index.js.map

package/dist/containerRegistration/containerRegistration.core.d.ts

@@ -57,4 +57,3 @@ export declare function defineRegistration<T>(token: RegistrationToken<T>, provi
 export declare const DEFAULT_REGISTRATION_SCOPE: ContainerScope;
 export type RegistrationMap = ReadonlyMap<Token<unknown>, ContainerRegistration<unknown>>;
 export declare function createRegistrationMap(registrations: readonly ContainerRegistration[]): RegistrationMap;
-//# sourceMappingURL=containerRegistration.core.d.ts.map

package/dist/containerRegistration/containerRegistration.core.js

@@ -126,4 +126,3 @@ export function createRegistrationMap(registrations) {
         map.set(unwrapToken(reg.token), reg);
     return map;
 }
-//# sourceMappingURL=containerRegistration.core.js.map

package/dist/containerRegistration/index.d.ts

@@ -4,4 +4,3 @@
  * Service registration and token binding.
  */
 export * from "./containerRegistration.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/containerRegistration/index.js

@@ -4,4 +4,3 @@
  * Service registration and token binding.
  */
 export * from "./containerRegistration.core.js";
-//# sourceMappingURL=index.js.map

package/dist/containerRegistry/containerRegistry.core.d.ts

@@ -47,4 +47,3 @@ export declare class ContainerRegistry {
      */
     restore(regs: readonly ContainerRegistration[]): void;
 }
-//# sourceMappingURL=containerRegistry.core.d.ts.map

package/dist/containerRegistry/containerRegistry.core.js

@@ -153,4 +153,3 @@ export class ContainerRegistry {
         });
     }
 }
-//# sourceMappingURL=containerRegistry.core.js.map

package/dist/containerRegistry/containerRegistry.type.d.ts

@@ -42,4 +42,3 @@ export interface ContainerRegistryOptions {
      */
     readonly allowDuplicates?: boolean;
 }
-//# sourceMappingURL=containerRegistry.type.d.ts.map

package/dist/containerRegistry/containerRegistry.type.js

@@ -13,4 +13,3 @@ export var RegistryOperation;
     /** Wholesale replacement of all registrations via `restore()`. */
     RegistryOperation["RESTORE"] = "restore";
 })(RegistryOperation || (RegistryOperation = {}));
-//# sourceMappingURL=containerRegistry.type.js.map

package/dist/containerRegistry/index.d.ts

@@ -5,4 +5,3 @@
  */
 export * from "./containerRegistry.type.js";
 export * from "./containerRegistry.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/containerRegistry/index.js

@@ -5,4 +5,3 @@
  */
 export * from "./containerRegistry.type.js";
 export * from "./containerRegistry.core.js";
-//# sourceMappingURL=index.js.map

package/dist/containerResolution/containerResolution.autoRegister.d.ts

@@ -9,8 +9,13 @@
  * Whether an unregistered token may be auto-registered: a class whose
  * constructor declares no required parameters (`Class.length === 0`).
  *
- * Parameters with a default value do not count, so
- * `constructor(value = 7)` still qualifies.
+ * `Function.length` counts parameters before the first default or rest
+ * parameter, so `constructor(value = 7)`, `constructor(deps: Deps = {})`
+ * and `constructor(...rest)` all qualify and are built with **no
+ * arguments** — their defaults apply and nothing is injected. A class that
+ * expects the container to supply a defaulted parameter must be registered
+ * explicitly with an `inject` list; the container cannot tell "optional"
+ * from "please inject" at runtime.
  */
 export declare function isAutoRegistrable(token: unknown): boolean;
 /**
@@ -39,4 +44,3 @@ export declare function assertClassInjectable(token: string, ctor: {
     readonly length: number;
     readonly name: string;
 }, inject: readonly unknown[]): void;
-//# sourceMappingURL=containerResolution.autoRegister.d.ts.map

package/dist/containerResolution/containerResolution.autoRegister.js

@@ -11,8 +11,13 @@ import { describeToken } from "../containerToken/containerToken.type.js";
  * Whether an unregistered token may be auto-registered: a class whose
  * constructor declares no required parameters (`Class.length === 0`).
  *
- * Parameters with a default value do not count, so
- * `constructor(value = 7)` still qualifies.
+ * `Function.length` counts parameters before the first default or rest
+ * parameter, so `constructor(value = 7)`, `constructor(deps: Deps = {})`
+ * and `constructor(...rest)` all qualify and are built with **no
+ * arguments** — their defaults apply and nothing is injected. A class that
+ * expects the container to supply a defaulted parameter must be registered
+ * explicitly with an `inject` list; the container cannot tell "optional"
+ * from "please inject" at runtime.
  */
 export function isAutoRegistrable(token) {
     return typeof token === "function" && token.length === 0;
@@ -59,4 +64,3 @@ export function assertClassInjectable(token, ctor, inject) {
         `dependencies. Register it with container.registerClass(${token}, ` +
         `${name}, { inject: [/* one token per parameter */] }).`);
 }
-//# sourceMappingURL=containerResolution.autoRegister.js.map

package/dist/containerResolution/containerResolution.core.d.ts

@@ -88,4 +88,3 @@ export declare class ContainerResolver {
     private evictAliasesOf;
     private aliasChainReaches;
 }
-//# sourceMappingURL=containerResolution.core.d.ts.map

package/dist/containerResolution/containerResolution.core.js

@@ -135,7 +135,16 @@ export class ContainerResolver {
                 }
             }
             else {
-                throw new RegistrationNotFoundError(describeToken(token));
+                // Name the consumer as well as the missing token: as a dependency
+                // this error is wrapped by the consumer's DependencyResolutionError,
+                // whose chain used to end at the consumer and never say what was
+                // missing.
+                const name = describeToken(token);
+                const requiredBy = state.path[state.path.length - 1];
+                throw new RegistrationNotFoundError(name, requiredBy === undefined
+                    ? undefined
+                    : `No registration found for token "${name}" (required by ` +
+                        `"${describeToken(requiredBy)}").`);
             }
         }
         const currentPath = [...state.path, token];
@@ -259,7 +268,13 @@ export class ContainerResolver {
                 error instanceof MaxResolutionDepthError ||
                 error instanceof AsyncProviderError)
                 throw error;
-            throw new DependencyResolutionError(describeToken(token), error, state.path.map((t) => describeToken(t)));
+            // A missing dependency is the one failure whose token is not on the
+            // path (it never started resolving), so append it: the chain must end
+            // at the token that was missing, not at the consumer that needed it.
+            const chain = state.path.map((t) => describeToken(t));
+            if (error instanceof RegistrationNotFoundError)
+                chain.push(error.requestedToken);
+            throw new DependencyResolutionError(describeToken(token), error, chain);
         }
     }
     /**
@@ -373,4 +388,3 @@ function isPromiseLike(value) {
         "then" in value &&
         typeof value.then === "function");
 }
-//# sourceMappingURL=containerResolution.core.js.map

package/dist/containerResolution/containerResolution.dependents.d.ts

@@ -30,4 +30,3 @@ export declare class DependentIndex {
     /** Forgets every recorded dependency. */
     clear(): void;
 }
-//# sourceMappingURL=containerResolution.dependents.d.ts.map

package/dist/containerResolution/containerResolution.dependents.js

@@ -63,4 +63,3 @@ export class DependentIndex {
         this.#dependents.clear();
     }
 }
-//# sourceMappingURL=containerResolution.dependents.js.map

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

@@ -70,4 +70,3 @@ 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

@@ -109,4 +109,3 @@ export class AsyncProviderError extends ContainerError {
         this.scope = scope;
     }
 }
-//# sourceMappingURL=containerResolution.error.js.map

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

@@ -36,7 +36,16 @@ export interface ResolutionOptions {
     readonly cache?: ResolutionCache;
     /** Current dependency resolution path. Normally managed internally. */
     readonly path?: ResolutionPath;
-    /** Whether unregistered class tokens may be resolved. Defaults to true. */
+    /**
+     * Whether unregistered class tokens may be resolved. Defaults to true.
+     *
+     * Only a class whose constructor declares no *required* parameters
+     * (`Class.length === 0`) qualifies, and it is built with no arguments.
+     * Parameters with defaults and rest parameters do not count, so such a
+     * class is auto-registered with its defaults applied and nothing
+     * injected; register it with an `inject` list when the container should
+     * supply those values. Set to `false` to require explicit registration.
+     */
     readonly autoRegisterClasses?: boolean;
     /**
      * Whether auto-resolved class tokens may be added to the registry.
@@ -69,4 +78,3 @@ export interface ResolutionResult<T> {
     readonly fromCache: boolean;
     readonly path: ResolutionPath;
 }
-//# sourceMappingURL=containerResolution.type.d.ts.map

package/dist/containerResolution/containerResolution.type.js

@@ -2,4 +2,3 @@
  * Types for dependency resolution.
  */
 export {};
-//# sourceMappingURL=containerResolution.type.js.map

package/dist/containerResolution/index.d.ts

@@ -6,4 +6,3 @@
 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

@@ -6,4 +6,3 @@
 export * from "./containerResolution.type.js";
 export * from "./containerResolution.error.js";
 export * from "./containerResolution.core.js";
-//# sourceMappingURL=index.js.map

package/dist/containerScope/containerScope.type.d.ts

@@ -14,4 +14,3 @@ export declare function isScopedScope(scope: ContainerScope): boolean;
 export declare function isTransientScope(scope: ContainerScope): boolean;
 export declare function isCachedScope(scope: ContainerScope): boolean;
 export declare function describeContainerScope(scope: ContainerScope): string;
-//# sourceMappingURL=containerScope.type.d.ts.map

package/dist/containerScope/containerScope.type.js

@@ -40,4 +40,3 @@ export function describeContainerScope(scope) {
             return "Unknown container scope.";
     }
 }
-//# sourceMappingURL=containerScope.type.js.map

package/dist/containerScope/index.d.ts

@@ -4,4 +4,3 @@
  * Scope management for dependency lifetimes.
  */
 export * from "./containerScope.type.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/containerScope/index.js

@@ -4,4 +4,3 @@
  * Scope management for dependency lifetimes.
  */
 export * from "./containerScope.type.js";
-//# sourceMappingURL=index.js.map

package/dist/containerToken/containerToken.type.d.ts

@@ -53,4 +53,3 @@ export declare function isStringToken<T = unknown>(token: Token<T>): token is st
  * `Symbol(MissingService)`. A symbol without a description is `Symbol()`.
  */
 export declare function describeToken<T>(token: Token<T> | InjectionToken<T>): string;
-//# sourceMappingURL=containerToken.type.d.ts.map

package/dist/containerToken/containerToken.type.js

@@ -66,4 +66,3 @@ export function describeToken(token) {
         return resolved.name || "AnonymousConstructor";
     return "UnknownToken";
 }
-//# sourceMappingURL=containerToken.type.js.map

package/dist/containerToken/index.d.ts

@@ -4,4 +4,3 @@
  * Token types for service identification.
  */
 export * from "./containerToken.type.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/containerToken/index.js

@@ -4,4 +4,3 @@
  * Token types for service identification.
  */
 export * from "./containerToken.type.js";
-//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -13,4 +13,3 @@ export * from "./containerResolution/index.js";
 export * from "./containerScope/index.js";
 export * from "./containerToken/index.js";
 export { CircularDependencyError, DuplicateRegistrationError, RegistrationNotFoundError, ProviderResolutionError, } from "@zudojs/errors";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -15,4 +15,3 @@ export * from "./containerToken/index.js";
 // Error classes the container throws but that live in @zudojs/errors,
 // re-exported so `instanceof` checks need only this package.
 export { CircularDependencyError, DuplicateRegistrationError, RegistrationNotFoundError, ProviderResolutionError, } from "@zudojs/errors";
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/container",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "Token-based dependency injection container for managing application dependencies and service lifetimes.",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,7 +18,7 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/errors": "1.3.2"
+    "@zudojs/errors": "1.4.0"
   },
   "devDependencies": {
     "typescript": "7.0.2",