@codefast/di 0.10.1 → 0.11.0

package/dist/resolution/context.d.ts

@@ -1,6 +1,6 @@
 /** The `ResolutionContext` a factory is handed, and the callbacks the resolver answers it with. */
 import type { Token } from "#core/token";
-import type { BindingIdentifier, BindingKind, BindingScope, ConstraintContext, Constructor, ResolutionFrame, ResolutionContext, ResolveOptions } from "#core/types";
+import type { ConstraintContext, Constructor, ResolutionFrame, ResolutionContext, ResolveOptions } from "#core/types";
 import type { BranchDepth, OwnedBranchStack } from "#resolution/path/resolution-path";
 /**
  * The engine surface a resolution context calls back into to resolve further dependencies.
@@ -11,8 +11,6 @@ export interface ResolverCallbacks {
     resolveFromContext<Value>(token: Token<Value> | Constructor<Value>, resolutionStack: Array<ResolutionFrame>): Value;
     resolve<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Value;
     resolveAsyncFromContext<Value>(token: Token<Value> | Constructor<Value>, resolutionStack: Array<ResolutionFrame>, branchDepth: BranchDepth): Promise<Value>;
-    /** Not one of the eight `Value`-naming entry points: its caller is, and casts once. */
-    resolveAsyncFromCascade(token: Token<unknown> | Constructor): Promise<unknown>;
     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>;
@@ -55,6 +53,8 @@ export declare class AsyncLevelContext implements ResolutionContext {
      */
     constructor(resolver: ResolverCallbacks, resolutionStack: OwnedBranchStack, currentOptions: ResolveOptions | undefined);
     get graph(): ConstraintContext;
+    /** This level's own path, fixed for its lifetime, for a caller that names it in an error. */
+    get ownPath(): ReadonlyArray<ResolutionFrame>;
     resolve<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value;
     resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value>;
     resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined;
@@ -63,27 +63,19 @@ export declare class AsyncLevelContext implements ResolutionContext {
     resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<ReadonlyArray<Value>>;
 }
 /**
- * The one context every level of an open synchronous factory cascade shares.
+ * The one constraint context every predicate reads, whatever lane built it.
  *
- * @remarks It carries no per-level state at all: while the cascade is open, the resolver's stack
- * *is* this level's ancestor chain, so nothing has to be allocated per level.
+ * @remarks One shape for the shared root, a selection over a live synchronous stack, an async
+ * level's prefix and an inspector's probe, so a predicate's call site stays monomorphic.
  *
- * @since 0.5.0-canary.9
+ * @since 0.11.0
  */
-export declare class AsyncCascadeContext implements ResolutionContext {
+export declare class DefaultConstraintContext implements ConstraintContext {
     #private;
-    constructor(resolver: ResolverCallbacks, cascadeStack: Array<ResolutionFrame>);
-    get graph(): ConstraintContext;
-    resolve<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value;
-    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): ReadonlyArray<Value>;
-    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<ReadonlyArray<Value>>;
-}
-/**
- * Creates the resolution-stack frame for one in-flight resolve.
- *
- * @since 0.3.16-canary.0
- */
-export declare function buildResolutionFrame(tokenName: string, scope: BindingScope, bindingId: BindingIdentifier, kind: BindingKind, slot: ResolutionFrame["slot"]): ResolutionFrame;
+    readonly resolutionStack: ReadonlyArray<ResolutionFrame>;
+    readonly parent: ResolutionFrame | undefined;
+    readonly currentResolveOptions: Readonly<ResolveOptions> | undefined;
+    constructor(resolutionStack: ReadonlyArray<ResolutionFrame>, currentResolveOptions: ResolveOptions | undefined);
+    get resolutionPath(): ReadonlyArray<string>;
+    get ancestors(): ReadonlyArray<ResolutionFrame>;
+}

package/dist/resolution/context.js

@@ -1,4 +1,4 @@
-import { UNOWNED_BRANCH } from "#resolution/path/resolution-path";
+import { bindingsOf, enterSeededPath, leaveSeededPath, UNOWNED_BRANCH } from "#resolution/path/resolution-path";
 /**
  * The `ResolutionContext` handed to factories and hooks, backed by the engine's callbacks.
  *
@@ -88,6 +88,7 @@ export class AsyncLevelContext {
     }
     #graph;
     #exactStackCache;
+    #exactBindingsCache;
     get graph() {
         if (this.#graph === undefined) {
             this.#graph = new DefaultConstraintContext(this.#exactStack(), this.#currentOptions);
@@ -99,11 +100,30 @@ export class AsyncLevelContext {
     #exactStack() {
         return (this.#exactStackCache ??= this.#resolutionStack.slice(0, this.#branchDepth));
     }
+    /** This level's own path, fixed for its lifetime, for a caller that names it in an error. */
+    get ownPath() {
+        return this.#exactStack();
+    }
+    // The bindings a synchronous call from this level marks in flight, read off the frames once.
+    #exactBindings() {
+        return (this.#exactBindingsCache ??= bindingsOf(this.#exactStack()));
+    }
+    // A synchronous call from an async level runs over a path no synchronous frame pushed, so the
+    // level's ancestors are marked in flight for its duration — and the level itself, whose factory is
+    // the caller: a factory resolving its own token synchronously has closed a cycle.
     resolve(token, options) {
-        if (options === undefined) {
-            return this.#resolver.resolveFromContext(token, this.#exactStack());
+        const path = this.#exactStack();
+        const marked = this.#exactBindings();
+        const alreadyInFlight = enterSeededPath(marked);
+        try {
+            if (options === undefined) {
+                return this.#resolver.resolveFromContext(token, path);
+            }
+            return this.#resolver.resolve(token, options, path);
+        }
+        finally {
+            leaveSeededPath(marked, alreadyInFlight);
         }
-        return this.#resolver.resolve(token, options, this.#exactStack());
     }
     resolveAsync(token, options) {
         if (options === undefined) {
@@ -113,64 +133,43 @@ export class AsyncLevelContext {
         return this.#resolver.resolveAsync(token, options, this.#exactStack());
     }
     resolveOptional(token, options) {
-        return this.#resolver.resolveOptional(token, options, this.#exactStack());
+        const path = this.#exactStack();
+        const marked = this.#exactBindings();
+        const alreadyInFlight = enterSeededPath(marked);
+        try {
+            return this.#resolver.resolveOptional(token, options, path);
+        }
+        finally {
+            leaveSeededPath(marked, alreadyInFlight);
+        }
     }
     resolveOptionalAsync(token, options) {
         return this.#resolver.resolveOptionalAsync(token, options, this.#exactStack());
     }
     resolveAll(token, options) {
-        return this.#resolver.resolveAll(token, options, this.#exactStack());
+        const path = this.#exactStack();
+        const marked = this.#exactBindings();
+        const alreadyInFlight = enterSeededPath(marked);
+        try {
+            return this.#resolver.resolveAll(token, options, path);
+        }
+        finally {
+            leaveSeededPath(marked, alreadyInFlight);
+        }
     }
     resolveAllAsync(token, options) {
         return this.#resolver.resolveAllAsync(token, options, this.#exactStack());
     }
 }
 /**
- * The one context every level of an open synchronous factory cascade shares.
+ * The one constraint context every predicate reads, whatever lane built it.
  *
- * @remarks It carries no per-level state at all: while the cascade is open, the resolver's stack
- * *is* this level's ancestor chain, so nothing has to be allocated per level.
+ * @remarks One shape for the shared root, a selection over a live synchronous stack, an async
+ * level's prefix and an inspector's probe, so a predicate's call site stays monomorphic.
  *
- * @since 0.5.0-canary.9
+ * @since 0.11.0
  */
-export class AsyncCascadeContext {
-    #resolver;
-    #cascadeStack;
-    constructor(resolver, cascadeStack) {
-        this.#resolver = resolver;
-        this.#cascadeStack = cascadeStack;
-    }
-    get graph() {
-        // Not memoized: this context outlives every level, so a cached graph would describe whichever
-        // level asked first. The cascade stack is only this level's ancestors while it is open.
-        return new DefaultConstraintContext(this.#cascadeStack, undefined);
-    }
-    resolve(token, options) {
-        if (options === undefined) {
-            return this.#resolver.resolveFromContext(token, this.#cascadeStack);
-        }
-        return this.#resolver.resolve(token, options, this.#cascadeStack);
-    }
-    resolveAsync(token, options) {
-        if (options === undefined) {
-            return this.#resolver.resolveAsyncFromCascade(token);
-        }
-        return this.#resolver.resolveAsync(token, options, [...this.#cascadeStack]);
-    }
-    resolveOptional(token, options) {
-        return this.#resolver.resolveOptional(token, options, this.#cascadeStack);
-    }
-    resolveOptionalAsync(token, options) {
-        return this.#resolver.resolveOptionalAsync(token, options, [...this.#cascadeStack]);
-    }
-    resolveAll(token, options) {
-        return this.#resolver.resolveAll(token, options, this.#cascadeStack);
-    }
-    resolveAllAsync(token, options) {
-        return this.#resolver.resolveAllAsync(token, options, [...this.#cascadeStack]);
-    }
-}
-class DefaultConstraintContext {
+export class DefaultConstraintContext {
     resolutionStack;
     parent;
     currentResolveOptions;
@@ -195,12 +194,4 @@ class DefaultConstraintContext {
         }
         return this.#ancestors;
     }
-}
-/**
- * Creates the resolution-stack frame for one in-flight resolve.
- *
- * @since 0.3.16-canary.0
- */
-export function buildResolutionFrame(tokenName, scope, bindingId, kind, slot) {
-    return { tokenName, scope, bindingId, kind, slot };
 }

package/dist/resolution/path/resolution-path.d.ts

@@ -1,12 +1,21 @@
-import type { BindingIdentifier, ResolutionFrame } from "#core/types";
+import type { Binding } from "#core/binding";
+import type { ResolutionFrame } from "#core/types";
 /**
- * Where the cycle check switches from a linear frame scan to an attached Set.
+ * Creates the resolution-stack frame for one in-flight resolve of a binding.
  *
- * @remarks Measured rather than guessed: below this depth the linear scan wins, above it the Set does.
+ * @remarks A literal, because the engine's hot loads read frames: a class instance costs every level
+ * a few nanoseconds, and a weak map beside the frames costs every cold container an ephemeron insert
+ * per binding. The binding rides under a symbol no caller enumerates.
  *
- * @since 0.5.0-canary.7
+ * @since 0.3.16-canary.0
  */
-export declare const RESOLUTION_SET_THRESHOLD = 32;
+export declare function buildResolutionFrame(binding: Binding, tokenName: string): ResolutionFrame;
+/**
+ * The bindings behind the resolver-built frames of a path, in path order.
+ *
+ * @since 0.11.0
+ */
+export declare function bindingsOf(frames: ReadonlyArray<ResolutionFrame>): Array<Binding>;
 /**
  * The token names along a stack plus the frame that closed the cycle — built only to throw.
  *
@@ -14,18 +23,44 @@ export declare const RESOLUTION_SET_THRESHOLD = 32;
  */
 export declare function cycleNamesOf(resolutionStack: ReadonlyArray<ResolutionFrame>, closingName: string): Array<string>;
 /**
- * Marks a level as in-flight on this stack, throwing if its binding is already an ancestor.
+ * Marks a level in flight on a synchronous path and pushes its frame, throwing if its binding already is.
  *
- * @remarks The check keys on binding identity — two distinct tokens may share a display name — and
- * the names an error prints are derived from the frames at the throw site. Unmark by popping the
- * stack plus `set?.delete(frame.bindingId)`. Sync only — the async lane never removes an entry, so
- * it extends a branch instead; see {@link extendResolutionBranch}.
+ * @remarks Synchronous code does not interleave, so the flag on the binding is exact membership in the
+ * path one call stack is resolving — at any depth, with no side table and nothing to size. The check
+ * keys on the binding, never on a token's display name, and the names an error prints are read off
+ * the frames at the throw site. Unmark with {@link leaveSyncPath}. Sync only: the async branch lane
+ * never unwinds, so it extends a branch instead; see {@link extendResolutionBranch}.
  *
- * @returns the membership set once the stack is deep enough to carry one, else `undefined`.
+ * @since 0.11.0
+ */
+export declare function enterSyncPath(resolutionStack: Array<ResolutionFrame>, binding: Binding, frame: ResolutionFrame): void;
+/**
+ * Pops the level {@link enterSyncPath} pushed and clears its binding's flag.
+ *
+ * @since 0.11.0
+ */
+export declare function leaveSyncPath(resolutionStack: Array<ResolutionFrame>, binding: Binding): void;
+/**
+ * Marks every binding of a seeded path in flight for the synchronous call about to run over it.
+ *
+ * @remarks A seed is a path no synchronous frame pushed — a plan's static ancestors handed to an
+ * escape, or an async level's branch handed to a factory's synchronous call — so its bindings carry no
+ * flag, and marking them is what keeps the flag the one check. A binding already in flight was
+ * flagged by an enclosing synchronous frame that is still running, which is the same fact stated
+ * once already, so it is left as it is and left alone on the way out; a cycle is reported where the
+ * path re-enters that binding, which is where the frames to name it are.
+ *
+ * @returns the bindings this call left flagged as it found them, when there were any, for {@link leaveSeededPath}
+ *
+ * @since 0.11.0
+ */
+export declare function enterSeededPath(bindings: ReadonlyArray<Binding>): Set<Binding> | undefined;
+/**
+ * Clears the flags {@link enterSeededPath} set, leaving the ones it found already set.
  *
- * @since 0.5.0-canary.7
+ * @since 0.11.0
  */
-export declare function enterResolutionPath(resolutionStack: Array<ResolutionFrame>, frame: ResolutionFrame): Set<BindingIdentifier> | undefined;
+export declare function leaveSeededPath(bindings: ReadonlyArray<Binding>, alreadyInFlight: Set<Binding> | undefined): void;
 declare const BRANCH_BRAND: unique symbol;
 /**
  * A resolution stack one async branch owns, so appending to it cannot disturb another branch.

package/dist/resolution/path/resolution-path.js

@@ -1,14 +1,42 @@
 /** Cycle-detection bookkeeping carried on the resolution stack itself. */
 import { CircularDependencyError } from "#errors/errors";
-const RESOLUTION_SET_KEY = Symbol("di:resolution-set");
+/** The key under which a resolver-built frame carries its binding, for marking a seeded path. */
+const FRAME_BINDING = Symbol("di:frame-binding");
 /**
- * Where the cycle check switches from a linear frame scan to an attached Set.
+ * Creates the resolution-stack frame for one in-flight resolve of a binding.
  *
- * @remarks Measured rather than guessed: below this depth the linear scan wins, above it the Set does.
+ * @remarks A literal, because the engine's hot loads read frames: a class instance costs every level
+ * a few nanoseconds, and a weak map beside the frames costs every cold container an ephemeron insert
+ * per binding. The binding rides under a symbol no caller enumerates.
  *
- * @since 0.5.0-canary.7
+ * @since 0.3.16-canary.0
  */
-export const RESOLUTION_SET_THRESHOLD = 32;
+export function buildResolutionFrame(binding, tokenName) {
+    const frame = {
+        tokenName,
+        scope: binding.scope,
+        bindingId: binding.identifier,
+        kind: binding.kind,
+        slot: binding.slot,
+        [FRAME_BINDING]: binding,
+    };
+    return frame;
+}
+/**
+ * The bindings behind the resolver-built frames of a path, in path order.
+ *
+ * @since 0.11.0
+ */
+export function bindingsOf(frames) {
+    const bindings = [];
+    for (let index = 0; index < frames.length; index += 1) {
+        const binding = frames[index][FRAME_BINDING];
+        if (binding !== undefined) {
+            bindings.push(binding);
+        }
+    }
+    return bindings;
+}
 /**
  * The token names along a stack plus the frame that closed the cycle — built only to throw.
  *
@@ -23,47 +51,70 @@ export function cycleNamesOf(resolutionStack, closingName) {
     return names;
 }
 /**
- * Marks a level as in-flight on this stack, throwing if its binding is already an ancestor.
+ * Marks a level in flight on a synchronous path and pushes its frame, throwing if its binding already is.
  *
- * @remarks The check keys on binding identity — two distinct tokens may share a display name — and
- * the names an error prints are derived from the frames at the throw site. Unmark by popping the
- * stack plus `set?.delete(frame.bindingId)`. Sync only — the async lane never removes an entry, so
- * it extends a branch instead; see {@link extendResolutionBranch}.
+ * @remarks Synchronous code does not interleave, so the flag on the binding is exact membership in the
+ * path one call stack is resolving — at any depth, with no side table and nothing to size. The check
+ * keys on the binding, never on a token's display name, and the names an error prints are read off
+ * the frames at the throw site. Unmark with {@link leaveSyncPath}. Sync only: the async branch lane
+ * never unwinds, so it extends a branch instead; see {@link extendResolutionBranch}.
  *
- * @returns the membership set once the stack is deep enough to carry one, else `undefined`.
- *
- * @since 0.5.0-canary.7
+ * @since 0.11.0
  */
-export function enterResolutionPath(resolutionStack, frame) {
-    const stackWithSet = resolutionStack;
-    let resolutionSet = stackWithSet[RESOLUTION_SET_KEY];
-    // A live set mirrors the stack exactly, so a size that disagrees means it is holding ids of
-    // frames that unwound: the ones already on the stack when it attached were handed no set to
-    // delete from. Dropped rather than repaired, because the next deep frame rebuilds it.
-    if (resolutionSet !== undefined && resolutionSet.size !== resolutionStack.length) {
-        resolutionSet = undefined;
-        stackWithSet[RESOLUTION_SET_KEY] = undefined;
+export function enterSyncPath(resolutionStack, binding, frame) {
+    if (binding.inFlight) {
+        throw new CircularDependencyError(cycleNamesOf(resolutionStack, frame.tokenName));
     }
-    if (resolutionSet === undefined && resolutionStack.length >= RESOLUTION_SET_THRESHOLD) {
-        resolutionSet = new Set();
-        for (let index = 0; index < resolutionStack.length; index += 1) {
-            resolutionSet.add(resolutionStack[index].bindingId);
+    binding.inFlight = true;
+    resolutionStack.push(frame);
+}
+/**
+ * Pops the level {@link enterSyncPath} pushed and clears its binding's flag.
+ *
+ * @since 0.11.0
+ */
+export function leaveSyncPath(resolutionStack, binding) {
+    resolutionStack.pop();
+    binding.inFlight = false;
+}
+/**
+ * Marks every binding of a seeded path in flight for the synchronous call about to run over it.
+ *
+ * @remarks A seed is a path no synchronous frame pushed — a plan's static ancestors handed to an
+ * escape, or an async level's branch handed to a factory's synchronous call — so its bindings carry no
+ * flag, and marking them is what keeps the flag the one check. A binding already in flight was
+ * flagged by an enclosing synchronous frame that is still running, which is the same fact stated
+ * once already, so it is left as it is and left alone on the way out; a cycle is reported where the
+ * path re-enters that binding, which is where the frames to name it are.
+ *
+ * @returns the bindings this call left flagged as it found them, when there were any, for {@link leaveSeededPath}
+ *
+ * @since 0.11.0
+ */
+export function enterSeededPath(bindings) {
+    let alreadyInFlight;
+    for (let index = 0; index < bindings.length; index += 1) {
+        const binding = bindings[index];
+        if (binding.inFlight) {
+            (alreadyInFlight ??= new Set()).add(binding);
+            continue;
         }
-        stackWithSet[RESOLUTION_SET_KEY] = resolutionSet;
+        binding.inFlight = true;
     }
-    if (resolutionSet === undefined) {
-        for (let index = 0; index < resolutionStack.length; index += 1) {
-            if (resolutionStack[index].bindingId === frame.bindingId) {
-                throw new CircularDependencyError(cycleNamesOf(resolutionStack, frame.tokenName));
-            }
+    return alreadyInFlight;
+}
+/**
+ * Clears the flags {@link enterSeededPath} set, leaving the ones it found already set.
+ *
+ * @since 0.11.0
+ */
+export function leaveSeededPath(bindings, alreadyInFlight) {
+    for (let index = 0; index < bindings.length; index += 1) {
+        const binding = bindings[index];
+        if (alreadyInFlight === undefined || !alreadyInFlight.has(binding)) {
+            binding.inFlight = false;
         }
     }
-    else if (resolutionSet.has(frame.bindingId)) {
-        throw new CircularDependencyError(cycleNamesOf(resolutionStack, frame.tokenName));
-    }
-    resolutionStack.push(frame);
-    resolutionSet?.add(frame.bindingId);
-    return resolutionSet;
 }
 /**
  * A stack no async branch owns yet, so its first extension must copy rather than append.

package/dist/resolution/plan/instantiation-plan.js

@@ -2,10 +2,9 @@ import { NO_INSTANCE } from "#core/binding";
 import { tokenName } from "#core/token";
 import { AsyncResolutionError } from "#errors/errors";
 import { injectionSlotToResolveOptions } from "#injection/resolve-options";
+import { settleInOrder } from "#resolution/async-fan-out";
+import { enterSeededPath, leaveSeededPath } from "#resolution/path/resolution-path";
 import { generateAsyncPlan, generatePlan, isPlanCodegenAvailable, PLAN_CODEGEN_THRESHOLD, } from "#resolution/plan/plan-codegen";
-// Past this depth a dependency escapes to the runtime path rather than inlining further —
-// compiled closures nest one JS frame per level, and pathological graphs are the runtime's job.
-const PLAN_DEPTH_LIMIT = 32;
 /**
  * Compilation asked to retry later (class lifecycle metadata not discovered yet).
  *
@@ -21,12 +20,28 @@ function allSynchronous(deps) {
     return true;
 }
 /**
- * The promise-aware combinator: run every dep thunk, await them together, then apply.
+ * The promise-aware combinator: run every dep thunk, settle them together, then apply.
  *
  * @remarks A dep's sync throw becomes that slot's rejection so its siblings still start — the
- * interpreted path starts every sibling before the first rejection propagates, and so does this.
+ * interpreted path starts every sibling before any failure is reported, and so does this; a failure
+ * is the first in declaration order, as it is on every other lane.
  */
 function settleThenApply(deps, apply) {
+    if (deps.length === 1) {
+        // One dependency has one outcome, so there is nothing to order and no fan-out to settle.
+        const only = deps[0].run;
+        const applyOne = (value) => apply([value]);
+        return () => {
+            let pending;
+            try {
+                pending = only();
+            }
+            catch (dependencyError) {
+                pending = Promise.reject(dependencyError);
+            }
+            return Promise.resolve(pending).then(applyOne);
+        };
+    }
     return () => {
         const pending = new Array(deps.length);
         for (let index = 0; index < deps.length; index += 1) {
@@ -37,7 +52,7 @@ function settleThenApply(deps, apply) {
                 pending[index] = Promise.reject(dependencyError);
             }
         }
-        return Promise.all(pending).then(apply);
+        return settleInOrder(pending, apply);
     };
 }
 /**
@@ -94,24 +109,52 @@ export class InstantiationPlanCompiler {
      * root-stack rule one level down: every sync lane pops what it pushes, so the owned array still
      * holds exactly the seed when a call returns. A reentrant call finds it claimed and mints its
      * own copy; a return that did not restore the length hands nothing back, so the next call mints.
+     * The plan pushed no frame for the ancestors it inlined, so the seed's bindings are marked in
+     * flight around the call: an escaped factory cycling back into one is caught as the interpreted
+     * path would catch it.
      */
     #compileEscapeThunk(token, ancestors, arity = "single", options) {
         const host = this.#host;
         const frames = ancestors.map((ancestor) => host.getResolutionFrame(ancestor));
         const depth = frames.length;
         let owned = [...frames];
-        const run = () => {
-            const stack = owned ?? [...frames];
-            owned = undefined;
-            try {
-                return host.resolveEscaped(token, options, arity, stack);
-            }
-            finally {
-                if (stack.length === depth) {
-                    owned = stack;
+        // A plan root's own opaque dependency has one ancestor, and it is the common escape, so its
+        // marking is written out: one flag read and at most two writes, no loop and no call.
+        const only = ancestors.length === 1 ? ancestors[0] : undefined;
+        const run = only === undefined
+            ? () => {
+                const stack = owned ?? [...frames];
+                owned = undefined;
+                const alreadyInFlight = enterSeededPath(ancestors);
+                try {
+                    return host.resolveEscaped(token, options, arity, stack);
+                }
+                finally {
+                    leaveSeededPath(ancestors, alreadyInFlight);
+                    if (stack.length === depth) {
+                        owned = stack;
+                    }
                 }
             }
-        };
+            : () => {
+                const stack = owned ?? [...frames];
+                owned = undefined;
+                const wasInFlight = only.inFlight;
+                if (!wasInFlight) {
+                    only.inFlight = true;
+                }
+                try {
+                    return host.resolveEscaped(token, options, arity, stack);
+                }
+                finally {
+                    if (!wasInFlight) {
+                        only.inFlight = false;
+                    }
+                    if (stack.length === depth) {
+                        owned = stack;
+                    }
+                }
+            };
         return { run, node: { kind: "thunk", run } };
     }
     // A resolved binding declares its deps as explicit descriptors — same rules as
@@ -282,10 +325,7 @@ export class InstantiationPlanCompiler {
                 node: { kind: "singleton", binding: singletonBinding, escape },
             };
         }
-        if (scope === "transient" &&
-            binding.kind === "class" &&
-            depth < PLAN_DEPTH_LIMIT &&
-            !compileStack.has(binding.identifier)) {
+        if (scope === "transient" && binding.kind === "class" && !compileStack.has(binding.identifier)) {
             const inlined = this.#compileClassPlan(binding, compileStack, depth + 1, ancestors);
             if (inlined !== null) {
                 return inlined;
@@ -476,7 +516,7 @@ export class InstantiationPlanCompiler {
                 node: { kind: "singleton", binding: singletonBinding, escape },
             };
         }
-        if (scope === "transient" && depth < PLAN_DEPTH_LIMIT && !compileStack.has(binding.identifier)) {
+        if (scope === "transient" && !compileStack.has(binding.identifier)) {
             let inlined = null;
             if (binding.kind === "class") {
                 inlined = this.#compileAsyncClassNode(binding, compileStack, depth + 1, ancestors);

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

@@ -6,12 +6,14 @@ import type { ConstructorInvocation } from "#core/constructor-type";
 /**
  * The number of runs a plan's closure makes before the plan is generated as its own function.
  *
- * @remarks Below it a plan stays a closure, which is all a cold container or a per-request child
- * ever runs; above it a plan pays one compile for call sites nothing else feeds.
+ * @remarks A measured policy, not a machine width, a contract value or bind-time data: generating
+ * costs some fifty closure runs and the new function runs cold for thirty more, so it repays only
+ * over runs in the thousands. Below it a plan stays a closure, which is all a cold container or a
+ * per-request child ever runs.
  *
  * @since 0.10.0
  */
-export declare const PLAN_CODEGEN_THRESHOLD = 32;
+export declare const PLAN_CODEGEN_THRESHOLD = 1024;
 /**
  * The shape of a compiled sync plan: what its closure does, stated as data the generator can read.
  *
@@ -49,7 +51,8 @@ export type PlanNode = {
  *
  * @remarks A node that `awaits` has a dependency that may yield a promise, so it runs as the
  * interpreted async path does: every dependency starts in order, a sync throw becomes that slot's
- * rejection, and the constructor or factory runs on the settled values.
+ * rejection, the constructor or factory runs on the settled values, and a failure is reported in
+ * declaration order.
  *
  * @since 0.10.0
  */