@codefast/di 0.8.1 → 0.10.0

package/dist/metadata/metadata-reader-token.js

@@ -4,4 +4,4 @@ import { token } from "#/core/token";
  *
  * @since 0.3.16-canary.0
  */
-export const MetadataReaderToken = token("MetadataReader");
+export const MetadataReaderToken = token("di:MetadataReader");

package/dist/resolution/cache/activation-need.d.ts

@@ -16,6 +16,8 @@ import type { ClassIntrospector } from "#/resolution/cache/class-introspector";
 export declare class ActivationNeedCache {
     #private;
     constructor(lifecycle: LifecycleManager, classes: ClassIntrospector, registry: BindingRegistry);
+    /** Whether an answer the early returns could not give has had to allocate the memo. */
+    get isMemoBuilt(): boolean;
     needsActivation<Value>(binding: Binding<Value>): boolean;
     /**
      * Settles a class binding's answer once its lifecycle metadata has actually been read, which

package/dist/resolution/cache/activation-need.js

@@ -4,7 +4,9 @@
  * @since 0.5.0-canary.8
  */
 export class ActivationNeedCache {
-    #needByBindingId = new Map();
+    // Allocated by the first answer the early returns cannot give, so a hook-free container that
+    // resolves no class or alias never pays for it.
+    #needByBindingId;
     #version = -1;
     #lifecycle;
     #classes;
@@ -14,10 +16,14 @@ export class ActivationNeedCache {
         this.#classes = classes;
         this.#registry = registry;
     }
+    /** Whether an answer the early returns could not give has had to allocate the memo. */
+    get isMemoBuilt() {
+        return this.#needByBindingId !== undefined;
+    }
     needsActivation(binding) {
         // The chain writes a binding's own hook in place with no version anything here can see, so it
         // is read fresh on every call; the memo covers only container hooks and lifecycle metadata.
-        if (binding.kind !== "alias" && binding.onActivation !== undefined) {
+        if (binding.kind !== "alias" && binding.activationHook !== undefined) {
             return true;
         }
         const lifecycleVersion = this.#lifecycle.activationVersion;
@@ -29,15 +35,16 @@ export class ActivationNeedCache {
         // The registry version evicts entries for binding ids a rebind has retired.
         const version = lifecycleVersion + this.#registry.version;
         if (this.#version !== version) {
-            this.#needByBindingId.clear();
+            this.#needByBindingId?.clear();
             this.#version = version;
         }
-        const cached = this.#needByBindingId.get(binding.id);
+        const memo = (this.#needByBindingId ??= new Map());
+        const cached = memo.get(binding.identifier);
         if (cached !== undefined) {
             return cached;
         }
         const needsActivation = binding.kind === "class" ? this.#classNeedsActivation(binding) : this.#nonClassNeedsActivation(binding);
-        this.#needByBindingId.set(binding.id, needsActivation);
+        memo.set(binding.identifier, needsActivation);
         return needsActivation;
     }
     /**
@@ -52,7 +59,7 @@ export class ActivationNeedCache {
             return needsActivation;
         }
         this.#classes.discoverPostConstruct(binding.target);
-        this.#needByBindingId.delete(binding.id);
+        this.#needByBindingId?.delete(binding.identifier);
         return this.needsActivation(binding);
     }
     // Own hooks are answered before the memo, so both computations cover the memoizable rest only.

package/dist/resolution/cache/binding-lookup-cache.d.ts

@@ -20,6 +20,20 @@ export interface DefaultLookupEntry<Owner> {
     readonly binding: Binding;
     readonly owner: Owner;
 }
+/**
+ * A root-level collection read, memoized until any registry in the chain changes.
+ *
+ * @remarks `values` is kept only while every member is a hook-free constant or a hook-free singleton
+ * whose instance is cached, and `activationVersion` is the chain's activation version that promise was
+ * made under.
+ *
+ * @since 0.10.0
+ */
+export interface CollectionEntry {
+    readonly candidates: ReadonlyArray<Binding>;
+    values: ReadonlyArray<unknown> | undefined;
+    activationVersion: number;
+}
 /**
  * Alias folding gives up past this many hops and defers to the full resolve loop, whose
  * Set-based traversal detects genuine cycles exactly rather than by an arbitrary cap.
@@ -35,10 +49,29 @@ export declare const ALIAS_HOP_LIMIT = 32;
 export declare class BindingLookupCache<Owner> {
     #private;
     constructor(registry: BindingRegistry, owner: Owner, parent: BindingLookupCache<Owner> | undefined);
-    /** Summed registry versions of this cache's whole chain — the memo stamp. */
+    /** Whether a second distinct token or tag has had to allocate a memo map behind the one-entry fronts. */
+    get isMemoBuilt(): boolean;
+    /**
+     * Summed registry versions of this cache's whole chain — the memo stamp.
+     *
+     * @remarks Re-summed only when the process-wide state epoch has moved since the last sum: no
+     * registry anywhere changed in between, so no registry in this chain did either.
+     */
     chainVersion(): number;
     /** `null` when the token's shape needs the full selection path. */
     defaultEntry(token: Token<unknown> | Constructor): DefaultLookupEntry<Owner> | null;
     /** `null` when the tag's shape needs the full selection path. */
     taggedEntry(token: Token<unknown> | Constructor, tag: BindingTag): DefaultLookupEntry<Owner> | null;
+    /**
+     * The memoized entry for a request carrying a name and one tag, or `null` when the answer is not this lane's.
+     *
+     * @remarks Same contract as the one-criterion memo: a predicate needs a live context and an alias
+     * carries options through the full path, so both decline; a registry that holds the token without the
+     * exact slot declines too, leaving the parent walk to the full lookup.
+     */
+    namedTaggedEntry(token: Token<unknown> | Constructor, nameCriterion: BindingTag, tag: BindingTag): DefaultLookupEntry<Owner> | null;
+    /** The memoized root-level collection for a token, or `undefined` once the chain changed since it was stored. */
+    collection(token: Token<unknown> | Constructor): CollectionEntry | undefined;
+    /** Stores a root-level collection under the chain version the last `collection()` read stamped. */
+    rememberCollection(token: Token<unknown> | Constructor, entry: CollectionEntry): void;
 }

package/dist/resolution/cache/binding-lookup-cache.js

@@ -1,4 +1,5 @@
 import { getOrInsertComputed } from "#/core/map-upsert";
+import { stateEpoch } from "#/core/state-epoch";
 /**
  * Alias folding gives up past this many hops and defers to the full resolve loop, whose
  * Set-based traversal detects genuine cycles exactly rather than by an arbitrary cap.
@@ -7,27 +8,37 @@ import { getOrInsertComputed } from "#/core/map-upsert";
  */
 export const ALIAS_HOP_LIMIT = 32;
 const newTagToEntryMap = () => new Map();
+const newNameToTagMap = () => new Map();
 /**
  * A version-stamped cache of binding lookups by token and criterion across the container chain.
  *
  * @since 0.5.0-canary.9
  */
 export class BindingLookupCache {
-    #byToken = new Map();
+    #byToken;
     #version = -1;
-    // One entry in front of the map: the two shapes that reach here — an alias, and a token owned by
-    // a parent — are both resolved in a loop over the same token. `null` is a real answer, so absence
-    // is tracked by the token slot rather than by the entry.
+    // The last chain sum and the epoch it was taken at.
+    #chainVersion = -1;
+    #chainEpoch = -1;
+    // One entry in front of the map, and the map is not written until a second distinct token appears
+    // in one generation: the two shapes that reach here — an alias, and a token owned by a parent —
+    // are both resolved in a loop over the same token. `null` is a real answer, so absence is tracked
+    // by the token slot rather than by the entry.
     #lastToken;
     #lastEntry = null;
-    #byTokenAndTag = new Map();
+    #byTokenAndTag;
     #taggedVersion = -1;
+    #byTokenNameAndTag;
+    #pairVersion = -1;
     // One entry in front of the tag map, and the map is not written until a second distinct request
     // shape appears: a per-request child usually asks one (token, tag) once, and the inner-map
     // allocation was that shape's whole regression when this memo landed.
     #lastTagToken;
     #lastTag;
     #lastTaggedEntry = null;
+    // Root-level collections by token, stamped with the chain version like the two memos above.
+    #collections;
+    #collectionsVersion = -1;
     #registry;
     #owner;
     #parent;
@@ -36,29 +47,56 @@ export class BindingLookupCache {
         this.#owner = owner;
         this.#parent = parent;
     }
-    /** Summed registry versions of this cache's whole chain — the memo stamp. */
+    /** Whether a second distinct token or tag has had to allocate a memo map behind the one-entry fronts. */
+    get isMemoBuilt() {
+        return this.#byToken !== undefined || this.#byTokenAndTag !== undefined || this.#byTokenNameAndTag !== undefined;
+    }
+    /**
+     * Summed registry versions of this cache's whole chain — the memo stamp.
+     *
+     * @remarks Re-summed only when the process-wide state epoch has moved since the last sum: no
+     * registry anywhere changed in between, so no registry in this chain did either.
+     */
     chainVersion() {
+        // A root's sum is its own version: one field read, cheaper than the memo it would stamp.
+        if (this.#parent === undefined) {
+            return this.#registry.version;
+        }
+        const epoch = stateEpoch();
+        if (epoch === this.#chainEpoch) {
+            return this.#chainVersion;
+        }
         let version = this.#registry.version;
         for (let cache = this.#parent; cache !== undefined; cache = cache.#parent) {
             version += cache.#registry.version;
         }
+        this.#chainEpoch = epoch;
+        this.#chainVersion = version;
         return version;
     }
     /** `null` when the token's shape needs the full selection path. */
     defaultEntry(token) {
         const version = this.chainVersion();
         if (version !== this.#version) {
-            this.#byToken.clear();
+            this.#byToken?.clear();
             this.#version = version;
             this.#lastToken = undefined;
         }
         else if (token === this.#lastToken) {
             return this.#lastEntry;
         }
-        let entry = this.#byToken.get(token);
-        if (entry === undefined) {
+        let entry;
+        if (this.#lastToken === undefined) {
+            // First token this cache generation sees: answer from the walk and defer the map entirely.
             entry = this.#foldAliases(token);
-            this.#byToken.set(token, entry);
+        }
+        else {
+            const byToken = (this.#byToken ??= new Map());
+            entry = byToken.get(token);
+            if (entry === undefined) {
+                entry = this.#foldAliases(token);
+                byToken.set(token, entry);
+            }
         }
         this.#lastToken = token;
         this.#lastEntry = entry;
@@ -68,7 +106,7 @@ export class BindingLookupCache {
     taggedEntry(token, tag) {
         const version = this.chainVersion();
         if (version !== this.#taggedVersion) {
-            this.#byTokenAndTag.clear();
+            this.#byTokenAndTag?.clear();
             this.#taggedVersion = version;
             this.#lastTagToken = undefined;
             this.#lastTag = undefined;
@@ -84,7 +122,7 @@ export class BindingLookupCache {
         else {
             // Keyed by the criterion object itself: criteria are interned, so identity is the slot
             // contract's own `Object.is` — the same exactness the registry's tagged index relies on.
-            const byTag = getOrInsertComputed(this.#byTokenAndTag, token, newTagToEntryMap);
+            const byTag = getOrInsertComputed((this.#byTokenAndTag ??= new Map()), token, newTagToEntryMap);
             entry = byTag.get(tag);
             if (entry === undefined) {
                 entry = this.#findTaggedInChain(token, tag);
@@ -96,6 +134,52 @@ export class BindingLookupCache {
         this.#lastTaggedEntry = entry;
         return entry;
     }
+    /**
+     * The memoized entry for a request carrying a name and one tag, or `null` when the answer is not this lane's.
+     *
+     * @remarks Same contract as the one-criterion memo: a predicate needs a live context and an alias
+     * carries options through the full path, so both decline; a registry that holds the token without the
+     * exact slot declines too, leaving the parent walk to the full lookup.
+     */
+    namedTaggedEntry(token, nameCriterion, tag) {
+        const version = this.chainVersion();
+        if (version !== this.#pairVersion) {
+            this.#byTokenNameAndTag?.clear();
+            this.#pairVersion = version;
+        }
+        const byName = getOrInsertComputed((this.#byTokenNameAndTag ??= new Map()), token, newNameToTagMap);
+        const byTag = getOrInsertComputed(byName, nameCriterion, newTagToEntryMap);
+        let entry = byTag.get(tag);
+        if (entry === undefined) {
+            entry = this.#findPairInChain(token, nameCriterion, tag);
+            byTag.set(tag, entry);
+        }
+        return entry;
+    }
+    #findPairInChain(token, nameCriterion, tag) {
+        const found = this.#registry.getPairTagged(token, nameCriterion, tag);
+        if (found !== undefined) {
+            return found.predicate !== undefined || found.kind === "alias" ? null : { binding: found, owner: this.#owner };
+        }
+        if (this.#registry.has(token)) {
+            return null;
+        }
+        return this.#parent === undefined ? null : this.#parent.#findPairInChain(token, nameCriterion, tag);
+    }
+    /** The memoized root-level collection for a token, or `undefined` once the chain changed since it was stored. */
+    collection(token) {
+        const version = this.chainVersion();
+        if (version !== this.#collectionsVersion) {
+            this.#collections?.clear();
+            this.#collectionsVersion = version;
+            return undefined;
+        }
+        return this.#collections?.get(token);
+    }
+    /** Stores a root-level collection under the chain version the last `collection()` read stamped. */
+    rememberCollection(token, entry) {
+        (this.#collections ??= new Map()).set(token, entry);
+    }
     #foldAliases(token) {
         let current = token;
         for (let hop = 0; hop < ALIAS_HOP_LIMIT; hop += 1) {

package/dist/resolution/cache/class-introspector.d.ts

@@ -52,7 +52,7 @@ export declare function verifyAccessorMetadata(reader: MetadataReader, target: C
  */
 export declare class ClassIntrospector {
     #private;
-    constructor(reader: MetadataReader, container: Container);
+    constructor(reader: MetadataReader, container: Container, inherited: ClassIntrospector | undefined);
     constructorMetadata(target: Constructor): ConstructorMetadata | undefined;
     /**
      * Whether the class has a `@postConstruct` hook, or `undefined` until {@link discoverPostConstruct}.

package/dist/resolution/cache/class-introspector.js

@@ -3,7 +3,7 @@
  *
  * @remarks Metadata cannot change once a class is defined, so nothing here needs version stamping.
  */
-import { runWithAmbientResolution } from "#/ambient/active-container";
+import { constructWithAmbientResolution, runWithAmbientResolution } from "#/ambient/active-container";
 import { InvalidMetadataError } from "#/errors/errors";
 // Verified pairs, not verified classes: two readers may disagree about the same class, and a reader
 // that goes out of scope takes its record with it.
@@ -138,30 +138,40 @@ export function verifyAccessorMetadata(reader, target) {
     markVerified(verifiedAccessorTargets, reader, target);
     return metadata;
 }
+const cachesByReader = new WeakMap();
+function cachesFor(reader) {
+    let caches = cachesByReader.get(reader);
+    if (caches === undefined) {
+        caches = { constructorMetadata: undefined, hasPostConstruct: undefined, needsActiveContainer: undefined };
+        cachesByReader.set(reader, caches);
+    }
+    return caches;
+}
 /**
  * A per-class cache of constructor metadata and the activation facts derived from it.
  *
  * @since 0.5.0-canary.8
  */
 export class ClassIntrospector {
-    // Unallocated until the container resolves its first class binding — a container bound entirely
-    // to constants, factories or aliases never introspects one.
-    #constructorMetadata;
-    #hasPostConstruct;
-    #needsActiveContainer;
+    #caches;
     #reader;
     #container;
-    constructor(reader, container) {
+    constructor(reader, container, inherited) {
+        this.#caches = inherited !== undefined && inherited.#reader === reader ? inherited.#caches : undefined;
         this.#reader = reader;
         this.#container = container;
     }
+    #shared() {
+        return (this.#caches ??= cachesFor(this.#reader));
+    }
     constructorMetadata(target) {
-        const cached = this.#constructorMetadata?.get(target);
+        const caches = this.#shared();
+        const cached = caches.constructorMetadata?.get(target);
         if (cached !== undefined) {
             return cached === null ? undefined : cached;
         }
         const metadata = this.#reader.getConstructorMetadata(target);
-        (this.#constructorMetadata ??= new WeakMap()).set(target, metadata ?? null);
+        (caches.constructorMetadata ??= new WeakMap()).set(target, metadata ?? null);
         return metadata;
     }
     /**
@@ -170,18 +180,19 @@ export class ClassIntrospector {
      * @remarks Callers treat unknown as "assume it does", so the first activation settles it.
      */
     knownPostConstruct(target) {
-        return this.#hasPostConstruct?.get(target);
+        return this.#shared().hasPostConstruct?.get(target);
     }
     discoverPostConstruct(target) {
         const lifecycle = this.#reader.getLifecycleMetadata(target);
-        (this.#hasPostConstruct ??= new WeakMap()).set(target, lifecycle !== undefined && lifecycle.postConstruct !== undefined && lifecycle.postConstruct.length > 0);
+        (this.#shared().hasPostConstruct ??= new WeakMap()).set(target, lifecycle !== undefined && lifecycle.postConstruct !== undefined && lifecycle.postConstruct.length > 0);
     }
     /** True when the class has accessor injection, which reads the container during construction. */
     needsActiveContainer(target) {
-        let needsActiveContainer = this.#needsActiveContainer?.get(target);
+        const caches = this.#shared();
+        let needsActiveContainer = caches.needsActiveContainer?.get(target);
         if (needsActiveContainer === undefined) {
             needsActiveContainer = (this.#reader.getAccessorMetadata?.(target)?.length ?? 0) > 0;
-            (this.#needsActiveContainer ??= new WeakMap()).set(target, needsActiveContainer);
+            (caches.needsActiveContainer ??= new WeakMap()).set(target, needsActiveContainer);
         }
         return needsActiveContainer;
     }
@@ -190,6 +201,9 @@ export class ClassIntrospector {
         if (!this.needsActiveContainer(target)) {
             return new invokable(...deps);
         }
-        return runWithAmbientResolution(this.#container, resolution, () => new invokable(...deps));
+        if (resolution === undefined) {
+            return runWithAmbientResolution(this.#container, undefined, () => new invokable(...deps));
+        }
+        return constructWithAmbientResolution(this.#container, resolution, invokable, deps);
     }
 }

package/dist/resolution/context.d.ts

@@ -16,8 +16,8 @@ export interface ResolverCallbacks {
     resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
     resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Value | undefined;
     resolveOptionalAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Promise<Value | undefined>;
-    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Array<Value>;
-    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Promise<Array<Value>>;
+    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): ReadonlyArray<Value>;
+    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Promise<ReadonlyArray<Value>>;
 }
 /**
  * The `ResolutionContext` handed to factories and hooks, backed by the engine's callbacks.
@@ -33,8 +33,8 @@ export declare class DefaultResolutionContext implements ResolutionContext {
     resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value>;
     resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined;
     resolveOptionalAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value | undefined>;
-    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value>;
-    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Array<Value>>;
+    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): ReadonlyArray<Value>;
+    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<ReadonlyArray<Value>>;
 }
 /**
  * One async level's resolution context, which is also its branch of the resolution stack.
@@ -59,8 +59,8 @@ export declare class AsyncLevelContext implements ResolutionContext {
     resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value>;
     resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined;
     resolveOptionalAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value | undefined>;
-    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value>;
-    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Array<Value>>;
+    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): ReadonlyArray<Value>;
+    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<ReadonlyArray<Value>>;
 }
 /**
  * The one context every level of an open synchronous factory cascade shares.
@@ -78,8 +78,8 @@ export declare class AsyncCascadeContext implements ResolutionContext {
     resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value>;
     resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined;
     resolveOptionalAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value | undefined>;
-    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value>;
-    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Array<Value>>;
+    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): ReadonlyArray<Value>;
+    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<ReadonlyArray<Value>>;
 }
 /**
  * Creates the resolution-stack frame for one in-flight resolve.

package/dist/resolution/plan/instantiation-plan.d.ts

@@ -5,6 +5,7 @@
  * closure must stay callable for it, which is what bounds what may be inlined.
  */
 import type { Binding } from "#/core/binding";
+import type { ConstructorInvocation } from "#/core/constructor-type";
 import type { Token } from "#/core/token";
 import type { Constructor, ResolutionFrame, ResolveOptions } from "#/core/types";
 import type { ConstructorMetadata } from "#/metadata/metadata-types";
@@ -41,6 +42,11 @@ export interface InstantiationPlanHost {
     /** Cached postConstruct presence — `undefined` until a runtime resolve discovers it. */
     knownPostConstruct(target: Constructor): boolean | undefined;
     needsActiveContainer(target: Constructor): boolean;
+    /**
+     * Constructs a class whose accessors resolve during construction, with the container ambient and
+     * the binding's frame on the path so an accessor that cycles back is still caught.
+     */
+    constructWithAccessors(binding: Binding, target: ConstructorInvocation, deps: Array<unknown>): unknown;
     getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
     /** Options-less lookup with alias hops folded; `null` when the fast lane can't answer. */
     lookupDependencyEntry(token: Token<unknown> | Constructor): InstantiationPlanDependencyEntry | null;
@@ -54,6 +60,10 @@ export interface InstantiationPlanHost {
     lookupPathIndependentEntry(token: Token<unknown> | Constructor, options: ResolveOptions): InstantiationPlanDependencyEntry | null;
     /** The frame the interpreted path pushes for this binding, so escapes can replay it. */
     getResolutionFrame(binding: Binding): ResolutionFrame;
+    /** Swaps a plan the host still holds for its successor; a plan the host has since dropped stays dropped. */
+    replacePlan(binding: Binding, current: () => unknown, next: () => unknown): void;
+    /** The async counterpart of {@link InstantiationPlanHost.replacePlan}, over the async plan map. */
+    replaceAsyncPlan(binding: Binding, current: () => unknown, next: () => unknown): void;
     /** Runtime resolve for an escaped dependency, seeded with the ancestor frames above it. */
     resolveEscaped(token: Token<unknown> | Constructor, options: ResolveOptions | undefined, arity: EscapeArity, resolutionStack: Array<ResolutionFrame>): unknown;
     /** The async counterpart of {@link InstantiationPlanHost.resolveEscaped}, replaying the async dispatch. */
@@ -74,6 +84,8 @@ export type EscapeArity = "all" | "optional" | "single";
 export declare class InstantiationPlanCompiler {
     #private;
     constructor(host: InstantiationPlanHost);
+    /** Plans this compiler has generated as functions of their own. */
+    get generatedPlanCount(): number;
     compile(binding: Binding & {
         kind: "class" | "resolved";
     }): InstantiationPlanCompileResult;