@codefast/di 0.3.14-canary.1 → 0.3.14

package/dist/binding.mjs

@@ -1,337 +1,24 @@
-import { InternalError } from "./errors.mjs";
 //#region src/binding.ts
-/**
-* Allocates a new opaque binding identifier (used when `.id(...)` is not supplied).
-*/
-function createBindingIdentifier() {
-	return globalThis.crypto.randomUUID();
+function slotKeyEquals(a, b) {
+	if (a.name !== b.name) return false;
+	if (a.tags.length !== b.tags.length) return false;
+	for (const [tagKey, tagValue] of a.tags) if (!b.tags.some(([k, v]) => k === tagKey && Object.is(v, tagValue))) return false;
+	return true;
 }
-/**
-* Fluent builder for registering a single binding against a {@link Token} or {@link Constructor}.
-*
-* A builder has two phases:
-* 1. **Strategy selection** — exactly one `to*()` call (`to`, `toSelf`, `toConstantValue`,
-*    `toDynamic`, `toDynamicAsync`, `toResolved`, `toAlias`) that determines how the value is produced.
-* 2. **Refinement chain** — optional calls to `singleton()`, `transient()`, `scoped()`,
-*    `onActivation()`, `onDeactivation()`, `whenNamed()`, `whenTagged()`, `when()`, and `id()`.
-*
-* Calling a second `to*()` method throws {@link InternalError}.
-*
-* The builder is created by {@link Container.bind} or by `bind` on {@link ModuleBuilder}.
-* The container injects {@link RegistryCallbacks} so that every strategy selection and
-* refinement is immediately reflected in the live registry.
-*/
-var BindingBuilder = class {
-	/**
-	* Current resolution strategy; starts as `"unset"` until a `to*()` method is called.
-	*/
-	strategy = { type: "unset" };
-	/**
-	* Lifetime scope applied to the next binding snapshot; defaults to `"transient"`.
-	*/
-	scope = "transient";
-	/**
-	* True after an explicit `.singleton()` / `.transient()` / `.scoped()` call (prevents constant scope change).
-	*/
-	isScopeExplicit = false;
-	/**
-	* Pre-allocated binding ID set via `id(identifier)` before the first `to*()` call.
-	*/
-	explicitId;
-	/**
-	* Resolve-hint name filter set by `.whenNamed()`.
-	*/
-	bindingName;
-	/**
-	* Tag filters accumulated by successive `.whenTagged()` calls.
-	*/
-	tags = /* @__PURE__ */ new Map();
-	/**
-	* Custom constraint predicates accumulated by `.when()`; all must pass for this binding to be selected.
-	*/
-	constraintPredicates = [];
-	/**
-	* Latest `onActivation` hook provided by `.onActivation(...)`.
-	* Applied to emitted binding snapshots until replaced.
-	*/
-	onActivationHandler;
-	/**
-	* Latest `onDeactivation` hook provided by `.onDeactivation(...)`.
-	* Emitted only on builder variants that expose deactivation support.
-	*/
-	onDeactivationHandler;
-	/**
-	* Set when this binding was created inside a {@link Module} / {@link AsyncModule} setup callback.
-	*/
-	moduleId;
-	/**
-	* The most recently emitted {@link Binding} snapshot; `undefined` before the first `to*()` call.
-	*/
-	currentBinding;
-	/**
-	* Container-injected hooks that sync builder mutations into the live registry.
-	*/
-	callbacks;
-	constructor(bindingKey, moduleId, callbacks) {
-		this.bindingKey = bindingKey;
-		this.moduleId = moduleId;
-		this.callbacks = callbacks ?? {};
-	}
-	/**
-	* Binds the token to a concrete implementation class; the container constructs it on demand.
-	*/
-	to(implementationClass) {
-		this.registerWithStrategy({
-			type: "class",
-			implementationClass
-		});
-		return this;
-	}
-	/**
-	* Binds the class key to itself — only valid when the key is a constructor.
-	*/
-	toSelf() {
-		if (typeof this.bindingKey !== "function") throw new InternalError("toSelf() requires the binding key to be a constructor; use bind(SomeClass) or call to(Class) instead.");
-		this.registerWithStrategy({
-			type: "class",
-			implementationClass: this.bindingKey
-		});
-		return this;
-	}
-	/**
-	* Binds the token to a pre-existing value; always resolved as singleton, no construction.
-	*/
-	toConstantValue(value) {
-		this.scope = "singleton";
-		this.registerWithStrategy({
-			type: "constant",
-			value
-		});
-		return this;
-	}
-	/**
-	* Binds to a synchronous factory; `ctx` provides nested resolution within the same path.
-	*/
-	toDynamic(factory) {
-		this.registerWithStrategy({
-			type: "dynamic",
-			factory
-		});
-		return this;
-	}
-	/**
-	* Binds to an async factory; must be resolved via `resolveAsync` / `resolveAllAsync`.
-	*/
-	toDynamicAsync(factory) {
-		this.registerWithStrategy({
-			type: "async-dynamic",
-			factory
-		});
-		return this;
-	}
-	/**
-	* Binds to a factory whose dependencies are declared explicitly in `deps` and pre-resolved by
-	* the container before the factory is called — no `ResolutionContext` needed inside the factory.
-	*/
-	toResolved(factory, deps) {
-		this.registerWithStrategy({
-			type: "resolved",
-			factory,
-			dependencyTokens: deps
-		});
-		return this;
-	}
-	/**
-	* Redirects resolution to `targetToken`; the container resolves whatever is bound there.
-	*/
-	toAlias(targetToken) {
-		this.registerWithStrategy({
-			type: "alias",
-			targetToken
-		});
-		return this;
-	}
-	/**
-	* One instance per container; supports `onDeactivation`.
-	*/
-	singleton() {
-		this.assertScopeMutable();
-		this.scope = "singleton";
-		this.isScopeExplicit = true;
-		this.refreshRegisteredBinding();
-		return this;
-	}
-	/**
-	* New instance on every resolution (default scope).
-	*/
-	transient() {
-		this.assertScopeMutable();
-		this.scope = "transient";
-		this.isScopeExplicit = true;
-		this.refreshRegisteredBinding();
-		return this;
-	}
-	/**
-	* One instance per child container scope.
-	*/
-	scoped() {
-		this.assertScopeMutable();
-		this.scope = "scoped";
-		this.isScopeExplicit = true;
-		this.refreshRegisteredBinding();
-		return this;
-	}
-	/**
-	* Called with the resolved instance after construction; the return value replaces the instance.
-	*/
-	onActivation(handler) {
-		this.onActivationHandler = handler;
-		this.refreshRegisteredBinding();
-		return this;
-	}
-	/**
-	* @internal Keep public for runtime correctness; hidden from transient/scoped builders via type aliases.
-	*/
-	onDeactivation(handler) {
-		this.onDeactivationHandler = handler;
-		this.refreshRegisteredBinding();
-		return this;
-	}
-	/**
-	* This binding only resolves when the caller passes `{ name }` as the resolve hint.
-	*/
-	whenNamed(name) {
-		this.bindingName = name;
-		this.refreshRegisteredBinding();
-		return this;
-	}
-	/**
-	* This binding only resolves when the caller passes `{ tag: [tag, tagValue] }` as the resolve hint.
-	*/
-	whenTagged(tag, tagValue) {
-		this.tags.set(tag, tagValue);
-		this.refreshRegisteredBinding();
-		return this;
-	}
-	/**
-	* Adds a custom predicate; all predicates must pass for the binding to be selected.
-	*/
-	when(constraint) {
-		this.constraintPredicates.push(constraint);
-		this.refreshRegisteredBinding();
-		return this;
-	}
-	id(identifier) {
-		if (this.currentBinding !== void 0) {
-			if (identifier !== void 0 && identifier !== this.currentBinding.id) throw new InternalError("Cannot change binding identifier after registration.");
-			return this.currentBinding.id;
-		}
-		if (identifier !== void 0) {
-			this.explicitId = identifier;
-			return this.explicitId;
-		}
-		this.explicitId = this.explicitId ?? createBindingIdentifier();
-		return this.explicitId;
-	}
-	/**
-	* Records the chosen strategy and emits the first {@link Binding} snapshot.
-	* Throws {@link InternalError} if a strategy was already selected (double `to*()` call).
-	*/
-	registerWithStrategy(next) {
-		if (this.strategy.type !== "unset") throw new InternalError("A binding strategy was already selected; only one to*(...) chain is allowed per builder.");
-		this.strategy = next;
-		const bindingId = this.id();
-		const binding = this.createBinding(bindingId, next);
-		this.currentBinding = binding;
-		this.callbacks.register?.(binding);
-	}
-	/**
-	* Re-creates the {@link Binding} snapshot from the current builder state and pushes
-	* the update to the registry. No-op if no strategy has been set yet.
-	*/
-	refreshRegisteredBinding() {
-		if (this.currentBinding === void 0 || this.strategy.type === "unset") return;
-		const next = this.createBinding(this.currentBinding.id, this.strategy);
-		this.currentBinding = next;
-		this.callbacks.update?.(next);
-	}
-	/**
-	* Guards against calling `.singleton()` / `.transient()` / `.scoped()` on a constant binding,
-	* which is locked to `"singleton"` scope by invariant.
-	*/
-	assertScopeMutable() {
-		if (this.strategy.type === "constant") throw new InternalError("Constant bindings are always singleton and do not support scope changes.");
-	}
-	/**
-	* Produces an immutable {@link Binding} snapshot from the current builder fields.
-	* Called by both {@link registerWithStrategy} and {@link refreshRegisteredBinding}.
-	*/
-	createBinding(id, strategy) {
-		const constraint = this.constraintPredicates.length === 0 ? void 0 : (ctx) => this.constraintPredicates.every((predicate) => predicate(ctx));
-		const lifecycle = {
-			bindingName: this.bindingName,
-			tags: new Map(this.tags),
-			onActivation: this.onActivationHandler,
-			onDeactivation: this.onDeactivationHandler,
-			constraint
-		};
-		const moduleFields = this.moduleId === void 0 ? {} : { moduleId: this.moduleId };
-		switch (strategy.type) {
-			case "constant": return {
-				...lifecycle,
-				...moduleFields,
-				id,
-				scope: "singleton",
-				kind: "constant",
-				value: strategy.value
-			};
-			case "class": return {
-				...lifecycle,
-				...moduleFields,
-				id,
-				scope: this.scope,
-				kind: "class",
-				implementationClass: strategy.implementationClass
-			};
-			case "dynamic": return {
-				...lifecycle,
-				...moduleFields,
-				id,
-				scope: this.scope,
-				kind: "dynamic",
-				factory: strategy.factory
-			};
-			case "async-dynamic": return {
-				...lifecycle,
-				...moduleFields,
-				id,
-				scope: this.scope,
-				kind: "async-dynamic",
-				factory: strategy.factory
-			};
-			case "resolved": return {
-				...lifecycle,
-				...moduleFields,
-				id,
-				scope: this.scope,
-				kind: "resolved",
-				dependencyTokens: strategy.dependencyTokens,
-				factory: strategy.factory
-			};
-			case "alias": return {
-				...lifecycle,
-				...moduleFields,
-				id,
-				scope: this.scope,
-				kind: "alias",
-				targetToken: strategy.targetToken
-			};
-			default: return strategy;
-		}
-	}
+const DEFAULT_SLOT = {
+	name: void 0,
+	tags: []
 };
-function bind(key) {
-	return new BindingBuilder(key, void 0);
+function slotKeyToString(slot) {
+	if (slot.name === void 0 && slot.tags.length === 0) return "default";
+	const parts = [];
+	if (slot.name !== void 0) parts.push(`name:${slot.name}`);
+	for (const [k, v] of slot.tags) parts.push(`tag:${k}=${String(v)}`);
+	return parts.join(",");
+}
+let _idCounter = 0;
+function generateBindingId() {
+	return String(++_idCounter);
 }
 //#endregion
-export { BindingBuilder, bind, createBindingIdentifier };
+export { DEFAULT_SLOT, generateBindingId, slotKeyEquals, slotKeyToString };

package/dist/constraints.d.mts

@@ -1,33 +1,15 @@
+import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { ConstraintContext, Constructor } from "./binding.mjs";
+import { ConstraintContext } from "./types.mjs";
 
 //#region src/constraints.d.ts
-/**
- * Constraint predicate factory: matches when the direct parent on the materialization stack
- * was registered under `registryKey`. Pass the result to {@link BindingBuilder.when}.
- *
- * @param registryKey - Token or constructor that the parent binding must be registered against.
- * @returns A predicate compatible with {@link BindingBuilder.when}.
- */
-declare function whenParentIs(registryKey: Token<unknown> | Constructor<unknown>): (ctx: ConstraintContext) => boolean;
-/**
- * Constraint predicate factory: matches when *any* ancestor on the materialization stack
- * (not just the immediate parent) was registered under `registryKey`.
- * Pass the result to {@link BindingBuilder.when}.
- *
- * @param registryKey - Token or constructor to search for across the full construction chain.
- * @returns A predicate compatible with {@link BindingBuilder.when}.
- */
-declare function whenAnyAncestorIs(registryKey: Token<unknown> | Constructor<unknown>): (ctx: ConstraintContext) => boolean;
-/**
- * Constraint predicate factory: matches when the immediate parent binding carries a tag
- * whose key is `tag` and whose value is reference-equal to `tagValue` (`Object.is`).
- * Pass the result to {@link BindingBuilder.when}.
- *
- * @param tag - Tag key to check on the parent binding.
- * @param tagValue - Expected value; compared via `Object.is`.
- * @returns A predicate compatible with {@link BindingBuilder.when}.
- */
-declare function whenTargetTagged(tag: string, tagValue: unknown): (ctx: ConstraintContext) => boolean;
+declare function whenParentIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenNoParentIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenNoAncestorIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenParentNamed(name: string): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorNamed(name: string): (ctx: ConstraintContext) => boolean;
+declare function whenParentTagged(tag: string, value: unknown): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorTagged(tag: string, value: unknown): (ctx: ConstraintContext) => boolean;
 //#endregion
-export { whenAnyAncestorIs, whenParentIs, whenTargetTagged };
+export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged };

package/dist/constraints.mjs

@@ -1,39 +1,35 @@
+import { tokenName } from "./token.mjs";
 //#region src/constraints.ts
-/**
-* Constraint predicate factory: matches when the direct parent on the materialization stack
-* was registered under `registryKey`. Pass the result to {@link BindingBuilder.when}.
-*
-* @param registryKey - Token or constructor that the parent binding must be registered against.
-* @returns A predicate compatible with {@link BindingBuilder.when}.
-*/
-function whenParentIs(registryKey) {
-	return (ctx) => ctx.parent?.registryKey === registryKey;
-}
-/**
-* Constraint predicate factory: matches when *any* ancestor on the materialization stack
-* (not just the immediate parent) was registered under `registryKey`.
-* Pass the result to {@link BindingBuilder.when}.
-*
-* @param registryKey - Token or constructor to search for across the full construction chain.
-* @returns A predicate compatible with {@link BindingBuilder.when}.
-*/
-function whenAnyAncestorIs(registryKey) {
-	return (ctx) => ctx.materializationStack.some((frame) => frame.registryKey === registryKey);
-}
-/**
-* Constraint predicate factory: matches when the immediate parent binding carries a tag
-* whose key is `tag` and whose value is reference-equal to `tagValue` (`Object.is`).
-* Pass the result to {@link BindingBuilder.when}.
-*
-* @param tag - Tag key to check on the parent binding.
-* @param tagValue - Expected value; compared via `Object.is`.
-* @returns A predicate compatible with {@link BindingBuilder.when}.
-*/
-function whenTargetTagged(tag, tagValue) {
-	return (ctx) => {
-		if (ctx.parent === void 0) return false;
-		return Object.is(ctx.parent.tags.get(tag), tagValue);
-	};
+function tokenNameOf(t) {
+	return tokenName(t);
+}
+function whenParentIs(t) {
+	const name = tokenNameOf(t);
+	return (ctx) => ctx.parent !== void 0 && ctx.parent.tokenName === name;
+}
+function whenNoParentIs(t) {
+	const name = tokenNameOf(t);
+	return (ctx) => ctx.parent === void 0 || ctx.parent.tokenName !== name;
+}
+function whenAnyAncestorIs(t) {
+	const name = tokenNameOf(t);
+	return (ctx) => ctx.ancestors.some((f) => f.tokenName === name);
+}
+function whenNoAncestorIs(t) {
+	const name = tokenNameOf(t);
+	return (ctx) => ctx.ancestors.every((f) => f.tokenName !== name);
+}
+function whenParentNamed(name) {
+	return (ctx) => ctx.parent !== void 0 && ctx.parent.slot.name === name;
+}
+function whenAnyAncestorNamed(name) {
+	return (ctx) => ctx.ancestors.some((f) => f.slot.name === name);
+}
+function whenParentTagged(tag, value) {
+	return (ctx) => ctx.parent !== void 0 && ctx.parent.slot.tags.some(([t, v]) => t === tag && Object.is(v, value));
+}
+function whenAnyAncestorTagged(tag, value) {
+	return (ctx) => ctx.ancestors.some((f) => f.slot.tags.some(([t, v]) => t === tag && Object.is(v, value)));
 }
 //#endregion
-export { whenAnyAncestorIs, whenParentIs, whenTargetTagged };
+export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged };

package/dist/constructor-type.d.mts

@@ -0,0 +1,17 @@
+//#region src/constructor-type.d.ts
+/**
+ * A class (newable) that produces `Value`. Rest parameters are `never[]` so
+ * real classes with typed constructors remain assignable under
+ * `strictFunctionTypes` (unlike `unknown[]`, which is not assignable from
+ * narrower parameter types). Runtime construction still uses the real shape;
+ * this alias is the DI “class token” surface only.
+ */
+type Constructor<Value = unknown> = new (...args: never[]) => Value;
+/**
+ * Class constructor as invoked by the resolver after metadata-driven
+ * resolution of `unknown[]` dependencies — separate from {@link Constructor},
+ * which is the public assignable class token.
+ */
+type ConstructorInvocation = new (...args: unknown[]) => unknown;
+//#endregion
+export { Constructor, ConstructorInvocation };

package/dist/constructor-type.mjs

@@ -0,0 +1 @@
+export {};

package/dist/container.d.mts

@@ -1,132 +1,53 @@
+import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { RegistryKey } from "./registry.mjs";
-import { Binding, BindingBuilder, BindingIdentifier, Constructor, ResolveHint } from "./binding.mjs";
-import { ContainerGraphJson, ContainerSnapshot, GraphOptions } from "./inspector.mjs";
-import { AsyncModule, Module } from "./module.mjs";
+import { ActivationHandler, BindingIdentifier, DeactivationHandler, ResolveOptions } from "./types.mjs";
+import { BindToBuilder } from "./binding.mjs";
+import { AsyncModule, SyncModule } from "./module.mjs";
+import { BindingSnapshot, ContainerSnapshot } from "./inspector.mjs";
+import { ContainerGraphJson, GraphOptions } from "./dependency-graph.mjs";
+import { AutoRegisterRegistry } from "./decorators/injectable.mjs";
 
 //#region src/container.d.ts
-/**
- * Union of sync and async modules accepted by `loadAsync` / `unloadAsync`.
- */
-type ModuleLike = Module | AsyncModule;
-/**
- * Public contract for an IoC container (registry, modules, resolution, lifecycle).
- * Construct instances with {@link Container.create} or {@link Container.fromModules}.
- *
- * Implements {@link AsyncDisposable} so `await using container = Container.create()` runs
- * {@link Container.dispose} automatically at scope exit (TC39 Explicit Resource Management).
- */
-interface Container extends AsyncDisposable {
-  /**
-   * Starts a fluent binding builder for the given token or constructor.
-   */
-  bind<Value>(token: Token<Value> | Constructor<Value>): BindingBuilder<Value>;
-  /**
-   * Removes all existing bindings for the token (with sync deactivation) then starts a fresh builder.
-   */
-  rebind<Value>(token: Token<Value> | Constructor<Value>): BindingBuilder<Value>;
-  /**
-   * Removes all bindings for a token or a single binding by its {@link BindingIdentifier}; runs sync deactivation.
-   */
-  unbind(tokenOrId: RegistryKey | BindingIdentifier): void;
-  /**
-   * Same as {@link unbind} but awaits async `onDeactivation` handlers before removing.
-   */
-  unbindAsync(tokenOrId: RegistryKey | BindingIdentifier): Promise<void>;
-  /**
-   * Returns `true` if at least one binding exists for `token`, optionally filtered by `hint`.
-   */
-  has(token: RegistryKey, hint?: ResolveHint): boolean;
-  /**
-   * Resolves the token synchronously. Throws {@link AsyncResolutionError} if any binding in the chain is async.
-   */
-  resolve<Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveHint): Value;
-  /**
-   * Resolves the token, awaiting any async factory in the chain. Safe for both sync and async bindings.
-   */
-  resolveAsync<Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveHint): Promise<Value>;
-  /**
-   * Resolves all bindings registered for the token (multi-binding). Throws {@link AsyncResolutionError} if any is async.
-   */
-  resolveAll<Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveHint): Value[];
-  /**
-   * Async variant of {@link resolveAll} — safe when the multi-binding set contains async factories.
-   */
-  resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveHint): Promise<Value[]>;
-  /**
-   * Resolves the token or returns `undefined` if no binding is registered (never throws on missing).
-   */
-  resolveOptional<Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveHint): Value | undefined;
-  /**
-   * Registers bindings from one or more synchronous modules. Re-loading a module already present is a no-op.
-   */
-  load(...modules: Module[]): void;
-  /**
-   * Registers bindings from sync and/or async modules, awaiting each async setup in sequence.
-   */
-  loadAsync(...modules: ModuleLike[]): Promise<void>;
-  /**
-   * Removes all bindings contributed by the given modules; runs sync deactivation on released singletons.
-   */
-  unload(...modules: ModuleLike[]): void;
-  /**
-   * Same as {@link unload} but awaits async `onDeactivation` handlers.
-   */
-  unloadAsync(...modules: ModuleLike[]): Promise<void>;
-  /**
-   * Eagerly constructs every singleton binding so the first request is never cold.
-   */
+interface Container {
+  readonly isDisposed: boolean;
+  bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+  unbind(tokenOrId: Token<unknown> | Constructor | BindingIdentifier): void;
+  unbindAsync(tokenOrId: Token<unknown> | Constructor | BindingIdentifier): Promise<void>;
+  unbindAll(): void;
+  unbindAllAsync(): Promise<void>;
+  rebind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+  load(...modules: SyncModule[]): void;
+  loadAsync(...modules: Array<SyncModule | AsyncModule>): Promise<void>;
+  unload(...modules: SyncModule[]): void;
+  unloadAsync(...modules: Array<SyncModule | AsyncModule>): Promise<void>;
+  loadAutoRegistered(registry: AutoRegisterRegistry): number;
+  onActivation<const Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
+  onDeactivation<const Value>(token: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): void;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value[];
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value[]>;
+  createChild(): Container;
+  dispose(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+  [Symbol.dispose](): never;
   initializeAsync(): Promise<void>;
-  /**
-   * Scans {@link getAutoRegistered} entries and binds each to its declared scope. Returns the count added.
-   */
-  loadAutoRegistered(): number;
-  /**
-   * Checks for scope violations (captive dependencies). Throws {@link ScopeViolationError} on the first violation found.
-   */
   validate(): void;
-  /**
-   * Returns a debug snapshot of all registered bindings and their activation state.
-   */
+  has(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
+  hasOwn(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
+  lookupBindings<const Value>(token: Token<Value> | Constructor<Value>): readonly BindingSnapshot[];
   inspect(): ContainerSnapshot;
-  /**
-   * Returns the canonical dependency graph as typed JSON (`nodes` + `edges`).
-   */
   generateDependencyGraph(options?: GraphOptions): ContainerGraphJson;
-  /**
-   * Creates a child container that inherits bindings from this container without polluting its registry.
-   */
-  createChild(): Container;
-  /**
-   * @throws Always — container disposal is async; use `await using` or `await container.dispose()`.
-   */
-  [Symbol.dispose](): never;
-  /**
-   * Returns the raw binding list for a token without triggering resolution. `undefined` means no binding.
-   */
-  lookupBindings(token: RegistryKey): readonly Binding<unknown>[] | undefined;
-  /**
-   * Runs all `onDeactivation` hooks on active singletons and releases all caches.
-   */
-  dispose(): Promise<void>;
-  [Symbol.asyncDispose](): Promise<void>;
 }
-/**
- * Factory functions for {@link Container} instances (interface + namespace merge).
- */
-declare namespace Container {
-  /**
-   * Creates an empty container with no bindings.
-   */
-  function create(): Container;
-  /**
-   * Creates a container and immediately loads the given sync modules.
-   */
-  function fromModules(...modules: Module[]): Container;
-  /**
-   * Creates a container and awaits loading of sync and/or async modules.
-   */
-  function fromModulesAsync(...modules: (Module | AsyncModule)[]): Promise<Container>;
+interface ContainerStatic {
+  create(): Container;
+  fromModules(...modules: SyncModule[]): Container;
+  fromModulesAsync(...modules: Array<SyncModule | AsyncModule>): Promise<Container>;
 }
+declare const Container: ContainerStatic & {
+  create(): Container;
+};
 //#endregion
-export { Container };
+export { Container, ContainerStatic };