@zudojs/container 1.1.1 → 1.1.2

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

@@ -77,7 +77,10 @@ export declare class Container implements ContainerLike {
     getRegistration<T>(token: RegistrationToken<T>): ContainerRegistration<T> | undefined;
     replace<T>(token: RegistrationToken<T>, provider: ContainerProvider<T>, options?: CreateRegistrationOptions): ContainerRegistration<T>;
     remove<T>(token: RegistrationToken<T>): boolean;
-    /** Removes every registration (evicting and disposing cached singletons). */
+    /**
+     * Removes every registration, evicting and disposing cached instances:
+     * container-owned singletons and every live scope's SCOPED copies alike.
+     */
     clearRegistrations(): void;
     createScope(options?: ContainerScopeOptions): ContainerScopeContext;
     getRegistrations(): readonly ContainerRegistration[];
@@ -91,8 +94,10 @@ export declare class Container implements ContainerLike {
     snapshot(): readonly ContainerRegistration[];
     /**
      * Wholesale-replaces the registration set with a previous snapshot.
-     * Entries are validated, cached singletons for the old set are evicted and
-     * disposed, and the operation is refused when registrations are frozen.
+     * Entries are validated, cached instances built from the old set are
+     * evicted and disposed — container-owned singletons and every live
+     * scope's SCOPED copies alike — and the operation is refused when
+     * registrations are frozen.
      */
     restoreSnapshot(registrations: readonly ContainerRegistration[]): void;
     isStarted(): boolean;

package/dist/containerCore/containerCore.core.js

@@ -19,7 +19,7 @@ import { ContainerResolver } from "../containerResolution/containerResolution.co
 import { ContainerLifecycle, ContainerLifecycleOwner, } from "../containerLifecycle/containerLifecycle.core.js";
 import { resolveContainerOptions } from "../containerOptions/containerOptions.type.js";
 import { unwrapToken } from "../containerToken/containerToken.type.js";
-import { RegistrationNotFoundError } from "@zudojs/errors";
+import { ContainerError, ContainerLifecycleError, RegistrationNotFoundError, } from "@zudojs/errors";
 import { ContainerScopeContext } from "./containerCore.scope.js";
 export class Container {
     name;
@@ -147,7 +147,10 @@ export class Container {
         this.ensureMutable();
         return this.#registry.remove(token);
     }
-    /** Removes every registration (evicting and disposing cached singletons). */
+    /**
+     * Removes every registration, evicting and disposing cached instances:
+     * container-owned singletons and every live scope's SCOPED copies alike.
+     */
     clearRegistrations() {
         this.ensureMutable();
         this.#registry.clear();
@@ -155,7 +158,7 @@ export class Container {
     createScope(options = {}) {
         this.ensureActive();
         if (!this.options.allowScopes)
-            throw new Error(`Container scopes are disabled for "${this.name}".`);
+            throw new ContainerError(`Container scopes are disabled for "${this.name}".`);
         const scope = new ContainerScopeContext(this, options);
         this.#liveScopes.add(scope);
         return scope;
@@ -182,8 +185,10 @@ export class Container {
     }
     /**
      * Wholesale-replaces the registration set with a previous snapshot.
-     * Entries are validated, cached singletons for the old set are evicted and
-     * disposed, and the operation is refused when registrations are frozen.
+     * Entries are validated, cached instances built from the old set are
+     * evicted and disposed — container-owned singletons and every live
+     * scope's SCOPED copies alike — and the operation is refused when
+     * registrations are frozen.
      */
     restoreSnapshot(registrations) {
         this.ensureMutable();
@@ -318,14 +323,14 @@ export class Container {
     }
     ensureNotDisposed() {
         if (this.#disposed)
-            throw new Error(`Container "${this.name}" has already been disposed.`);
+            throw new ContainerLifecycleError("dispose", `Container "${this.name}" has already been disposed.`);
     }
     ensureMutable() {
         this.ensureNotDisposed();
         if (!this.options.freezeRegistrations)
             return;
         if (this.#started)
-            throw new Error(`Registrations for container "${this.name}" are frozen.`);
+            throw new ContainerError(`Registrations for container "${this.name}" are frozen.`);
     }
 }
 export function createContainer(options = {}) {

package/dist/containerCore/containerCore.scope.js

@@ -18,6 +18,7 @@
  */
 import { ContainerLifecycle, ContainerLifecycleOwner, } from "../containerLifecycle/containerLifecycle.core.js";
 import { ContainerScope } from "../containerScope/containerScope.type.js";
+import { ContainerLifecycleError } from "@zudojs/errors";
 export class ContainerScopeContext {
     disposed = false;
     disposing;
@@ -189,13 +190,13 @@ export class ContainerScopeContext {
      */
     ensureActive() {
         if (this.disposed) {
-            throw new Error(`Container scope "${this.name}" has already been disposed.`);
+            throw new ContainerLifecycleError("dispose", `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.`);
+            throw new ContainerLifecycleError("dispose", `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.`);
+            throw new ContainerLifecycleError("dispose", `Container "${this.container.name}" owning scope "${this.name}" has been disposed.`);
         }
     }
 }

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

@@ -22,7 +22,10 @@
  * 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.
+ * callback so the owning container can dispose the instance, and every
+ * invalidated token — for CLEAR/RESTORE that is every cached token, SCOPED
+ * ones included — through `onTokenInvalidated` so live scopes drop and
+ * dispose their own copies.
  */
 import type { RegistrationToken } from "../containerRegistration/containerRegistration.core.js";
 import type { ContainerRegistry } from "../containerRegistry/containerRegistry.core.js";
@@ -34,12 +37,24 @@ export declare class ContainerResolver {
     private readonly onSingletonEvicted;
     private readonly onTokenInvalidated;
     private readonly dependents;
+    /**
+     * Tokens for which a SCOPED instance has ever been cached in a scope.
+     *
+     * The singleton cache only knows about SINGLETON tokens and the
+     * dependent index only records tokens consumed by another cached
+     * instance, so neither can name a SCOPED token that a scope resolved
+     * directly. A wholesale CLEAR/RESTORE must still tell live scopes to
+     * drop those instances.
+     */
+    private readonly scopedTokens;
     /**
      * @param onSingletonEvicted Called for each evicted cached singleton so
      *   the owner can dispose it.
      * @param onTokenInvalidated Called for every token invalidated by a
-     *   `replace()`/`remove()` (the token itself and each cached consumer),
-     *   so owners of scope caches can drop and dispose their SCOPED copies.
+     *   registry change — for `replace()`/`remove()` the token itself and
+     *   each cached consumer, for `clear()`/`restore()` every token that
+     *   was cached at all — so owners of scope caches can drop and dispose
+     *   their SCOPED copies.
      */
     constructor(registry: ContainerRegistry, onSingletonEvicted?: (token: Token<unknown>) => void, onTokenInvalidated?: (token: Token<unknown>) => void);
     resolve<T>(token: RegistrationToken<T>, options?: ResolutionOptions): T;

package/dist/containerResolution/containerResolution.core.js

@@ -22,14 +22,17 @@
  * 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.
+ * callback so the owning container can dispose the instance, and every
+ * invalidated token — for CLEAR/RESTORE that is every cached token, SCOPED
+ * ones included — through `onTokenInvalidated` so live scopes drop and
+ * dispose their own copies.
  */
 import { isClassProvider, isExistingProvider, isFactoryProvider, isValueProvider, normalizeProvider, } from "../containerProvider/containerProvider.core.js";
 import { ContainerScope as Scope } from "../containerScope/containerScope.type.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, RegistrationNotFoundError, } from "@zudojs/errors";
+import { CircularDependencyError, ContainerError, ProviderResolutionError, RegistrationNotFoundError, } from "@zudojs/errors";
 import { AsyncProviderError, CaptiveDependencyError, DependencyResolutionError, MaxResolutionDepthError, ScopedResolutionError, } from "./containerResolution.error.js";
 import { describeToken } from "../containerToken/containerToken.type.js";
 import { DependentIndex } from "./containerResolution.dependents.js";
@@ -69,12 +72,24 @@ export class ContainerResolver {
     onSingletonEvicted;
     onTokenInvalidated;
     dependents = new DependentIndex();
+    /**
+     * Tokens for which a SCOPED instance has ever been cached in a scope.
+     *
+     * The singleton cache only knows about SINGLETON tokens and the
+     * dependent index only records tokens consumed by another cached
+     * instance, so neither can name a SCOPED token that a scope resolved
+     * directly. A wholesale CLEAR/RESTORE must still tell live scopes to
+     * drop those instances.
+     */
+    scopedTokens = new Set();
     /**
      * @param onSingletonEvicted Called for each evicted cached singleton so
      *   the owner can dispose it.
      * @param onTokenInvalidated Called for every token invalidated by a
-     *   `replace()`/`remove()` (the token itself and each cached consumer),
-     *   so owners of scope caches can drop and dispose their SCOPED copies.
+     *   registry change — for `replace()`/`remove()` the token itself and
+     *   each cached consumer, for `clear()`/`restore()` every token that
+     *   was cached at all — so owners of scope caches can drop and dispose
+     *   their SCOPED copies.
      */
     constructor(registry, onSingletonEvicted, onTokenInvalidated) {
         this.registry = registry;
@@ -165,8 +180,11 @@ export class ContainerResolver {
         }
         if (registration.scope === Scope.SINGLETON)
             this.singletonCache.set(token, value);
-        else if (registration.scope === Scope.SCOPED)
+        else if (registration.scope === Scope.SCOPED) {
             state.scopeCache?.set(token, value);
+            if (state.scopeCache)
+                this.scopedTokens.add(token);
+        }
         const result = {
             value,
             token,
@@ -197,8 +215,8 @@ export class ContainerResolver {
                 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.`);
+                    throw new ContainerError(`useExisting target "${describeToken(target)}" for token ` +
+                        `"${describeToken(token)}" is not registered.`, { token: describeToken(token) });
                 }
                 const resolved = this.resolveInternal(target, state, singletonAncestor);
                 // Only a TRANSIENT target has no owner of its own; a cached alias
@@ -224,7 +242,9 @@ export class ContainerResolver {
                 const ctor = provider.useClass;
                 return { value: new ctor(...args), owned: true };
             }
-            throw new Error("Unsupported container provider.");
+            throw new ContainerError("Unsupported container provider.", {
+                token: describeToken(token),
+            });
         }
         catch (error) {
             // Resolution errors created deeper in the chain already carry the full
@@ -282,9 +302,21 @@ export class ContainerResolver {
             }
             case RegistryOperation.CLEAR:
             case RegistryOperation.RESTORE: {
+                // Every cached token is discarded by a wholesale change, so every
+                // one of them must be reported as invalidated — not just the
+                // singletons. Only REPLACE/REMOVE used to notify, so a live scope
+                // went on serving (and never disposed) the SCOPED instance built
+                // from a registration that clear()/restore() had thrown away.
+                const invalidated = new Set([
+                    ...this.singletonCache.keys(),
+                    ...this.scopedTokens,
+                ]);
                 for (const t of [...this.singletonCache.keys()])
                     this.evictSingleton(t);
                 this.dependents.clear();
+                this.scopedTokens.clear();
+                for (const t of invalidated)
+                    this.onTokenInvalidated?.(t);
                 break;
             }
             default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/container",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "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.1.0"
+    "@zudojs/errors": "1.2.0"
   },
   "devDependencies": {
     "typescript": "7.0.2",