@codefast/di 0.5.0-canary.7 → 0.5.0-canary.9

package/dist/resolution/resolver.js

@@ -1,16 +1,17 @@
+import { NO_INSTANCE } from "#/binding";
 import { AsyncActivationError, AsyncResolutionError, CircularDependencyError, InternalError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, TokenNotBoundError, } from "#/errors";
-import { selectAllBindings, selectBinding } from "#/resolution/binding-select";
-import { buildResolutionFrame, DefaultResolutionContext, runWithContainer } from "#/resolution/environment";
+import { ActivationNeedCache } from "#/resolution/activation-need";
+import { BindingLookupCache } from "#/resolution/binding-lookup-cache";
+import { matchesSlot, selectAllBindings, selectBinding } from "#/resolution/binding-select";
+import { ClassIntrospector } from "#/resolution/class-introspector";
+import { AsyncCascadeContext, AsyncLevelContext, buildResolutionFrame, DefaultResolutionContext, } from "#/resolution/environment";
 import { InstantiationPlanCompiler, PLAN_RETRY } from "#/resolution/instantiation-plan";
-import { enterResolutionPath, exitResolutionPath } from "#/resolution/resolution-path";
-import { injectionSlotToResolveOptions } from "#/resolution/resolve-options";
-import { SINGLETON_MISS } from "#/resolution/scope";
+import { branchDepthOf, enterResolutionPath, extendResolutionBranch, extendResolutionStackBranch, ROOT_BRANCH, UNOWNED_BRANCH, } from "#/resolution/resolution-path";
+import { injectionSlotToResolveOptions, isNameOnlyOptions, singleTagOnlyOf } from "#/resolution/resolve-options";
 import { tokenName } from "#/token";
-// Fast-lane alias folding gives up past this many hops and defers to the resolve()
-// loop, whose Set-based traversal detects genuine cycles exactly (no arbitrary cap).
-const ALIAS_HOP_LIMIT = 32;
 const EMPTY_STRING_LIST = [];
 const EMPTY_FRAME_LIST = [];
+const EMPTY_PARAM_LIST = [];
 const ROOT_CONSTRAINT_CONTEXT = {
     resolutionPath: EMPTY_STRING_LIST,
     resolutionStack: EMPTY_FRAME_LIST,
@@ -23,51 +24,23 @@ const ROOT_CONSTRAINT_CONTEXT = {
  */
 export class DependencyResolver {
     #syncResolutionContextPool = [];
-    // Cycle detection for the sync transient-dynamic lane lives on `binding.inFlight` — see the
-    // field's doc comment in binding.ts. It is an O(1) field read with no hashing, no path scan and
-    // no side table to allocate or grow, so the lane needs no depth split.
-    // Shared-context state for the async transient-dynamic lane.
-    //
-    // Every level of a SEQUENTIAL async chain shares the same resolutionPath and resolutionStack
-    // arrays (passed by reference through ctx.resolveAsync), and the context stores references
-    // rather than snapshots, so one DefaultResolutionContext can serve the whole chain — the arrays
-    // reflect the current state automatically as levels push and pop.
-    //
-    // #asyncChainCtx: the shared context, created on first use and reset at each new root call.
-    //   Inner levels of the same chain reuse it with zero setup.
-    // #asyncChainCtxPath: identity of the resolutionPath array owning the shared context — same
-    //   reference means an inner level of that chain, a different one means a concurrent chain
-    //   (e.g. Promise.all) which gets its own context instead.
-    // #asyncChainActiveLevels: active levels of the OWNING chain, so the path pointer is released
-    //   when the last one settles. Concurrent fallback calls are not counted.
-    //
-    // The method is NOT declared async: that would allocate an async state machine and an implicit
-    // promise per level, where a `.then(settle, settle)` side listener costs neither.
-    #asyncChainCtx;
-    #asyncChainCtxPath;
-    #asyncChainActiveLevels = 0;
-    // Settle callback shared by every level of the owning async chain: all of them pop the same
-    // resolutionPath and decrement the same counter, so one closure serves the whole chain instead
-    // of allocating one per level (the async lane's dominant per-level allocation).
-    #asyncChainSettle;
-    #classHasPostConstruct = new WeakMap();
-    #classNeedsActiveContainer = new WeakMap();
-    #classConstructorMetadata = new WeakMap();
-    #activationNeedByBindingId = new Map();
-    #activationCacheVersion = -1;
-    // Options-less lookup memo across the parent chain: token → terminal {binding, owner}
-    // (alias hops folded). `null` = token must take the slow lookup path. Invalidated when
-    // any registry in the chain mutates (monotonic version sum).
-    #defaultLookupByToken = new Map();
-    #defaultLookupVersion = -1;
-    // Name-only lookup memo (token → name → entry) with the same chain-version
-    // invalidation. `null` = shape needs the full selection path.
-    #namedLookupByToken = new Map();
-    #namedLookupVersion = -1;
-    // Compiled transient-class plans (Dagger-style): a pure-static subgraph (class/constant/
-    // cached-singleton deps only) compiles once into a nested-constructor closure — cycle
-    // checking happens at compile time, so execution skips all per-resolve bookkeeping.
-    // `null` = binding is not plannable under the current versions.
+    /**
+     * The pair a top-level **sync** resolve reuses instead of minting two arrays per call.
+     *
+     * @remarks Read directly rather than through an accessor returning both: a shallow resolve is one
+     * top-level call, so a call and an object literal there are not amortised over anything. Every sync
+     * lane pops what it pushes, so `rootStack.length === 0` means no resolve holds the pair; async
+     * appends without popping and mints its own. Keeping the pair stable is also what lets a pooled
+     * context skip storing pointers it already holds.
+     */
+    rootPath = [];
+    rootStack = [];
+    // The open synchronous factory cascade: its arrays are the ancestor chain, and they are balanced
+    // because synchronous code does not interleave.
+    #cascadePath = [];
+    #cascadeStack = [];
+    #cascadeContext;
+    // Compiled plans; `null` marks a binding as unplannable under the current cache versions.
     #classPlanByBindingId = new Map();
     #classPlanRegistryVersion = -1;
     #classPlanActivationVersion = -1;
@@ -75,15 +48,32 @@ export class DependencyResolver {
     #scope;
     #lifecycle;
     #metadataReader;
-    #container;
     #parent;
+    #lookup;
+    #classes;
+    #activation;
     constructor(registry, scope, lifecycle, metadataReader, container, parent) {
         this.#registry = registry;
         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);
+        this.#activation = new ActivationNeedCache(lifecycle, this.#classes, registry);
+    }
+    /** Structural counts for {@link RESOLUTION_DIAGNOSTICS}; see `resolution/diagnostics.ts`. */
+    describeCaches() {
+        let compiledPlanCount = 0;
+        for (const plan of this.#classPlanByBindingId.values()) {
+            if (plan !== null) {
+                compiledPlanCount += 1;
+            }
+        }
+        return {
+            compiledPlanCount,
+            syncContextPoolSize: this.#syncResolutionContextPool.length,
+        };
     }
     // ── Binding lookup ─────────────────────────────────────────────────────────
     #findBinding(token, options, resolutionPath, resolutionStack) {
@@ -93,39 +83,33 @@ export class DependencyResolver {
                 return { binding: fastDefaultBinding, owner: this };
             }
         }
-        if (options?.name !== undefined && options.tag === undefined && (options.tags?.length ?? 0) === 0) {
+        else if (isNameOnlyOptions(options)) {
             const namedBinding = this.#registry.getSimpleNamed(token, options.name);
             if (namedBinding !== undefined &&
                 this.#matchesBindingFast(namedBinding, options, resolutionPath, resolutionStack)) {
                 return { binding: namedBinding, owner: this };
             }
         }
-        if (options !== undefined &&
-            options.name === undefined &&
-            options.tag === undefined &&
-            (options.tags?.length ?? 0) === 1) {
-            const [tagKey, tagValue] = options.tags[0];
-            const tagged = this.#registry.getSimpleTagged(token, tagKey, tagValue);
-            if (tagged !== undefined) {
-                return { binding: tagged, owner: this };
+        else {
+            const singleTag = singleTagOnlyOf(options);
+            if (singleTag !== undefined) {
+                const tagged = this.#registry.getSimpleTagged(token, singleTag[0], singleTag[1]);
+                if (tagged !== undefined && matchesIndexedTagValue(tagged, singleTag[1])) {
+                    return { binding: tagged, owner: this };
+                }
             }
         }
         const bindings = this.#registry.getAll(token);
         if (bindings.length > 0) {
-            if (bindings.length === 1) {
-                const onlyBinding = bindings[0];
-                const isDefaultSlot = onlyBinding.slot.name === undefined && onlyBinding.slot.tags.length === 0;
-                if (options === undefined && isDefaultSlot && onlyBinding.predicate === undefined) {
-                    return { binding: onlyBinding, owner: this };
-                }
-                if (this.#matchesBindingFast(onlyBinding, options, resolutionPath, resolutionStack)) {
-                    return { binding: onlyBinding, owner: this };
-                }
-            }
-            const ctx = this.#makeConstraintContext(resolutionPath, resolutionStack, options);
-            const binding = selectBinding(bindings, options, ctx, this.#getTokenName(token));
-            if (binding !== undefined) {
-                return { binding, owner: this };
+            // A lone candidate is its own selection: matching it is the whole decision, with no
+            // specificity to weigh and no ambiguity to report.
+            const selected = bindings.length === 1
+                ? this.#matchesBindingFast(bindings[0], options, resolutionPath, resolutionStack)
+                    ? bindings[0]
+                    : undefined
+                : selectBinding(bindings, options, this.#makeConstraintContext(resolutionPath, resolutionStack, options), tokenName(token));
+            if (selected !== undefined) {
+                return { binding: selected, owner: this };
             }
         }
         if (this.#parent !== undefined) {
@@ -133,6 +117,36 @@ export class DependencyResolver {
         }
         return undefined;
     }
+    /**
+     * The binding a token resolves to with alias hops followed, or a diagnostic throw.
+     *
+     * @remarks Alias hops are followed iteratively with exact cycle detection — a revisited alias
+     * token raises {@link CircularDependencyError} instead of overflowing the call stack.
+     */
+    #requireBinding(token, options, resolutionPath, resolutionStack) {
+        let currentToken = token;
+        let visitedAliasTokens;
+        let found = this.#findBinding(currentToken, options, resolutionPath, resolutionStack);
+        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, resolutionPath, resolutionStack);
+        }
+        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));
+            }
+            throw new TokenNotBoundError(tokenName(currentToken));
+        }
+        return found;
+    }
     /**
      * Binding lookup aligned with `resolve` — used by `Container.validate` without instantiating.
      */
@@ -143,15 +157,7 @@ export class DependencyResolver {
      * Mirrors {@link DependencyResolver.resolveAll} candidate selection only (no instantiation).
      */
     peekCandidateBindingsForValidate(token, options) {
-        if (options?.name !== undefined && options.tag === undefined && (options.tags?.length ?? 0) === 0) {
-            return this.#getSimpleNamedBindingsFromChain(token, options.name);
-        }
-        const allBindings = this.#getAllBindingsFromChain(token);
-        if (allBindings.length === 0) {
-            return [];
-        }
-        const ctx = this.#makeConstraintContext([], [], options);
-        return selectAllBindings(allBindings, options, ctx);
+        return this.#candidateBindings(token, options, [], []);
     }
     // ── Sync resolve ───────────────────────────────────────────────────────────
     resolveFromContext(token, resolutionPath, resolutionStack) {
@@ -161,19 +167,14 @@ export class DependencyResolver {
         if (fastBinding !== undefined && fastBinding.kind !== "alias") {
             return this.#resolveDefaultEntry(fastBinding, this, resolutionPath, resolutionStack);
         }
-        const entry = this.#lookupDefaultEntry(token);
+        const entry = this.#lookup.defaultEntry(token);
         if (entry === null) {
             return this.resolve(token, undefined, resolutionPath, resolutionStack);
         }
         return this.#resolveDefaultEntry(entry.binding, entry.owner, resolutionPath, resolutionStack);
     }
     #resolveDefaultEntry(binding, owner, resolutionPath, resolutionStack) {
-        if (binding.kind === "constant" &&
-            binding.onActivation === undefined &&
-            (this.#lifecycle.activationVersion === 0 || !this.#lifecycle.hasActivationHandlers(binding.token))) {
-            return binding.value;
-        }
-        const scope = binding.scope ?? "transient";
+        const scope = binding.scope;
         if (scope === "transient") {
             if (binding.kind === "dynamic") {
                 const containerHooks = this.#lifecycle.activationVersion === 0 ? undefined : this.#lifecycle.activationHandlersFor(binding.token);
@@ -191,8 +192,12 @@ export class DependencyResolver {
             }
         }
         else if (scope === "singleton") {
-            const cachedSingleton = owner.#scope.peekSingleton(binding.id);
-            if (cachedSingleton !== SINGLETON_MISS) {
+            // A constant is a singleton that is already its own instance.
+            if (this.#isPlainConstant(binding)) {
+                return binding.value;
+            }
+            const cachedSingleton = binding.instance;
+            if (cachedSingleton !== NO_INSTANCE) {
                 return cachedSingleton;
             }
             if (owner !== this) {
@@ -200,11 +205,9 @@ export class DependencyResolver {
             }
         }
         else {
-            if (!this.#scope.isChild) {
-                throw new MissingScopeContextError(this.#getTokenName(binding.token));
-            }
-            if (this.#scope.hasScoped(binding.id)) {
-                return this.#scope.getScoped(binding.id);
+            const cachedScoped = this.#readScoped(binding);
+            if (cachedScoped !== SCOPED_MISS) {
+                return cachedScoped;
             }
         }
         return this.#resolveBinding(binding, undefined, resolutionPath, resolutionStack);
@@ -213,9 +216,15 @@ export class DependencyResolver {
     // generic #resolveBinding path (guard, frame, ctx, per-binding then container hooks) with
     // the kind/activation dispatch resolved statically.
     #resolveTransientDynamicActivatedSync(binding, containerHooks, resolutionPath, resolutionStack) {
+        // Same O(1) cycle guard as the unhooked lane: this is still one sync call stack, so the flag
+        // *is* exact path membership — see ARCHITECTURE.md.
         const frame = this.#getResolutionFrame(binding);
         const tokenDisplayName = frame.tokenName;
-        const resolutionSet = enterResolutionPath(resolutionPath, tokenDisplayName, false);
+        if (binding.inFlight) {
+            throw new CircularDependencyError([...resolutionPath, tokenDisplayName]);
+        }
+        binding.inFlight = true;
+        resolutionPath.push(tokenDisplayName);
         resolutionStack.push(frame);
         try {
             const resolutionCtx = this.#acquireSyncResolutionContext(resolutionPath, resolutionStack, undefined);
@@ -245,86 +254,11 @@ export class DependencyResolver {
         finally {
             resolutionStack.pop();
             resolutionPath.pop();
-            resolutionSet?.delete(tokenDisplayName);
-        }
-    }
-    #chainRegistryVersion() {
-        let version = this.#registry.version;
-        for (let resolver = this.#parent; resolver !== undefined; resolver = resolver.#parent) {
-            version += resolver.#registry.version;
-        }
-        return version;
-    }
-    #lookupDefaultEntry(token) {
-        const version = this.#chainRegistryVersion();
-        if (version !== this.#defaultLookupVersion) {
-            this.#defaultLookupByToken.clear();
-            this.#defaultLookupVersion = version;
-        }
-        let entry = this.#defaultLookupByToken.get(token);
-        if (entry === undefined) {
-            entry = this.#computeDefaultEntry(token);
-            this.#defaultLookupByToken.set(token, entry);
-        }
-        return entry;
-    }
-    #computeDefaultEntry(token) {
-        let current = token;
-        for (let hop = 0; hop < ALIAS_HOP_LIMIT; hop += 1) {
-            const entry = this.#findDefaultEntryInChain(current);
-            if (entry === null) {
-                return null;
-            }
-            if (entry.binding.kind === "alias") {
-                current = entry.binding.target;
-                continue;
-            }
-            return entry;
-        }
-        return null;
-    }
-    #lookupNamedEntry(token, name) {
-        const version = this.#chainRegistryVersion();
-        if (version !== this.#namedLookupVersion) {
-            this.#namedLookupByToken.clear();
-            this.#namedLookupVersion = version;
-        }
-        // ✓ TS6.0: Map.getOrInsert (ES2025)
-        const entriesByName = this.#namedLookupByToken.getOrInsert(token, new Map());
-        let entry = entriesByName.get(name);
-        if (entry === undefined) {
-            entry = this.#findNamedEntryInChain(token, name);
-            entriesByName.set(name, entry);
-        }
-        return entry;
-    }
-    #findNamedEntryInChain(token, name) {
-        const named = this.#registry.getSimpleNamed(token, name);
-        if (named !== undefined) {
-            // Predicates need a live context; aliases carry options through the full path.
-            if (named.predicate !== undefined || named.kind === "alias") {
-                return null;
-            }
-            return { binding: named, owner: this };
-        }
-        if (this.#registry.has(token)) {
-            return null;
-        }
-        return this.#parent === undefined ? null : this.#parent.#findNamedEntryInChain(token, name);
-    }
-    #findDefaultEntryInChain(token) {
-        const fast = this.#registry.getFastDefault(token);
-        if (fast !== undefined) {
-            return { binding: fast, owner: this };
-        }
-        // A level with non-fast bindings (multi-slot / predicate) needs full selection — bail.
-        if (this.#registry.has(token)) {
-            return null;
+            binding.inFlight = false;
         }
-        return this.#parent === undefined ? null : this.#parent.#findDefaultEntryInChain(token);
     }
     #getInstantiationPlan(binding) {
-        const registryVersion = this.#chainRegistryVersion();
+        const registryVersion = this.#lookup.chainVersion();
         const activationVersion = this.#lifecycle.activationVersion;
         if (registryVersion !== this.#classPlanRegistryVersion || activationVersion !== this.#classPlanActivationVersion) {
             this.#classPlanByBindingId.clear();
@@ -343,141 +277,94 @@ export class DependencyResolver {
         this.#classPlanByBindingId.set(binding.id, compiled);
         return compiled;
     }
-    // Compiler behind #getClassPlan — cold path, so the host indirection costs nothing hot.
+    // Compiler behind #getInstantiationPlan — cold path, so the host indirection costs nothing hot.
     #planCompiler = new InstantiationPlanCompiler({
         hasActivationHandlers: (token) => this.#lifecycle.hasActivationHandlers(token),
-        knownPostConstruct: (target) => this.#classHasPostConstruct.get(target),
-        needsActiveContainer: (target) => {
-            let needsActiveContainer = this.#classNeedsActiveContainer.get(target);
-            if (needsActiveContainer === undefined) {
-                const accessorMetadata = this.#metadataReader.getAccessorMetadata?.(target);
-                needsActiveContainer = (accessorMetadata?.length ?? 0) > 0;
-                this.#classNeedsActiveContainer.set(target, needsActiveContainer);
-            }
-            return needsActiveContainer;
-        },
-        getConstructorMetadata: (target) => this.#getConstructorMetadata(target),
+        knownPostConstruct: (target) => this.#classes.knownPostConstruct(target),
+        needsActiveContainer: (target) => this.#classes.needsActiveContainer(target),
+        getConstructorMetadata: (target) => this.#classes.constructorMetadata(target),
         lookupDependencyEntry: (token) => {
-            const entry = this.#lookupDefaultEntry(token);
-            return entry === null ? null : { binding: entry.binding, ownerScope: entry.owner.#scope };
+            const entry = this.#lookup.defaultEntry(token);
+            return entry === null ? null : { binding: entry.binding };
+        },
+        getResolutionFrame: (binding) => this.#getResolutionFrame(binding),
+        // Dispatches exactly as #resolveDep does, so an escaped dep is indistinguishable
+        // from the same dep on a fully interpreted resolve.
+        resolveEscaped: (token, options, arity, resolutionPath, resolutionStack) => {
+            if (arity === "all") {
+                return this.resolveAll(token, options, resolutionPath, resolutionStack);
+            }
+            if (arity === "optional") {
+                return this.resolveOptional(token, options, resolutionPath, resolutionStack);
+            }
+            if (options === undefined) {
+                return this.resolveFromContext(token, resolutionPath, resolutionStack);
+            }
+            return this.resolve(token, options, resolutionPath, resolutionStack);
         },
-        resolveFallback: (token) => this.resolve(token, undefined, [], []),
     });
     resolve(token, options, resolutionPath, resolutionStack) {
         // Name-only fast lane: memoized lookup, dispatching just the shapes whose
         // semantics involve no resolution context (constants, cached singletons).
-        if (options !== undefined &&
-            options.name !== undefined &&
-            options.tag === undefined &&
-            (options.tags === undefined || options.tags.length === 0)) {
-            const namedEntry = this.#lookupNamedEntry(token, options.name);
+        if (options !== undefined && isNameOnlyOptions(options)) {
+            const namedEntry = this.#lookup.namedEntry(token, options.name);
             if (namedEntry !== null) {
                 const namedBinding = namedEntry.binding;
-                if (namedBinding.kind === "constant" &&
-                    namedBinding.onActivation === undefined &&
-                    (this.#lifecycle.activationVersion === 0 || !this.#lifecycle.hasActivationHandlers(namedBinding.token))) {
+                if (this.#isPlainConstant(namedBinding)) {
                     return namedBinding.value;
                 }
-                const namedScope = namedBinding.scope ?? "transient";
-                if (namedScope === "singleton") {
-                    const cachedSingleton = namedEntry.owner.#scope.peekSingleton(namedBinding.id);
-                    if (cachedSingleton !== SINGLETON_MISS) {
-                        return cachedSingleton;
-                    }
+                if (namedBinding.scope === "singleton" && namedBinding.instance !== NO_INSTANCE) {
+                    return namedBinding.instance;
                 }
                 // Everything else keeps the full path (context, activation, guards).
             }
         }
-        let currentToken = token;
-        let visitedAliasTokens;
-        let found = this.#findBinding(currentToken, options, resolutionPath, resolutionStack);
-        // Follow aliases iteratively with exact cycle detection — a revisited alias
-        // token throws CircularDependencyError instead of overflowing the call stack.
-        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, resolutionPath, resolutionStack);
-        }
-        if (found === undefined) {
-            const ownBindings = this.#registry.getAll(currentToken);
-            if (ownBindings.length > 0) {
-                throw new NoMatchingBindingError(this.#getTokenName(currentToken), options ?? {}, this.#getAvailableSlots(currentToken));
-            }
-            throw new TokenNotBoundError(this.#getTokenName(currentToken));
-        }
-        const { binding, owner } = found;
-        const scope = binding.scope ?? "transient";
-        // Singleton from a parent resolver: delegate so the parent caches it correctly
-        if (scope === "singleton" && owner !== this) {
+        const { binding, owner } = this.#requireBinding(token, options, resolutionPath, resolutionStack);
+        // A singleton owned by a parent resolver is resolved there, so the parent caches it.
+        if (binding.scope === "singleton" && owner !== this) {
             return owner.#resolveBinding(binding, options, resolutionPath, resolutionStack);
         }
-        // Scoped/transient (or own singleton): resolve with this resolver's container/scope
         return this.#resolveBinding(binding, options, resolutionPath, resolutionStack);
     }
     #resolveBinding(binding, options, resolutionPath, resolutionStack) {
-        if (binding.kind === "constant" &&
-            binding.onActivation === undefined &&
-            (this.#lifecycle.activationVersion === 0 || !this.#lifecycle.hasActivationHandlers(binding.token))) {
+        if (this.#isPlainConstant(binding)) {
             return binding.value;
         }
-        const scope = binding.scope ?? "transient";
-        // Singleton cache check
+        const scope = binding.scope;
         if (scope === "singleton") {
-            if (this.#scope.hasSingleton(binding.id)) {
-                return this.#scope.getSingleton(binding.id);
+            if (binding.instance !== NO_INSTANCE) {
+                return binding.instance;
             }
         }
-        // Scoped cache check
-        if (scope === "scoped") {
-            if (!this.#scope.isChild) {
-                throw new MissingScopeContextError(this.#getTokenName(binding.token));
-            }
-            if (this.#scope.hasScoped(binding.id)) {
-                return this.#scope.getScoped(binding.id);
+        else if (scope === "scoped") {
+            const cachedScoped = this.#readScoped(binding);
+            if (cachedScoped !== SCOPED_MISS) {
+                return cachedScoped;
             }
         }
         const frame = this.#getResolutionFrame(binding);
         const tokenDisplayName = frame.tokenName;
-        const resolutionSet = enterResolutionPath(resolutionPath, tokenDisplayName, false);
+        const resolutionSet = enterResolutionPath(resolutionPath, tokenDisplayName);
         resolutionStack.push(frame);
-        const needsActivation = this.#needsActivation(binding);
-        if (!needsActivation && scope === "transient" && binding.kind === "dynamic") {
-            const resolutionCtx = this.#acquireSyncResolutionContext(resolutionPath, resolutionStack, options);
-            try {
+        try {
+            const needsActivation = this.#activation.needsActivation(binding);
+            if (!needsActivation && scope === "transient" && binding.kind === "dynamic") {
+                const resolutionCtx = this.#acquireSyncResolutionContext(resolutionPath, resolutionStack, options);
                 const dynamicResult = binding.factory(resolutionCtx);
                 if (dynamicResult instanceof Promise) {
-                    throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+                    throw new AsyncResolutionError(tokenDisplayName, tokenDisplayName);
                 }
-                resolutionStack.pop();
-                resolutionPath.pop();
-                resolutionSet?.delete(tokenDisplayName);
                 return dynamicResult;
             }
-            catch (error) {
-                resolutionStack.pop();
-                resolutionPath.pop();
-                resolutionSet?.delete(tokenDisplayName);
-                throw error;
-            }
-        }
-        try {
-            const needsResolutionContext = needsActivation || this.#requiresResolutionContext(binding);
-            const resolutionCtx = needsResolutionContext
+            const resolutionCtx = needsActivation || requiresResolutionContext(binding)
                 ? this.#acquireSyncResolutionContext(resolutionPath, resolutionStack, options)
                 : undefined;
             const instance = this.#instantiateSync(binding, resolutionCtx, resolutionPath, resolutionStack);
-            const shouldActivate = this.#refreshActivationCacheIfNeeded(binding, needsActivation);
-            const activated = shouldActivate
+            const activated = this.#activation.refreshAfterFirstInstantiation(binding, needsActivation)
                 ? this.#lifecycle.runActivationSync(resolutionCtx, binding, instance, this.#metadataReader)
                 : instance;
-            // Cache by scope
             if (scope === "singleton") {
-                this.#scope.setSingleton(binding.id, activated);
+                this.#scope.setSingleton(binding, activated);
             }
             else if (scope === "scoped") {
                 this.#scope.setScoped(binding.id, activated);
@@ -507,12 +394,11 @@ export class DependencyResolver {
             case "dynamic-async":
                 throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
             case "class": {
-                const deps = this.#resolveClassDeps(binding.target, resolutionPath, resolutionStack);
-                const instance = this.#instantiateClass(binding.target, deps);
-                return instance;
+                const deps = this.#resolveDeps(this.#constructorParams(binding.target), resolutionPath, resolutionStack);
+                return this.#classes.instantiate(binding.target, deps);
             }
             case "resolved": {
-                const deps = this.#resolveDescriptorDeps(binding.deps, resolutionPath, resolutionStack);
+                const deps = this.#resolveDeps(binding.deps, resolutionPath, resolutionStack);
                 const factoryResult = binding.factory(...deps);
                 if (factoryResult instanceof Promise) {
                     throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
@@ -525,70 +411,51 @@ export class DependencyResolver {
                 throw new InternalError("alias should have been followed before instantiation");
         }
     }
-    #resolveClassDeps(target, resolutionPath, resolutionStack) {
-        const meta = this.#getConstructorMetadata(target);
-        if (meta === undefined) {
-            if (target.length === 0) {
-                return [];
-            }
-            throw new MissingMetadataError(target.name);
+    /**
+     * The parameters a class binding injects.
+     *
+     * @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);
+        if (meta !== undefined) {
+            return meta.params;
+        }
+        if (target.length === 0) {
+            return EMPTY_PARAM_LIST;
         }
-        if (meta.params.length === 0) {
+        throw new MissingMetadataError(target.name);
+    }
+    // One dispatch table for both dependency sources — constructor params and `toResolved`
+    // descriptors declare the same four things.
+    #resolveDeps(deps, resolutionPath, resolutionStack) {
+        const count = deps.length;
+        if (count === 0) {
             return [];
         }
-        if (meta.params.length === 1) {
-            const param = meta.params[0];
-            const paramOptions = injectionSlotToResolveOptions(param);
-            if (param.multi) {
-                return [this.resolveAll(param.token, paramOptions, resolutionPath, resolutionStack)];
-            }
-            if (param.optional) {
-                return [this.resolveOptional(param.token, paramOptions, resolutionPath, resolutionStack)];
-            }
-            if (paramOptions === undefined) {
-                return [this.resolveFromContext(param.token, resolutionPath, resolutionStack)];
-            }
-            return [this.resolve(param.token, paramOptions, resolutionPath, resolutionStack)];
-        }
-        const deps = new Array(meta.params.length);
-        for (let index = 0; index < meta.params.length; index += 1) {
-            const param = meta.params[index];
-            const paramOptions = injectionSlotToResolveOptions(param);
-            if (param.multi) {
-                deps[index] = this.resolveAll(param.token, paramOptions, resolutionPath, resolutionStack);
-                continue;
-            }
-            if (param.optional) {
-                deps[index] = this.resolveOptional(param.token, paramOptions, resolutionPath, resolutionStack);
-                continue;
-            }
-            deps[index] =
-                paramOptions === undefined
-                    ? this.resolveFromContext(param.token, resolutionPath, resolutionStack)
-                    : this.resolve(param.token, paramOptions, resolutionPath, resolutionStack);
+        if (count === 1) {
+            return [this.#resolveDep(deps[0], resolutionPath, resolutionStack)];
         }
-        return deps;
-    }
-    #resolveDescriptorDeps(deps, resolutionPath, resolutionStack) {
-        const resolved = new Array(deps.length);
-        for (let index = 0; index < deps.length; index += 1) {
-            const dep = deps[index];
-            const depOptions = injectionSlotToResolveOptions(dep);
-            if (dep.multi) {
-                resolved[index] = this.resolveAll(dep.token, depOptions, resolutionPath, resolutionStack);
-                continue;
-            }
-            if (dep.optional) {
-                resolved[index] = this.resolveOptional(dep.token, depOptions, resolutionPath, resolutionStack);
-                continue;
-            }
-            resolved[index] =
-                depOptions === undefined
-                    ? this.resolveFromContext(dep.token, resolutionPath, resolutionStack)
-                    : this.resolve(dep.token, depOptions, resolutionPath, resolutionStack);
+        const resolved = new Array(count);
+        for (let index = 0; index < count; index += 1) {
+            resolved[index] = this.#resolveDep(deps[index], resolutionPath, resolutionStack);
         }
         return resolved;
     }
+    #resolveDep(dep, resolutionPath, resolutionStack) {
+        const options = injectionSlotToResolveOptions(dep);
+        if (dep.multi) {
+            return this.resolveAll(dep.token, options, resolutionPath, resolutionStack);
+        }
+        if (dep.optional) {
+            return this.resolveOptional(dep.token, options, resolutionPath, resolutionStack);
+        }
+        if (options === undefined) {
+            return this.resolveFromContext(dep.token, resolutionPath, resolutionStack);
+        }
+        return this.resolve(dep.token, options, resolutionPath, resolutionStack);
+    }
     resolveOptional(token, options, resolutionPath, resolutionStack) {
         if (this.#findBinding(token, options, resolutionPath, resolutionStack) === undefined) {
             return undefined;
@@ -596,31 +463,32 @@ export class DependencyResolver {
         return this.resolve(token, options, resolutionPath, resolutionStack);
     }
     resolveAll(token, options, resolutionPath, resolutionStack) {
-        if (options?.name !== undefined && options.tag === undefined && (options.tags?.length ?? 0) === 0) {
-            const namedCandidates = this.#getSimpleNamedBindingsFromChain(token, options.name);
-            if (namedCandidates.length === 0) {
-                return [];
-            }
-            const resolved = new Array(namedCandidates.length);
-            for (let index = 0; index < namedCandidates.length; index += 1) {
-                resolved[index] = this.#resolveCandidateSync(namedCandidates[index], options, resolutionPath, resolutionStack);
-            }
-            return resolved;
-        }
-        const allBindings = this.#getAllBindingsFromChain(token);
-        if (allBindings.length === 0) {
-            return [];
-        }
-        const ctx = this.#makeConstraintContext(resolutionPath, resolutionStack, options);
-        const candidates = selectAllBindings(allBindings, options, ctx);
+        const candidates = this.#candidateBindings(token, options, resolutionPath, resolutionStack);
         const resolved = new Array(candidates.length);
         for (let index = 0; index < candidates.length; index += 1) {
             resolved[index] = this.#resolveCandidateSync(candidates[index], options, resolutionPath, resolutionStack);
         }
         return resolved;
     }
+    /** Every binding in the chain a `resolveAll` request matches, in chain order. */
+    #candidateBindings(token, options, resolutionPath, resolutionStack) {
+        if (options !== undefined && isNameOnlyOptions(options)) {
+            // The name index has matched the slot already, but a hit may still carry a predicate —
+            // and that is the selection path's job to evaluate.
+            const named = this.#namedBindingsFromChain(token, options.name);
+            if (!anyPredicate(named)) {
+                return named;
+            }
+            return selectAllBindings(named, options, this.#makeConstraintContext(resolutionPath, resolutionStack, options));
+        }
+        const allBindings = this.#allBindingsFromChain(token);
+        if (allBindings.length === 0) {
+            return allBindings;
+        }
+        return selectAllBindings(allBindings, options, this.#makeConstraintContext(resolutionPath, resolutionStack, options));
+    }
     // ── Async resolve ──────────────────────────────────────────────────────────
-    resolveAsyncFromContext(token, resolutionPath, resolutionStack) {
+    resolveAsyncFromContext(token, resolutionPath, resolutionStack, branchDepth) {
         // Hot lane: own-registry fast default (async chains resolve sibling dynamic bindings).
         // Fall back to the chain-versioned memo only on miss or alias.
         const fastBinding = this.#registry.getFastDefault(token);
@@ -628,174 +496,118 @@ export class DependencyResolver {
             // Inline the dominant chain shape — transient dynamic factory with no activation.
             if ((fastBinding.kind === "dynamic-async" || fastBinding.kind === "dynamic") &&
                 fastBinding.scope === "transient" &&
-                fastBinding.onActivation === undefined &&
-                (this.#lifecycle.activationVersion === 0 || !this.#lifecycle.hasActivationHandlers(fastBinding.token))) {
-                return this.#resolveTransientDynamicAsyncFromContext(fastBinding, resolutionPath, resolutionStack);
+                !this.#hasAnyActivation(fastBinding)) {
+                return this.#resolveTransientDynamicAsyncFromContext(fastBinding, resolutionPath, resolutionStack, branchDepth);
             }
-            return this.#resolveAsyncDefaultEntry(fastBinding, this, resolutionPath, resolutionStack);
+            return this.#resolveAsyncDefaultEntry(fastBinding, this, resolutionPath, resolutionStack, branchDepth);
         }
-        const entry = this.#lookupDefaultEntry(token);
+        const entry = this.#lookup.defaultEntry(token);
         if (entry === null) {
-            return this.resolveAsync(token, undefined, resolutionPath, resolutionStack);
+            return this.resolveAsync(token, undefined, resolutionPath, resolutionStack, branchDepth);
         }
-        return this.#resolveAsyncDefaultEntry(entry.binding, entry.owner, resolutionPath, resolutionStack);
+        return this.#resolveAsyncDefaultEntry(entry.binding, entry.owner, resolutionPath, resolutionStack, branchDepth);
     }
-    #resolveAsyncDefaultEntry(binding, owner, resolutionPath, resolutionStack) {
-        if (binding.kind === "constant" &&
-            binding.onActivation === undefined &&
-            (this.#lifecycle.activationVersion === 0 || !this.#lifecycle.hasActivationHandlers(binding.token))) {
+    #resolveAsyncDefaultEntry(binding, owner, resolutionPath, resolutionStack, branchDepth) {
+        if (this.#isPlainConstant(binding)) {
             return Promise.resolve(binding.value);
         }
-        const scope = binding.scope ?? "transient";
+        const scope = binding.scope;
         if (scope === "transient") {
-            if ((binding.kind === "dynamic" || binding.kind === "dynamic-async") &&
-                binding.onActivation === undefined &&
-                (this.#lifecycle.activationVersion === 0 || !this.#lifecycle.hasActivationHandlers(binding.token))) {
-                return this.#resolveTransientDynamicAsyncFromContext(binding, resolutionPath, resolutionStack);
+            if ((binding.kind === "dynamic" || binding.kind === "dynamic-async") && !this.#hasAnyActivation(binding)) {
+                return this.#resolveTransientDynamicAsyncFromContext(binding, resolutionPath, resolutionStack, branchDepth);
             }
         }
         else if (scope === "singleton") {
-            const cachedSingleton = owner.#scope.peekSingleton(binding.id);
-            if (cachedSingleton !== SINGLETON_MISS) {
-                return Promise.resolve(cachedSingleton);
+            if (binding.instance !== NO_INSTANCE) {
+                return Promise.resolve(binding.instance);
             }
             if (owner !== this) {
-                return owner.#resolveBindingAsync(binding, undefined, resolutionPath, resolutionStack);
+                return owner.#resolveBindingAsync(binding, undefined, resolutionPath, resolutionStack, branchDepth);
             }
         }
-        else {
-            if (!this.#scope.isChild) {
-                return Promise.reject(new MissingScopeContextError(this.#getTokenName(binding.token)));
-            }
+        else if (this.#scope.isChild) {
             if (this.#scope.hasScoped(binding.id)) {
                 return Promise.resolve(this.#scope.getScoped(binding.id));
             }
         }
-        return this.#resolveBindingAsync(binding, undefined, resolutionPath, resolutionStack);
-    }
-    async resolveAsync(token, options, resolutionPath, resolutionStack) {
-        const found = this.#findBinding(token, options, resolutionPath, resolutionStack);
-        if (found === undefined) {
-            const ownBindings = this.#registry.getAll(token);
-            if (ownBindings.length > 0) {
-                throw new NoMatchingBindingError(this.#getTokenName(token), options ?? {}, this.#getAvailableSlots(token));
-            }
-            throw new TokenNotBoundError(this.#getTokenName(token));
-        }
-        let currentToken = token;
-        let visitedAliasTokens;
-        let aliasFollowed = found;
-        while (aliasFollowed !== undefined && aliasFollowed.binding.kind === "alias") {
-            const target = aliasFollowed.binding.target;
-            visitedAliasTokens ??= new Set([currentToken]);
-            if (visitedAliasTokens.has(target)) {
-                throw new CircularDependencyError([...visitedAliasTokens, target].map((entry) => tokenName(entry)));
-            }
-            visitedAliasTokens.add(target);
-            currentToken = target;
-            aliasFollowed = this.#findBinding(currentToken, options, resolutionPath, resolutionStack);
-        }
-        if (aliasFollowed === undefined) {
-            const ownBindings = this.#registry.getAll(currentToken);
-            if (ownBindings.length > 0) {
-                throw new NoMatchingBindingError(this.#getTokenName(currentToken), options ?? {}, this.#getAvailableSlots(currentToken));
-            }
-            throw new TokenNotBoundError(this.#getTokenName(currentToken));
+        else {
+            // Not `#readScoped`: this entry point reports failure as a rejection, never a sync throw.
+            return Promise.reject(new MissingScopeContextError(tokenName(binding.token)));
         }
-        const { binding, owner } = aliasFollowed;
-        const scope = binding.scope ?? "transient";
-        if (scope === "singleton" && owner !== this) {
-            return owner.#resolveBindingAsync(binding, options, resolutionPath, resolutionStack);
+        return this.#resolveBindingAsync(binding, undefined, resolutionPath, resolutionStack, branchDepth);
+    }
+    async resolveAsync(token, options, resolutionPath, resolutionStack, branchDepth = UNOWNED_BRANCH) {
+        const { binding, owner } = this.#requireBinding(token, options, resolutionPath, resolutionStack);
+        if (binding.scope === "singleton" && owner !== this) {
+            return owner.#resolveBindingAsync(binding, options, resolutionPath, resolutionStack, branchDepth);
         }
-        return this.#resolveBindingAsync(binding, options, resolutionPath, resolutionStack);
+        return this.#resolveBindingAsync(binding, options, resolutionPath, resolutionStack, branchDepth);
     }
-    async #resolveBindingAsync(binding, options, resolutionPath, resolutionStack) {
-        if (binding.kind === "constant" &&
-            binding.onActivation === undefined &&
-            !this.#lifecycle.hasActivationHandlers(binding.token)) {
+    async #resolveBindingAsync(binding, options, resolutionPath, resolutionStack, branchDepth) {
+        if (this.#isPlainConstant(binding)) {
             return binding.value;
         }
-        const scope = binding.scope ?? "transient";
-        // Singleton cache
+        const scope = binding.scope;
         if (scope === "singleton") {
-            if (this.#scope.hasSingleton(binding.id)) {
-                return this.#scope.getSingleton(binding.id);
+            if (binding.instance !== NO_INSTANCE) {
+                return binding.instance;
             }
-            // In-flight dedup
+            // In-flight dedup: concurrent callers share the first creation.
             const inflight = this.#scope.getInflight(binding.id);
             if (inflight !== undefined) {
                 return inflight;
             }
         }
-        // Scoped cache
-        if (scope === "scoped") {
-            if (!this.#scope.isChild) {
-                throw new MissingScopeContextError(this.#getTokenName(binding.token));
-            }
-            if (this.#scope.hasScoped(binding.id)) {
-                return this.#scope.getScoped(binding.id);
+        else if (scope === "scoped") {
+            const cachedScoped = this.#readScoped(binding);
+            if (cachedScoped !== SCOPED_MISS) {
+                return cachedScoped;
             }
         }
         const frame = this.#getResolutionFrame(binding);
-        const frameName = frame.tokenName;
-        const resolutionSet = enterResolutionPath(resolutionPath, frameName, false);
-        resolutionStack.push(frame);
-        const needsActivation = this.#needsActivation(binding);
+        // This level appends to its own branch and never unwinds — see ARCHITECTURE.md.
+        const levelPath = extendResolutionBranch(resolutionPath, branchDepth, frame.tokenName);
+        const levelStack = extendResolutionStackBranch(resolutionStack, branchDepth, frame);
+        const levelDepth = branchDepthOf(levelPath);
+        const needsActivation = this.#activation.needsActivation(binding);
         if (!needsActivation && scope === "transient" && (binding.kind === "dynamic" || binding.kind === "dynamic-async")) {
-            const resolutionCtx = new DefaultResolutionContext(this, resolutionPath, resolutionStack, options);
-            try {
-                if (binding.kind === "dynamic-async") {
-                    return await binding.factory(resolutionCtx);
-                }
-                const dynamicResult = binding.factory(resolutionCtx);
-                return dynamicResult instanceof Promise ? await dynamicResult : dynamicResult;
-            }
-            finally {
-                resolutionStack.pop();
-                resolutionPath.pop();
-                resolutionSet?.delete(frameName);
+            const resolutionCtx = new AsyncLevelContext(this, levelPath, levelStack, options);
+            if (binding.kind === "dynamic-async") {
+                return await binding.factory(resolutionCtx);
             }
+            const dynamicResult = binding.factory(resolutionCtx);
+            return dynamicResult instanceof Promise ? await dynamicResult : dynamicResult;
         }
-        const needsResolutionContext = needsActivation || this.#requiresResolutionContext(binding);
-        const resolutionCtx = needsResolutionContext
-            ? new DefaultResolutionContext(this, resolutionPath, resolutionStack, options)
+        const resolutionCtx = needsActivation || requiresResolutionContext(binding)
+            ? new AsyncLevelContext(this, levelPath, levelStack, options)
             : undefined;
-        try {
-            if (scope === "singleton") {
-                const createSingletonPromise = async () => {
-                    const instance = await this.#instantiateAsync(binding, resolutionCtx, resolutionPath, resolutionStack);
-                    const shouldActivate = this.#refreshActivationCacheIfNeeded(binding, needsActivation);
-                    const activated = shouldActivate
-                        ? await this.#lifecycle.runActivation(resolutionCtx, binding, instance, this.#metadataReader)
-                        : instance;
-                    this.#scope.setSingleton(binding.id, activated);
-                    this.#scope.clearInflight(binding.id);
-                    return activated;
-                };
-                const singletonPromise = createSingletonPromise().catch((err) => {
-                    this.#scope.clearInflight(binding.id);
-                    throw err;
-                });
-                this.#scope.setInflight(binding.id, singletonPromise);
-                return await singletonPromise;
-            }
-            const instance = await this.#instantiateAsync(binding, resolutionCtx, resolutionPath, resolutionStack);
-            const shouldActivate = this.#refreshActivationCacheIfNeeded(binding, needsActivation);
-            const activated = shouldActivate
-                ? await this.#lifecycle.runActivation(resolutionCtx, binding, instance, this.#metadataReader)
-                : instance;
-            if (scope === "scoped") {
-                this.#scope.setScoped(binding.id, activated);
-            }
-            return activated;
+        if (scope === "singleton") {
+            // The promise is published before it settles, so concurrent callers dedup onto it.
+            const singletonPromise = this.#instantiateAndActivateAsync(binding, resolutionCtx, levelPath, levelStack, levelDepth, needsActivation).then((activated) => {
+                this.#scope.setSingleton(binding, activated);
+                this.#scope.clearInflight(binding.id);
+                return activated;
+            }, (error) => {
+                this.#scope.clearInflight(binding.id);
+                throw error;
+            });
+            this.#scope.setInflight(binding.id, singletonPromise);
+            return await singletonPromise;
         }
-        finally {
-            resolutionStack.pop();
-            resolutionPath.pop();
-            resolutionSet?.delete(frameName);
+        const activated = await this.#instantiateAndActivateAsync(binding, resolutionCtx, levelPath, levelStack, levelDepth, needsActivation);
+        if (scope === "scoped") {
+            this.#scope.setScoped(binding.id, activated);
         }
+        return activated;
     }
-    async #instantiateAsync(binding, ctx, resolutionPath, resolutionStack) {
+    async #instantiateAndActivateAsync(binding, ctx, resolutionPath, resolutionStack, branchDepth, needsActivation) {
+        const instance = await this.#instantiateAsync(binding, ctx, resolutionPath, resolutionStack, branchDepth);
+        if (!this.#activation.refreshAfterFirstInstantiation(binding, needsActivation)) {
+            return instance;
+        }
+        return this.#lifecycle.runActivation(ctx, binding, instance, this.#metadataReader);
+    }
+    async #instantiateAsync(binding, ctx, resolutionPath, resolutionStack, branchDepth) {
         switch (binding.kind) {
             case "constant":
                 return binding.value;
@@ -812,260 +624,151 @@ export class DependencyResolver {
                 }
                 return binding.factory(ctx);
             case "class": {
-                const deps = await this.#resolveClassDepsAsync(binding.target, resolutionPath, resolutionStack);
-                const instance = this.#instantiateClass(binding.target, deps);
-                return instance;
+                const deps = await this.#resolveDepsAsync(this.#constructorParams(binding.target), resolutionPath, resolutionStack, branchDepth);
+                return this.#classes.instantiate(binding.target, deps);
             }
             case "resolved": {
                 if (ctx === undefined) {
                     throw new InternalError("resolved binding requires resolution context");
                 }
-                const deps = await this.#resolveDescriptorDepsAsync(binding.deps, resolutionPath, resolutionStack);
+                const deps = await this.#resolveDepsAsync(binding.deps, resolutionPath, resolutionStack, branchDepth);
                 const factoryResult = binding.factory(...deps);
                 return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
             }
             case "resolved-async": {
-                const deps = await this.#resolveDescriptorDepsAsync(binding.deps, resolutionPath, resolutionStack);
+                const deps = await this.#resolveDepsAsync(binding.deps, resolutionPath, resolutionStack, branchDepth);
                 return binding.factory(...deps);
             }
             case "alias":
                 throw new InternalError("alias should have been followed before instantiation");
         }
     }
-    async #resolveClassDepsAsync(target, resolutionPath, resolutionStack) {
-        const meta = this.#getConstructorMetadata(target);
-        if (meta === undefined) {
-            if (target.length === 0) {
-                return [];
-            }
-            throw new MissingMetadataError(target.name);
-        }
-        if (meta.params.length === 0) {
+    async #resolveDepsAsync(deps, resolutionPath, resolutionStack, branchDepth) {
+        const count = deps.length;
+        if (count === 0) {
             return [];
         }
-        if (meta.params.length === 1) {
-            const param = meta.params[0];
-            const paramOptions = injectionSlotToResolveOptions(param);
-            if (param.multi) {
-                return [await this.resolveAllAsync(param.token, paramOptions, resolutionPath, resolutionStack)];
-            }
-            if (param.optional) {
-                return [await this.resolveOptionalAsync(param.token, paramOptions, resolutionPath, resolutionStack)];
-            }
-            if (paramOptions === undefined) {
-                return [await this.resolveAsyncFromContext(param.token, resolutionPath, resolutionStack)];
-            }
-            return [await this.resolveAsync(param.token, paramOptions, resolutionPath, resolutionStack)];
-        }
-        const pending = new Array(meta.params.length);
-        const shouldCloneContext = meta.params.length > 1;
-        for (let index = 0; index < meta.params.length; index += 1) {
-            const param = meta.params[index];
-            const paramOptions = injectionSlotToResolveOptions(param);
-            if (param.multi) {
-                pending[index] = this.resolveAllAsync(param.token, paramOptions, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
-            }
-            else if (param.optional) {
-                pending[index] = this.resolveOptionalAsync(param.token, paramOptions, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
-            }
-            else {
-                pending[index] =
-                    paramOptions === undefined
-                        ? this.resolveAsyncFromContext(param.token, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack)
-                        : this.resolveAsync(param.token, paramOptions, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
-            }
+        if (count === 1) {
+            return [await this.#resolveDepAsync(deps[0], resolutionPath, resolutionStack, branchDepth)];
+        }
+        // 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.
+        const pending = new Array(count);
+        for (let index = 0; index < count; index += 1) {
+            pending[index] = this.#resolveDepAsync(deps[index], resolutionPath, resolutionStack, branchDepth);
         }
         return Promise.all(pending);
     }
-    async #resolveDescriptorDepsAsync(deps, resolutionPath, resolutionStack) {
-        const pending = new Array(deps.length);
-        const shouldCloneContext = deps.length > 1;
-        for (let index = 0; index < deps.length; index += 1) {
-            const dep = deps[index];
-            const depOptions = injectionSlotToResolveOptions(dep);
-            if (dep.multi) {
-                pending[index] = this.resolveAllAsync(dep.token, depOptions, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
-            }
-            else if (dep.optional) {
-                pending[index] = this.resolveOptionalAsync(dep.token, depOptions, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
-            }
-            else {
-                pending[index] =
-                    depOptions === undefined
-                        ? this.resolveAsyncFromContext(dep.token, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack)
-                        : this.resolveAsync(dep.token, depOptions, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
-            }
+    #resolveDepAsync(dep, resolutionPath, resolutionStack, branchDepth) {
+        const options = injectionSlotToResolveOptions(dep);
+        if (dep.multi) {
+            return this.resolveAllAsync(dep.token, options, resolutionPath, resolutionStack, branchDepth);
         }
-        return Promise.all(pending);
+        if (dep.optional) {
+            return this.resolveOptionalAsync(dep.token, options, resolutionPath, resolutionStack, branchDepth);
+        }
+        if (options === undefined) {
+            return this.resolveAsyncFromContext(dep.token, resolutionPath, resolutionStack, branchDepth);
+        }
+        return this.resolveAsync(dep.token, options, resolutionPath, resolutionStack, branchDepth);
     }
-    async resolveOptionalAsync(token, options, resolutionPath, resolutionStack) {
+    async resolveOptionalAsync(token, options, resolutionPath, resolutionStack, branchDepth = UNOWNED_BRANCH) {
         if (this.#findBinding(token, options, resolutionPath, resolutionStack) === undefined) {
             return undefined;
         }
-        return this.resolveAsync(token, options, resolutionPath, resolutionStack);
+        return this.resolveAsync(token, options, resolutionPath, resolutionStack, branchDepth);
     }
-    async resolveAllAsync(token, options, resolutionPath, resolutionStack) {
-        if (options?.name !== undefined && options.tag === undefined && (options.tags?.length ?? 0) === 0) {
-            const namedCandidates = this.#getSimpleNamedBindingsFromChain(token, options.name);
-            if (namedCandidates.length === 0) {
-                return [];
-            }
-            const pending = new Array(namedCandidates.length);
-            for (let index = 0; index < namedCandidates.length; index += 1) {
-                pending[index] = this.#resolveCandidateAsync(namedCandidates[index], options, resolutionPath, resolutionStack);
-            }
-            return Promise.all(pending);
-        }
-        const allBindings = this.#getAllBindingsFromChain(token);
-        if (allBindings.length === 0) {
-            return [];
-        }
-        const ctx = this.#makeConstraintContext(resolutionPath, resolutionStack, options);
-        const candidates = selectAllBindings(allBindings, options, ctx);
+    async resolveAllAsync(token, options, resolutionPath, resolutionStack, branchDepth = UNOWNED_BRANCH) {
+        const candidates = this.#candidateBindings(token, options, resolutionPath, resolutionStack);
         const pending = new Array(candidates.length);
         for (let index = 0; index < candidates.length; index += 1) {
-            pending[index] = this.#resolveCandidateAsync(candidates[index], options, resolutionPath, resolutionStack);
+            pending[index] = this.#resolveCandidateAsync(candidates[index], options, resolutionPath, resolutionStack, branchDepth);
         }
         return Promise.all(pending);
     }
     // ── Helpers ────────────────────────────────────────────────────────────────
-    #getAllBindingsFromChain(token) {
+    #allBindingsFromChain(token) {
         const ownBindings = this.#registry.getAll(token);
         if (this.#parent === undefined) {
             return ownBindings;
         }
         const result = [...ownBindings];
-        let current = this.#parent;
-        while (current !== undefined) {
+        for (let current = this.#parent; current !== undefined; current = current.#parent) {
             const own = current.#registry.getAll(token);
             if (own.length > 0) {
                 result.push(...own);
             }
-            current = current.#parent;
         }
         return result;
     }
-    #getSimpleNamedBindingsFromChain(token, name) {
+    /** Every binding the chain's name indexes hold for one name, nearest container first. */
+    #namedBindingsFromChain(token, name) {
+        // A name resolves to at most one binding per registry, so a root container's answer is built
+        // whole rather than grown — the list is sized at its allocation.
         const ownBinding = this.#registry.getSimpleNamed(token, name);
         if (this.#parent === undefined) {
-            return ownBinding !== undefined ? [ownBinding] : [];
-        }
-        const result = [];
-        if (ownBinding !== undefined) {
-            result.push(ownBinding);
+            return ownBinding === undefined ? [] : [ownBinding];
         }
-        let current = this.#parent;
-        while (current !== undefined) {
+        const result = ownBinding === undefined ? [] : [ownBinding];
+        for (let current = this.#parent; current !== undefined; current = current.#parent) {
             const binding = current.#registry.getSimpleNamed(token, name);
             if (binding !== undefined) {
                 result.push(binding);
             }
-            current = current.#parent;
         }
         return result;
     }
-    #getAvailableSlots(token) {
-        return this.#registry.availableSlotStrings(token);
+    /** A constant with no activation anywhere resolves to its value with no pipeline at all. */
+    #isPlainConstant(binding) {
+        return (binding.kind === "constant" &&
+            binding.onActivation === undefined &&
+            (this.#lifecycle.activationVersion === 0 || !this.#lifecycle.hasActivationHandlers(binding.token)));
+    }
+    /** Whether either an own hook or a container-level hook would run for this binding. */
+    #hasAnyActivation(binding) {
+        if (binding.onActivation !== undefined) {
+            return true;
+        }
+        return this.#lifecycle.activationVersion !== 0 && this.#lifecycle.hasActivationHandlers(binding.token);
+    }
+    /**
+     * The cached instance of a `scoped` binding, or {@link SCOPED_MISS}.
+     *
+     * @remarks A `scoped` binding outside a child container is a configuration error, not a miss, so
+     * the check lives with the read that depends on it.
+     */
+    #readScoped(binding) {
+        if (!this.#scope.isChild) {
+            throw new MissingScopeContextError(tokenName(binding.token));
+        }
+        if (this.#scope.hasScoped(binding.id)) {
+            return this.#scope.getScoped(binding.id);
+        }
+        return SCOPED_MISS;
     }
     #makeConstraintContext(resolutionPath, resolutionStack, options) {
         if (options === undefined && resolutionPath.length === 0 && resolutionStack.length === 0) {
             return ROOT_CONSTRAINT_CONTEXT;
         }
-        const parent = resolutionStack.at(-1);
-        const ancestors = resolutionStack.length > 1 ? resolutionStack.slice(0, -1) : [];
         return {
             resolutionPath,
             resolutionStack,
-            parent,
-            ancestors,
+            parent: resolutionStack.at(-1),
+            ancestors: resolutionStack.length > 1 ? resolutionStack.slice(0, -1) : [],
             currentResolveOptions: options,
         };
     }
     #matchesBindingFast(binding, options, resolutionPath, resolutionStack) {
-        if (!this.#matchesSlotFast(binding.slot, options)) {
+        if (!matchesSlot(binding.slot, options)) {
             return false;
         }
         if (binding.predicate === undefined) {
             return true;
         }
-        const ctx = this.#makeConstraintContext(resolutionPath, resolutionStack, options);
-        return binding.predicate(ctx);
-    }
-    #matchesSlotFast(slot, options) {
-        const requestedName = options?.name;
-        const requestedTags = options?.tags;
-        const singleRequestedTag = options?.tag;
-        const hasRequestedTags = (requestedTags?.length ?? 0) > 0 || singleRequestedTag !== undefined;
-        if (slot.name !== undefined) {
-            if (requestedName === undefined || slot.name !== requestedName) {
-                return false;
-            }
-        }
-        else if (requestedName !== undefined) {
-            return false;
-        }
-        if (slot.tags.length > 0) {
-            if (!hasRequestedTags) {
-                return false;
-            }
-            for (const [tagKey, tagValue] of slot.tags) {
-                if (!this.#matchesRequestedTag(tagKey, tagValue, requestedTags, singleRequestedTag)) {
-                    return false;
-                }
-            }
-        }
-        else if (hasRequestedTags) {
-            return false;
-        }
-        return true;
-    }
-    #getTokenName(token) {
-        return tokenName(token);
-    }
-    #getConstructorMetadata(target) {
-        const cached = this.#classConstructorMetadata.get(target);
-        if (cached !== undefined) {
-            return cached === null ? undefined : cached;
-        }
-        const metadata = this.#metadataReader.getConstructorMetadata(target);
-        this.#classConstructorMetadata.set(target, metadata ?? null);
-        return metadata;
-    }
-    #instantiateClass(target, deps) {
-        let needsActiveContainer = this.#classNeedsActiveContainer.get(target);
-        if (needsActiveContainer === undefined) {
-            const accessorMetadata = this.#metadataReader.getAccessorMetadata?.(target);
-            needsActiveContainer = (accessorMetadata?.length ?? 0) > 0;
-            this.#classNeedsActiveContainer.set(target, needsActiveContainer);
-        }
-        const invokable = target;
-        if (!needsActiveContainer) {
-            return new invokable(...deps);
-        }
-        return runWithContainer(this.#container, () => new invokable(...deps));
-    }
-    #matchesRequestedTag(tagKey, tagValue, requestedTags, singleRequestedTag) {
-        if (singleRequestedTag !== undefined &&
-            singleRequestedTag[0] === tagKey &&
-            Object.is(singleRequestedTag[1], tagValue)) {
-            return true;
-        }
-        if (requestedTags === undefined || requestedTags.length === 0) {
-            return false;
-        }
-        for (let index = 0; index < requestedTags.length; index += 1) {
-            const requestedTag = requestedTags[index];
-            if (requestedTag[0] === tagKey && Object.is(requestedTag[1], tagValue)) {
-                return true;
-            }
-        }
-        return false;
+        return binding.predicate(this.#makeConstraintContext(resolutionPath, resolutionStack, options));
     }
     #resolveTransientDynamicSyncFromContext(binding, resolutionPath, resolutionStack) {
-        // One lane at every depth. The separate deep lane existed because cycle detection used to be
-        // an O(depth) `resolutionPath.includes()` scan, which had to be escaped past ~32 levels; with
-        // the O(1) `binding.inFlight` mark there is nothing to escape, so the depth split — and the
-        // divergent behaviour it caused — is gone.
+        // One lane at every depth: `binding.inFlight` is O(1), so there is nothing to escape.
         const frame = this.#getResolutionFrame(binding);
         const tokenDisplayName = frame.tokenName;
         if (binding.inFlight) {
@@ -1088,150 +791,122 @@ export class DependencyResolver {
             binding.inFlight = false;
         }
     }
-    // NOT declared `async` — avoids creating a JSAsyncGeneratorObject + implicit Promise wrapper on
-    // every invocation.  Cleanup is handled via .then(onFulfilled, onRejected) so the behaviour is
-    // identical to a try/finally but without the async machinery overhead.
-    #resolveTransientDynamicAsyncFromContext(binding, resolutionPath, resolutionStack) {
-        // One lane at every depth. Cycle detection goes through `enterResolutionPath`, which is
-        // path-scoped — the only mechanism that stays correct when chains interleave (Promise.all) —
-        // and adapts on its own: a linear scan while the path is short, an attached Set past
-        // RESOLUTION_SET_THRESHOLD. That removes the depth split, and with it a silent change of
-        // behaviour (context identity, stack frames, promise shape) at the old threshold.
-        //
-        // For a sequential chain every level shares one resolutionPath/resolutionStack, so a single
-        // DefaultResolutionContext serves the whole chain: inner levels of the owning chain allocate
-        // nothing. A concurrent chain is detected by path identity and gets its own context.
+    // Deliberately not `async`: that would allocate a state machine and a promise per level.
+    #resolveTransientDynamicAsyncFromContext(binding, resolutionPath, resolutionStack, branchDepth) {
         const frame = this.#getResolutionFrame(binding);
-        const tokenDisplayName = frame.tokenName;
+        let levelPath;
         try {
-            enterResolutionPath(resolutionPath, tokenDisplayName, false);
+            levelPath = extendResolutionBranch(resolutionPath, branchDepth, frame.tokenName);
         }
         catch (cycleError) {
             // This method is not `async`; keep failures as rejections rather than sync throws.
             return Promise.reject(cycleError);
         }
-        let ctx;
-        let isOwnerLevel;
-        if (this.#asyncChainCtxPath === resolutionPath) {
-            ctx = this.#asyncChainCtx;
-            isOwnerLevel = true;
-        }
-        else if (this.#asyncChainCtxPath === undefined) {
-            const existing = this.#asyncChainCtx;
-            if (existing === undefined) {
-                ctx = new DefaultResolutionContext(this, resolutionPath, resolutionStack, undefined);
-                this.#asyncChainCtx = ctx;
-            }
-            else {
-                existing.reset(this, resolutionPath, resolutionStack, undefined);
-                ctx = existing;
+        const levelStack = extendResolutionStackBranch(resolutionStack, branchDepth, frame);
+        // Nothing this level appended is ever removed, so no level observes its own settlement.
+        const ctx = new AsyncLevelContext(this, levelPath, levelStack, undefined);
+        try {
+            if (binding.kind === "dynamic-async") {
+                return binding.factory(ctx);
             }
-            this.#asyncChainCtxPath = resolutionPath;
-            isOwnerLevel = true;
+            const factoryResult = binding.factory(ctx);
+            return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
         }
-        else {
-            ctx = new DefaultResolutionContext(this, resolutionPath, resolutionStack, undefined);
-            isOwnerLevel = false;
+        catch (factoryError) {
+            return Promise.reject(factoryError);
+        }
+    }
+    // ── The cascade lane ───────────────────────────────────────────────────────
+    /**
+     * Entry for a request a factory makes from inside an open synchronous cascade.
+     *
+     * @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. See `ARCHITECTURE.md`.
+     */
+    resolveAsyncFromCascade(token) {
+        if (this.#cascadePath.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);
+            }
         }
-        if (isOwnerLevel) {
-            this.#asyncChainActiveLevels++;
+        // 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.#cascadePath], [...this.#cascadeStack], UNOWNED_BRANCH);
+    }
+    #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([...this.#cascadePath, frame.tokenName]));
         }
-        // Invoke the factory synchronously to get its Promise (or a resolved value for "dynamic").
-        let factoryPromise;
+        const ctx = (this.#cascadeContext ??= new AsyncCascadeContext(this, this.#cascadePath, this.#cascadeStack));
+        binding.inFlight = true;
+        this.#cascadePath.push(frame.tokenName);
+        this.#cascadeStack.push(frame);
         try {
             if (binding.kind === "dynamic-async") {
-                factoryPromise = binding.factory(ctx);
-            }
-            else {
-                const factoryResult = binding.factory(ctx);
-                factoryPromise =
-                    factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
+                return binding.factory(ctx);
             }
+            const factoryResult = binding.factory(ctx);
+            return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
         }
         catch (factoryError) {
-            // Synchronous throw from the factory (rare) — clean up immediately.
-            exitResolutionPath(resolutionPath);
-            if (isOwnerLevel && --this.#asyncChainActiveLevels === 0) {
-                this.#asyncChainCtxPath = undefined;
-                this.#asyncChainSettle = undefined;
-            }
             return Promise.reject(factoryError);
         }
-        // Cleanup runs as a SIDE listener on the factory promise instead of a derived-promise chain:
-        // registered synchronously here, it is FIFO-guaranteed to run before the awaiting caller
-        // resumes, so ordering is identical while saving one intermediate promise and one microtask
-        // hop per level. Trade-off: the settle handler marks a rejection as handled, so an unawaited
-        // failing resolveAsync no longer surfaces as an unhandledRejection — callers are expected to
-        // await (or .catch) the returned promise.
-        //
-        // Every level of the owning chain unwinds identically, so one closure serves them all.
-        let settle;
-        if (isOwnerLevel) {
-            settle =
-                this.#asyncChainSettle ??
-                    (this.#asyncChainSettle = () => {
-                        exitResolutionPath(resolutionPath);
-                        if (--this.#asyncChainActiveLevels === 0) {
-                            this.#asyncChainCtxPath = undefined;
-                            this.#asyncChainSettle = undefined;
-                        }
-                    });
-        }
-        else {
-            settle = () => {
-                exitResolutionPath(resolutionPath);
-            };
+        finally {
+            this.#cascadeStack.pop();
+            this.#cascadePath.pop();
+            binding.inFlight = false;
         }
-        factoryPromise.then(settle, settle);
-        return factoryPromise;
     }
+    // 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, resolutionPath, resolutionStack) {
-        if (binding.kind === "constant" &&
-            binding.onActivation === undefined &&
-            !this.#lifecycle.hasActivationHandlers(binding.token)) {
+        if (this.#isPlainConstant(binding)) {
             return binding.value;
         }
         if (binding.kind === "alias") {
             return this.resolve(binding.target, options, resolutionPath, resolutionStack);
         }
-        const scope = binding.scope ?? "transient";
-        if (scope === "singleton" && this.#scope.hasSingleton(binding.id)) {
-            return this.#scope.getSingleton(binding.id);
-        }
-        if (scope === "scoped") {
-            if (!this.#scope.isChild) {
-                throw new MissingScopeContextError(this.#getTokenName(binding.token));
-            }
-            if (this.#scope.hasScoped(binding.id)) {
-                return this.#scope.getScoped(binding.id);
-            }
+        if (binding.scope === "singleton" && binding.instance !== NO_INSTANCE) {
+            return binding.instance;
         }
         return this.#resolveBinding(binding, options, resolutionPath, resolutionStack);
     }
-    #resolveCandidateAsync(binding, options, resolutionPath, resolutionStack) {
-        if (binding.kind === "constant" &&
-            binding.onActivation === undefined &&
-            !this.#lifecycle.hasActivationHandlers(binding.token)) {
+    #resolveCandidateAsync(binding, options, resolutionPath, resolutionStack, branchDepth) {
+        if (this.#isPlainConstant(binding)) {
             return Promise.resolve(binding.value);
         }
-        const isolatedPath = [...resolutionPath];
-        const isolatedStack = [...resolutionStack];
         if (binding.kind === "alias") {
-            return this.resolveAsync(binding.target, options, isolatedPath, isolatedStack);
+            return this.resolveAsync(binding.target, options, resolutionPath, resolutionStack, branchDepth);
         }
-        const scope = binding.scope ?? "transient";
-        if (scope === "singleton" && this.#scope.hasSingleton(binding.id)) {
-            return Promise.resolve(this.#scope.getSingleton(binding.id));
+        if (binding.scope === "singleton" && binding.instance !== NO_INSTANCE) {
+            return Promise.resolve(binding.instance);
         }
-        if (scope === "scoped") {
-            if (!this.#scope.isChild) {
-                return Promise.reject(new MissingScopeContextError(this.#getTokenName(binding.token)));
-            }
-            if (this.#scope.hasScoped(binding.id)) {
-                return Promise.resolve(this.#scope.getScoped(binding.id));
-            }
-        }
-        return this.#resolveBindingAsync(binding, options, isolatedPath, isolatedStack);
+        return this.#resolveBindingAsync(binding, options, resolutionPath, resolutionStack, branchDepth);
     }
     #getResolutionFrame(binding) {
         // Memoized on the binding rather than in a per-resolver Map: the frame derives only from
@@ -1241,70 +916,10 @@ export class DependencyResolver {
         if (existing !== undefined) {
             return existing;
         }
-        const scope = binding.scope ?? "transient";
-        const frame = buildResolutionFrame(tokenName(binding.token), scope, binding.id, binding.kind, binding.slot);
+        const frame = buildResolutionFrame(tokenName(binding.token), binding.scope, binding.id, binding.kind, binding.slot);
         binding.frame = frame;
         return frame;
     }
-    #needsActivation(binding) {
-        const lifecycleVersion = this.#lifecycle.activationVersion;
-        if (lifecycleVersion === 0 &&
-            binding.kind !== "class" &&
-            binding.kind !== "alias" &&
-            binding.onActivation === undefined) {
-            return false;
-        }
-        if (this.#activationCacheVersion !== lifecycleVersion) {
-            this.#activationNeedByBindingId.clear();
-            this.#activationCacheVersion = lifecycleVersion;
-        }
-        const cached = this.#activationNeedByBindingId.get(binding.id);
-        if (cached !== undefined) {
-            return cached;
-        }
-        if (binding.kind === "class") {
-            let hasActivation = this.#lifecycle.hasActivationHandlers(binding.token) || binding.onActivation !== undefined;
-            const cachedPostConstruct = this.#classHasPostConstruct.get(binding.target);
-            // Unknown class lifecycle metadata: activate once, then cache after first instantiation.
-            if (cachedPostConstruct === undefined) {
-                hasActivation = true;
-            }
-            else if (cachedPostConstruct) {
-                hasActivation = true;
-            }
-            this.#activationNeedByBindingId.set(binding.id, hasActivation);
-            return hasActivation;
-        }
-        let hasActivation = false;
-        if (binding.kind !== "alias" && binding.onActivation !== undefined) {
-            hasActivation = true;
-        }
-        else if (this.#lifecycle.hasActivationHandlers(binding.token)) {
-            hasActivation = true;
-        }
-        this.#activationNeedByBindingId.set(binding.id, hasActivation);
-        return hasActivation;
-    }
-    #refreshClassPostConstructCache(target) {
-        const lifecycle = this.#metadataReader.getLifecycleMetadata(target);
-        const hasPostConstruct = lifecycle !== undefined && lifecycle.postConstruct !== undefined && lifecycle.postConstruct.length > 0;
-        this.#classHasPostConstruct.set(target, hasPostConstruct);
-    }
-    /**
-     * Refreshes the post-construct cache for class bindings on first instantiation and
-     * returns the (possibly updated) shouldActivate flag.
-     */
-    #refreshActivationCacheIfNeeded(binding, needsActivation) {
-        if (binding.kind === "class" && this.#classHasPostConstruct.get(binding.target) === undefined) {
-            this.#refreshClassPostConstructCache(binding.target);
-            this.#activationNeedByBindingId.delete(binding.id);
-            return this.#needsActivation(binding);
-        }
-        return needsActivation;
-    }
-    #requiresResolutionContext(binding) {
-        return binding.kind === "dynamic" || binding.kind === "dynamic-async";
-    }
     #acquireSyncResolutionContext(resolutionPath, resolutionStack, options) {
         const depth = resolutionStack.length;
         const existing = this.#syncResolutionContextPool[depth];
@@ -1317,4 +932,30 @@ export class DependencyResolver {
         return created;
     }
 }
+/** Absent scoped entry — distinguishes it from a cached `undefined`. */
+const SCOPED_MISS = Symbol("di:scoped-miss");
+function anyPredicate(bindings) {
+    for (let index = 0; index < bindings.length; index += 1) {
+        if (bindings[index].predicate !== undefined) {
+            return true;
+        }
+    }
+    return false;
+}
+/** 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";
+}
+/**
+ * Whether the tag index's answer is the one `Object.is` would give.
+ *
+ * @remarks An indexed binding has no name, no predicate and exactly one tag, and the request carries
+ * only that tag, so `matchesSlot` reduces to the tag values — and the index matched the key already.
+ * It answers by SameValueZero, which parts from `Object.is` (SPEC §3.5) on exactly one pair: `+0` and
+ * `-0`. So a request whose value is not zero is already exact, and only a zero-valued one is worth
+ * reading the stored value for.
+ */
+function matchesIndexedTagValue(binding, requestedValue) {
+    return requestedValue !== 0 || Object.is(binding.slot.tags[0][1], requestedValue);
+}
 //# sourceMappingURL=resolver.js.map