@codefast/di 0.3.14-canary.1 → 0.3.14

package/dist/registry.mjs

@@ -1,95 +1,144 @@
+import { slotKeyEquals } from "./binding.mjs";
 //#region src/registry.ts
-/**
-* 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.
-*/
 var BindingRegistry = class {
-	/**
-	* Primary index: registry key → ordered binding list.
-	* Reference equality on the key (i.e. the same {@link Token} or {@link Constructor} object).
-	*/
-	bindingsByKey = /* @__PURE__ */ new Map();
-	/**
-	* Appends `binding` to the list for `key` (multi-binding: each call adds an entry).
-	*/
-	add(key, binding) {
-		const registryKey = key;
-		const nextBinding = binding;
-		const existing = this.bindingsByKey.get(registryKey);
-		const merged = existing === void 0 ? [nextBinding] : [...existing, nextBinding];
-		this.bindingsByKey.set(registryKey, merged);
+	_bindings = /* @__PURE__ */ new Map();
+	_byId = /* @__PURE__ */ new Map();
+	_simpleNamed = /* @__PURE__ */ new Map();
+	_fastDefault = /* @__PURE__ */ new Map();
+	/** Add or replace binding using slot-aware last-wins. */
+	add(binding) {
+		const key = binding.token;
+		let list = this._bindings.get(key);
+		if (list === void 0) {
+			list = [];
+			this._bindings.set(key, list);
+		}
+		if (!this._isPurePredicateBinding(binding)) {
+			const existingIndex = list.findIndex((b) => !this._isPurePredicateBinding(b) && slotKeyEquals(b.slot, binding.slot));
+			if (existingIndex !== -1) {
+				const old = list[existingIndex];
+				this._byId.delete(old.id);
+				list.splice(existingIndex, 1);
+			}
+		}
+		list.push(binding);
+		this._byId.set(binding.id, binding);
+		this._indexSimpleNamedBinding(key, binding);
+		this._refreshFastDefaultForToken(key);
 	}
-	/**
-	* Returns all bindings registered for `key`, or `undefined` if none exist.
-	*/
-	get(key) {
-		return this.bindingsByKey.get(key);
+	/** Remove all bindings for a token. Returns removed bindings. */
+	removeByToken(t) {
+		const key = t;
+		const list = this._bindings.get(key) ?? [];
+		this._bindings.delete(key);
+		this._simpleNamed.delete(key);
+		this._fastDefault.delete(key);
+		for (const b of list) this._byId.delete(b.id);
+		return list;
 	}
-	/**
-	* 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) {
-		this.bindingsByKey.delete(key);
+	/** Remove a specific binding by ID. Returns the removed binding or undefined. */
+	removeById(id) {
+		const binding = this._byId.get(id);
+		if (binding === void 0) return;
+		this._byId.delete(id);
+		const key = binding.token;
+		const list = this._bindings.get(key);
+		if (list !== void 0) {
+			const idx = list.findIndex((b) => b.id === id);
+			if (idx !== -1) list.splice(idx, 1);
+			this._deindexSimpleNamedBinding(key, binding);
+			if (list.length === 0) {
+				this._bindings.delete(key);
+				this._simpleNamed.delete(key);
+				this._fastDefault.delete(key);
+			} else this._refreshFastDefaultForToken(key);
+		}
+		return binding;
 	}
-	/**
-	* Returns owned registry rows (does not include parent containers).
-	*/
-	listEntries() {
-		return [...this.bindingsByKey.entries()].map(([key, bindings]) => ({
-			key,
-			bindings
-		}));
+	/** Get all bindings for a token. */
+	getAll(t) {
+		return this._bindings.get(t) ?? [];
 	}
-	/**
-	* Removes the single binding whose `id` matches, scanning all keys.
-	* Like {@link remove}, does **not** invoke a removal callback.
-	*/
-	removeById(id) {
-		for (const [registryKey, list] of [...this.bindingsByKey.entries()]) {
-			const filtered = list.filter((binding) => binding.id !== id);
-			if (filtered.length === list.length) continue;
-			if (filtered.length === 0) this.bindingsByKey.delete(registryKey);
-			else this.bindingsByKey.set(registryKey, filtered);
+	/** Get binding by ID. */
+	getById(id) {
+		return this._byId.get(id);
+	}
+	/** Check if any binding exists for token. */
+	has(t) {
+		const key = t;
+		const list = this._bindings.get(key);
+		return list !== void 0 && list.length > 0;
+	}
+	/** All bindings in the registry. */
+	allBindings() {
+		const result = [];
+		for (const list of this._bindings.values()) result.push(...list);
+		return result;
+	}
+	/** Remove all bindings. Returns all removed. */
+	clear() {
+		const all = this.allBindings();
+		this._bindings.clear();
+		this._byId.clear();
+		this._simpleNamed.clear();
+		this._fastDefault.clear();
+		return all;
+	}
+	getSimpleNamed(token, name) {
+		return this._simpleNamed.get(token)?.get(name);
+	}
+	getFastDefault(token) {
+		return this._fastDefault.get(token);
+	}
+	/** Summarize available slot strings for a token (for error messages). */
+	availableSlotStrings(t) {
+		return (this._bindings.get(t) ?? []).map((b) => {
+			const s = b.slot;
+			if (s.name === void 0 && s.tags.length === 0) return "default";
+			const parts = [];
+			if (s.name !== void 0) parts.push(`name:${s.name}`);
+			for (const [k, v] of s.tags) parts.push(`tag:${k}=${String(v)}`);
+			return parts.join(",");
+		});
+	}
+	_isPurePredicateBinding(binding) {
+		const slot = binding.slot;
+		const hasPredicate = binding.predicate !== void 0;
+		const hasConstraint = slot.name !== void 0 || slot.tags.length > 0;
+		return hasPredicate && !hasConstraint;
+	}
+	_indexSimpleNamedBinding(tokenKeyValue, binding) {
+		const slot = binding.slot;
+		if (slot.name === void 0 || slot.tags.length > 0) return;
+		let byName = this._simpleNamed.get(tokenKeyValue);
+		if (byName === void 0) {
+			byName = /* @__PURE__ */ new Map();
+			this._simpleNamed.set(tokenKeyValue, byName);
 		}
+		byName.set(slot.name, binding);
 	}
-	/**
-	* Swaps the binding with the given `id` in place, preserving its position in the list.
-	*/
-	replaceById(id, next) {
-		for (const [registryKey, list] of this.bindingsByKey.entries()) {
-			const index = list.findIndex((binding) => binding.id === id);
-			if (index === -1) continue;
-			const updated = [...list];
-			updated[index] = next;
-			this.bindingsByKey.set(registryKey, updated);
-			return;
+	_deindexSimpleNamedBinding(tokenKeyValue, binding) {
+		const slot = binding.slot;
+		if (slot.name === void 0 || slot.tags.length > 0) return;
+		const byName = this._simpleNamed.get(tokenKeyValue);
+		if (byName === void 0) return;
+		if (byName.get(slot.name)?.id === binding.id) {
+			byName.delete(slot.name);
+			if (byName.size === 0) this._simpleNamed.delete(tokenKeyValue);
 		}
 	}
-	/**
-	* 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(key, binding, onReplaced) {
-		const registryKey = key;
-		const nextBinding = binding;
-		const existing = this.bindingsByKey.get(registryKey);
-		if (existing !== void 0) for (const removed of existing) onReplaced(removed);
-		this.bindingsByKey.set(registryKey, [nextBinding]);
+	_refreshFastDefaultForToken(tokenKeyValue) {
+		const list = this._bindings.get(tokenKeyValue);
+		if (list === void 0 || list.length !== 1) {
+			this._fastDefault.delete(tokenKeyValue);
+			return;
+		}
+		const onlyBinding = list[0];
+		if (!(onlyBinding.slot.name === void 0 && onlyBinding.slot.tags.length === 0) || onlyBinding.predicate !== void 0) {
+			this._fastDefault.delete(tokenKeyValue);
+			return;
+		}
+		this._fastDefault.set(tokenKeyValue, onlyBinding);
 	}
 };
 //#endregion

package/dist/resolve-options.d.mts

@@ -0,0 +1,18 @@
+import { ResolveOptions } from "./types.mjs";
+import { SlotKey } from "./binding.mjs";
+
+//#region src/resolve-options.d.ts
+/**
+ * Builds a {@link ResolveOptions} safe for `exactOptionalPropertyTypes`:
+ * omits keys instead of assigning `undefined`.
+ */
+declare function injectableSlotToResolveOptions(slot: {
+  readonly name?: string;
+  readonly tags?: ReadonlyArray<readonly [string, unknown]>;
+}): ResolveOptions | undefined;
+/**
+ * Hint from a binding {@link SlotKey} (tags may be empty; omits when nothing to match).
+ */
+declare function slotKeyToResolveOptions(slot: SlotKey): ResolveOptions | undefined;
+//#endregion
+export { injectableSlotToResolveOptions, slotKeyToResolveOptions };

package/dist/resolve-options.mjs

@@ -0,0 +1,22 @@
+//#region src/resolve-options.ts
+/**
+* Builds a {@link ResolveOptions} safe for `exactOptionalPropertyTypes`:
+* omits keys instead of assigning `undefined`.
+*/
+function injectableSlotToResolveOptions(slot) {
+	const options = {};
+	if (slot.name !== void 0) options.name = slot.name;
+	if (slot.tags !== void 0) options.tags = slot.tags;
+	return options.name !== void 0 || options.tags !== void 0 ? options : void 0;
+}
+/**
+* Hint from a binding {@link SlotKey} (tags may be empty; omits when nothing to match).
+*/
+function slotKeyToResolveOptions(slot) {
+	const options = {};
+	if (slot.name !== void 0) options.name = slot.name;
+	if (slot.tags.length > 0) options.tags = slot.tags;
+	return options.name !== void 0 || options.tags !== void 0 ? options : void 0;
+}
+//#endregion
+export { injectableSlotToResolveOptions, slotKeyToResolveOptions };

package/dist/resolver.d.mts

@@ -1,197 +1,74 @@
+import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { RegistryKey } from "./registry.mjs";
-import { Binding, Constructor, ResolveHint } from "./binding.mjs";
-import { MetadataReader } from "./metadata/metadata-types.mjs";
+import { MaterializationFrame, ResolveOptions } from "./types.mjs";
+import { BindingRegistry } from "./registry.mjs";
 import { ScopeManager } from "./scope.mjs";
+import { MetadataReader } from "./metadata/metadata-types.mjs";
+import { Container } from "./container.mjs";
+import { LifecycleManager } from "./lifecycle.mjs";
 
 //#region src/resolver.d.ts
-/**
- * Dependencies injected into {@link DependencyResolver} at construction time.
- */
-type ResolverDependencies = {
-  /**
-   * Looks up all bindings registered for a given registry key (own + parent containers).
-   */
-  readonly lookup: (key: RegistryKey) => readonly Binding<unknown>[] | undefined;
-  /**
-   * Manages singleton/scoped instance caches and deactivation.
-   */
-  readonly scopeManager: ScopeManager;
-  /**
-   * Reads `@injectable()` and lifecycle metadata from constructors. Omit to disable decorator support.
-   */
-  readonly metadataReader?: MetadataReader;
-};
-/**
- * Stateless graph walker: selects a binding, checks for cycles and scope violations,
- * delegates instance caching to `ScopeManager`, and runs lifecycle hooks.
- *
- * Resolution algorithm (per token):
- * 1. Lookup all bindings for the registry key.
- * 2. Apply name/tag hint and `when()` constraint filtering.
- * 3. Circular-dependency check via a mutable `visiting` set (per call tree).
- * 4. Captive-dependency check via the `materializationStack`.
- * 5. Scope-cache hit → return cached instance.
- * 6. Scope-cache miss → `materialize` → `@postConstruct` → `onActivation` → cache.
- *
- * Used exclusively by `DefaultContainer`; not part of the public API.
- */
 declare class DependencyResolver {
-  private readonly deps;
-  constructor(deps: ResolverDependencies);
-  /**
-   * Entry point for synchronous single-binding resolution.
-   *
-   * @throws {@link TokenNotBoundError} — no binding registered for `key`, or a nested dependency is unbound.
-   * @throws {@link NoMatchingBindingError} — a name/tag `hint` was given for `key` but no binding matched it.
-   * @throws {@link InternalError} — multiple bindings matched for `key` after applying the hint (ambiguous).
-   * @throws {@link CircularDependencyError} — `key` or a nested token appears twice on the resolution stack.
-   * @throws {@link AsyncResolutionError} — an `async-dynamic` binding or async lifecycle/activation on the sync path.
-   * @throws {@link ScopeViolationError} — captive dependency (singleton → scoped/transient).
-   * @throws {@link MissingMetadataError} — `class` binding lacks injectable metadata when the reader requires it.
-   */
-  resolveRoot<Value>(key: Token<Value> | Constructor<Value>, hint?: ResolveHint): Value;
-  /**
-   * Entry point for async single-binding resolution. Awaits `async-dynamic` factories
-   * and async lifecycle hooks that would cause {@link AsyncResolutionError} on the sync path.
-   *
-   * @throws {@link TokenNotBoundError} — no binding registered for `key`, or a nested dependency is unbound.
-   * @throws {@link NoMatchingBindingError} — a name/tag `hint` was given for `key` but no binding matched it.
-   * @throws {@link InternalError} — multiple bindings matched for `key` after applying the hint (ambiguous).
-   * @throws {@link CircularDependencyError} — `key` or a nested token appears twice on the resolution stack.
-   * @throws {@link ScopeViolationError} — captive dependency (singleton → scoped/transient).
-   * @throws {@link MissingMetadataError} — `class` binding lacks injectable metadata when the reader requires it.
-   */
-  resolveAsyncRoot<Value>(key: Token<Value> | Constructor<Value>, hint?: ResolveHint): Promise<Value>;
-  /**
-   * Optional resolution for the **requested key only**: returns `undefined` when that key has no
-   * bindings or every candidate is filtered out **without** a name/tag hint — without throwing
-   * {@link TokenNotBoundError} for those cases. Instantiating the selected binding still runs the
-   * normal sync resolution path for nested dependencies; an unregistered transitive dependency
-   * throws {@link TokenNotBoundError} as usual.
-   *
-   * Behavioral rules:
-   * 1. If the registry key is completely unbound → returns `undefined`.
-   * 2. If no candidate survives constraint filtering (without a hint) → returns `undefined`.
-   * 3. If a name/tag hint was provided but no binding matches it → throws {@link NoMatchingBindingError}.
-   * 4. Still throws on: circular dependencies, async operations on the sync path,
-   *    scope violations, ambiguous multi-binding matches, and {@link TokenNotBoundError} when a
-   *    required nested dependency is unbound.
-   */
-  resolveOptionalRoot<Value>(key: Token<Value> | Constructor<Value>, hint?: ResolveHint): Value | undefined;
-  /**
-   * Resolves every matching binding for `key` synchronously into an array.
-   * Returns an empty array when no bindings exist (does not throw).
-   *
-   * @throws {@link AsyncResolutionError} — any candidate is `async-dynamic`.
-   * @throws {@link NoMatchingBindingError} — hint was specified but no binding matched it.
-   * @throws {@link TokenNotBoundError} — nested dependency unbound (same as {@link resolveRoot}).
-   * @throws {@link CircularDependencyError} — cycle while materializing a candidate.
-   * @throws {@link ScopeViolationError} — captive dependency during materialization.
-   * @throws {@link MissingMetadataError} — class binding lacks injectable metadata when required.
-   */
-  resolveAllRoot<Value>(key: Token<Value> | Constructor<Value>, hint?: ResolveHint): Value[];
-  /**
-   * Async counterpart of {@link resolveAllRoot}: resolves every matching binding for `key`,
-   * awaiting `async-dynamic` factories. Returns an empty array when no bindings exist.
-   *
-   * @throws {@link NoMatchingBindingError} — hint was specified but no binding matched it.
-   * @throws {@link TokenNotBoundError} — nested dependency unbound (same as {@link resolveAsyncRoot}).
-   * @throws {@link CircularDependencyError} — cycle while materializing a candidate.
-   * @throws {@link ScopeViolationError} — captive dependency during materialization.
-   * @throws {@link MissingMetadataError} — class binding lacks injectable metadata when required.
-   */
-  resolveAllAsyncRoot<Value>(key: Token<Value> | Constructor<Value>, hint?: ResolveHint): Promise<Value[]>;
-  /**
-   * Context-aware sync `resolveAll`: extends the current resolution path and preserves
-   * visiting/materialization stacks so nested multi-resolution participates in cycle and
-   * captive-dependency checks exactly like single-value {@link resolve}.
-   */
-  private resolveAll;
-  /**
-   * Async counterpart of {@link resolveAll}: keeps the current path and materialization stack
-   * so `when()` constraints and scope validation behave consistently for nested multi-resolution.
-   */
-  private resolveAllAsync;
-  /**
-   * Assembles the read-only {@link ConstraintContext} snapshot passed to `when()` predicates.
-   * Extracts the top-of-stack frame as `parent` and the rest as `ancestors`.
-   */
-  private buildConstraintContext;
-  /**
-   * Throws {@link ScopeViolationError} when the immediate consumer on the stack is a singleton
-   * and the dependency has `"scoped"` or `"transient"` lifetime (captive dependency).
-   * Constants are exempt — they have no scope cache.
-   */
-  private assertDependencyScopeAllowed;
-  /**
-   * Builds a {@link ResolutionContext} for use inside factories and lifecycle hooks.
-   * The `resolve` / `resolveAsync` / `resolveOptional` closures carry the current path and
-   * materialization stack forward so nested calls inherit captive-dependency checks.
-   */
-  private createContext;
-  /**
-   * Core synchronous resolution: lookup → filter → cycle check → scope check → instantiate.
-   * Called recursively when a binding's dependencies need resolution.
-   *
-   * @param key - Token or constructor being resolved.
-   * @param hint - Optional name/tag filter for multi-binding selection.
-   * @param pathLabels - Mutable label path accumulated during graph walk; extended in place.
-   * @param visiting - Registry keys currently on the call stack; used for circular-dependency detection.
-   * @param materializationStack - Bindings along the current construction chain; used to block singleton→scoped/transient.
-   */
-  private resolve;
-  /**
-   * Core async resolution: same pipeline as {@link resolve} but awaits `async-dynamic`
-   * factories and async lifecycle hooks instead of throwing {@link AsyncResolutionError}.
-   *
-   * @param key - Token or constructor being resolved.
-   * @param hint - Optional name/tag filter for multi-binding selection.
-   * @param pathLabels - Mutable label path accumulated during graph walk; extended in place.
-   * @param visiting - Registry keys currently on the call stack; used for circular-dependency detection.
-   * @param materializationStack - Same captive-dependency chain as {@link resolve}.
-   */
-  private resolveAsync;
-  /**
-   * Handles scope-cache lookup / storage and lifecycle hooks (`@postConstruct`, `onActivation`)
-   * around a synchronous call to {@link materialize}.
-   */
-  private instantiateBinding;
-  /**
-   * Async counterpart of {@link instantiateBinding}: delegates to {@link materializeAsync}
-   * and awaits `@postConstruct` and `onActivation` hooks.
-   */
-  private instantiateBindingAsync;
-  /**
-   * Duplicate captive-dependency guard applied at instantiation time (after scope-cache miss),
-   * checking the top of the materialization stack rather than the raw `ConstraintContext`.
-   */
-  private assertCaptiveDependencyFromMaterializationStack;
-  /**
-   * Synchronously produces the raw instance for a binding **without** touching the scope cache
-   * or running lifecycle hooks. The caller ({@link instantiateBinding}) wraps this with
-   * cache logic and post-construction hooks.
-   *
-   * Dispatches on `binding.kind`; throws {@link AsyncResolutionError} if the binding is
-   * `async-dynamic` or if a `dynamic` / `resolved` factory returns a Promise.
-   */
-  private materialize;
-  /**
-   * Async counterpart of {@link materialize}; awaits `async-dynamic` factories and
-   * recursively resolves `resolved`-binding dependencies with {@link resolveAsync}.
-   */
-  private materializeAsync;
-  /**
-   * Reads `@injectable()` constructor metadata and synchronously resolves each parameter,
-   * then calls `new ImplementationClass(...deps)`. Throws {@link MissingMetadataError} when
-   * the class has constructor parameters but no metadata.
-   */
-  private instantiateClassBinding;
-  /**
-   * Async counterpart of {@link instantiateClassBinding}: resolves constructor dependencies
-   * with {@link resolveAsync} so `async-dynamic` parameters are awaited in order.
-   */
-  private instantiateClassBindingAsync;
+  private readonly _registry;
+  private readonly _scope;
+  private readonly _lifecycle;
+  private readonly _metadataReader;
+  private readonly _container;
+  private readonly _parent;
+  private readonly _frameByBindingId;
+  private readonly _syncResolutionContextPool;
+  private readonly _deepCycleMarks;
+  private _deepCycleGen;
+  private _deepActiveLevels;
+  private _deepSyncCtx;
+  private _deepSyncCtxPath;
+  private _deepAsyncCtx;
+  private _deepAsyncCtxPath;
+  private _deepAsyncActiveLevels;
+  private readonly _classHasPostConstruct;
+  private readonly _classNeedsActiveContainer;
+  private readonly _classConstructorMetadata;
+  private readonly _activationNeedByBindingId;
+  private _activationCacheVersion;
+  constructor(_registry: BindingRegistry, _scope: ScopeManager, _lifecycle: LifecycleManager, _metadataReader: MetadataReader, _container: Container, _parent: DependencyResolver | undefined);
+  private _findBinding;
+  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: string[], materializationStack: MaterializationFrame[]): Value;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Value;
+  private _resolveBinding;
+  private _instantiateSync;
+  private _resolveClassDeps;
+  private _resolveDescriptorDeps;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Value | undefined;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Value[];
+  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: string[], materializationStack: MaterializationFrame[]): Promise<Value>;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Promise<Value>;
+  private _resolveBindingAsync;
+  private _instantiateAsync;
+  private _resolveClassDepsAsync;
+  private _resolveDescriptorDepsAsync;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Promise<Value | undefined>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Promise<Value[]>;
+  private _getAllBindingsFromChain;
+  private _getSimpleNamedBindingsFromChain;
+  private _getAvailableSlots;
+  private _makeConstraintContext;
+  private _matchesBindingFast;
+  private _matchesSlotFast;
+  private _getTokenName;
+  private _getConstructorMetadata;
+  private _instantiateClass;
+  private _matchesHintTag;
+  private _resolveTransientDynamicSyncFromContext;
+  private _resolveTransientDynamicSyncSlow;
+  private _resolveTransientDynamicAsyncFromContext;
+  private _resolveTransientDynamicAsyncSlow;
+  private _resolveCandidateSync;
+  private _resolveCandidateAsync;
+  private _getMaterializationFrame;
+  private _needsActivation;
+  private _refreshClassPostConstructCache;
+  private _requiresResolutionContext;
+  private _acquireSyncResolutionContext;
 }
 //#endregion
-export { DependencyResolver, ResolverDependencies };
+export { DependencyResolver };