@velajs/vela 1.4.0 → 1.5.0

package/dist/container/container.js

@@ -1,46 +1,63 @@
 import { Scope } from "../constants.js";
 import { getConstructorDependencies, getInjectMetadata, getScope, isInjectable } from "./decorators.js";
-import { ForwardRef, InjectionToken, ModuleVisibilityError } from "./types.js";
+import { ForwardRef, InjectionToken, ModuleVisibilityError, MultipleProvidersFoundError, ROOT_MODULE_ID } from "./types.js";
 const IMPORT_TYPE_HINT = 'Did you use `import type { X }`? TypeScript strips type-only imports at ' + 'runtime and `design:paramtypes` emits `Object`/`undefined` for their ' + 'positions. Use a runtime `import { X }` for DI tokens.';
-export class Container {
+/**
+ * Sentinel comparing a token to the bare `Object` class — `design:paramtypes`
+ * emits `Object` when TypeScript erases a type-only import, so any token that
+ * is `Object` (or nullish) is the fingerprint of a stripped type.
+ */ function isErasedTypeToken(token) {
+    return token === Object || token == null;
+}
+/**
+ * Per-module provider buckets. Each module instance owns its providers under
+ * its `moduleId`; the same logical token can have distinct registrations in
+ * different buckets, supporting multi-instance dynamic modules.
+ *
+ * The `__root__` bucket holds bootstrap-time framework primitives (Container,
+ * ModuleRef, REQUEST_CONTEXT, etc.) and any `register()` call that doesn't
+ * supply a `declaringModuleId`.
+ */ export class Container {
     providers = new Map();
+    exporterIndex = new Map();
     resolutionStack = new Set();
     requestInstances = new Map();
     scopes = new Map();
     globals = new Set();
-    providerOrigin = new Map();
     diagnostics;
     constructor(options = {}){
         this.diagnostics = options.diagnostics ?? 'log';
     }
     register(provider, declaringModuleId) {
+        const moduleId = declaringModuleId ?? ROOT_MODULE_ID;
         if (typeof provider === 'function') {
-            this.registerClass(provider, declaringModuleId);
+            this.registerClass(provider, moduleId);
         } else {
-            this.registerOptions(provider, declaringModuleId);
+            this.registerOptions(provider, moduleId);
         }
         return this;
     }
-    registerClass(target, declaringModuleId) {
+    registerClass(target, moduleId) {
         if (!isInjectable(target)) {
             console.warn(`Warning: ${target.name} is not decorated with @Injectable(). ` + `It will be registered but dependency resolution may not work correctly.`);
         }
         const scope = getScope(target);
-        this.providers.set(target, {
+        this.writeRegistration(moduleId, target, {
             provide: target,
             scope,
+            declaringModuleId: moduleId,
             useClass: target
         });
-        this.recordOrigin(target, declaringModuleId);
     }
-    registerOptions(options, declaringModuleId) {
+    registerOptions(options, moduleId) {
         const token = options.provide;
         if (!token) {
             throw new Error('Provider registration requires a token');
         }
         const registration = {
             provide: token,
-            scope: options.scope ?? Scope.SINGLETON
+            scope: options.scope ?? Scope.SINGLETON,
+            declaringModuleId: moduleId
         };
         if (options.useValue !== undefined) {
             registration.useValue = options.useValue;
@@ -55,27 +72,27 @@ export class Container {
         } else if (typeof token === 'function') {
             registration.useClass = token;
         }
-        this.providers.set(token, registration);
-        this.recordOrigin(token, declaringModuleId);
-        // For aliases like `{ provide: Foo, useClass: Bar }`, also record Bar's
-        // origin so `resolveClass(Bar)` resolves Bar's deps from the alias's
-        // declaring module. Idempotent if Bar === Foo.
-        if (options.useClass !== undefined) {
-            this.recordOrigin(options.useClass, declaringModuleId);
-        }
+        this.writeRegistration(moduleId, token, registration);
     }
-    recordOrigin(token, moduleId) {
-        if (moduleId !== undefined) {
-            this.providerOrigin.set(token, moduleId);
-        } else {
-            // Sandbox containers (createDetached) re-register tokens with no
-            // moduleId; clearing keeps the token "module-less" so it's only
-            // resolvable when the requester is also undefined.
-            this.providerOrigin.delete(token);
+    writeRegistration(moduleId, token, registration) {
+        let bucket = this.providers.get(moduleId);
+        if (!bucket) {
+            bucket = new Map();
+            this.providers.set(moduleId, bucket);
+        }
+        bucket.set(token, registration);
+        let exporters = this.exporterIndex.get(token);
+        if (!exporters) {
+            exporters = new Set();
+            this.exporterIndex.set(token, exporters);
         }
+        exporters.add(moduleId);
     }
     registerScope(scope) {
         this.scopes.set(scope.moduleId, scope);
+        if (!this.providers.has(scope.moduleId)) {
+            this.providers.set(scope.moduleId, new Map());
+        }
         if (scope.isGlobal) {
             // Match NestJS / the loader's existing globalExports semantic: only
             // exported tokens become globally visible. Non-exported providers of
@@ -98,47 +115,188 @@ export class Container {
         return this.diagnostics;
     }
     resolve(token, requestingModuleId) {
-        if (requestingModuleId !== undefined) {
-            this.assertVisible(requestingModuleId, token);
+        const registration = this.findRegistration(token, requestingModuleId);
+        if (registration) {
+            return this.resolveRegistration(registration, requestingModuleId);
         }
-        const registration = this.providers.get(token);
-        if (!registration) {
-            // `Object`/undefined at a token position is the fingerprint of a
-            // type-only import that TypeScript stripped — emit the hint before
-            // attempting any other recovery.
-            if (token === Object || token == null) {
-                throw new Error(`No provider found for token: ${this.tokenToString(token)}. ` + IMPORT_TYPE_HINT);
+        // Visibility error fires first when the token exists in some bucket but
+        // isn't reachable from the requester's scope — the user wants to know
+        // their wiring is wrong, not that the token doesn't exist.
+        if (requestingModuleId !== undefined && this.scopes.has(requestingModuleId) && this.exporterIndex.has(token)) {
+            throw new ModuleVisibilityError(requestingModuleId, token);
+        }
+        // `Object`/undefined at a token position is the fingerprint of a
+        // type-only import that TypeScript stripped — emit the hint before
+        // attempting any other recovery.
+        if (isErasedTypeToken(token)) {
+            throw new Error(`No provider found for token: ${this.tokenToString(token)}. ` + IMPORT_TYPE_HINT);
+        }
+        if (typeof token === 'function') {
+            throw new Error(`No provider found for token: ${this.tokenToString(token)}. ` + `Declare it in a module's providers.`);
+        }
+        // InjectionToken default factories are explicit user declarations
+        // attached to the token at construction — self-providing singletons.
+        if (token instanceof InjectionToken && token.options?.factory) {
+            this.register({
+                provide: token,
+                useFactory: token.options.factory
+            });
+            return this.resolve(token, requestingModuleId);
+        }
+        throw new Error(`No provider found for token: ${this.tokenToString(token)}`);
+    }
+    resolveAll(token, requestingModuleId) {
+        const registrations = this.findAllRegistrations(token, requestingModuleId);
+        return registrations.map((r)=>this.resolveRegistration(r, requestingModuleId));
+    }
+    /**
+   * Find a single reachable registration for a token, applying the visibility
+   * walk: requester's bucket → globals → requester's importedModules
+   * (transitively, following re-exports).
+   *
+   * Returns `undefined` if no candidate exists. Throws
+   * `MultipleProvidersFoundError` if the imports walk yields more than one.
+   */ findRegistration(token, requestingModuleId) {
+        // No requester OR no scope for this requester: framework-internal /
+        // sandbox lookup. Prefer the `__root__` bucket so sandbox-registered
+        // transients (ModuleRef.create) and bootstrap primitives win over module
+        // buckets that may hold the same token under SINGLETON scope.
+        if (requestingModuleId === undefined || !this.scopes.has(requestingModuleId)) {
+            const rootHit = this.lookupInBucket(ROOT_MODULE_ID, token);
+            if (rootHit) return rootHit;
+            const exporters = this.exporterIndex.get(token);
+            if (!exporters) return undefined;
+            for (const owner of exporters){
+                const hit = this.lookupInBucket(owner, token);
+                if (hit) return hit;
             }
-            if (typeof token === 'function') {
-                throw new Error(`No provider found for token: ${this.tokenToString(token)}. ` + `Declare it in a module's providers.`);
+            return undefined;
+        }
+        // 1. Local bucket.
+        const local = this.lookupInBucket(requestingModuleId, token);
+        if (local) return local;
+        // 2. Global tokens — registration still lives in some module's bucket.
+        if (this.globals.has(token)) {
+            const exporters = this.exporterIndex.get(token);
+            if (exporters && exporters.size > 0) {
+                if (exporters.size > 1) {
+                    throw new MultipleProvidersFoundError(requestingModuleId, token, [
+                        ...exporters
+                    ]);
+                }
+                const [owner] = [
+                    ...exporters
+                ];
+                return this.lookupInBucket(owner, token);
             }
-            // InjectionToken default factories are explicit user declarations
-            // attached to the token at construction — self-providing singletons.
-            if (token instanceof InjectionToken && token.options?.factory) {
-                this.register({
-                    provide: token,
-                    useFactory: token.options.factory
-                });
-                return this.resolve(token, requestingModuleId);
+            return undefined;
+        }
+        // 3. InjectionToken with default factory — self-providing from any
+        // scope. If already auto-registered (in `__root__`), return that;
+        // otherwise let the caller materialize it.
+        if (token instanceof InjectionToken && token.options?.factory) {
+            return this.lookupInBucket(ROOT_MODULE_ID, token);
+        }
+        // 4. Imported modules' exports — walk transitively so re-exports work.
+        const scope = this.scopes.get(requestingModuleId);
+        if (!scope) return undefined;
+        const candidates = [];
+        const candidateModuleIds = [];
+        const visited = new Set([
+            requestingModuleId
+        ]);
+        this.collectFromImports(scope, token, visited, candidates, candidateModuleIds);
+        if (candidates.length === 0) return undefined;
+        if (candidates.length > 1) {
+            throw new MultipleProvidersFoundError(requestingModuleId, token, candidateModuleIds);
+        }
+        return candidates[0];
+    }
+    /** Typed bucket lookup — single seam where the Map<Token, Registration> erases T. */ lookupInBucket(moduleId, token) {
+        return this.providers.get(moduleId)?.get(token);
+    }
+    /**
+   * Walk a scope's imports (and their imports' imports, …) collecting every
+   * registration reachable through re-export chains. A child only contributes
+   * if it explicitly exports the token — non-exported providers stay private.
+   */ collectFromImports(scope, token, visited, candidates, candidateModuleIds) {
+        for (const importedId of scope.importedModules){
+            if (visited.has(importedId)) continue;
+            visited.add(importedId);
+            const imported = this.scopes.get(importedId);
+            if (!imported?.exportedTokens.has(token)) continue;
+            const direct = this.lookupInBucket(importedId, token);
+            if (direct) {
+                candidates.push(direct);
+                candidateModuleIds.push(importedId);
+                continue;
             }
-            throw new Error(`No provider found for token: ${this.tokenToString(token)}`);
+            // Imported module re-exports the token without owning it — recurse
+            // into ITS imports.
+            this.collectFromImports(imported, token, visited, candidates, candidateModuleIds);
         }
-        return this.resolveRegistration(registration, requestingModuleId);
     }
-    resolveAll(token, requestingModuleId) {
-        if (!this.has(token)) return [];
-        return [
-            this.resolve(token, requestingModuleId)
-        ];
+    findAllRegistrations(token, requestingModuleId) {
+        if (requestingModuleId === undefined) {
+            const exporters = this.exporterIndex.get(token);
+            if (!exporters) return [];
+            return [
+                ...exporters
+            ].map((id)=>this.lookupInBucket(id, token)).filter((r)=>r !== undefined);
+        }
+        const out = [];
+        const seen = new Set();
+        const local = this.lookupInBucket(requestingModuleId, token);
+        if (local && !seen.has(local)) {
+            out.push(local);
+            seen.add(local);
+        }
+        if (this.globals.has(token)) {
+            for (const owner of this.exporterIndex.get(token) ?? []){
+                const reg = this.lookupInBucket(owner, token);
+                if (reg && !seen.has(reg)) {
+                    out.push(reg);
+                    seen.add(reg);
+                }
+            }
+        }
+        const scope = this.scopes.get(requestingModuleId);
+        if (scope) {
+            for (const importedId of scope.importedModules){
+                const imported = this.scopes.get(importedId);
+                if (!imported?.exportedTokens.has(token)) continue;
+                const reg = this.lookupInBucket(importedId, token);
+                if (reg && !seen.has(reg)) {
+                    out.push(reg);
+                    seen.add(reg);
+                }
+            }
+        }
+        return out;
+    }
+    /** True if any bucket has a registration for `token`. Sandbox-friendly. */ has(token) {
+        return this.exporterIndex.has(token);
     }
-    has(token) {
-        return this.providers.has(token);
+    /** True if the specified module's bucket has a registration for `token`. */ hasInScope(token, moduleId) {
+        return this.providers.get(moduleId)?.has(token) ?? false;
     }
     getProviderScope(token) {
-        return this.providers.get(token)?.scope;
+        const exporters = this.exporterIndex.get(token);
+        if (!exporters) return undefined;
+        for (const owner of exporters){
+            const reg = this.providers.get(owner)?.get(token);
+            if (reg) return reg.scope;
+        }
+        return undefined;
     }
     getTokens() {
-        return Array.from(this.providers.keys());
+        const out = new Set();
+        for (const bucket of this.providers.values()){
+            for (const token of bucket.keys())out.add(token);
+        }
+        return [
+            ...out
+        ];
     }
     /**
    * Create a child container for request-scoped resolution.
@@ -151,30 +309,40 @@ export class Container {
         // Share state by reference — request-scope children must see the same
         // module graph as the root.
         child.providers = this.providers;
+        child.exporterIndex = this.exporterIndex;
         child.scopes = this.scopes;
         child.globals = this.globals;
-        child.providerOrigin = this.providerOrigin;
         return child;
     }
     createDetached() {
         const child = new Container({
             diagnostics: this.diagnostics
         });
-        // Copy mutable per-resolution state; share static module-graph metadata
-        // so sandbox resolutions can still see exported providers.
-        child.providers = new Map(this.providers);
-        child.providerOrigin = new Map(this.providerOrigin);
+        // Deep-clone provider buckets so sandbox writes don't leak back to the
+        // parent. Inner ProviderRegistration objects are shallow-shared (we only
+        // mutate `instance` cache, and per-bucket clones already give per-sandbox
+        // singleton isolation when needed).
+        const clonedProviders = new Map();
+        for (const [moduleId, bucket] of this.providers){
+            clonedProviders.set(moduleId, new Map(bucket));
+        }
+        child.providers = clonedProviders;
+        const clonedIndex = new Map();
+        for (const [token, owners] of this.exporterIndex){
+            clonedIndex.set(token, new Set(owners));
+        }
+        child.exporterIndex = clonedIndex;
         child.scopes = this.scopes;
         child.globals = this.globals;
         return child;
     }
     clear() {
         this.providers.clear();
+        this.exporterIndex.clear();
         this.resolutionStack.clear();
         this.requestInstances.clear();
         this.scopes.clear();
         this.globals.clear();
-        this.providerOrigin.clear();
     }
     resolveRegistration(registration, requestingModuleId) {
         if (registration.useValue !== undefined) {
@@ -208,11 +376,11 @@ export class Container {
             if (registration.useFactory) {
                 // Factories (forRootAsync, useFactory) commonly inject deps from the
                 // importing module's scope. Vela has no `forRootAsync({ imports })`
-                // surface to track that, so factory inject deps resolve without a
-                // requester — same escape-hatch shape as ModuleRef.
+                // surface to track that, so factory inject deps resolve from the
+                // declaring module's POV — same escape-hatch shape as ModuleRef.
                 instance = this.resolveFactory(registration);
             } else if (registration.useClass) {
-                instance = this.resolveClass(registration.useClass);
+                instance = this.resolveClass(registration.useClass, registration.declaringModuleId);
             } else {
                 throw new Error(`Invalid provider registration for: ${this.tokenToString(registration.provide)}`);
             }
@@ -226,9 +394,7 @@ export class Container {
             this.resolutionStack.delete(registration.provide);
         }
     }
-    resolveClass(target, callerModuleId) {
-        // The class's dependencies resolve from ITS module's POV, not the caller's.
-        const ownerModuleId = this.providerOrigin.get(target) ?? callerModuleId;
+    resolveClass(target, ownerModuleId) {
         const paramTypes = getConstructorDependencies(target);
         const injectMetadata = getInjectMetadata(target);
         const injectMap = new Map(injectMetadata.map((m)=>[
@@ -240,7 +406,7 @@ export class Container {
             const rawToken = meta?.token;
             const isForwardRef = rawToken instanceof ForwardRef;
             const token = isForwardRef ? rawToken.factory() : rawToken ?? paramType;
-            if (!token || token === Object) {
+            if (!token || isErasedTypeToken(token)) {
                 if (meta?.optional) return undefined;
                 throw new Error(`Cannot resolve dependency at index ${index} for ${target.name}. ` + `Parameter type is undefined or Object. ` + IMPORT_TYPE_HINT + ` Alternatively, use \`@Inject()\` to specify the token explicitly.`);
             }
@@ -255,13 +421,16 @@ export class Container {
         });
         return new target(...dependencies);
     }
-    resolveFactory(registration, requestingModuleId) {
+    resolveFactory(registration) {
         if (!registration.useFactory) {
             throw new Error('Factory function is missing');
         }
+        // Factory inject deps resolve without a requester — Vela has no
+        // `forRootAsync({ imports })` surface to track which module the factory
+        // resolves from, so it uses the same escape-hatch shape as ModuleRef.
         const dependencies = (registration.inject || []).map((token)=>{
             const resolved = token instanceof ForwardRef ? token.factory() : token;
-            return this.resolve(resolved, requestingModuleId);
+            return this.resolve(resolved);
         });
         const result = registration.useFactory(...dependencies);
         if (result instanceof Promise) {
@@ -270,16 +439,15 @@ export class Container {
         return result;
     }
     async resolveAsync(token, requestingModuleId) {
-        if (requestingModuleId !== undefined) {
-            this.assertVisible(requestingModuleId, token);
-        }
-        const registration = this.providers.get(token);
+        const registration = this.findRegistration(token, requestingModuleId);
         if (!registration) {
+            if (requestingModuleId !== undefined && this.scopes.has(requestingModuleId) && this.exporterIndex.has(token)) {
+                throw new ModuleVisibilityError(requestingModuleId, token);
+            }
             if (typeof token === 'function') {
                 throw new Error(`No provider found for token: ${this.tokenToString(token)}. ` + `Declare it in a module's providers.`);
             }
             if (token instanceof InjectionToken && token.options?.factory) {
-                // Self-providing token — register on demand from its declared factory.
                 this.register({
                     provide: token,
                     useFactory: token.options.factory
@@ -292,8 +460,8 @@ export class Container {
             if (registration.scope === Scope.SINGLETON && registration.instance !== undefined) {
                 return registration.instance;
             }
-            // Factory inject deps resolve without a requester (escape hatch — see
-            // resolveRegistration's useFactory branch).
+            // Factory inject deps resolve without a requester (same escape hatch as
+            // sync resolveFactory).
             const dependencies = await Promise.all((registration.inject || []).map((t)=>{
                 const resolved = t instanceof ForwardRef ? t.factory() : t;
                 return this.resolveAsync(resolved);
@@ -312,38 +480,19 @@ export class Container {
         return new Proxy(target, {
             get (_target, prop) {
                 const instance = container.resolve(token, requestingModuleId);
-                const value = instance[prop];
+                // Annotate `unknown` to contain `Reflect.get`'s `any` return so the
+                // typeof-narrows-to-Function guard below stays honest.
+                const value = Reflect.get(instance, prop, instance);
                 return typeof value === 'function' ? value.bind(instance) : value;
             },
             set (_target, prop, value) {
                 const instance = container.resolve(token, requestingModuleId);
-                instance[prop] = value;
-                return true;
+                // `Reflect.set` returns whether the assignment succeeded — that's the
+                // spec-correct Proxy `set` return, vs returning `true` unconditionally.
+                return Reflect.set(instance, prop, value);
             }
         });
     }
-    assertVisible(moduleId, token) {
-        if (this.globals.has(token)) return;
-        // InjectionTokens with a default factory are self-providing singletons —
-        // visible from any module without requiring explicit declaration.
-        if (token instanceof InjectionToken && token.options?.factory) return;
-        const scope = this.scopes.get(moduleId);
-        if (!scope) {
-            // No scope registered for this moduleId — typically synthetic /
-            // framework-internal callers. Allow rather than break primitives.
-            return;
-        }
-        if (scope.localProviders.has(token)) return;
-        if (this.isExportedFromImports(scope, token)) return;
-        throw new ModuleVisibilityError(moduleId, token);
-    }
-    isExportedFromImports(scope, token) {
-        for (const importedId of scope.importedModules){
-            const imported = this.scopes.get(importedId);
-            if (imported?.exportedTokens.has(token)) return true;
-        }
-        return false;
-    }
     tokenToString(token) {
         if (token instanceof InjectionToken) {
             return token.toString();

package/dist/container/decorators.d.ts

@@ -6,5 +6,12 @@ export declare function Optional(): ParameterDecorator;
 export declare function Inject(token: Token | ForwardRef): ParameterDecorator;
 export declare function isInjectable(target: object): boolean;
 export declare function getScope(target: object): Scope;
-export declare function getConstructorDependencies(target: object): unknown[];
+/**
+ * Read through Reflect so dist/src coexistence in tests routes through the
+ * single polyfill-installed registry — SWC writes `design:paramtypes` via
+ * Reflect, so reads must too. The runtime contract is that each entry is a
+ * constructor reference (a `Token`); we surface that contract directly so
+ * callers don't need to re-cast.
+ */
+export declare function getConstructorDependencies(target: object): Array<Token | undefined>;
 export declare function getInjectMetadata(target: object): InjectMetadata[];

package/dist/container/decorators.js

@@ -43,10 +43,13 @@ export function isInjectable(target) {
 export function getScope(target) {
     return MetadataRegistry.getScope(target) ?? Scope.SINGLETON;
 }
-export function getConstructorDependencies(target) {
-    // Read through Reflect so dist/src coexistence in tests routes through the
-    // single polyfill-installed registry — SWC writes `design:paramtypes` via
-    // Reflect, so reads must too.
+/**
+ * Read through Reflect so dist/src coexistence in tests routes through the
+ * single polyfill-installed registry — SWC writes `design:paramtypes` via
+ * Reflect, so reads must too. The runtime contract is that each entry is a
+ * constructor reference (a `Token`); we surface that contract directly so
+ * callers don't need to re-cast.
+ */ export function getConstructorDependencies(target) {
     return Reflect.getMetadata('design:paramtypes', target) ?? [];
 }
 export function getInjectMetadata(target) {

package/dist/container/index.d.ts

@@ -1,6 +1,6 @@
 export { Container } from './container';
 export { Injectable, Inject, Optional, isInjectable, getScope } from './decorators';
-export { InjectionToken, ForwardRef, forwardRef, ModuleVisibilityError } from './types';
+export { InjectionToken, ForwardRef, forwardRef, ModuleVisibilityError, MultipleProvidersFoundError, ROOT_MODULE_ID, } from './types';
 export { ModuleRef } from './module-ref';
 export { mixin } from './mixin';
 export type { Type, Token, InjectableOptions, InjectMetadata, ProviderOptions, ProviderRegistration, InjectionTokenOptions, ModuleScope, ContainerOptions, Diagnostics, } from './types';

package/dist/container/index.js

@@ -1,5 +1,5 @@
 export { Container } from "./container.js";
 export { Injectable, Inject, Optional, isInjectable, getScope } from "./decorators.js";
-export { InjectionToken, ForwardRef, forwardRef, ModuleVisibilityError } from "./types.js";
+export { InjectionToken, ForwardRef, forwardRef, ModuleVisibilityError, MultipleProvidersFoundError, ROOT_MODULE_ID } from "./types.js";
 export { ModuleRef } from "./module-ref.js";
 export { mixin } from "./mixin.js";

package/dist/container/types.d.ts

@@ -36,6 +36,12 @@ export interface ProviderOptions<T = unknown> {
 export interface ProviderRegistration<T = unknown> {
     provide: Token<T>;
     scope: Scope;
+    /**
+     * Module that owns this registration. Used by `resolveClass` to determine
+     * the POV from which the class's dependencies resolve. Sandbox/bootstrap
+     * registrations land in the `"__root__"` bucket.
+     */
+    declaringModuleId: string;
     instance?: T;
     useValue?: T;
     useFactory?: (...args: any[]) => T | Promise<T>;
@@ -59,3 +65,10 @@ export declare class ModuleVisibilityError extends Error {
     readonly token: Token;
     constructor(moduleId: string, token: Token);
 }
+export declare class MultipleProvidersFoundError extends Error {
+    readonly moduleId: string;
+    readonly token: Token;
+    readonly candidates: string[];
+    constructor(moduleId: string, token: Token, candidates: string[]);
+}
+export declare const ROOT_MODULE_ID = "__root__";

package/dist/container/types.js

@@ -32,3 +32,13 @@ export class ModuleVisibilityError extends Error {
         this.name = 'ModuleVisibilityError';
     }
 }
+export class MultipleProvidersFoundError extends Error {
+    moduleId;
+    token;
+    candidates;
+    constructor(moduleId, token, candidates){
+        super(`Multiple providers found for '${describeToken(token)}' in module '${moduleId}':\n` + candidates.map((c)=>`  - ${c}`).join('\n') + `\nResolve ambiguity by importing only one instance, or by using a per-instance ` + `accessor exposed by the module (e.g., Module.tokenFor(key)).`), this.moduleId = moduleId, this.token = token, this.candidates = candidates;
+        this.name = 'MultipleProvidersFoundError';
+    }
+}
+export const ROOT_MODULE_ID = '__root__';

package/dist/cors/cors.module.d.ts

@@ -1,5 +1,7 @@
 import type { DynamicModule } from '../module/types';
 import type { CorsOptions } from './cors.types';
 export declare class CorsModule {
-    static forRoot(options?: CorsOptions): DynamicModule;
+    static forRoot(options?: CorsOptions & {
+        key?: string;
+    }): DynamicModule;
 }

package/dist/cors/cors.module.js

@@ -1,4 +1,5 @@
 import { cors } from "hono/cors";
+import { stableHash } from "../module/stable-hash.js";
 import { APP_MIDDLEWARE } from "../pipeline/tokens.js";
 import { CORS_OPTIONS } from "./cors.tokens.js";
 export class CorsModule {
@@ -16,6 +17,7 @@ export class CorsModule {
         };
         return {
             module: CorsModule,
+            key: options.key ?? stableHash(options),
             providers: [
                 {
                     provide: CORS_OPTIONS,

package/dist/fetch/fetch.module.d.ts

@@ -2,5 +2,7 @@ import type { AsyncModuleOptions, DynamicModule } from '../module/types';
 import type { HttpModuleOptions } from './fetch.types';
 export declare class HttpModule {
     static forRoot(options?: HttpModuleOptions): DynamicModule;
-    static forRootAsync(options: AsyncModuleOptions<HttpModuleOptions>): DynamicModule;
+    static forRootAsync(options: AsyncModuleOptions<HttpModuleOptions> & {
+        key?: string;
+    }): DynamicModule;
 }