@codefast/di 0.3.14-canary.1 → 0.3.14

package/dist/container.mjs

@@ -1,540 +1,725 @@
-import { AsyncModuleLoadError, CircularDependencyError, InternalError } from "./errors.mjs";
-import { BindingBuilder } from "./binding.mjs";
-import { getAutoRegistered } from "./decorators/injectable.mjs";
-import { SymbolMetadataReader } from "./metadata/symbol-metadata-reader.mjs";
-import { ContainerInspector } from "./inspector.mjs";
-import { AsyncModule } from "./module.mjs";
+import { effectiveBindingScope } from "./binding-scope.mjs";
+import { DisposedContainerError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError } from "./errors.mjs";
+import { DEFAULT_SLOT, generateBindingId } from "./binding.mjs";
+import { tokenName } from "./token.mjs";
 import { BindingRegistry } from "./registry.mjs";
-import { DependencyResolver } from "./resolver.mjs";
-import { validateScopeRules } from "./scope-validation.mjs";
 import { ScopeManager } from "./scope.mjs";
-import { isDevelopmentOrTestEnvironment } from "./environment.mjs";
+import { LifecycleManager } from "./lifecycle.mjs";
+import { slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { DependencyResolver } from "./resolver.mjs";
+import { Inspector } from "./inspector.mjs";
+import { buildDependencyGraph } from "./dependency-graph.mjs";
+import { defaultMetadataReader } from "./metadata/symbol-metadata-reader.mjs";
+import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
+import { normalizeToDescriptor } from "./decorators/inject.mjs";
+import { isSyncModule } from "./module.mjs";
 //#region src/container.ts
-/**
-* Derives a {@link ResolveHint} from a binding's name or first tag.
-* Used by {@link DefaultContainer.initializeAsync} to re-resolve named/tagged singletons
-* through the standard resolution path.
-*/
-function resolveHintForBinding(binding) {
-	if (binding.bindingName !== void 0) return { name: binding.bindingName };
-	for (const [tagKey, tagValue] of binding.tags) return { tag: [tagKey, tagValue] };
-}
-/**
-* Module {@link ModuleBuilder.bind}: append when the binding is disambiguated **at first
-* registration** (`whenNamed` / `whenTagged` / `when` before `to*()`). Otherwise replace
-* all bindings for the token (last-wins). Chaining `.whenNamed()` after `.to*()` only updates
-* in place and does not enable multi-binding for subsequent module lines — use hint-before-`to*()`
-* in modules (same style as `container.bind(...).whenNamed("x").to*(...)` in the package README).
-*/
-function moduleBindingUsesMultiSlot(built) {
-	return built.bindingName !== void 0 || built.tags.size > 0 || built.constraint !== void 0;
-}
-/**
-* Default IoC container: registry + scoped caches + synchronous / asynchronous resolution.
-* @internal Implementation of {@link Container}; not part of the public package contract.
-*/
 var DefaultContainer = class DefaultContainer {
-	/**
-	* Stack guard for detecting circular sync module imports during {@link ensureSyncModuleLoaded}.
-	*/
-	syncModuleStack = [];
-	/**
-	* Stack guard for detecting circular async module imports during {@link ensureAsyncModuleLoaded}.
-	*/
-	asyncModuleStack = [];
-	/**
-	* Tracks loaded modules → their binding IDs so {@link unload} / {@link unloadAsync} can
-	* remove exactly the bindings contributed by each module.
-	* Also serves as a deduplication set: a module present as a key is considered loaded.
-	*/
-	loadedModules = /* @__PURE__ */ new Map();
-	/**
-	* True after the first dev/test one-shot scope validation has run for the current registry state.
-	* Reset to `false` by {@link invalidateDevValidationState} on every registry mutation.
-	*/
-	devValidationRan = false;
-	/**
-	* Internal constructor for root/child instances.
-	* Use {@link Container.create}, {@link Container.fromModules}, or {@link createChild}.
-	*/
-	constructor(ownRegistry, ownScopeManager, parent, resolver, metadataReader) {
-		this.ownRegistry = ownRegistry;
-		this.ownScopeManager = ownScopeManager;
-		this.parent = parent;
-		this.resolver = resolver;
-		this.metadataReader = metadataReader;
-	}
-	/**
-	* Creates a root container with an empty registry and fresh singleton/scoped caches.
-	* Wires the circular container↔resolver reference via a mutable {@link ContainerRef} holder.
-	*/
-	static create() {
-		const ownRegistry = new BindingRegistry();
-		const ownScopeManager = ScopeManager.createRoot();
-		const metadataReader = new SymbolMetadataReader();
-		const holder = { current: void 0 };
-		const container = new DefaultContainer(ownRegistry, ownScopeManager, void 0, new DependencyResolver({
-			lookup: (token) => {
-				const current = holder.current;
-				if (current === void 0) throw new InternalError("container is not initialized");
-				return current.lookupBindings(token);
-			},
-			scopeManager: ownScopeManager,
-			metadataReader
-		}), metadataReader);
-		holder.current = container;
-		return container;
+	_disposed = false;
+	_registry;
+	_scope;
+	_lifecycle;
+	_resolver;
+	_inspector;
+	_parent;
+	_moduleRefs = /* @__PURE__ */ new Map();
+	_moduleBindingIds = /* @__PURE__ */ new Map();
+	constructor(parent) {
+		this._parent = parent;
+		this._registry = new BindingRegistry();
+		this._scope = new ScopeManager(parent !== void 0);
+		this._lifecycle = new LifecycleManager();
+		this._inspector = new Inspector(this._registry, this._scope, parent !== void 0, () => this._disposed);
+		this._initResolver();
+	}
+	_initResolver() {
+		const metadataReader = this._getMetadataReader();
+		const parentResolver = this._parent?._resolver;
+		this._resolver = new DependencyResolver(this._registry, this._scope, this._lifecycle, metadataReader, this, parentResolver);
+	}
+	_getMetadataReader() {
+		if (this._registry.getAll(MetadataReaderToken).length > 0) try {
+			return this._resolver.resolve(MetadataReaderToken, void 0, [], []);
+		} catch {}
+		if (this._parent !== void 0) return this._parent._getMetadataReader();
+		return defaultMetadataReader;
+	}
+	get isDisposed() {
+		return this._disposed;
 	}
-	/**
-	* Starts a fluent {@link BindingBuilder} for the given token or constructor.
-	* The binding is registered into this container's registry immediately when a
-	* `to*()` strategy method is called on the returned builder.
-	*/
 	bind(token) {
-		return new BindingBuilder(token, void 0, {
-			register: (built) => {
-				this.invalidateDevValidationState();
-				this.ownRegistry.add(token, built);
-			},
-			update: (built) => {
-				this.invalidateDevValidationState();
-				this.ownRegistry.replaceById(built.id, built);
+		this._assertNotDisposed();
+		return this._createBindToBuilder(token);
+	}
+	_createBindToBuilder(token, moduleRef) {
+		const registry = this._registry;
+		const commitBinding = (b, previousId) => {
+			if (previousId !== void 0) {
+				registry.removeById(previousId);
+				if (moduleRef !== void 0) {
+					const ids = this._moduleBindingIds.get(moduleRef);
+					if (ids !== void 0) {
+						const idx = ids.indexOf(previousId);
+						if (idx !== -1) ids.splice(idx, 1);
+					}
+				}
 			}
-		});
-	}
-	/**
-	* Fast registry presence check without instantiation.
-	*
-	* When `hint` is provided, this only verifies that at least one binding matches
-	* the name/tag discriminator; it does not evaluate runtime `when()` predicates.
-	*/
-	has(token, hint) {
-		const list = this.lookupBindings(token);
-		if (list === void 0 || list.length === 0) return false;
-		if (hint === void 0) return true;
-		return list.some((binding) => {
-			if (hint.name !== void 0 && binding.bindingName !== hint.name) return false;
-			if (hint.tag !== void 0) {
-				const tag = hint.tag;
-				if (binding.tags.get(tag[0]) !== tag[1]) return false;
+			registry.add(b);
+			if (moduleRef !== void 0) {
+				let ids = this._moduleBindingIds.get(moduleRef);
+				if (ids === void 0) {
+					ids = [];
+					this._moduleBindingIds.set(moduleRef, ids);
+				}
+				ids.push(b.id);
 			}
-			return true;
-		});
-	}
-	/**
-	* Removes bindings by token or by binding id and synchronously releases cached instances.
-	*
-	* - `binding id` path removes one binding and its cache entry.
-	* - `token` path removes all owned bindings for that key at once.
-	*/
+			return b.id;
+		};
+		return new BindToBuilderImpl(token, commitBinding);
+	}
 	unbind(tokenOrId) {
-		this.invalidateDevValidationState();
-		if (typeof tokenOrId === "string") {
-			this.ownScopeManager.releaseByBindingId(tokenOrId);
-			this.ownRegistry.removeById(tokenOrId);
-			return;
+		this._assertNotDisposed();
+		this._unbindSync(tokenOrId);
+	}
+	_unbindSync(tokenOrId) {
+		const bindings = this._getBindingsForTokenOrId(tokenOrId);
+		for (const binding of bindings) {
+			this._registry.removeById(binding.id);
+			if (this._scope.hasSingleton(binding.id)) {
+				const instance = this._scope.getSingleton(binding.id);
+				this._scope.deleteSingleton(binding.id);
+				this._lifecycle.runDeactivationSync(binding, instance, this._getMetadataReader());
+			}
 		}
-		const owned = this.ownRegistry.get(tokenOrId);
-		if (owned !== void 0) for (const binding of owned) this.ownScopeManager.releaseBinding(binding);
-		this.ownRegistry.remove(tokenOrId);
 	}
-	/**
-	* Async counterpart of {@link unbind}; awaits deactivation hooks before registry removal.
-	*/
 	async unbindAsync(tokenOrId) {
-		this.invalidateDevValidationState();
-		if (typeof tokenOrId === "string") {
-			await this.ownScopeManager.releaseByBindingIdAsync(tokenOrId);
-			this.ownRegistry.removeById(tokenOrId);
-			return;
+		this._assertNotDisposed();
+		const bindings = this._getBindingsForTokenOrId(tokenOrId);
+		for (const binding of bindings) {
+			this._registry.removeById(binding.id);
+			if (this._scope.hasSingleton(binding.id)) {
+				const instance = this._scope.getSingleton(binding.id);
+				this._scope.deleteSingleton(binding.id);
+				await this._lifecycle.runDeactivation(binding, instance, this._getMetadataReader());
+			}
 		}
-		const owned = this.ownRegistry.get(tokenOrId);
-		if (owned !== void 0) for (const binding of owned) await this.ownScopeManager.releaseBindingAsync(binding);
-		this.ownRegistry.remove(tokenOrId);
-	}
-	/**
-	* Replaces all owned bindings for `token` and returns a fresh builder.
-	*
-	* Existing cached instances for the removed bindings are synchronously released first.
-	*/
+	}
+	unbindAll() {
+		this._assertNotDisposed();
+		const all = this._registry.clear();
+		for (const binding of all) if (this._scope.hasSingleton(binding.id)) {
+			const instance = this._scope.getSingleton(binding.id);
+			this._scope.deleteSingleton(binding.id);
+			this._lifecycle.runDeactivationSync(binding, instance, this._getMetadataReader());
+		}
+	}
+	async unbindAllAsync() {
+		this._assertNotDisposed();
+		const all = this._registry.clear();
+		for (const binding of all) if (this._scope.hasSingleton(binding.id)) {
+			const instance = this._scope.getSingleton(binding.id);
+			this._scope.deleteSingleton(binding.id);
+			await this._lifecycle.runDeactivation(binding, instance, this._getMetadataReader());
+		}
+	}
 	rebind(token) {
-		this.invalidateDevValidationState();
-		const owned = this.ownRegistry.get(token);
-		if (owned !== void 0) for (const binding of owned) this.ownScopeManager.releaseBinding(binding);
-		this.ownRegistry.remove(token);
-		return this.bind(token);
-	}
-	/**
-	* Registers bindings from synchronous modules. Re-loading a module already present on this
-	* container is a no-op (deduplication, spec §7.3 Phase 3). When {@link isDevelopmentOrTestEnvironment}
-	* is true, runs {@link validate} at most once after the registry changes.
-	*/
+		this._assertNotDisposed();
+		if (!this._registry.has(token)) throw new RebindUnboundTokenError(tokenName(token));
+		this._unbindSync(token);
+		return this._createBindToBuilder(token);
+	}
+	_getBindingsForTokenOrId(tokenOrId) {
+		if (typeof tokenOrId === "string") {
+			const b = this._registry.getById(tokenOrId);
+			return b !== void 0 ? [b] : [];
+		}
+		return [...this._registry.getAll(tokenOrId)];
+	}
 	load(...modules) {
-		this.invalidateDevValidationState();
-		for (const syncModule of modules) {
-			if (syncModule instanceof AsyncModule) throw new AsyncModuleLoadError(syncModule.name);
-			this.ensureSyncModuleLoaded(syncModule);
+		this._assertNotDisposed();
+		this._loadSyncModules(modules);
+	}
+	_loadSyncModules(modules) {
+		const toLoad = this._collectModuleDeps(modules);
+		for (const mod of toLoad) {
+			const ref = mod;
+			const existing = this._moduleRefs.get(ref);
+			if (existing !== void 0) {
+				this._moduleRefs.set(ref, existing + 1);
+				continue;
+			}
+			this._moduleRefs.set(ref, 1);
+			const builder = this._createModuleBuilder(ref);
+			mod._setup(builder);
 		}
-		this.maybeRunDevValidationOnce();
 	}
-	/**
-	* Like {@link load} but allows async modules. Re-loading is deduplicated the same way.
-	*/
+	_collectModuleDeps(modules) {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		const visit = (mod) => {
+			const ref = mod;
+			if (seen.has(ref)) return;
+			seen.add(ref);
+			result.push(mod);
+		};
+		for (const m of modules) visit(m);
+		return result;
+	}
 	async loadAsync(...modules) {
-		this.invalidateDevValidationState();
-		for (const moduleOrAsync of modules) if (moduleOrAsync instanceof AsyncModule) await this.ensureAsyncModuleLoaded(moduleOrAsync);
-		else this.ensureSyncModuleLoaded(moduleOrAsync);
-		this.maybeRunDevValidationOnce();
+		this._assertNotDisposed();
+		for (const mod of modules) await this._loadOneModuleAsync(mod);
+	}
+	async _loadOneModuleAsync(mod) {
+		const ref = mod;
+		const existing = this._moduleRefs.get(ref);
+		if (existing !== void 0) {
+			this._moduleRefs.set(ref, existing + 1);
+			return;
+		}
+		this._moduleRefs.set(ref, 1);
+		if (isSyncModule(mod)) {
+			const builder = this._createModuleBuilder(ref);
+			mod._setup(builder);
+		} else {
+			const importPromises = [];
+			const builder = this._createAsyncModuleBuilder(ref, importPromises);
+			await mod._setup(builder);
+			if (importPromises.length > 0) await Promise.all(importPromises);
+		}
+	}
+	_createModuleBuilder(moduleRef) {
+		return {
+			bind: (t) => this._createBindToBuilder(t, moduleRef),
+			import: (...mods) => {
+				this._loadSyncModules(mods);
+			}
+		};
+	}
+	_createAsyncModuleBuilder(moduleRef, importPromises) {
+		return {
+			bind: (t) => this._createBindToBuilder(t, moduleRef),
+			import: (...mods) => {
+				for (const mod of mods) importPromises.push(this._loadOneModuleAsync(mod));
+			}
+		};
 	}
 	unload(...modules) {
-		this.invalidateDevValidationState();
-		for (const module of modules) {
-			const ownedBindingIds = this.loadedModules.get(module);
-			if (ownedBindingIds === void 0) throw new InternalError(`Module "${module.name}" is not loaded on this container.`);
-			for (const bindingId of [...ownedBindingIds].reverse()) {
-				this.ownScopeManager.releaseByBindingId(bindingId);
-				this.ownRegistry.removeById(bindingId);
+		this._assertNotDisposed();
+		for (const mod of modules) this._unloadModuleSync(mod);
+	}
+	_unloadModuleSync(ref) {
+		const count = this._moduleRefs.get(ref) ?? 0;
+		if (count <= 1) {
+			this._moduleRefs.delete(ref);
+			const ids = this._moduleBindingIds.get(ref) ?? [];
+			this._moduleBindingIds.delete(ref);
+			for (const id of ids) {
+				const binding = this._registry.getById(id);
+				if (binding !== void 0) {
+					this._registry.removeById(id);
+					if (this._scope.hasSingleton(id)) {
+						const instance = this._scope.getSingleton(id);
+						this._scope.deleteSingleton(id);
+						this._lifecycle.runDeactivationSync(binding, instance, this._getMetadataReader());
+					}
+				}
 			}
-			this.loadedModules.delete(module);
-		}
+		} else this._moduleRefs.set(ref, count - 1);
 	}
 	async unloadAsync(...modules) {
-		this.invalidateDevValidationState();
-		for (const module of modules) {
-			const ownedBindingIds = this.loadedModules.get(module);
-			if (ownedBindingIds === void 0) throw new InternalError(`Module "${module.name}" is not loaded on this container.`);
-			for (const bindingId of [...ownedBindingIds].reverse()) {
-				await this.ownScopeManager.releaseByBindingIdAsync(bindingId);
-				this.ownRegistry.removeById(bindingId);
+		this._assertNotDisposed();
+		for (const mod of modules) await this._unloadModuleAsync(mod);
+	}
+	async _unloadModuleAsync(ref) {
+		const count = this._moduleRefs.get(ref) ?? 0;
+		if (count <= 1) {
+			this._moduleRefs.delete(ref);
+			const ids = this._moduleBindingIds.get(ref) ?? [];
+			this._moduleBindingIds.delete(ref);
+			for (const id of ids) {
+				const binding = this._registry.getById(id);
+				if (binding !== void 0) {
+					this._registry.removeById(id);
+					if (this._scope.hasSingleton(id)) {
+						const instance = this._scope.getSingleton(id);
+						this._scope.deleteSingleton(id);
+						await this._lifecycle.runDeactivation(binding, instance, this._getMetadataReader());
+					}
+				}
 			}
-			this.loadedModules.delete(module);
+		} else this._moduleRefs.set(ref, count - 1);
+	}
+	loadAutoRegistered(registry) {
+		this._assertNotDisposed();
+		const entries = registry.entries();
+		for (const { target, scope } of entries) {
+			const bb = this._createBindToBuilder(target).toSelf();
+			if (scope === "singleton") bb.singleton();
+			else if (scope === "scoped") bb.scoped();
+			else bb.transient();
 		}
+		return entries.length;
 	}
-	/**
-	* Resolves synchronously. Captive dependency (singleton holding scoped/transient) throws
-	* {@link ScopeViolationError} with binding ids and full resolution path. In dev/test, the first
-	* successful resolution also triggers a one-time static {@link validate} when not in production.
-	*/
-	resolve(key, hint) {
-		try {
-			return this.resolver.resolveRoot(key, hint);
-		} finally {
-			this.maybeRunDevValidationOnce();
-		}
+	onActivation(token, handler) {
+		this._assertNotDisposed();
+		this._lifecycle.registerActivation(token, handler);
 	}
-	/**
-	* Async variant of {@link resolve}; same dev/test validation and runtime scope enforcement.
-	*/
-	resolveAsync(key, hint) {
-		return this.resolver.resolveAsyncRoot(key, hint).finally(() => {
-			this.maybeRunDevValidationOnce();
-		});
-	}
-	/**
-	* Optional root resolution: returns `undefined` when the requested key is absent (or filtered out
-	* without a name/tag hint), while preserving normal errors for nested required dependencies.
-	*/
-	resolveOptional(key, hint) {
-		try {
-			return this.resolver.resolveOptionalRoot(key, hint);
-		} finally {
-			this.maybeRunDevValidationOnce();
-		}
+	onDeactivation(token, handler) {
+		this._assertNotDisposed();
+		this._lifecycle.registerDeactivation(token, handler);
+	}
+	resolve(token, hint) {
+		this._assertNotDisposed();
+		if (hint === void 0) return this._resolver.resolveFromContext(token, [], []);
+		return this._resolver.resolve(token, hint, [], []);
+	}
+	resolveAsync(token, hint) {
+		this._assertNotDisposed();
+		if (hint === void 0) return this._resolver.resolveAsyncFromContext(token, [], []);
+		return this._resolver.resolveAsync(token, hint, [], []);
 	}
-	/**
-	* Synchronously resolves every matching binding for a key.
-	* Returns an empty array when no binding exists.
-	*/
-	resolveAll(key, hint) {
-		try {
-			return this.resolver.resolveAllRoot(key, hint);
-		} finally {
-			this.maybeRunDevValidationOnce();
+	resolveOptional(token, hint) {
+		this._assertNotDisposed();
+		return this._resolver.resolveOptional(token, hint, [], []);
+	}
+	resolveOptionalAsync(token, hint) {
+		this._assertNotDisposed();
+		return this._resolver.resolveOptionalAsync(token, hint, [], []);
+	}
+	resolveAll(token, hint) {
+		this._assertNotDisposed();
+		return this._resolver.resolveAll(token, hint, [], []);
+	}
+	resolveAllAsync(token, hint) {
+		this._assertNotDisposed();
+		return this._resolver.resolveAllAsync(token, hint, [], []);
+	}
+	createChild() {
+		this._assertNotDisposed();
+		return new DefaultContainer(this);
+	}
+	async dispose() {
+		if (this._disposed) return;
+		this._disposed = true;
+		const reader = this._getMetadataReader();
+		for (const [id, instance] of this._scope.getAllSingletons()) {
+			const binding = this._registry.getById(id);
+			if (binding !== void 0) await this._lifecycle.runDeactivation(binding, instance, reader);
 		}
+		this._scope.clearAll();
+	}
+	[Symbol.asyncDispose]() {
+		return this.dispose();
+	}
+	[Symbol.dispose]() {
+		throw new SyncDisposalNotSupportedError();
 	}
-	/**
-	* Async variant of {@link resolveAll}: safe for multi-bindings that mix sync and async factories
-	* (spec §5.2).
-	*/
-	resolveAllAsync(key, hint) {
-		return this.resolver.resolveAllAsyncRoot(key, hint).finally(() => {
-			this.maybeRunDevValidationOnce();
-		});
-	}
-	/**
-	* Eagerly resolves every registered `singleton` binding, including `async-dynamic` factories.
-	*/
 	async initializeAsync() {
-		for (const registryKey of this.collectAllRegistryKeysInHierarchy()) {
-			const list = this.lookupBindings(registryKey);
-			if (list === void 0) continue;
-			for (const binding of list) {
-				if (binding.scope !== "singleton") continue;
-				const hint = resolveHintForBinding(binding);
-				await this.resolveAsync(registryKey, hint);
+		this._assertNotDisposed();
+		const allBindings = this._registry.allBindings();
+		for (const binding of allBindings) {
+			if (binding.kind === "alias") continue;
+			if (effectiveBindingScope(binding) === "singleton" && !this._scope.hasSingleton(binding.id)) {
+				if (binding.predicate !== void 0) continue;
+				if (binding.kind === "constant" && binding.onActivation === void 0) continue;
+				const slotHint = slotKeyToResolveOptions(binding.slot);
+				await this.resolveAsync(binding.token, slotHint);
 			}
 		}
 	}
-	/**
-	* Marks the dev/test one-shot validation as stale so the next resolve or load triggers it again.
-	* Called on every registry mutation (bind, unbind, rebind, load, unload).
-	*/
-	invalidateDevValidationState() {
-		this.devValidationRan = false;
-	}
-	/**
-	* Runs scope validation at most once per registry epoch when `NODE_ENV` is not `"production"`.
-	* Guards against repeated validation on successive resolves without intervening mutations.
-	*/
-	maybeRunDevValidationOnce() {
-		if (!isDevelopmentOrTestEnvironment()) return;
-		if (this.devValidationRan) return;
-		this.devValidationRan = true;
-		this.validate();
-	}
-	/**
-	* Validates static dependency scope rules: a singleton must not depend on scoped/transient
-	* class/factory/alias targets. Constant dependencies are always allowed.
-	*/
 	validate() {
-		validateScopeRules({
-			collectAllRegistryKeys: () => this.collectAllRegistryKeysInHierarchy(),
-			lookupBindings: (registryKey) => this.lookupBindings(registryKey),
-			getMetadataReader: () => this.metadataReader
-		});
-	}
-	/**
-	* Dev/debug snapshot of registered bindings and activation status (design spec §5.5).
-	*/
-	inspect() {
-		return this.createInspector().getSnapshot();
+		this._assertNotDisposed();
+		const reader = this._getMetadataReader();
+		const allBindings = this._registry.allBindings();
+		for (const binding of allBindings) {
+			if (binding.kind === "alias" || binding.kind === "constant" || binding.kind === "dynamic" || binding.kind === "dynamic-async") continue;
+			const scope = effectiveBindingScope(binding);
+			if (scope !== "singleton") continue;
+			const deps = this._getDepsForBinding(binding, reader);
+			for (const dep of deps) this._validateDep(tokenName(binding.token), scope, dep, [tokenName(binding.token)], reader);
+		}
 	}
-	/**
-	* Delegates canonical dependency-graph generation to {@link ContainerInspector}.
-	*/
-	generateDependencyGraph(options) {
-		return this.createInspector().generateDependencyGraph(options);
-	}
-	/**
-	* Registers every class collected by `@injectable({ autoRegister: true })`.
-	* Returns how many entries were processed.
-	*/
-	loadAutoRegistered() {
-		const entries = getAutoRegistered();
-		let count = 0;
-		for (const { implementationClass, scope } of entries) {
-			const builder = this.bind(implementationClass).toSelf();
-			switch (scope) {
-				case "singleton":
-					builder.singleton();
-					break;
-				case "scoped":
-					builder.scoped();
-					break;
-				default: builder.transient();
+	_getDepsForBinding(binding, reader) {
+		const result = [];
+		if (binding.kind === "class") {
+			const meta = reader.getConstructorMetadata(binding.target);
+			if (meta !== void 0) for (const param of meta.params) {
+				const depBindings = this._registry.getAll(param.token);
+				for (const db of depBindings) if (db.kind !== "alias") result.push({
+					token: param.token,
+					scope: effectiveBindingScope(db)
+				});
 			}
-			count++;
+		} else if (binding.kind === "resolved" || binding.kind === "resolved-async") for (const dep of binding.deps) {
+			const depBindings = this._registry.getAll(dep.token);
+			for (const db of depBindings) if (db.kind !== "alias") result.push({
+				token: dep.token,
+				scope: effectiveBindingScope(db)
+			});
+		}
+		return result;
+	}
+	_validateDep(consumerToken, consumerScope, dep, path, _reader) {
+		if (consumerScope === "singleton") {
+			if (dep.scope === "scoped" || dep.scope === "transient") throw new ScopeViolationError({
+				consumerToken,
+				consumerScope,
+				dependencyToken: tokenName(dep.token),
+				dependencyScope: dep.scope,
+				path
+			});
 		}
-		return count;
 	}
-	[Symbol.dispose]() {
-		throw new InternalError("Container disposal is async. Use `await using container = Container.create()` or call `await container.dispose()` instead of `using`.");
-	}
-	/**
-	* Constructs a {@link ContainerInspector} wired to this container's full hierarchy.
-	*/
-	createInspector() {
-		return new ContainerInspector({
-			collectAllRegistryKeys: () => this.collectAllRegistryKeysInHierarchy(),
-			lookupBindings: (token) => this.lookupBindings(token),
-			isBindingCached: (binding) => this.ownScopeManager.isBindingCached(binding),
-			metadataReader: this.metadataReader
-		});
-	}
-	/**
-	* Collects the union of all registry keys from this container and every ancestor.
-	* Deduplicates by reference equality (tokens are objects).
-	*/
-	collectAllRegistryKeysInHierarchy() {
-		const keys = /* @__PURE__ */ new Set();
-		this.accumulateRegistryKeysFromHierarchy(keys, this);
-		return [...keys];
-	}
-	/**
-	* Recursive helper: walks the parent chain bottom-up, adding each level's registry keys.
-	*/
-	accumulateRegistryKeysFromHierarchy(keys, container) {
-		if (container === void 0) return;
-		for (const entry of container.ownRegistry.listEntries()) keys.add(entry.key);
-		this.accumulateRegistryKeysFromHierarchy(keys, container.parent);
-	}
-	/**
-	* Child inherits parent bindings via lookup fallback and shares singleton instances,
-	* but receives an isolated scoped cache.
-	*/
-	createChild() {
-		const childRegistry = new BindingRegistry();
-		const childScope = this.ownScopeManager.createChildScope();
-		const holder = { current: void 0 };
-		const resolver = new DependencyResolver({
-			lookup: (token) => {
-				const current = holder.current;
-				if (current === void 0) throw new InternalError("child container is not initialized");
-				return current.lookupBindings(token);
-			},
-			scopeManager: childScope,
-			metadataReader: this.metadataReader
-		});
-		const child = new DefaultContainer(childRegistry, childScope, this, resolver, this.metadataReader);
-		holder.current = child;
-		return child;
-	}
-	/**
-	* Lookup helper with parent fallback: own bindings take precedence over parent bindings.
-	*/
+	has(token, hint) {
+		this._assertNotDisposed();
+		return this._inspector.has(token, hint, () => this._parent?.has(token, hint) ?? false);
+	}
+	hasOwn(token, hint) {
+		this._assertNotDisposed();
+		return this._inspector.hasOwn(token, hint);
+	}
 	lookupBindings(token) {
-		const own = this.ownRegistry.get(token);
-		if (own !== void 0 && own.length > 0) return own;
-		return this.parent?.lookupBindings(token);
+		this._assertNotDisposed();
+		return this._inspector.lookupBindings(token);
 	}
-	/**
-	* Disposes this container's scope manager and runs async deactivation hooks.
-	*/
-	async dispose() {
-		await this.ownScopeManager.disposeAsync();
+	inspect() {
+		this._assertNotDisposed();
+		return this._inspector.inspect();
 	}
-	/**
-	* Async-dispose protocol hook used by `await using`.
-	*/
-	[Symbol.asyncDispose]() {
-		return this.dispose();
+	generateDependencyGraph(options) {
+		this._assertNotDisposed();
+		return buildDependencyGraph(this._registry, this._getMetadataReader(), options, this._parent?._registry);
 	}
-	/**
-	* Returns a `bind` function scoped to a module. Registrations are tracked in
-	* {@link loadedModules} for {@link unload}.
-	*
-	* - **Last-wins** (replaces every binding for that token): `bind(token).to*(...)` with no
-	*   `whenNamed` / `whenTagged` / `when` **before** the `to*()` call.
-	* - **Multi-binding** (append): call `whenNamed`, `whenTagged`, and/or `when` **before** `to*()`
-	*   so the disambiguator exists at registration time — supports `resolveAll` and per-binding
-	*   hints in {@link Container.initializeAsync}.
-	*/
-	bindForModule(owner) {
-		return (token) => new BindingBuilder(token, owner.name, {
-			register: (built) => {
-				this.invalidateDevValidationState();
-				if (moduleBindingUsesMultiSlot(built)) this.ownRegistry.add(token, built);
-				else this.ownRegistry.replaceKeyLastWins(token, built, (removed) => {
-					this.ownScopeManager.releaseBinding(removed);
-				});
-				this.recordBindingForModule(owner, built.id);
-			},
-			update: (built) => {
-				this.invalidateDevValidationState();
-				this.ownRegistry.replaceById(built.id, built);
-			}
-		});
-	}
-	/**
-	* Appends a binding ID to the tracking list for `owner` so {@link unload} can remove it later.
-	*/
-	recordBindingForModule(owner, id) {
-		const list = this.loadedModules.get(owner);
-		if (list === void 0) {
-			this.loadedModules.set(owner, [id]);
-			return;
-		}
-		list.push(id);
+	_assertNotDisposed() {
+		if (this._disposed) throw new DisposedContainerError();
 	}
-	/**
-	* Creates the {@link ModuleBuilder} passed to a sync module's setup callback.
-	* The `import` method throws {@link InternalError} if an {@link AsyncModule} is passed.
-	*/
-	createSyncModuleBuilder(module) {
-		return {
-			import: (...deps) => {
-				for (const dep of deps) {
-					if (dep instanceof AsyncModule) throw new InternalError(`Module "${module.name}" cannot synchronously import async module "${dep.name}".`);
-					this.ensureSyncModuleLoaded(dep);
-				}
-			},
-			bind: this.bindForModule(module)
+};
+var BindToBuilderImpl = class {
+	constructor(_token, _commit) {
+		this._token = _token;
+		this._commit = _commit;
+	}
+	to(type) {
+		return new BindingBuilderImpl(this._token, {
+			kind: "class",
+			target: type,
+			scope: "transient"
+		}, this._commit);
+	}
+	toSelf() {
+		if (typeof this._token !== "function") throw new Error("toSelf() requires token to be a Constructor");
+		return new BindingBuilderImpl(this._token, {
+			kind: "class",
+			target: this._token,
+			scope: "transient"
+		}, this._commit);
+	}
+	toConstantValue(value) {
+		return new ConstantBindingBuilderImpl(this._token, value, this._commit);
+	}
+	toDynamic(factory) {
+		return new BindingBuilderImpl(this._token, {
+			kind: "dynamic",
+			factory,
+			scope: "transient"
+		}, this._commit);
+	}
+	toDynamicAsync(factory) {
+		return new BindingBuilderImpl(this._token, {
+			kind: "dynamic-async",
+			factory,
+			scope: "transient"
+		}, this._commit);
+	}
+	toResolved(factory, deps) {
+		const normalizedDeps = deps.map((d) => normalizeToDescriptor(d));
+		return new BindingBuilderImpl(this._token, {
+			kind: "resolved",
+			factory,
+			deps: normalizedDeps,
+			scope: "transient"
+		}, this._commit);
+	}
+	toResolvedAsync(factory, deps) {
+		const normalizedDeps = deps.map((d) => normalizeToDescriptor(d));
+		return new BindingBuilderImpl(this._token, {
+			kind: "resolved-async",
+			factory,
+			deps: normalizedDeps,
+			scope: "transient"
+		}, this._commit);
+	}
+	toAlias(target) {
+		return new AliasBindingBuilderImpl(this._token, target, this._commit);
+	}
+};
+var BindingBuilderImpl = class {
+	_slot;
+	_predicate;
+	_committed;
+	constructor(_token, _partial, _commit) {
+		this._token = _token;
+		this._partial = _partial;
+		this._commit = _commit;
+		this._slot = {
+			...DEFAULT_SLOT,
+			tags: []
 		};
+		this._doCommit();
+	}
+	_doCommit() {
+		const previousId = this._committed;
+		const binding = {
+			...this._partial,
+			id: generateBindingId(),
+			token: this._token,
+			slot: this._slot,
+			predicate: this._predicate
+		};
+		this._committed = this._commit(binding, previousId);
 	}
-	/**
-	* Creates the {@link AsyncModuleBuilder} and a companion `awaitImports` thunk.
-	* Async sub-imports are collected into `pendingImports` and flushed after the module's
-	* own setup returns — this avoids interleaving setup code with dependency loading.
-	*/
-	createAsyncModuleBuilder(module) {
-		const pendingImports = [];
-		return {
-			moduleBuilder: {
-				import: (...deps) => {
-					for (const dep of deps) if (dep instanceof AsyncModule) pendingImports.push(this.ensureAsyncModuleLoaded(dep));
-					else this.ensureSyncModuleLoaded(dep);
-				},
-				bind: this.bindForModule(module)
-			},
-			awaitImports: async () => {
-				if (pendingImports.length === 0) return;
-				await Promise.all(pendingImports);
-			}
+	when(predicate) {
+		this._predicate = predicate;
+		this._doCommit();
+		return this;
+	}
+	whenNamed(name) {
+		this._slot = {
+			...this._slot,
+			name
 		};
+		this._doCommit();
+		return this;
+	}
+	whenTagged(tag, value) {
+		const existing = [...this._slot.tags];
+		const idx = existing.findIndex(([k]) => k === tag);
+		if (idx !== -1) existing[idx] = [tag, value];
+		else existing.push([tag, value]);
+		this._slot = {
+			...this._slot,
+			tags: existing
+		};
+		this._doCommit();
+		return this;
+	}
+	whenDefault() {
+		return this;
+	}
+	singleton() {
+		const previousId = this._committed;
+		this._committed = void 0;
+		return new ScopeBuilderImpl(this._token, {
+			...this._partial,
+			scope: "singleton"
+		}, this._slot, this._predicate, this._commit, "singleton", previousId);
+	}
+	transient() {
+		const previousId = this._committed;
+		this._committed = void 0;
+		return new ScopeBuilderImpl(this._token, {
+			...this._partial,
+			scope: "transient"
+		}, this._slot, this._predicate, this._commit, "transient", previousId);
+	}
+	scoped() {
+		const previousId = this._committed;
+		this._committed = void 0;
+		return new ScopeBuilderImpl(this._token, {
+			...this._partial,
+			scope: "scoped"
+		}, this._slot, this._predicate, this._commit, "scoped", previousId);
+	}
+	id() {
+		return this._committed;
 	}
-	/**
-	* Loads a sync module if not already loaded. Detects circular module imports via
-	* {@link syncModuleStack} and throws {@link CircularDependencyError} with the full cycle path.
-	* The module is marked as loaded *before* its setup runs so that re-entrant imports are deduped.
-	*/
-	ensureSyncModuleLoaded(module) {
-		if (this.loadedModules.has(module)) return;
-		if (this.syncModuleStack.includes(module)) throw new CircularDependencyError([...this.syncModuleStack.map((stackedModule) => stackedModule.name), module.name]);
-		this.syncModuleStack.push(module);
-		try {
-			this.loadedModules.set(module, []);
-			const moduleBuilder = this.createSyncModuleBuilder(module);
-			module.runSyncSetup(moduleBuilder);
-		} finally {
-			this.syncModuleStack.pop();
-		}
+};
+var ScopeBuilderImpl = class {
+	_onActivation;
+	_onDeactivation;
+	_committed;
+	constructor(_token, _partial, _slot, _predicate, _commit, _scope, _initialPreviousId) {
+		this._token = _token;
+		this._partial = _partial;
+		this._slot = _slot;
+		this._predicate = _predicate;
+		this._commit = _commit;
+		this._scope = _scope;
+		this._initialPreviousId = _initialPreviousId;
+		this._doCommit();
+	}
+	_doCommit() {
+		const previousId = this._committed ?? this._initialPreviousId;
+		const binding = {
+			...this._partial,
+			id: generateBindingId(),
+			token: this._token,
+			slot: this._slot,
+			predicate: this._predicate,
+			onActivation: this._onActivation,
+			onDeactivation: this._onDeactivation
+		};
+		this._committed = this._commit(binding, previousId);
 	}
-	/**
-	* Async counterpart of {@link ensureSyncModuleLoaded}: loads the module's async setup,
-	* then flushes any pending async sub-imports collected during setup.
-	*/
-	async ensureAsyncModuleLoaded(asyncModule) {
-		if (this.loadedModules.has(asyncModule)) return;
-		if (this.asyncModuleStack.includes(asyncModule)) throw new CircularDependencyError([...this.asyncModuleStack.map((stackedAsyncModule) => stackedAsyncModule.name), asyncModule.name]);
-		this.asyncModuleStack.push(asyncModule);
-		try {
-			this.loadedModules.set(asyncModule, []);
-			const { moduleBuilder, awaitImports } = this.createAsyncModuleBuilder(asyncModule);
-			await asyncModule.runAsyncSetup(moduleBuilder);
-			await awaitImports();
-		} finally {
-			this.asyncModuleStack.pop();
-		}
+	onActivation(fn) {
+		this._onActivation = fn;
+		this._doCommit();
+		return this;
+	}
+	onDeactivation(fn) {
+		this._onDeactivation = fn;
+		this._doCommit();
+		return this;
+	}
+	id() {
+		return this._committed;
+	}
+};
+var ConstantBindingBuilderImpl = class {
+	_slot;
+	_predicate;
+	_onActivation;
+	_onDeactivation;
+	_committed;
+	constructor(_token, _value, _commit) {
+		this._token = _token;
+		this._value = _value;
+		this._commit = _commit;
+		this._slot = {
+			...DEFAULT_SLOT,
+			tags: []
+		};
+		this._doCommit();
+	}
+	_doCommit() {
+		const previousId = this._committed;
+		const binding = {
+			kind: "constant",
+			id: generateBindingId(),
+			token: this._token,
+			slot: this._slot,
+			predicate: this._predicate,
+			value: this._value,
+			scope: "singleton",
+			onActivation: this._onActivation,
+			onDeactivation: this._onDeactivation
+		};
+		this._committed = this._commit(binding, previousId);
+	}
+	when(predicate) {
+		this._predicate = predicate;
+		this._doCommit();
+		return this;
+	}
+	whenNamed(name) {
+		this._slot = {
+			...this._slot,
+			name
+		};
+		this._doCommit();
+		return this;
+	}
+	whenTagged(tag, value) {
+		const existing = [...this._slot.tags];
+		const idx = existing.findIndex(([k]) => k === tag);
+		if (idx !== -1) existing[idx] = [tag, value];
+		else existing.push([tag, value]);
+		this._slot = {
+			...this._slot,
+			tags: existing
+		};
+		this._doCommit();
+		return this;
+	}
+	whenDefault() {
+		return this;
+	}
+	onActivation(fn) {
+		this._onActivation = fn;
+		this._doCommit();
+		return this;
+	}
+	onDeactivation(fn) {
+		this._onDeactivation = fn;
+		this._doCommit();
+		return this;
+	}
+	id() {
+		return this._committed;
+	}
+};
+var AliasBindingBuilderImpl = class {
+	_slot;
+	_predicate;
+	_committed;
+	constructor(_token, _target, _commit) {
+		this._token = _token;
+		this._target = _target;
+		this._commit = _commit;
+		this._slot = {
+			...DEFAULT_SLOT,
+			tags: []
+		};
+		this._doCommit();
+	}
+	_doCommit() {
+		const previousId = this._committed;
+		const binding = {
+			kind: "alias",
+			id: generateBindingId(),
+			token: this._token,
+			slot: this._slot,
+			predicate: this._predicate,
+			target: this._target
+		};
+		this._committed = this._commit(binding, previousId);
+	}
+	when(predicate) {
+		this._predicate = predicate;
+		this._doCommit();
+		return this;
+	}
+	whenNamed(name) {
+		this._slot = {
+			...this._slot,
+			name
+		};
+		this._doCommit();
+		return this;
+	}
+	whenTagged(tag, value) {
+		const existing = [...this._slot.tags];
+		const idx = existing.findIndex(([k]) => k === tag);
+		if (idx !== -1) existing[idx] = [tag, value];
+		else existing.push([tag, value]);
+		this._slot = {
+			...this._slot,
+			tags: existing
+		};
+		this._doCommit();
+		return this;
+	}
+	whenDefault() {
+		return this;
+	}
+	id() {
+		return this._committed;
 	}
 };
-let Container;
-(function(_Container) {
-	function create() {
-		return DefaultContainer.create();
-	}
-	_Container.create = create;
-	function fromModules(...modules) {
-		const container = DefaultContainer.create();
+const Container = {
+	create() {
+		return new DefaultContainer();
+	},
+	fromModules(...modules) {
+		const container = new DefaultContainer();
 		container.load(...modules);
 		return container;
-	}
-	_Container.fromModules = fromModules;
-	async function fromModulesAsync(...modules) {
-		const container = DefaultContainer.create();
+	},
+	async fromModulesAsync(...modules) {
+		const container = new DefaultContainer();
 		await container.loadAsync(...modules);
 		return container;
 	}
-	_Container.fromModulesAsync = fromModulesAsync;
-})(Container || (Container = {}));
+};
 //#endregion
 export { Container };