@codefast/di 0.10.1 → 0.12.0

package/dist/resolution/resolver.js

@@ -1,21 +1,21 @@
-import { NO_INSTANCE } from "#core/binding";
-import { NO_TAG_KEYS, slotNameCriterionOf } from "#core/tag";
+import { bindingSlotToString, NO_INSTANCE } from "#core/binding";
+import { slotNameCriterionOf } from "#core/tag";
 import { tokenName } from "#core/token";
-import { AsyncActivationError, AsyncResolutionError, CircularDependencyError, DisposedContainerError, InternalError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, TokenNotBoundError, } from "#errors/errors";
-import { loneTagBesideNameOf, resolveOptionsForSlot, singleCriterionForSlot, singleCriterionOnlyOf, } from "#injection/resolve-options";
-import { SCOPED_MISS } from "#lifecycle/scope-manager";
+import { AsyncActivationError, AsyncResolutionError, CircularDependencyError, DisposedContainerError, InternalError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, TokenNotBoundError, } from "#errors";
+import { loneTagBesideNameOf, resolveOptionsForSlot, singleCriterionForSlot, singleCriterionOnlyOf, } from "#injection/dependency-slot";
+import { SCOPED_MISS } from "#lifecycle/scopes";
+import { settleInOrder } from "#resolution/async-fan-out";
 import { ActivationNeedCache } from "#resolution/cache/activation-need";
-import { BindingLookupCache } from "#resolution/cache/binding-lookup-cache";
 import { ClassIntrospector } from "#resolution/cache/class-introspector";
-import { AsyncCascadeContext, AsyncLevelContext, buildResolutionFrame, DefaultResolutionContext, } from "#resolution/context";
-import { branchDepthOf, cycleNamesOf, enterResolutionPath, extendResolutionBranch, ROOT_BRANCH, UNOWNED_BRANCH, } from "#resolution/path/resolution-path";
-import { InstantiationPlanCompiler, PLAN_RETRY } from "#resolution/plan/instantiation-plan";
-import { matchesSlot, requestedTagKeyMask, selectAllBindings, selectBinding } from "#resolution/select/binding-select";
-// Where a multi-tag resolve switches from scanning the token's list to walking the tag indexes.
-const MULTI_TAG_INDEX_THRESHOLD = 8;
-const EMPTY_STRING_LIST = [];
+import { BindingLookupCache } from "#resolution/cache/lookup";
+import { AsyncLevelContext, DefaultConstraintContext, DefaultResolutionContext } from "#resolution/context";
+import { branchDepthOf, buildResolutionFrame, cycleNamesOf, enterSyncPath, extendResolutionBranch, leaveSyncPath, ROOT_BRANCH, UNOWNED_BRANCH, } from "#resolution/path";
+import { InstantiationPlanCompiler, PLAN_RETRY } from "#resolution/plan/compiler";
+import { matchesSlot, selectAllBindings, selectBinding } from "#resolution/select/candidates";
 const EMPTY_FRAME_LIST = [];
 const EMPTY_PARAM_LIST = [];
+// A class with no params is constructed with no arguments, so no dependency array is built for it.
+const NO_ARGUMENTS = [];
 /** Plans compiled so far, with the `null` unplannable marks left out. */
 function countCompiledPlans(plans) {
     let count = 0;
@@ -28,22 +28,15 @@ function countCompiledPlans(plans) {
     }
     return count;
 }
-const ROOT_CONSTRAINT_CONTEXT = {
-    resolutionPath: EMPTY_STRING_LIST,
-    resolutionStack: EMPTY_FRAME_LIST,
-    parent: undefined,
-    ancestors: EMPTY_FRAME_LIST,
-    currentResolveOptions: undefined,
-};
+const ROOT_CONSTRAINT_CONTEXT = new DefaultConstraintContext(EMPTY_FRAME_LIST, undefined);
 /**
  * The resolution engine driving binding selection, instantiation, scoping, and lifecycle hooks.
  *
  * @since 0.3.16-canary.0
  */
 export class DependencyResolver {
-    #syncResolutionContextPool = [];
-    // Contexts bound to the cascade pair — deferred: only an async cascade's sync resolves need it.
-    #cascadeContextPool;
+    // Contexts pooled by depth over the root stack — deferred: a plan-served or constant-only container never needs one.
+    #syncResolutionContextPool;
     /**
      * The stack a top-level **sync** resolve reuses instead of minting an array per call.
      *
@@ -53,25 +46,31 @@ export class DependencyResolver {
      * mints its own. Keeping it stable is also what lets a pooled context skip re-storing it.
      */
     rootStack = [];
-    // The open synchronous factory cascade: its stack is the ancestor chain, and it is balanced
-    // because synchronous code does not interleave.
-    #cascadeStack = [];
-    #cascadeContext;
+    // The last root level's context, kept so one instance is always live: a full collection that finds
+    // none deoptimizes every optimized site that embedded the class's shape, and does so on every
+    // collection after — measured on the async chain rows, and removed by this one field.
+    #recentRootLevelContext;
     // Compiled plans; `null` marks a binding as unplannable under the current cache versions. Both
-    // maps are allocated by the first plan request, which only a class or resolved binding makes.
+    // maps are allocated by the first plan request, which only a class or resolved binding makes. A
+    // root is compiled on the request that repeats it — the first interprets, so a container that
+    // resolves a root once never compiles — and the set below remembers the first.
     #classPlanByBindingId;
+    #classPlanRequestedOnce;
     #classPlanRegistryVersion = -1;
     #classPlanActivationVersion = -1;
     // The async lane's plans, stamped and invalidated apart so neither lane pays the other's misses.
     #asyncPlanByBindingId;
+    #asyncPlanRequestedOnce;
     #asyncPlanRegistryVersion = -1;
     #asyncPlanActivationVersion = -1;
     #registry;
     #scope;
     #lifecycle;
     #metadataReader;
+    #container;
     #parent;
     #lookup;
+    // Built by the first class resolve: a container that never resolves a class never pays for it.
     #classes;
     // Built by the first interpreted resolve that asks; a plan-served or constant-only container never does.
     #activation;
@@ -80,16 +79,19 @@ export class DependencyResolver {
         this.#scope = scope;
         this.#lifecycle = lifecycle;
         this.#metadataReader = metadataReader;
+        this.#container = container;
         this.#parent = parent;
         this.#lookup = new BindingLookupCache(registry, this, parent === undefined ? undefined : parent.#lookup);
-        this.#classes = new ClassIntrospector(metadataReader, container, parent === undefined ? undefined : parent.#classes);
+    }
+    #introspector() {
+        return (this.#classes ??= new ClassIntrospector(this.#metadataReader, this.#container, this.#parent === undefined ? undefined : this.#parent.#introspector()));
     }
     /** The reader this resolver was built with, which is the one its container answers with. */
     get metadataReader() {
         return this.#metadataReader;
     }
     #activationNeed() {
-        return (this.#activation ??= new ActivationNeedCache(this.#lifecycle, this.#classes, this.#registry));
+        return (this.#activation ??= new ActivationNeedCache(this.#lifecycle, this.#introspector(), this.#registry));
     }
     /** Structural counts and the resolver-owned collaborators built so far, for the {@link ResolutionDiagnostics} a container reports. */
     describeCaches() {
@@ -100,18 +102,18 @@ export class DependencyResolver {
         if (this.#lookup.isMemoBuilt) {
             builtSubsystems.push("resolver.lookupMemo");
         }
-        if (this.#activation?.isMemoBuilt === true) {
-            builtSubsystems.push("resolver.activationNeedMemo");
-        }
         const generatedPlanCount = this.#planCompiler?.generatedPlanCount ?? 0;
         if (generatedPlanCount > 0) {
             builtSubsystems.push("resolver.planCodegen");
         }
+        if (this.#recentRootLevelContext !== undefined) {
+            builtSubsystems.push("resolver.asyncRootLevel");
+        }
         return {
             compiledPlanCount: countCompiledPlans(this.#classPlanByBindingId),
             compiledAsyncPlanCount: countCompiledPlans(this.#asyncPlanByBindingId),
             generatedPlanCount,
-            syncContextPoolSize: this.#syncResolutionContextPool.length,
+            syncContextPoolSize: this.#syncResolutionContextPool?.length ?? 0,
             builtSubsystems,
         };
     }
@@ -134,23 +136,19 @@ export class DependencyResolver {
             if (indexed === undefined) {
                 // A one-criterion request matches only a slot carrying exactly that criterion, and every such
                 // slot is in the index, so a miss here is a miss for this registry: nothing left to scan.
-                return this.#parent === undefined
-                    ? undefined
-                    : this.#parent.#findBinding(token, options, resolutionStack, singleCriterion);
+                return this.#forwardingAliasOrParent(token, options, resolutionStack, singleCriterion);
             }
             if (this.#satisfiesPredicate(indexed, options, resolutionStack)) {
                 return { binding: indexed, owner: this };
             }
         }
-        else {
-            if (options.name !== undefined) {
-                const pairTag = loneTagBesideNameOf(options);
-                if (pairTag !== undefined) {
-                    const nameCriterion = slotNameCriterionOf(options.name);
-                    if (nameCriterion === undefined) {
-                        // No binding anywhere has declared this name, so no slot in any registry can carry it.
-                        return undefined;
-                    }
+        else if (options.name !== undefined) {
+            const pairTag = loneTagBesideNameOf(options);
+            if (pairTag !== undefined) {
+                const nameCriterion = slotNameCriterionOf(options.name);
+                // A name interned nowhere cannot key a slot, but a slot whose criteria are a subset of the
+                // request's still matches — so an index miss falls through to the scan, never a clean miss.
+                if (nameCriterion !== undefined) {
                     // The exact two-criterion slot, memoized over the chain; a predicate or an alias declines to the scan.
                     const entry = this.#lookup.namedTaggedEntry(token, nameCriterion, pairTag);
                     if (entry !== null) {
@@ -158,22 +156,6 @@ export class DependencyResolver {
                     }
                 }
             }
-            if (
-            // A threshold switches the data structure, never the semantics: under it the generic scan
-            // below beats walking the indexes, and both paths answer identically. Sized first, so a
-            // small list pays one length read and nothing else.
-            this.#registry.countBindings(token) > MULTI_TAG_INDEX_THRESHOLD &&
-                requestedTagKeyMask(options) !== NO_TAG_KEYS) {
-                // A multi-criterion request matches only slots whose every criterion it carries, and every
-                // such slot is in the two tag indexes — their union is the whole candidate set, unscanned.
-                const selected = this.#selectMultiTagged(token, options, resolutionStack);
-                if (selected !== undefined) {
-                    return { binding: selected, owner: this };
-                }
-                return this.#parent === undefined
-                    ? undefined
-                    : this.#parent.#findBinding(token, options, resolutionStack, singleCriterion);
-            }
         }
         // A lone default-slot candidate is its own selection: the slot match is the whole decision,
         // it carries no predicate, and asking for it first keeps the registry from materialising its list.
@@ -194,10 +176,29 @@ export class DependencyResolver {
                 }
             }
         }
-        if (this.#parent !== undefined) {
-            return this.#parent.#findBinding(token, options, resolutionStack, singleCriterion);
+        if (options === undefined) {
+            return this.#parent === undefined
+                ? undefined
+                : this.#parent.#findBinding(token, options, resolutionStack, singleCriterion);
+        }
+        return this.#forwardingAliasOrParent(token, options, resolutionStack, singleCriterion);
+    }
+    /**
+     * What a request with criteria finds once no slot of this registry matches them: the token's
+     * default-slot alias, which forwards them to its target, else the parent's answer.
+     *
+     * @remarks A default-slot alias carries no criterion, predicate or membership, so it is a pointer
+     * rather than a candidate — every exact slot here was tried first, and the nearest container that
+     * can answer still does.
+     */
+    #forwardingAliasOrParent(token, options, resolutionStack, singleCriterion) {
+        const defaultSlotAlias = this.#registry.defaultSlotAlias(token);
+        if (defaultSlotAlias !== undefined) {
+            return { binding: defaultSlotAlias, owner: this };
         }
-        return undefined;
+        return this.#parent === undefined
+            ? undefined
+            : this.#parent.#findBinding(token, options, resolutionStack, singleCriterion);
     }
     /**
      * The scan a candidate list gets before full selection.
@@ -248,14 +249,40 @@ export class DependencyResolver {
         }
         if (found === undefined) {
             // Thrown here rather than from a helper: the error captures this stack, and an error path is
-            // dominated by that capture. Bindings under the token mean the request matched none of them.
-            if (this.#registry.getAll(currentToken).length > 0) {
-                throw new NoMatchingBindingError(tokenName(currentToken), options ?? {}, this.#registry.availableSlotStrings(currentToken));
+            // dominated by that capture. Bindings under the token anywhere in the chain mean the request
+            // matched none of them, so a child reports the same miss its parent would.
+            const bound = this.#allBindingsFromChain(currentToken);
+            if (bound.length > 0) {
+                throw new NoMatchingBindingError(tokenName(currentToken), options ?? {}, bound.map((binding) => bindingSlotToString(binding.slot)));
             }
             throw new TokenNotBoundError(tokenName(currentToken));
         }
         return found;
     }
+    /**
+     * Follows an alias binding's chain to its terminal binding, or `undefined` when the chain ends at
+     * a token nothing matches.
+     *
+     * @remarks The non-throwing twin of {@link DependencyResolver.#requireBinding}'s alias walk, for
+     * the optional and collection lanes: a dangling chain is a miss, but a revisited alias token still
+     * raises {@link CircularDependencyError} — a cycle has no absent reading.
+     */
+    #terminalOfAliasBinding(alias, options, resolutionStack, singleCriterion) {
+        let currentToken = alias.token;
+        let found = { binding: alias, owner: this };
+        let visitedAliasTokens;
+        while (found !== undefined && found.binding.kind === "alias") {
+            const target = found.binding.target;
+            visitedAliasTokens ??= new Set([currentToken]);
+            if (visitedAliasTokens.has(target)) {
+                throw new CircularDependencyError([...visitedAliasTokens, target].map((entry) => tokenName(entry)));
+            }
+            visitedAliasTokens.add(target);
+            currentToken = target;
+            found = this.#findBinding(currentToken, options, resolutionStack, singleCriterion);
+        }
+        return found;
+    }
     /**
      * Binding lookup aligned with `resolve` — used by `Container.validate` without instantiating.
      */
@@ -346,6 +373,8 @@ export class DependencyResolver {
             if (binding.activationHook !== undefined) {
                 const activationResult = binding.activationHook(resolutionCtx, activated);
                 if (activationResult instanceof Promise) {
+                    // The hook has already run; adopt its rejection so it cannot surface as unhandled.
+                    void activationResult.catch(() => { });
                     throw new AsyncActivationError(tokenDisplayName, "onActivation");
                 }
                 activated = activationResult;
@@ -354,6 +383,7 @@ export class DependencyResolver {
                 for (let index = 0; index < containerHooks.length; index += 1) {
                     const activationResult = containerHooks[index](resolutionCtx, activated);
                     if (activationResult instanceof Promise) {
+                        void activationResult.catch(() => { });
                         throw new AsyncActivationError(tokenDisplayName, "onActivation");
                     }
                     activated = activationResult;
@@ -390,6 +420,7 @@ export class DependencyResolver {
             }
             else {
                 this.#classPlanByBindingId.clear();
+                this.#classPlanRequestedOnce?.clear();
             }
             this.#classPlanRegistryVersion = registryVersion;
             this.#classPlanActivationVersion = activationVersion;
@@ -399,6 +430,12 @@ export class DependencyResolver {
         if (cached !== undefined) {
             return cached;
         }
+        const requestedOnce = (this.#classPlanRequestedOnce ??= new Set());
+        if (!requestedOnce.has(binding.identifier)) {
+            // The first request interprets; the one that repeats it compiles.
+            requestedOnce.add(binding.identifier);
+            return null;
+        }
         const compiled = this.#compiler().compile(binding);
         if (compiled === PLAN_RETRY) {
             // Lifecycle metadata not discovered yet — the fallback resolve discovers it; retry then.
@@ -416,25 +453,24 @@ export class DependencyResolver {
     // The behaviour the plan compiler needs from this resolver — lookups, escapes, plan swaps, and the
     // accessor construction path. Built once with the compiler, so each closure is allocated once.
     #buildPlanCompilerHost() {
+        const classes = this.#introspector();
         return {
             hasActivationHandlers: (binding) => this.#ownerOf(binding).#lifecycle.hasActivationHandlers(binding.token),
-            knownPostConstruct: (target) => this.#classes.knownPostConstruct(target),
-            needsActiveContainer: (target) => this.#classes.needsActiveContainer(target),
+            knownPostConstruct: (target) => classes.knownPostConstruct(target),
+            needsActiveContainer: (target) => classes.needsActiveContainer(target),
             // A plan runs at the top level, so the lent root stack is free when it is; a plan reached
             // with the root stack held mints its own path, exactly as the interpreted lane would.
             constructWithAccessors: (binding, target, deps) => {
                 const stack = this.rootStack.length === 0 ? this.rootStack : [];
-                const frame = this.#getResolutionFrame(binding);
-                const resolutionSet = enterResolutionPath(stack, frame);
+                enterSyncPath(stack, binding, this.#getResolutionFrame(binding));
                 try {
-                    return this.#classes.instantiate(target, deps, this.#ambientResolutionFor(stack));
+                    return classes.instantiate(target, deps, this.#ambientResolutionFor(stack));
                 }
                 finally {
-                    stack.pop();
-                    resolutionSet?.delete(frame.bindingId);
+                    leaveSyncPath(stack, binding);
                 }
             },
-            getConstructorMetadata: (target) => this.#classes.constructorMetadata(target),
+            getConstructorMetadata: (target) => classes.constructorMetadata(target),
             lookupDependencyEntry: (token) => {
                 const entry = this.#lookup.defaultEntry(token);
                 return entry === null ? null : { binding: entry.binding };
@@ -480,7 +516,7 @@ export class DependencyResolver {
                 }
                 return this.resolve(token, options, resolutionStack);
             },
-            // Dispatches exactly as #resolveDepAsync does, for the async lane's escapes.
+            // Dispatches exactly as #settleDep does, for the async lane's escapes.
             resolveEscapedAsync: (token, options, arity, resolutionStack) => {
                 if (arity === "all") {
                     return this.resolveAllAsync(token, options, resolutionStack, UNOWNED_BRANCH);
@@ -505,6 +541,7 @@ export class DependencyResolver {
             }
             else {
                 this.#asyncPlanByBindingId.clear();
+                this.#asyncPlanRequestedOnce?.clear();
             }
             this.#asyncPlanRegistryVersion = registryVersion;
             this.#asyncPlanActivationVersion = activationVersion;
@@ -514,6 +551,11 @@ export class DependencyResolver {
         if (cached !== undefined) {
             return cached;
         }
+        const requestedOnce = (this.#asyncPlanRequestedOnce ??= new Set());
+        if (!requestedOnce.has(binding.identifier)) {
+            requestedOnce.add(binding.identifier);
+            return null;
+        }
         const compiled = this.#compiler().compileAsync(binding);
         if (compiled === PLAN_RETRY) {
             // Lifecycle metadata not discovered yet — the fallback resolve discovers it; retry then.
@@ -581,7 +623,8 @@ export class DependencyResolver {
         }
         const frame = this.#getResolutionFrame(binding);
         const tokenDisplayName = frame.tokenName;
-        const resolutionSet = enterResolutionPath(resolutionStack, frame);
+        // The level holds its binding's flag for its whole duration, so a factory below runs bare.
+        enterSyncPath(resolutionStack, binding, frame);
         try {
             const needsActivation = owner.#activationNeed().needsActivation(binding);
             if (!needsActivation && scope === "transient" && binding.kind === "dynamic") {
@@ -609,8 +652,7 @@ export class DependencyResolver {
             return activated;
         }
         finally {
-            resolutionStack.pop();
-            resolutionSet?.delete(frame.bindingId);
+            leaveSyncPath(resolutionStack, binding);
         }
     }
     /**
@@ -651,8 +693,13 @@ export class DependencyResolver {
             case "dynamic-async":
                 throw asyncResolutionErrorFor(binding, resolutionStack);
             case "class": {
-                const deps = this.#resolveDeps(this.#constructorParams(binding.target), resolutionStack);
-                return this.#classes.instantiate(binding.target, deps, this.#classes.needsActiveContainer(binding.target) ? this.#ambientResolutionFor(resolutionStack) : undefined);
+                // One lookup of the class's facts serves the params, the accessor need and the construction.
+                const introspector = this.#introspector();
+                const target = binding.target;
+                const facts = introspector.facts(target);
+                const params = this.#constructorParams(target, facts);
+                const needsActiveContainer = introspector.needsActiveContainerOf(target, facts);
+                return introspector.construct(target, params.length === 0 ? NO_ARGUMENTS : this.#resolveDeps(params, resolutionStack), needsActiveContainer, needsActiveContainer ? this.#ambientResolutionFor(resolutionStack) : undefined);
             }
             case "resolved": {
                 const deps = this.#resolveDeps(binding.deps, resolutionStack);
@@ -674,12 +721,25 @@ export class DependencyResolver {
      * @remarks A class the metadata reader knows nothing about is constructible only if it declares
      * no parameters; anything else is a missing `@injectable()`.
      */
-    #constructorParams(target) {
-        const meta = this.#classes.constructorMetadata(target);
+    #constructorParams(target, facts) {
+        // Metadata is fixed once a class is defined, so the answer is too; only a throw is left unsettled.
+        return (facts.params ??= this.#settleConstructorParams(target, facts));
+    }
+    #settleConstructorParams(target, facts) {
+        const meta = this.#introspector().constructorMetadataOf(target, facts);
         if (meta !== undefined) {
             return meta.params;
         }
         if (target.length === 0) {
+            // A subclass with an implicit constructor and no own metadata inherits its base's declared
+            // deps but would be built with zero arguments, injecting `undefined` silently — reject it.
+            const inherited = this.#introspector().inheritedConstructorMetadata(target);
+            if (inherited !== undefined && inherited.metadata.params.length > 0) {
+                throw new MissingMetadataError(target.name, {
+                    baseName: inherited.base.name,
+                    dependencyCount: inherited.metadata.params.length,
+                });
+            }
             return EMPTY_PARAM_LIST;
         }
         throw new MissingMetadataError(target.name);
@@ -727,16 +787,18 @@ export class DependencyResolver {
                 return undefined;
             }
         }
-        const entry = this.#findBinding(token, options, resolutionStack, precomputedCriterion === undefined ? singleCriterionOnlyOf(options) : (precomputedCriterion ?? undefined));
+        const singleCriterion = precomputedCriterion === undefined ? singleCriterionOnlyOf(options) : (precomputedCriterion ?? undefined);
+        let entry = this.#findBinding(token, options, resolutionStack, singleCriterion);
+        // Resolve the entry the probe found: re-looking the token up would evaluate every `when()`
+        // predicate a second time, and a changed answer would throw where `undefined` was promised.
+        if (entry !== undefined && entry.binding.kind === "alias") {
+            // Follow the alias off the throwing path: a chain that ends nowhere is a miss, not an error.
+            entry = this.#terminalOfAliasBinding(entry.binding, options, resolutionStack, singleCriterion);
+        }
         if (entry === undefined) {
             return undefined;
         }
-        // Resolve the entry the probe found: re-looking the token up would evaluate every `when()`
-        // predicate a second time, and a changed answer would throw where `undefined` was promised.
         const { binding, owner } = entry;
-        if (binding.kind === "alias") {
-            return this.resolve(token, options, resolutionStack);
-        }
         if (binding.scope === "singleton" && owner !== this) {
             return owner.#resolveBinding(binding, options, resolutionStack, owner);
         }
@@ -761,37 +823,45 @@ export class DependencyResolver {
         const resolutionStack = this.rootStack;
         const memo = this.#rootCollection(token, resolutionStack);
         if (memo.values !== undefined && memo.activationVersion === this.#chainActivationVersion()) {
-            return memo.values;
+            // A copy, never the memo itself: a caller that writes into its result must not rewrite the
+            // next caller's. Reading a frozen array is several times slower than reading a plain one, so
+            // the copy is the cheaper guard by far, and it costs one allocation the read already paid before the memo.
+            return memo.values.slice();
         }
         const { candidates } = memo;
         const resolved = new Array(candidates.length);
         for (let index = 0; index < candidates.length; index += 1) {
             resolved[index] = this.#resolveCandidateSync(candidates[index], undefined, resolutionStack);
         }
-        // The members this read materialised may have made the list stable for the next one.
-        this.#settleCollectionValues(memo);
+        this.#settleOnRepeat(memo);
         return resolved;
     }
-    /** The async twin of `resolveRootCollection`: a stable value list settles at once, candidates fan out as usual. */
+    /** The async twin of `resolveRootCollection`: a stable value list answers at once, candidates fan out as usual. */
     resolveRootCollectionAsync(token) {
         // The async lane appends to its branch and never unwinds, so it works on a stack of its own.
         const resolutionStack = [];
-        const memo = this.#rootCollection(token, resolutionStack);
-        if (memo.values !== undefined && memo.activationVersion === this.#chainActivationVersion()) {
-            return Promise.resolve(memo.values);
+        try {
+            // Selection runs `when()` predicates and follows aliases, either of which may throw.
+            const memo = this.#rootCollection(token, resolutionStack);
+            if (memo.values !== undefined && memo.activationVersion === this.#chainActivationVersion()) {
+                return Promise.resolve(memo.values.slice());
+            }
+            return asPromise(this.#settleCandidates(memo.candidates, undefined, resolutionStack, UNOWNED_BRANCH, (values) => {
+                this.#settleOnRepeat(memo);
+                return values;
+            }));
+        }
+        catch (collectionError) {
+            return Promise.reject(collectionError);
         }
-        return Promise.all(memo.candidates.map((candidate) => this.#resolveCandidateAsync(candidate, undefined, resolutionStack, UNOWNED_BRANCH))).then((values) => {
-            this.#settleCollectionValues(memo);
-            return values;
-        });
     }
     /**
      * The memoized candidate list of a root-level, options-less collection, built on its first read.
      *
      * @remarks Sound because a `when()` predicate is pure over its context and the root context is a
      * constant: the list can only change when a registry in the chain does, which is the version the
-     * memo is stamped with. The value list is kept too while every member is a hook-free constant
-     * and no activation hook exists anywhere in the chain.
+     * memo is stamped with. From the second read on, the value list is kept too while every member is
+     * a hook-free constant and no activation hook exists anywhere in the chain.
      */
     #rootCollection(token, resolutionStack) {
         const memo = this.#lookup.collection(token);
@@ -799,11 +869,20 @@ export class DependencyResolver {
             return memo;
         }
         const candidates = this.#candidateBindings(token, undefined, resolutionStack);
-        const entry = { candidates, values: undefined, activationVersion: -1 };
-        this.#settleCollectionValues(entry);
+        const entry = { candidates, values: undefined, activationVersion: -1, readBefore: false };
         this.#lookup.rememberCollection(token, entry);
         return entry;
     }
+    // The first read interprets and the read that repeats it settles the value list, as a plan compiles on repeat;
+    // the members either read materialised may have made the list stable for the next one.
+    #settleOnRepeat(entry) {
+        if (entry.readBefore) {
+            this.#settleCollectionValues(entry);
+        }
+        else {
+            entry.readBefore = true;
+        }
+    }
     /**
      * Fills a collection memo's value list once every member is stable: a hook-free constant, or a
      * hook-free singleton whose instance is cached — anything that changes either bumps a registry
@@ -819,8 +898,7 @@ export class DependencyResolver {
                 return;
             }
         }
-        // Handed out as is, unfrozen: a frozen array iterates through a slow elements kind, so the
-        // contract's read-only return is the guard against a caller writing into the memo.
+        // Kept unfrozen: a frozen array reads through a slow elements kind, and every read copies it anyway.
         entry.values = candidates.map(stableMemberValue);
         entry.activationVersion = 0;
     }
@@ -829,14 +907,52 @@ export class DependencyResolver {
         if (options !== undefined) {
             const indexed = this.#indexedCandidates(token, options, resolutionStack);
             if (indexed !== null) {
-                return indexed;
+                return this.#withoutDanglingAliases(indexed, options, resolutionStack);
             }
         }
         const allBindings = this.#allBindingsFromChain(token);
         if (allBindings.length === 0) {
             return allBindings;
         }
-        return selectAllBindings(allBindings, options, this.#makeConstraintContext(resolutionStack, options));
+        const selected = selectAllBindings(allBindings, options, this.#makeConstraintContext(resolutionStack, options));
+        return this.#withoutDanglingAliases(selected, options, resolutionStack);
+    }
+    // A chain none of whose registries ever held an alias has none to drop, which spares the scan.
+    #chainHeldAlias() {
+        if (this.#registry.hasHeldAlias) {
+            return true;
+        }
+        for (let current = this.#parent; current !== undefined; current = current.#parent) {
+            if (current.#registry.hasHeldAlias) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * The candidates with any alias whose chain ends nowhere dropped, so a fan-out skips a dangling
+     * alias rather than throwing on it.
+     *
+     * @remarks A live alias stays and resolves as before; the common list carries no alias at all and
+     * is returned untouched, so nothing is allocated for it.
+     */
+    #withoutDanglingAliases(candidates, options, resolutionStack) {
+        if (!this.#chainHeldAlias()) {
+            return candidates;
+        }
+        let hasAlias = false;
+        for (let index = 0; index < candidates.length; index += 1) {
+            if (candidates[index].kind === "alias") {
+                hasAlias = true;
+                break;
+            }
+        }
+        if (!hasAlias) {
+            return candidates;
+        }
+        const singleCriterion = singleCriterionOnlyOf(options);
+        return candidates.filter((candidate) => candidate.kind !== "alias" ||
+            this.#terminalOfAliasBinding(candidate, options, resolutionStack, singleCriterion) !== undefined);
     }
     // ── Async resolve ──────────────────────────────────────────────────────────────────────────────────────────────────
     resolveAsyncFromContext(token, resolutionStack, branchDepth) {
@@ -858,35 +974,55 @@ export class DependencyResolver {
         }
         return this.#resolveAsyncDefaultEntry(entry.binding, entry.owner, resolutionStack, branchDepth);
     }
+    // A `#settle*` lane answers with the value when its level completed in this tick and with a promise
+    // only where something had to be awaited, so a singleton or scoped instance built without yielding
+    // is cached before the fan-out that started it moves on to a sibling that may read it synchronously.
     #resolveAsyncDefaultEntry(binding, owner, resolutionStack, branchDepth) {
+        try {
+            return asPromise(this.#settleDefaultEntry(binding, owner, resolutionStack, branchDepth));
+        }
+        catch (entryError) {
+            // Not `async`: a failure is turned into the rejection the entry point promises.
+            return Promise.reject(entryError);
+        }
+    }
+    /** `resolveAsyncFromContext` for a dependency slot: the same lanes, answered in this tick where they can be. */
+    #settleDefault(token, resolutionStack, branchDepth) {
+        const fastBinding = this.#registry.getFastDefault(token);
+        if (fastBinding !== undefined && fastBinding.kind !== "alias") {
+            return this.#settleDefaultEntry(fastBinding, this, resolutionStack, branchDepth);
+        }
+        const entry = this.#lookup.defaultEntry(token);
+        if (entry === null) {
+            return this.#settleRequest(token, undefined, resolutionStack, branchDepth);
+        }
+        return this.#settleDefaultEntry(entry.binding, entry.owner, resolutionStack, branchDepth);
+    }
+    #settleDefaultEntry(binding, owner, resolutionStack, branchDepth) {
         if (owner.#isPlainConstant(binding)) {
-            return Promise.resolve(binding.value);
+            return binding.value;
         }
         const scope = binding.scope;
         if (scope === "transient") {
             if ((binding.kind === "dynamic" || binding.kind === "dynamic-async") && !owner.#hasAnyActivation(binding)) {
-                return this.#resolveTransientDynamicAsyncFromContext(binding, resolutionStack, branchDepth);
+                return this.#settleTransientFactory(binding, resolutionStack, branchDepth);
             }
         }
         else if (scope === "singleton") {
             if (binding.instance !== NO_INSTANCE) {
-                return Promise.resolve(binding.instance);
+                return binding.instance;
             }
             if (owner !== this) {
-                return owner.#resolveBindingAsync(binding, undefined, resolutionStack, branchDepth, owner);
+                return owner.#settleBinding(binding, undefined, resolutionStack, branchDepth, owner);
             }
         }
-        else if (this.#scope.isChild) {
-            const cachedScoped = this.#scope.readScoped(binding.identifier);
+        else {
+            const cachedScoped = this.#readScoped(binding);
             if (cachedScoped !== SCOPED_MISS) {
-                return Promise.resolve(cachedScoped);
+                return cachedScoped;
             }
         }
-        else {
-            // Not `#readScoped`: this entry point reports failure as a rejection, never a sync throw.
-            return Promise.reject(new MissingScopeContextError(tokenName(binding.token)));
-        }
-        return this.#resolveBindingAsync(binding, undefined, resolutionStack, branchDepth, owner);
+        return this.#settleBinding(binding, undefined, resolutionStack, branchDepth, owner);
     }
     /**
      * Instantiates one owned binding directly, bypassing selection.
@@ -895,16 +1031,38 @@ export class DependencyResolver {
      * could pick a different candidate whose criteria are a subset of them.
      */
     warmBindingAsync(binding, options) {
-        return this.#resolveBindingAsync(binding, options, [], ROOT_BRANCH, this);
+        try {
+            return asPromise(this.#settleBinding(binding, options, [], ROOT_BRANCH, this));
+        }
+        catch (bindingError) {
+            return Promise.reject(bindingError);
+        }
+    }
+    resolveAsync(token, options, resolutionStack, branchDepth = UNOWNED_BRANCH, precomputedCriterion) {
+        try {
+            return asPromise(this.#settleRequest(token, options, resolutionStack, branchDepth, precomputedCriterion));
+        }
+        catch (requestError) {
+            return Promise.reject(requestError);
+        }
     }
-    async resolveAsync(token, options, resolutionStack, branchDepth = UNOWNED_BRANCH, precomputedCriterion) {
-        const { binding, owner } = this.#requireBinding(token, options, resolutionStack, precomputedCriterion);
+    /** Selects the binding a request names and settles it on the async lane. */
+    #settleRequest(token, options, resolutionStack, branchDepth, precomputedCriterion) {
+        const path = ownPrefixOf(resolutionStack, branchDepth);
+        const depth = path === resolutionStack ? branchDepth : branchDepthOf(path);
+        const { binding, owner } = this.#requireBinding(token, options, path, precomputedCriterion);
         if (binding.scope === "singleton" && owner !== this) {
-            return owner.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
+            return owner.#settleBinding(binding, options, path, depth, owner);
         }
-        return this.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
+        return this.#settleBinding(binding, options, path, depth, owner);
     }
-    async #resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner) {
+    /**
+     * Materialises one binding on the async lane: the instance once nothing yielded, else its promise.
+     *
+     * @remarks A singleton or scoped instance built in this tick is cached in this tick, so a sibling
+     * reading it synchronously finds it; only a materialisation still pending is published in flight.
+     */
+    #settleBinding(binding, options, resolutionStack, branchDepth, owner) {
         if (owner.#isPlainConstant(binding)) {
             return binding.value;
         }
@@ -916,7 +1074,7 @@ export class DependencyResolver {
             // In-flight dedup: concurrent callers share the first creation.
             const inflight = this.#scope.getInflight(binding.identifier);
             if (inflight !== undefined) {
-                return inflight;
+                return ownPromiseOf(inflight);
             }
             if (this.#scope.isClosed) {
                 throw new DisposedContainerError();
@@ -930,7 +1088,7 @@ export class DependencyResolver {
             // In-flight dedup, scoped flavor: one instance per scope even under concurrency.
             const inflight = this.#scope.getInflight(binding.identifier);
             if (inflight !== undefined) {
-                return inflight;
+                return ownPromiseOf(inflight);
             }
             if (this.#scope.isClosed) {
                 throw new DisposedContainerError();
@@ -943,42 +1101,52 @@ export class DependencyResolver {
         const needsActivation = owner.#activationNeed().needsActivation(binding);
         if (!needsActivation && scope === "transient" && (binding.kind === "dynamic" || binding.kind === "dynamic-async")) {
             const resolutionCtx = new AsyncLevelContext(this, levelStack, options);
-            if (binding.kind === "dynamic-async") {
-                return await binding.factory(resolutionCtx);
+            if (branchDepth === ROOT_BRANCH) {
+                this.#recentRootLevelContext = resolutionCtx;
             }
-            const dynamicResult = binding.factory(resolutionCtx);
-            return dynamicResult instanceof Promise ? await dynamicResult : dynamicResult;
+            return runFactoryPrefix(binding, resolutionCtx, levelStack);
         }
         const resolutionCtx = needsActivation || requiresResolutionContext(binding)
             ? new AsyncLevelContext(this, levelStack, options)
             : undefined;
+        if (resolutionCtx !== undefined && branchDepth === ROOT_BRANCH) {
+            this.#recentRootLevelContext = resolutionCtx;
+        }
+        const activated = this.#settleActivated(binding, resolutionCtx, levelStack, levelDepth, needsActivation, owner);
+        if (scope === "transient") {
+            return activated;
+        }
+        if (isPending(activated)) {
+            return this.#publishInFlight(binding, activated, scope);
+        }
         if (scope === "singleton") {
-            // The promise is published before it settles, so concurrent callers dedup onto it.
-            const singletonPromise = this.#instantiateAndActivateAsync(binding, resolutionCtx, levelStack, levelDepth, needsActivation, owner).then((activated) => {
+            this.#scope.setSingleton(binding, activated);
+        }
+        else {
+            this.#scope.setScoped(binding, activated);
+        }
+        return activated;
+    }
+    /**
+     * Publishes a pending singleton or scoped materialisation so concurrent callers dedup onto it,
+     * and caches what it settles to; the creator, like every joiner, is handed a promise of its own.
+     */
+    #publishInFlight(binding, pending, scope) {
+        const published = pending.then((activated) => {
+            if (scope === "singleton") {
                 this.#scope.setSingleton(binding, activated);
-                this.#scope.clearInflight(binding.identifier);
-                return activated;
-            }, (error) => {
-                this.#scope.clearInflight(binding.identifier);
-                throw error;
-            });
-            this.#scope.setInflight(binding.identifier, singletonPromise);
-            return await singletonPromise;
-        }
-        if (scope === "scoped") {
-            // Published before it settles, like the singleton lane: concurrent callers share one creation.
-            const scopedPromise = this.#instantiateAndActivateAsync(binding, resolutionCtx, levelStack, levelDepth, needsActivation, owner).then((activated) => {
+            }
+            else {
                 this.#scope.setScoped(binding, activated);
-                this.#scope.clearInflight(binding.identifier);
-                return activated;
-            }, (error) => {
-                this.#scope.clearInflight(binding.identifier);
-                throw error;
-            });
-            this.#scope.setInflight(binding.identifier, scopedPromise);
-            return await scopedPromise;
-        }
-        return await this.#instantiateAndActivateAsync(binding, resolutionCtx, levelStack, levelDepth, needsActivation, owner);
+            }
+            this.#scope.clearInflight(binding.identifier);
+            return activated;
+        }, (error) => {
+            this.#scope.clearInflight(binding.identifier);
+            throw error;
+        });
+        this.#scope.setInflight(binding.identifier, published);
+        return ownPromiseOf(published);
     }
     /**
      * Settles this resolver's own `postConstruct` answer for a class binding a parent owns.
@@ -988,103 +1156,179 @@ export class DependencyResolver {
      * this binding on every call, forever.
      */
     #mirrorPostConstructFromOwner(binding, owner) {
-        if (owner !== this && binding.kind === "class" && this.#classes.knownPostConstruct(binding.target) === undefined) {
-            this.#classes.discoverPostConstruct(binding.target);
+        if (owner !== this &&
+            binding.kind === "class" &&
+            this.#introspector().knownPostConstruct(binding.target) === undefined) {
+            this.#introspector().discoverPostConstruct(binding.target);
+        }
+    }
+    /** The activated instance: built and activated in this tick when nothing yielded, else its promise. */
+    #settleActivated(binding, ctx, resolutionStack, branchDepth, needsActivation, owner) {
+        const instance = this.#settleInstance(binding, ctx, resolutionStack, branchDepth);
+        if (isPending(instance)) {
+            return instance.then((built) => this.#activateAsync(binding, ctx, built, needsActivation, owner));
         }
+        return this.#activateAsync(binding, ctx, instance, needsActivation, owner);
     }
-    async #instantiateAndActivateAsync(binding, ctx, resolutionStack, branchDepth, needsActivation, owner) {
-        const instance = await this.#instantiateAsync(binding, ctx, resolutionStack, branchDepth);
+    #activateAsync(binding, ctx, instance, needsActivation, owner) {
         this.#mirrorPostConstructFromOwner(binding, owner);
         if (!owner.#activationNeed().refreshAfterFirstInstantiation(binding, needsActivation)) {
             return instance;
         }
         return owner.#lifecycle.runActivation(ctx, binding, instance, owner.#metadataReader);
     }
-    async #instantiateAsync(binding, ctx, resolutionStack, branchDepth) {
+    /** The instance a binding builds: in this tick when every dependency settled in it, else its promise. */
+    #settleInstance(binding, ctx, resolutionStack, branchDepth) {
         switch (binding.kind) {
             case "constant":
                 return binding.value;
-            case "dynamic": {
+            case "dynamic":
+            case "dynamic-async": {
                 if (ctx === undefined) {
                     throw new InternalError("dynamic binding requires resolution context");
                 }
-                const factoryResult = binding.factory(ctx);
-                return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
+                return runFactoryPrefix(binding, ctx, resolutionStack);
             }
-            case "dynamic-async":
-                if (ctx === undefined) {
-                    throw new InternalError("dynamic-async binding requires resolution context");
-                }
-                return binding.factory(ctx);
             case "class": {
-                const deps = await this.#resolveDepsAsync(this.#constructorParams(binding.target), resolutionStack, branchDepth);
+                const introspector = this.#introspector();
+                const target = binding.target;
+                const facts = introspector.facts(target);
+                const params = this.#constructorParams(target, facts);
+                const needsActiveContainer = introspector.needsActiveContainerOf(target, facts);
                 // Accessor initializers resolve synchronously, so the branch-owned path serves them directly.
-                return this.#classes.instantiate(binding.target, deps, this.#classes.needsActiveContainer(binding.target) ? this.#ambientResolutionFor(resolutionStack) : undefined);
+                const ambient = needsActiveContainer ? this.#ambientResolutionFor(resolutionStack) : undefined;
+                if (params.length === 0) {
+                    return introspector.construct(target, NO_ARGUMENTS, needsActiveContainer, ambient);
+                }
+                const deps = this.#settleDeps(params, resolutionStack, branchDepth);
+                if (isPending(deps)) {
+                    return deps.then((settled) => introspector.construct(target, settled, needsActiveContainer, ambient));
+                }
+                return introspector.construct(target, deps, needsActiveContainer, ambient);
             }
             case "resolved": {
-                const deps = await this.#resolveDepsAsync(binding.deps, resolutionStack, branchDepth);
-                const factoryResult = binding.factory(...deps);
-                return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
+                const factory = binding.factory;
+                const deps = this.#settleDeps(binding.deps, resolutionStack, branchDepth);
+                return isPending(deps) ? deps.then((settled) => factory(...settled)) : factory(...deps);
             }
             case "resolved-async": {
-                const deps = await this.#resolveDepsAsync(binding.deps, resolutionStack, branchDepth);
-                return binding.factory(...deps);
+                const factory = binding.factory;
+                const deps = this.#settleDeps(binding.deps, resolutionStack, branchDepth);
+                return isPending(deps) ? deps.then((settled) => factory(...settled)) : factory(...deps);
             }
             case "alias":
                 throw new InternalError("alias should have been followed before instantiation");
         }
     }
-    async #resolveDepsAsync(deps, resolutionStack, branchDepth) {
+    /**
+     * One level's dependencies: their values when every one settled in this tick, else the fan-out
+     * that settles them in declaration order.
+     */
+    #settleDeps(deps, resolutionStack, branchDepth) {
         const count = deps.length;
         if (count === 0) {
             return [];
         }
         if (count === 1) {
-            return [await this.#resolveDepAsync(deps[0], resolutionStack, branchDepth)];
+            const only = this.#settleDep(deps[0], resolutionStack, branchDepth);
+            return isPending(only) ? only.then(settledAlone) : [only];
         }
-        // Siblings resolve concurrently and each extends the same branch, so the first appends in
-        // place and the rest copy the prefix — no caller has to isolate them.
+        // Siblings start concurrently and each extends the same branch, so the first appends in
+        // place and the rest copy the prefix — no caller has to isolate them. A sibling's sync throw
+        // becomes its slot's rejection so the ones after it still start, as on every other lane.
         const pending = new Array(count);
+        let yielded = false;
         for (let index = 0; index < count; index += 1) {
-            pending[index] = this.#resolveDepAsync(deps[index], resolutionStack, branchDepth);
+            let settled;
+            try {
+                settled = this.#settleDep(deps[index], resolutionStack, branchDepth);
+            }
+            catch (dependencyError) {
+                settled = Promise.reject(dependencyError);
+            }
+            if (isPending(settled)) {
+                yielded = true;
+            }
+            pending[index] = settled;
         }
-        return Promise.all(pending);
+        return yielded ? settleInOrder(pending, identity) : pending;
     }
-    #resolveDepAsync(dep, resolutionStack, branchDepth) {
+    #settleDep(dep, resolutionStack, branchDepth) {
         const options = resolveOptionsForSlot(dep);
         if (dep.multi) {
-            return this.resolveAllAsync(dep.token, options, resolutionStack, branchDepth);
+            return this.#settleCollection(dep.token, options, resolutionStack, branchDepth);
         }
         if (dep.optional) {
-            return this.resolveOptionalAsync(dep.token, options, resolutionStack, branchDepth, singleCriterionForSlot(dep));
+            return this.#settleOptionalRequest(dep.token, options, resolutionStack, branchDepth, singleCriterionForSlot(dep));
         }
         if (options === undefined) {
-            return this.resolveAsyncFromContext(dep.token, resolutionStack, branchDepth);
+            return this.#settleDefault(dep.token, resolutionStack, branchDepth);
+        }
+        return this.#settleRequest(dep.token, options, resolutionStack, branchDepth, singleCriterionForSlot(dep));
+    }
+    resolveOptionalAsync(token, options, resolutionStack, branchDepth = UNOWNED_BRANCH, precomputedCriterion) {
+        try {
+            return asPromise(this.#settleOptionalRequest(token, options, resolutionStack, branchDepth, precomputedCriterion));
+        }
+        catch (requestError) {
+            return Promise.reject(requestError);
         }
-        return this.resolveAsync(dep.token, options, resolutionStack, branchDepth, singleCriterionForSlot(dep));
     }
-    async resolveOptionalAsync(token, options, resolutionStack, branchDepth = UNOWNED_BRANCH, precomputedCriterion) {
-        const entry = this.#findBinding(token, options, resolutionStack, precomputedCriterion === undefined ? singleCriterionOnlyOf(options) : (precomputedCriterion ?? undefined));
+    #settleOptionalRequest(token, options, resolutionStack, branchDepth, precomputedCriterion) {
+        const path = ownPrefixOf(resolutionStack, branchDepth);
+        const depth = path === resolutionStack ? branchDepth : branchDepthOf(path);
+        const singleCriterion = precomputedCriterion === undefined ? singleCriterionOnlyOf(options) : (precomputedCriterion ?? undefined);
+        let entry = this.#findBinding(token, options, path, singleCriterion);
+        // Same single-evaluation contract as the sync lane: resolve what the probe found.
+        if (entry !== undefined && entry.binding.kind === "alias") {
+            // Follow the alias off the throwing path: a chain that ends nowhere is a miss, not an error.
+            entry = this.#terminalOfAliasBinding(entry.binding, options, path, singleCriterion);
+        }
         if (entry === undefined) {
             return undefined;
         }
-        // Same single-evaluation contract as the sync lane: resolve what the probe found.
         const { binding, owner } = entry;
-        if (binding.kind === "alias") {
-            return this.resolveAsync(token, options, resolutionStack, branchDepth);
-        }
         if (binding.scope === "singleton" && owner !== this) {
-            return owner.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
+            return owner.#settleBinding(binding, options, path, depth, owner);
         }
-        return this.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
+        return this.#settleBinding(binding, options, path, depth, owner);
     }
-    async resolveAllAsync(token, options, resolutionStack, branchDepth = UNOWNED_BRANCH) {
-        const candidates = this.#candidateBindings(token, options, resolutionStack);
-        const pending = new Array(candidates.length);
-        for (let index = 0; index < candidates.length; index += 1) {
-            pending[index] = this.#resolveCandidateAsync(candidates[index], options, resolutionStack, branchDepth);
+    resolveAllAsync(token, options, resolutionStack, branchDepth = UNOWNED_BRANCH) {
+        try {
+            return asPromise(this.#settleCollection(token, options, resolutionStack, branchDepth));
+        }
+        catch (collectionError) {
+            return Promise.reject(collectionError);
         }
-        return Promise.all(pending);
+    }
+    #settleCollection(token, options, resolutionStack, branchDepth) {
+        const path = ownPrefixOf(resolutionStack, branchDepth);
+        const depth = path === resolutionStack ? branchDepth : branchDepthOf(path);
+        const candidates = this.#candidateBindings(token, options, path);
+        return this.#settleCandidates(candidates, options, path, depth, identity);
+    }
+    /**
+     * Every candidate of a fan-out, started in order: `apply` over their values when all settled in
+     * this tick, else over the fan-out settled in declaration order.
+     */
+    #settleCandidates(candidates, options, resolutionStack, branchDepth, apply) {
+        const count = candidates.length;
+        const pending = new Array(count);
+        let yielded = false;
+        for (let index = 0; index < count; index += 1) {
+            let settled;
+            try {
+                settled = this.#settleCandidate(candidates[index], options, resolutionStack, branchDepth);
+            }
+            catch (memberError) {
+                settled = Promise.reject(memberError);
+            }
+            if (isPending(settled)) {
+                yielded = true;
+            }
+            pending[index] = settled;
+        }
+        return yielded ? settleInOrder(pending, apply) : apply(pending);
     }
     // ── Helpers ────────────────────────────────────────────────────────────────────────────────────────────────────────
     #allBindingsFromChain(token) {
@@ -1165,7 +1409,7 @@ export class DependencyResolver {
         if (!this.#scope.isChild) {
             throw new MissingScopeContextError(tokenName(binding.token));
         }
-        return this.#scope.readScoped(binding.identifier);
+        return this.#scope.readScoped(binding.scopedCacheKey);
     }
     // The shared root context answers every top-level request; building one is the rarer half and
     // lives outside, so what a selection inlines is the test and not the literal.
@@ -1173,46 +1417,7 @@ export class DependencyResolver {
         if (options === undefined && resolutionStack.length === 0) {
             return ROOT_CONSTRAINT_CONTEXT;
         }
-        return buildConstraintContext(resolutionStack, options);
-    }
-    /** Selection for a multi-criterion request, over the union of the two tag indexes. */
-    #selectMultiTagged(token, options, resolutionStack) {
-        const candidates = [];
-        const gathered = [];
-        if (options.name !== undefined) {
-            // Read, not minted: an unminted name has no criterion, so no slot can carry it.
-            this.#gatherTagCandidates(token, slotNameCriterionOf(options.name), candidates, gathered);
-        }
-        this.#gatherTagCandidates(token, options.tag, candidates, gathered);
-        const listed = options.tags;
-        if (listed !== undefined) {
-            for (let index = 0; index < listed.length; index += 1) {
-                this.#gatherTagCandidates(token, listed[index], candidates, gathered);
-            }
-        }
-        if (candidates.length === 0) {
-            return undefined;
-        }
-        return selectBinding(candidates, options, this.#makeConstraintContext(resolutionStack, options), tokenName(token));
-    }
-    /** One request criterion's candidates: its exact single-tag binding, plus its first-tag bucket. */
-    #gatherTagCandidates(token, criterion, out, gathered) {
-        // Distinct criteria never share a binding — a slot lives in exactly one bucket — so deduping
-        // by criterion covers a request repeating one across its spellings, without scanning `out`.
-        if (criterion === undefined || gathered.includes(criterion)) {
-            return;
-        }
-        gathered.push(criterion);
-        const single = this.#registry.getSimpleTagged(token, criterion);
-        if (single !== undefined) {
-            out.push(single);
-        }
-        const bucket = this.#registry.getMultiTagged(token, criterion);
-        if (bucket !== undefined) {
-            for (let index = 0; index < bucket.length; index += 1) {
-                out.push(bucket[index]);
-            }
-        }
+        return new DefaultConstraintContext(resolutionStack, options);
     }
     /** The predicate half of a match, for a lane whose index has already settled the slot. */
     #satisfiesPredicate(binding, options, resolutionStack) {
@@ -1244,7 +1449,19 @@ export class DependencyResolver {
             binding.inFlight = false;
         }
     }
-    // Deliberately not `async`: that would allocate a state machine and a promise per level.
+    /** A transient factory level with no activation: its factory's own result over the level's context. */
+    #settleTransientFactory(binding, resolutionStack, branchDepth) {
+        const frame = this.#getResolutionFrame(binding);
+        const levelStack = extendResolutionBranch(resolutionStack, branchDepth, frame);
+        // Nothing this level appended is ever removed, so no level observes its own settlement.
+        const ctx = new AsyncLevelContext(this, levelStack, undefined);
+        if (branchDepth === ROOT_BRANCH) {
+            this.#recentRootLevelContext = ctx;
+        }
+        return runFactoryPrefix(binding, ctx, levelStack);
+    }
+    // Deliberately not `async`: that would allocate a state machine and a promise per level. The
+    // dominant lane keeps its body whole rather than reaching the settle core through a call.
     #resolveTransientDynamicAsyncFromContext(binding, resolutionStack, branchDepth) {
         const frame = this.#getResolutionFrame(binding);
         let levelStack;
@@ -1257,68 +1474,64 @@ export class DependencyResolver {
         }
         // Nothing this level appended is ever removed, so no level observes its own settlement.
         const ctx = new AsyncLevelContext(this, levelStack, undefined);
+        if (branchDepth === ROOT_BRANCH) {
+            this.#recentRootLevelContext = ctx;
+        }
         try {
-            if (binding.kind === "dynamic-async") {
-                return binding.factory(ctx);
-            }
-            const factoryResult = binding.factory(ctx);
+            const factoryResult = runFactoryPrefix(binding, ctx, levelStack);
             return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
         }
         catch (factoryError) {
             return Promise.reject(factoryError);
         }
     }
-    // ── The cascade lane ───────────────────────────────────────────────────────────────────────────────────────────────
+    // ── The async root ─────────────────────────────────────────────────────────────────────────────────────────────────
     /**
-     * Entry for a request a factory makes from inside an open synchronous cascade.
+     * Entry for an options-less resolve the container starts: the root of a branch of its own.
      *
-     * @remarks A request arriving with no cascade open came out of a continuation, so its ancestors
-     * are on no call stack — it escapes to the branch lane.
+     * @remarks A statically-visible transient graph answers from its compiled async plan; everything
+     * else opens a branch over a fresh array, so every level's context keeps its own ancestors for as
+     * long as the factory holds it — across an `await` included.
      */
-    resolveAsyncFromCascade(token) {
-        if (this.#cascadeStack.length === 0) {
-            return this.resolveAsyncFromContext(token, [], ROOT_BRANCH);
-        }
-        return this.#dispatchCascade(token);
-    }
-    /** Entry for a resolve the container starts, which opens the cascade rather than joining one. */
     resolveAsyncFromRoot(token) {
-        return this.#dispatchCascade(token);
-    }
-    #dispatchCascade(token) {
         const fastBinding = this.#registry.getFastDefault(token);
         if (fastBinding !== undefined) {
-            if ((fastBinding.kind === "dynamic-async" || fastBinding.kind === "dynamic") &&
-                fastBinding.scope === "transient" &&
-                !this.#hasAnyActivation(fastBinding)) {
-                return this.#resolveTransientDynamicAsyncCascade(fastBinding);
-            }
-            // A value that already exists answers here: escaping would snapshot the cascade for a resolve
-            // that never looks at a path.
-            if (this.#isPlainConstant(fastBinding)) {
-                return Promise.resolve(fastBinding.value);
-            }
-            if (fastBinding.scope === "singleton" && fastBinding.instance !== NO_INSTANCE) {
-                return Promise.resolve(fastBinding.instance);
-            }
-            const planned = this.#plannedCascadeAnswer(fastBinding);
+            const planned = this.#plannedRootAnswer(fastBinding);
             if (planned !== null) {
                 return planned;
             }
+            if (fastBinding.scope === "transient" &&
+                (fastBinding.kind === "dynamic" || fastBinding.kind === "dynamic-async") &&
+                !this.#hasAnyActivation(fastBinding)) {
+                return this.#rootFactoryAnswer(fastBinding);
+            }
         }
-        // Anything else leaves the cascade lane for good, seeded with a snapshot of the ancestors it
-        // accumulated — so a cycle across the boundary is still on one path.
-        return this.resolveAsyncFromContext(token, [...this.#cascadeStack], UNOWNED_BRANCH);
+        return this.resolveAsyncFromContext(token, [], ROOT_BRANCH);
     }
     /**
-     * A statically-visible transient graph at a true root answers from its compiled async plan.
+     * A transient factory root's answer: its factory run over the one context the binding keeps.
      *
-     * @remarks Kept out of the dispatcher so its size stays inlinable. Inside an open cascade the
-     * graph must escape instead, so its escapes carry the live ancestors — hence the idle gate.
+     * @remarks The root's path is its own frame alone and the request carries no options, so the level's
+     * context is a function of the binding, built on the first resolve and reused by every later one —
+     * a concurrent root reads the same path, and a descendant that outgrows the branch copies its prefix.
      */
-    #plannedCascadeAnswer(fastBinding) {
-        if (this.#cascadeStack.length !== 0 ||
-            fastBinding.scope !== "transient" ||
+    #rootFactoryAnswer(binding) {
+        let ctx = binding.rootContext;
+        if (ctx === undefined) {
+            ctx = new AsyncLevelContext(this, extendResolutionBranch([], ROOT_BRANCH, this.#getResolutionFrame(binding)), undefined);
+            binding.rootContext = ctx;
+        }
+        try {
+            const factoryResult = runFactoryPrefix(binding, ctx, ctx.ownPath);
+            return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
+        }
+        catch (factoryError) {
+            return Promise.reject(factoryError);
+        }
+    }
+    /** The compiled async plan's answer for a transient class or factory root, or `null` when there is none. */
+    #plannedRootAnswer(fastBinding) {
+        if (fastBinding.scope !== "transient" ||
             (fastBinding.kind !== "class" && fastBinding.kind !== "resolved" && fastBinding.kind !== "resolved-async")) {
             return null;
         }
@@ -1335,32 +1548,6 @@ export class DependencyResolver {
             return Promise.reject(planError);
         }
     }
-    #resolveTransientDynamicAsyncCascade(binding) {
-        const frame = this.#getResolutionFrame(binding);
-        // The request that closes a cycle is made from a factory's synchronous prefix, and synchronous
-        // code does not interleave — so the O(1) flag is exact path membership here, as it is for the
-        // sync lane. It is cleared when the factory returns its promise, not when that promise settles.
-        if (binding.inFlight) {
-            return Promise.reject(new CircularDependencyError(cycleNamesOf(this.#cascadeStack, frame.tokenName)));
-        }
-        const ctx = (this.#cascadeContext ??= new AsyncCascadeContext(this, this.#cascadeStack));
-        binding.inFlight = true;
-        this.#cascadeStack.push(frame);
-        try {
-            if (binding.kind === "dynamic-async") {
-                return binding.factory(ctx);
-            }
-            const factoryResult = binding.factory(ctx);
-            return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
-        }
-        catch (factoryError) {
-            return Promise.reject(factoryError);
-        }
-        finally {
-            this.#cascadeStack.pop();
-            binding.inFlight = false;
-        }
-    }
     // A cached candidate answers here rather than re-entering the generic path: `resolveAll` pays
     // this per candidate, and a fan-out over cached handlers is the shape that makes it matter.
     #resolveCandidateSync(binding, options, resolutionStack) {
@@ -1385,33 +1572,33 @@ export class DependencyResolver {
         }
         return this.#resolveBinding(binding, options, resolutionStack, owner);
     }
-    #resolveCandidateAsync(binding, options, resolutionStack, branchDepth) {
+    #settleCandidate(binding, options, resolutionStack, branchDepth) {
         if (binding.kind === "constant" && binding.activationHook === undefined && this.#chainActivationVersion() === 0) {
-            return Promise.resolve(binding.value);
+            return binding.value;
         }
         const owner = this.#ownerOf(binding);
         if (owner.#isPlainConstant(binding)) {
-            return Promise.resolve(binding.value);
+            return binding.value;
         }
         if (binding.kind === "alias") {
-            return this.resolveAsync(binding.target, options, resolutionStack, branchDepth);
+            return this.#settleRequest(binding.target, options, resolutionStack, branchDepth);
         }
         if (binding.scope === "singleton") {
             if (binding.instance !== NO_INSTANCE) {
-                return Promise.resolve(binding.instance);
+                return binding.instance;
             }
-            return owner.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
+            return owner.#settleBinding(binding, options, resolutionStack, branchDepth, owner);
         }
         // The dominant collection member — a transient factory with no activation, asked with no
-        // options — takes the non-async lane a single resolve takes, so a fan-out costs one factory
-        // promise per member rather than a state machine on top of each.
+        // options — takes the lane a single resolve takes, so a fan-out costs one factory result per
+        // member rather than a promise on top of each.
         if (options === undefined &&
             binding.scope === "transient" &&
             (binding.kind === "dynamic" || binding.kind === "dynamic-async") &&
             !owner.#hasAnyActivation(binding)) {
-            return this.#resolveTransientDynamicAsyncFromContext(binding, resolutionStack, branchDepth);
+            return this.#settleTransientFactory(binding, resolutionStack, branchDepth);
         }
-        return this.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
+        return this.#settleBinding(binding, options, resolutionStack, branchDepth, owner);
     }
     /** The resolver whose registry holds `binding` — `this` (the common case) when it is own. */
     #ownerOf(binding) {
@@ -1434,7 +1621,7 @@ export class DependencyResolver {
         if (existing !== undefined) {
             return existing;
         }
-        const frame = buildResolutionFrame(tokenName(binding.token), binding.scope, binding.identifier, binding.kind, binding.slot);
+        const frame = buildResolutionFrame(binding, tokenName(binding.token));
         binding.frame = frame;
         return frame;
     }
@@ -1444,32 +1631,18 @@ export class DependencyResolver {
     #acquireSyncResolutionContext(resolutionStack, options) {
         if (resolutionStack === this.rootStack) {
             const depth = resolutionStack.length;
-            const existing = this.#syncResolutionContextPool[depth];
+            const pool = (this.#syncResolutionContextPool ??= []);
+            const existing = pool[depth];
             if (existing !== undefined) {
                 existing.reset(this, resolutionStack, options);
                 return existing;
             }
             const created = new DefaultResolutionContext(this, resolutionStack, options);
-            this.#syncResolutionContextPool[depth] = created;
+            pool[depth] = created;
             return created;
         }
-        return this.#acquireOffRootSyncContext(resolutionStack, options);
-    }
-    /** The cascade pair pools separately; a throwaway pair (nested resolve, async snapshot) mints per call. */
-    #acquireOffRootSyncContext(resolutionStack, options) {
-        if (resolutionStack !== this.#cascadeStack) {
-            return new DefaultResolutionContext(this, resolutionStack, options);
-        }
-        const depth = resolutionStack.length;
-        const pool = (this.#cascadeContextPool ??= []);
-        const existing = pool[depth];
-        if (existing !== undefined) {
-            existing.reset(this, resolutionStack, options);
-            return existing;
-        }
-        const created = new DefaultResolutionContext(this, resolutionStack, options);
-        pool[depth] = created;
-        return created;
+        // A throwaway pair — a nested resolve, an async level's prefix — mints per call.
+        return new DefaultResolutionContext(this, resolutionStack, options);
     }
 }
 /**
@@ -1496,27 +1669,71 @@ function anyPredicate(bindings) {
     }
     return false;
 }
-function buildConstraintContext(resolutionStack, options) {
-    return {
-        // Derived per read, never cached: the stack may be live, and the names must report it as it stands.
-        get resolutionPath() {
-            const names = new Array(resolutionStack.length);
-            for (let index = 0; index < resolutionStack.length; index += 1) {
-                names[index] = resolutionStack[index].tokenName;
-            }
-            return names;
-        },
-        resolutionStack,
-        parent: resolutionStack.at(-1),
-        ancestors: resolutionStack.length > 1 ? resolutionStack.slice(0, -1) : [],
-        currentResolveOptions: options,
-    };
+/**
+ * Runs an async lane's factory with its binding flagged in flight for the factory's synchronous prefix.
+ *
+ * @remarks The flag is exact path membership only while synchronous code runs, so it is cleared when
+ * the factory returns — its promise included — never when that promise settles: two branches that
+ * await one binding are a diamond, not a cycle. A factory that resolves its own token from that
+ * prefix is caught before it runs again, on the branch lane as on the sync lanes, where the level's
+ * own flag already covers the whole call.
+ */
+function runFactoryPrefix(binding, ctx, levelStack) {
+    if (binding.inFlight) {
+        // The level's own frame is the last one, and the path an error names ends where the cycle closed.
+        throw new CircularDependencyError(cycleNamesOf(levelStack.slice(0, -1), tokenName(binding.token)));
+    }
+    binding.inFlight = true;
+    try {
+        return binding.factory(ctx);
+    }
+    finally {
+        binding.inFlight = false;
+    }
+}
+/**
+ * The frames a level may read as its own path: the array itself while nothing has grown it past the
+ * level's depth, else a copy of the level's prefix.
+ *
+ * @remarks Siblings start concurrently on one branch and the first appends in place, so a later
+ * sibling that read the whole array would hand a `when()` predicate the first sibling's frame as its
+ * parent. The copy is the one the branch lane would take for that sibling anyway, and it owns itself.
+ */
+function ownPrefixOf(resolutionStack, branchDepth) {
+    if (branchDepth === UNOWNED_BRANCH || resolutionStack.length === branchDepth) {
+        return resolutionStack;
+    }
+    return resolutionStack.slice(0, branchDepth);
 }
 /** The async-resolution failure for a binding reached on a sync path, naming what to await instead. */
 function asyncResolutionErrorFor(binding, resolutionStack) {
     const sourceName = tokenName(binding.token);
     return new AsyncResolutionError(resolutionStack[0]?.tokenName ?? sourceName, sourceName);
 }
+/** The settled values of a fan-out, as they are. */
+function identity(values) {
+    return values;
+}
+/** A settled value, as it is. */
+function settledValue(value) {
+    return value;
+}
+/** A promise of its own over a shared in-flight one: the same settlement, never the stored object. */
+function ownPromiseOf(shared) {
+    return shared.then(settledValue);
+}
+/** A lone dependency's settled value as the argument list its level applies. */
+function settledAlone(value) {
+    return [value];
+}
+/** Whether an async-lane answer is still pending, narrowing it to the promise it is. */
+function isPending(answer) {
+    return answer instanceof Promise;
+}
+/** A settled answer as the promise an async entry point hands out; a pending one passes through. */
+function asPromise(answer) {
+    return answer instanceof Promise ? answer : Promise.resolve(answer);
+}
 /** Only a factory is handed the resolution context; everything else gets its deps directly. */
 function requiresResolutionContext(binding) {
     return binding.kind === "dynamic" || binding.kind === "dynamic-async";