@codefast/di 0.3.14-canary.1 → 0.3.14

package/dist/metadata/metadata-types.d.mts

@@ -1,79 +1,30 @@
+import { Constructor } from "../constructor-type.mjs";
 import { Token } from "../token.mjs";
-import { Constructor } from "../binding.mjs";
 
 //#region src/metadata/metadata-types.d.ts
-/**
- * Metadata written per `accessor` field decorated with `@inject`; collected into `Symbol.metadata`.
- */
-type AccessorInjectionMetadata = {
-  /** Accessor property name to inject after construction. */readonly name: string; /** Token/constructor resolved for this accessor. */
-  readonly token: Token<unknown> | Constructor<unknown>; /** Whether missing binding resolves to `undefined` instead of throwing. */
-  readonly optional: boolean; /** Optional name/tag filter forwarded to binding selection. */
-  readonly resolveHint?: {
-    /** Named-binding discriminator (`whenNamed`). */readonly name?: string; /** Tagged-binding discriminator (`whenTagged`). */
-    readonly tag?: readonly [tag: string, value: unknown];
-  };
-};
-/**
- * Lifecycle method names written by `@postConstruct()` / `@preDestroy()` into `Symbol.metadata`.
- */
-type LifecycleMetadata = {
-  /** Method name marked with `@postConstruct()`. */readonly postConstruct?: string; /** Method name marked with `@preDestroy()`. */
-  readonly preDestroy?: string;
-};
-/**
- * Per-parameter injection description collected by `@injectable()`.
- */
-type ParamMetadata = {
-  /** Zero-based constructor parameter index. */readonly index: number; /** Token/constructor used to resolve this parameter. */
-  readonly token: Token<unknown> | Constructor<unknown>; /** Whether missing binding resolves to `undefined`. */
-  readonly optional: boolean; /** Optional named-binding discriminator. */
-  readonly name?: string; /** Optional tagged-binding discriminator. */
-  readonly tag?: readonly [tag: string, value: unknown];
-  /**
-   * When true, the parameter receives every binding for `token` as an array (same semantics as
-   * `Container.resolveAll` / `ResolutionContext.resolveAll`), using `name` / `tag` as a filter when set.
-   */
-  readonly all?: boolean;
-};
-/**
- * Resolved form of an `inject()` / `optional()` call: token + optional flag + optional resolve hint.
- * Used both as a deps-array entry in `@injectable()` and as accessor-field injection metadata.
- */
-type InjectionDescriptor<Value = unknown> = {
-  /** Token/constructor to resolve. */readonly token: Token<Value> | Constructor<Value>; /** Whether unbound token should resolve as `undefined`. */
-  readonly optional: boolean; /** Optional named-binding discriminator. */
-  readonly name?: string; /** Optional tagged-binding discriminator. */
-  readonly tag?: readonly [tag: string, value: unknown]; /** When true, resolve every binding for {@link InjectionDescriptor.token} into an array. */
-  readonly all?: boolean;
-};
-/**
- * Constructor injection shape stored on the class `Symbol.metadata` object.
- */
-type ConstructorMetadata = {
-  /** Ordered constructor dependency descriptors. */readonly params: readonly ParamMetadata[];
-};
-/**
- * Abstraction for reading DI metadata without tying callers to `Symbol.metadata` directly.
- * The {@link DependencyResolver} uses this to instantiate `class` bindings and read lifecycle hooks.
- *
- * The default implementation is {@link SymbolMetadataReader}; consumers can supply a custom
- * reader (e.g. backed by a static config object) via `ResolverDependencies.metadataReader`.
- */
-type MetadataReader = {
-  /**
-   * Returns constructor parameter injection metadata for `implementationClass`, or `undefined`
-   * if the class has no own `@injectable()` metadata. When a {@link MetadataReader} is
-   * configured on the container, `undefined` here combined with `arity > 0` on the class
-   * causes {@link MissingMetadataError} during resolution; when no reader is configured, the
-   * resolver instantiates with zero arguments instead (see `DependencyResolver` class binding path).
-   */
-  getConstructorMetadata(implementationClass: Constructor<unknown>): ConstructorMetadata | undefined;
-  /**
-   * Returns lifecycle method names (`@postConstruct` / `@preDestroy`), or `undefined` if none.
-   * Optional: when absent the resolver skips lifecycle hooks entirely.
-   */
-  getLifecycleMetadata?(implementationClass: Constructor<unknown>): LifecycleMetadata | undefined;
-};
+interface ParamMetadata {
+  readonly index: number;
+  readonly token: Token<unknown> | Constructor;
+  readonly optional: boolean;
+  readonly multi: boolean;
+  readonly name?: string;
+  readonly tags?: ReadonlyArray<readonly [string, unknown]>;
+}
+interface ConstructorMetadata {
+  readonly params: readonly ParamMetadata[];
+}
+interface LifecycleMetadata {
+  readonly postConstruct: readonly string[];
+  readonly preDestroy: readonly string[];
+}
+/** Mutable buckets used while aggregating decorator metadata (same keys as {@link LifecycleMetadata}). */
+interface MutableLifecycleMetadata {
+  postConstruct: string[];
+  preDestroy: string[];
+}
+interface MetadataReader {
+  getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
+  getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined;
+}
 //#endregion
-export { AccessorInjectionMetadata, ConstructorMetadata, InjectionDescriptor, LifecycleMetadata, MetadataReader, ParamMetadata };
+export { ConstructorMetadata, LifecycleMetadata, MetadataReader, MutableLifecycleMetadata, ParamMetadata };

package/dist/metadata/symbol-metadata-reader.d.mts

@@ -1,32 +1,16 @@
-import { Constructor } from "../binding.mjs";
+import { Constructor } from "../constructor-type.mjs";
+import { InjectionDescriptor } from "../decorators/inject.mjs";
 import { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "./metadata-types.mjs";
 
 //#region src/metadata/symbol-metadata-reader.d.ts
-/**
- * Default {@link MetadataReader} implementation backed by TC39 `Symbol.metadata`.
- *
- * Constructor metadata (`@injectable()`) is read with `Object.hasOwn` to prevent
- * a subclass from silently inheriting a parent's dependency list — each class must
- * declare its own `@injectable()` decorator or be constructed with zero arguments.
- *
- * Lifecycle metadata (`@postConstruct` / `@preDestroy`) *is* inherited through the
- * prototype chain, matching the intent that a parent's lifecycle hook applies to children.
- */
 declare class SymbolMetadataReader implements MetadataReader {
-  /**
-   * Reads constructor param metadata written by `@injectable()`.
-   * Returns `undefined` if no own metadata is present on the class.
-   *
-   * @remarks
-   * Uses `Object.hasOwn` intentionally — TC39 `Symbol.metadata` prototype-chains from
-   * parent to child, so without this guard a subclass without `@injectable()` would
-   * silently inherit the parent's parameter list and inject the wrong dependency count.
-   */
-  getConstructorMetadata(implementationClass: Constructor<unknown>): ConstructorMetadata | undefined;
-  /**
-   * Reads lifecycle method names written by `@postConstruct()` / `@preDestroy()`. Inherits from parent classes.
-   */
-  getLifecycleMetadata(implementationClass: Constructor<unknown>): LifecycleMetadata | undefined;
+  getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
+  getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined;
+  getAccessorMetadata(target: Constructor): Array<{
+    key: string | symbol;
+    descriptor: InjectionDescriptor;
+  }> | undefined;
 }
+declare const defaultMetadataReader: SymbolMetadataReader;
 //#endregion
-export { SymbolMetadataReader };
+export { SymbolMetadataReader, defaultMetadataReader };

package/dist/metadata/symbol-metadata-reader.mjs

@@ -1,51 +1,38 @@
-import { CODEFAST_DI_CONSTRUCTOR_METADATA, CODEFAST_DI_LIFECYCLE_METADATA, decoratorMetadataObjectSymbol } from "./metadata-keys.mjs";
+import { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, LIFECYCLE_KEY, constructorMetadataMap, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "./metadata-keys.mjs";
 //#region src/metadata/symbol-metadata-reader.ts
-/**
-* Type guard — returns `true` when `value` has the shape of a {@link ConstructorMetadata} object.
-*/
-function isConstructorMetadata(value) {
-	if (typeof value !== "object" || value === null || !("params" in value)) return false;
-	return Array.isArray(value.params);
-}
-/**
-* Default {@link MetadataReader} implementation backed by TC39 `Symbol.metadata`.
-*
-* Constructor metadata (`@injectable()`) is read with `Object.hasOwn` to prevent
-* a subclass from silently inheriting a parent's dependency list — each class must
-* declare its own `@injectable()` decorator or be constructed with zero arguments.
-*
-* Lifecycle metadata (`@postConstruct` / `@preDestroy`) *is* inherited through the
-* prototype chain, matching the intent that a parent's lifecycle hook applies to children.
-*/
 var SymbolMetadataReader = class {
-	/**
-	* Reads constructor param metadata written by `@injectable()`.
-	* Returns `undefined` if no own metadata is present on the class.
-	*
-	* @remarks
-	* Uses `Object.hasOwn` intentionally — TC39 `Symbol.metadata` prototype-chains from
-	* parent to child, so without this guard a subclass without `@injectable()` would
-	* silently inherit the parent's parameter list and inject the wrong dependency count.
-	*/
-	getConstructorMetadata(implementationClass) {
-		const rawMetadata = implementationClass[decoratorMetadataObjectSymbol()];
-		if (typeof rawMetadata !== "object" || rawMetadata === null) return;
-		const metadataObject = rawMetadata;
-		if (!Object.hasOwn(metadataObject, "codefast/di:constructor-metadata:v1")) return;
-		const raw = metadataObject[CODEFAST_DI_CONSTRUCTOR_METADATA];
-		if (!isConstructorMetadata(raw)) return;
-		return raw;
+	getConstructorMetadata(target) {
+		const fromWeakMap = constructorMetadataMap.get(target);
+		if (fromWeakMap !== void 0) return fromWeakMap;
+		const own = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (own === void 0) return;
+		const meta = own.value;
+		if (!meta || typeof meta !== "object" || !Object.hasOwn(meta, INJECTABLE_KEY)) return;
+		return meta[INJECTABLE_KEY];
 	}
-	/**
-	* Reads lifecycle method names written by `@postConstruct()` / `@preDestroy()`. Inherits from parent classes.
-	*/
-	getLifecycleMetadata(implementationClass) {
-		const metadataObject = implementationClass[decoratorMetadataObjectSymbol()];
-		if (typeof metadataObject !== "object" || metadataObject === null) return;
-		const raw = metadataObject[CODEFAST_DI_LIFECYCLE_METADATA];
-		if (typeof raw !== "object" || raw === null) return;
-		return raw;
+	getLifecycleMetadata(target) {
+		const byConstructor = lifecycleByConstructorMetadataMap.get(target);
+		if (byConstructor !== void 0) return byConstructor;
+		const own = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (own !== void 0) {
+			const meta = own.value;
+			if (meta && typeof meta === "object" && Object.hasOwn(meta, LIFECYCLE_KEY)) return meta[LIFECYCLE_KEY];
+		}
+		const classMeta = target[Symbol.metadata];
+		if (classMeta !== void 0) {
+			const fromWeakMap = lifecycleMetadataMap.get(classMeta);
+			if (fromWeakMap !== void 0) return fromWeakMap;
+		}
+	}
+	getAccessorMetadata(target) {
+		const own = Object.getOwnPropertyDescriptor(target, Symbol.metadata);
+		if (own === void 0) return;
+		const meta = own.value;
+		if (!meta || typeof meta !== "object") return;
+		if (!Object.hasOwn(meta, INJECT_ACCESSOR_KEY)) return;
+		return meta[INJECT_ACCESSOR_KEY];
 	}
 };
+const defaultMetadataReader = new SymbolMetadataReader();
 //#endregion
-export { SymbolMetadataReader };
+export { SymbolMetadataReader, defaultMetadataReader };

package/dist/module.d.mts

@@ -1,104 +1,38 @@
+import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { BindingBuilder, Constructor } from "./binding.mjs";
+import { BindToBuilder } from "./binding.mjs";
 
 //#region src/module.d.ts
-/**
- * Builder passed to the setup callback of a synchronous {@link Module}.
- * Use `import()` to declare module dependencies (sync modules only —
- * passing an {@link AsyncModule} throws {@link InternalError}) and `bind()` to register tokens.
- *
- * **Single slot (last-wins)** — `bind(key).to*(...)` with no `whenNamed` / `whenTagged` / `when`
- * *before* the `to*()` call replaces all prior bindings for `key` from this module pass.
- *
- * **Multi-binding** — put at least one disambiguator *before* `to*()` (e.g.
- * `bind(key).whenNamed("a").to*(...)`, `whenTagged` before `to*()`, or `when` before `to*()`).
- * Each such line **appends** another binding so {@link Container.resolveAll} can return every
- * implementation. Use this order in modules; chaining `.to*(...).whenNamed()` only updates that
- * binding in place and does not stack multiple registrations across lines.
- */
-type ModuleBuilder = {
-  /**
-   * Declares synchronous module dependencies to load before/alongside current setup.
-   */
-  readonly import: (...modules: Module[]) => void;
-  /**
-   * Starts binding registration for a token/constructor within this module setup pass.
-   */
-  readonly bind: <Value>(key: Token<Value> | Constructor<Value>) => BindingBuilder<Value>;
-};
-/**
- * Builder passed to the setup callback of an {@link AsyncModule}.
- * Unlike {@link ModuleBuilder}, `import()` accepts both sync and async modules.
- * Async sub-imports are collected and awaited **after** the setup callback returns.
- */
-type AsyncModuleBuilder = {
-  /**
-   * Declares sync/async module dependencies to be loaded by the async module loader.
-   */
-  readonly import: (...modules: (Module | AsyncModule)[]) => void;
-  /**
-   * Starts binding registration for a token/constructor within this async module setup pass.
-   */
-  readonly bind: <Value>(key: Token<Value> | Constructor<Value>) => BindingBuilder<Value>;
-};
-/**
- * Immutable description of a bundle of bindings. A {@link Module} holds no runtime state and the
- * same instance may be loaded into any number of containers independently (spec §7.3).
- *
- * The owning container is responsible for tracking which modules have been loaded and which
- * binding ids each module produced; the module itself never sees a container reference.
- */
-declare class Module {
-  /**
-   * Human-readable label used in error messages, graph output, and module-cycle diagnostics.
-   */
+declare const SYNC_MODULE_BRAND: unique symbol;
+declare const ASYNC_MODULE_BRAND: unique symbol;
+interface SyncModule {
   readonly name: string;
-  /**
-   * The user-supplied setup callback; invoked exactly once per `load()` call.
-   */
-  private readonly syncSetup;
-  /**
-   * @internal Use {@link Module.create} instead.
-   */
-  private constructor();
-  /**
-   * Defines a synchronous module.
-   * @param name - Human-readable label used in error messages and debug output.
-   * @param setup - Callback that registers bindings via the {@link ModuleBuilder}.
-   */
-  static create(name: string, setup: (builder: ModuleBuilder) => void): Module;
-  /**
-   * Defines an async module — use when setup requires awaiting (e.g. reading config, dynamic imports).
-   * Load with {@link Container.loadAsync} or {@link Container.fromModulesAsync}.
-   */
-  static createAsync(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule;
-  /**
-   * @internal Invoked by the container while loading this module.
-   */
-  runSyncSetup(builder: ModuleBuilder): void;
+  readonly [SYNC_MODULE_BRAND]: true;
+  readonly _setup: (builder: ModuleBuilder) => void;
 }
-/**
- * An async module whose setup callback may `await` before registering bindings.
- * Prefer {@link Module.createAsync} over constructing this class directly.
- *
- * Load via `Container.loadAsync()` or `Container.fromModulesAsync()`;
- * passing an `AsyncModule` to the synchronous `Container.load()` throws
- * {@link AsyncModuleLoadError}.
- */
-declare class AsyncModule {
-  /**
-   * Human-readable label used in error messages and graph output.
-   */
+interface AsyncModule {
   readonly name: string;
-  /**
-   * The user-supplied async setup callback; invoked exactly once per `loadAsync()` call.
-   */
-  private readonly asyncSetup;
-  constructor(name: string, asyncSetup: (builder: AsyncModuleBuilder) => Promise<void>);
-  /**
-   * @internal Invoked by the container while loading this module.
-   */
-  runAsyncSetup(builder: AsyncModuleBuilder): Promise<void>;
+  readonly [ASYNC_MODULE_BRAND]: true;
+  readonly _setup: (builder: AsyncModuleBuilder) => Promise<void>;
+}
+interface ModuleBuilder {
+  bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+  import(...modules: SyncModule[]): void;
+}
+interface AsyncModuleBuilder {
+  bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+  import(...modules: Array<SyncModule | AsyncModule>): void;
 }
+declare const SyncModule: {
+  create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule;
+};
+declare const AsyncModule: {
+  create(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule;
+};
+declare const Module: {
+  create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule;
+  createAsync(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule;
+};
+declare function isSyncModule(m: SyncModule | AsyncModule): m is SyncModule;
 //#endregion
-export { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder };
+export { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule, isSyncModule };

package/dist/module.mjs

@@ -1,76 +1,30 @@
 //#region src/module.ts
-/**
-* Immutable description of a bundle of bindings. A {@link Module} holds no runtime state and the
-* same instance may be loaded into any number of containers independently (spec §7.3).
-*
-* The owning container is responsible for tracking which modules have been loaded and which
-* binding ids each module produced; the module itself never sees a container reference.
-*/
-var Module = class Module {
-	/**
-	* Human-readable label used in error messages, graph output, and module-cycle diagnostics.
-	*/
-	name;
-	/**
-	* The user-supplied setup callback; invoked exactly once per `load()` call.
-	*/
-	syncSetup;
-	/**
-	* @internal Use {@link Module.create} instead.
-	*/
-	constructor(name, syncSetup) {
-		this.name = name;
-		this.syncSetup = syncSetup;
-	}
-	/**
-	* Defines a synchronous module.
-	* @param name - Human-readable label used in error messages and debug output.
-	* @param setup - Callback that registers bindings via the {@link ModuleBuilder}.
-	*/
-	static create(name, setup) {
-		return new Module(name, setup);
-	}
-	/**
-	* Defines an async module — use when setup requires awaiting (e.g. reading config, dynamic imports).
-	* Load with {@link Container.loadAsync} or {@link Container.fromModulesAsync}.
-	*/
-	static createAsync(name, setup) {
-		return new AsyncModule(name, setup);
-	}
-	/**
-	* @internal Invoked by the container while loading this module.
-	*/
-	runSyncSetup(builder) {
-		this.syncSetup(builder);
-	}
-};
-/**
-* An async module whose setup callback may `await` before registering bindings.
-* Prefer {@link Module.createAsync} over constructing this class directly.
-*
-* Load via `Container.loadAsync()` or `Container.fromModulesAsync()`;
-* passing an `AsyncModule` to the synchronous `Container.load()` throws
-* {@link AsyncModuleLoadError}.
-*/
-var AsyncModule = class {
-	/**
-	* Human-readable label used in error messages and graph output.
-	*/
-	name;
-	/**
-	* The user-supplied async setup callback; invoked exactly once per `loadAsync()` call.
-	*/
-	asyncSetup;
-	constructor(name, asyncSetup) {
-		this.name = name;
-		this.asyncSetup = asyncSetup;
-	}
-	/**
-	* @internal Invoked by the container while loading this module.
-	*/
-	async runAsyncSetup(builder) {
-		await this.asyncSetup(builder);
+const SYNC_MODULE_BRAND = Symbol("di:sync-module");
+const ASYNC_MODULE_BRAND = Symbol("di:async-module");
+const SyncModule = { create(name, setup) {
+	return {
+		name,
+		[SYNC_MODULE_BRAND]: true,
+		_setup: setup
+	};
+} };
+const AsyncModule = { create(name, setup) {
+	return {
+		name,
+		[ASYNC_MODULE_BRAND]: true,
+		_setup: setup
+	};
+} };
+const Module = {
+	create(name, setup) {
+		return SyncModule.create(name, setup);
+	},
+	createAsync(name, setup) {
+		return AsyncModule.create(name, setup);
 	}
 };
+function isSyncModule(m) {
+	return m[SYNC_MODULE_BRAND] === true;
+}
 //#endregion
-export { AsyncModule, Module };
+export { AsyncModule, Module, SyncModule, isSyncModule };

package/dist/registry.d.mts

@@ -1,69 +1,38 @@
+import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { Binding, BindingIdentifier, Constructor } from "./binding.mjs";
+import { BindingIdentifier } from "./types.mjs";
+import { Binding } from "./binding.mjs";
 
 //#region src/registry.d.ts
-/**
- * Key used to group {@link Binding} instances in the registry (reference equality for tokens).
- */
-type RegistryKey = Token<unknown> | Constructor<unknown>;
-/**
- * Flat, in-memory storage for {@link Binding} entries keyed by {@link RegistryKey}.
- * Each key maps to an ordered list of bindings (multi-binding support).
- *
- * The registry is a "dumb" store — it does not perform selection, scope caching, or
- * lifecycle management. Those concerns live in `DependencyResolver` and `ScopeManager`.
- *
- * Mutation styles:
- * - `add` — append-only; never removes existing entries.
- * - `replaceById` — swaps a single binding in place by ID; no removal callback.
- * - `remove` / `removeById` — delete entries **without** notifying callers; the caller
- *   is responsible for draining the scope cache before calling these.
- * - `replaceKeyLastWins` — replaces all bindings for a key with a single new one **and**
- *   invokes the `onReplaced` callback for each evicted binding, giving the caller
- *   (typically the container or scope manager) a chance to run deactivation.
- */
 declare class BindingRegistry {
-  /**
-   * Primary index: registry key → ordered binding list.
-   * Reference equality on the key (i.e. the same {@link Token} or {@link Constructor} object).
-   */
-  private readonly bindingsByKey;
-  /**
-   * Appends `binding` to the list for `key` (multi-binding: each call adds an entry).
-   */
-  add<Value>(key: Token<Value> | Constructor<Value>, binding: Binding<Value>): void;
-  /**
-   * Returns all bindings registered for `key`, or `undefined` if none exist.
-   */
-  get<Value>(key: Token<Value> | Constructor<Value>): readonly Binding<Value>[] | undefined;
-  /**
-   * Removes all bindings for `key`. Does **not** invoke any callback — the caller must
-   * drain the scope cache (run deactivation) for the affected bindings before calling this.
-   */
-  remove(key: RegistryKey): void;
-  /**
-   * Returns owned registry rows (does not include parent containers).
-   */
-  listEntries(): readonly {
-    key: RegistryKey;
-    bindings: readonly Binding<unknown>[];
-  }[];
-  /**
-   * Removes the single binding whose `id` matches, scanning all keys.
-   * Like {@link remove}, does **not** invoke a removal callback.
-   */
-  removeById(id: BindingIdentifier): void;
-  /**
-   * Swaps the binding with the given `id` in place, preserving its position in the list.
-   */
-  replaceById(id: BindingIdentifier, next: Binding<unknown>): void;
-  /**
-   * Replaces all bindings for `key` with a single new binding (module "last-wins" semantics).
-   * Unlike {@link remove} / {@link removeById}, this method invokes `onReplaced` for every
-   * evicted binding **before** inserting the replacement, giving the caller (e.g. the
-   * container's scope manager) a chance to release cached instances and run deactivation hooks.
-   */
-  replaceKeyLastWins<Value>(key: Token<Value> | Constructor<Value>, binding: Binding<Value>, onReplaced: (removed: Binding<unknown>) => void): void;
+  private readonly _bindings;
+  private readonly _byId;
+  private readonly _simpleNamed;
+  private readonly _fastDefault;
+  /** Add or replace binding using slot-aware last-wins. */
+  add(binding: Binding): void;
+  /** Remove all bindings for a token. Returns removed bindings. */
+  removeByToken(t: Token<unknown> | Constructor): Binding[];
+  /** Remove a specific binding by ID. Returns the removed binding or undefined. */
+  removeById(id: BindingIdentifier): Binding | undefined;
+  /** Get all bindings for a token. */
+  getAll(t: Token<unknown> | Constructor): readonly Binding[];
+  /** Get binding by ID. */
+  getById(id: BindingIdentifier): Binding | undefined;
+  /** Check if any binding exists for token. */
+  has(t: Token<unknown> | Constructor): boolean;
+  /** All bindings in the registry. */
+  allBindings(): readonly Binding[];
+  /** Remove all bindings. Returns all removed. */
+  clear(): readonly Binding[];
+  getSimpleNamed(token: Token<unknown> | Constructor, name: string): Binding | undefined;
+  getFastDefault(token: Token<unknown> | Constructor): Binding | undefined;
+  /** Summarize available slot strings for a token (for error messages). */
+  availableSlotStrings(t: Token<unknown> | Constructor): string[];
+  private _isPurePredicateBinding;
+  private _indexSimpleNamedBinding;
+  private _deindexSimpleNamedBinding;
+  private _refreshFastDefaultForToken;
 }
 //#endregion
-export { BindingRegistry, RegistryKey };
+export { BindingRegistry };