@codefast/di 0.5.0 → 0.6.1

package/dist/resolution/resolver.js

@@ -1,14 +1,18 @@
-import { NO_INSTANCE } from "#/binding";
-import { AsyncActivationError, AsyncResolutionError, CircularDependencyError, InternalError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, TokenNotBoundError, } from "#/errors";
-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 { branchDepthOf, enterResolutionPath, extendResolutionBranch, extendResolutionStackBranch, ROOT_BRANCH, UNOWNED_BRANCH, } from "#/resolution/resolution-path";
-import { injectionSlotToResolveOptions, isNameOnlyOptions, singleTagOnlyOf } from "#/resolution/resolve-options";
-import { tokenName } from "#/token";
+import { NO_INSTANCE } from "#/core/binding";
+import { NO_TAG_KEYS } from "#/core/tag";
+import { tokenName } from "#/core/token";
+import { AsyncActivationError, AsyncResolutionError, CircularDependencyError, DisposedContainerError, InternalError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, TokenNotBoundError, } from "#/errors/errors";
+import { isNameOnlyOptions, resolveOptionsForSlot, singleTagOnlyOf } from "#/injection/resolve-options";
+import { SCOPED_MISS } from "#/lifecycle/scope-manager";
+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 = [];
 const EMPTY_FRAME_LIST = [];
 const EMPTY_PARAM_LIST = [];
@@ -24,26 +28,29 @@ const ROOT_CONSTRAINT_CONTEXT = {
  */
 export class DependencyResolver {
     #syncResolutionContextPool = [];
+    // Contexts bound to the cascade pair — deferred: only an async cascade's sync resolves need it.
+    #cascadeContextPool;
     /**
-     * The pair a top-level **sync** resolve reuses instead of minting two arrays per call.
+     * The stack a top-level **sync** resolve reuses instead of minting an array 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.
+     * @remarks Read directly rather than through an accessor: a shallow resolve is one top-level
+     * call, so a call there is not amortised over anything. Every sync lane pops what it pushes, so
+     * `rootStack.length === 0` means no resolve holds the stack; async appends without popping and
+     * mints its own. Keeping it stable is also what lets a pooled context skip re-storing it.
      */
-    rootPath = [];
     rootStack = [];
-    // The open synchronous factory cascade: its arrays are the ancestor chain, and they are balanced
+    // The open synchronous factory cascade: its stack is the ancestor chain, and it is 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;
+    // The async lane's plans, stamped and invalidated apart so neither lane pays the other's misses.
+    #asyncPlanByBindingId = new Map();
+    #asyncPlanRegistryVersion = -1;
+    #asyncPlanActivationVersion = -1;
     #registry;
     #scope;
     #lifecycle;
@@ -62,7 +69,11 @@ export class DependencyResolver {
         this.#classes = new ClassIntrospector(metadataReader, container);
         this.#activation = new ActivationNeedCache(lifecycle, this.#classes, registry);
     }
-    /** Structural counts for {@link RESOLUTION_DIAGNOSTICS}; see `resolution/diagnostics.ts`. */
+    /** The reader this resolver was built with, which is the one its container answers with. */
+    get metadataReader() {
+        return this.#metadataReader;
+    }
+    /** Structural counts for the {@link ResolutionDiagnostics} a container reports. */
     describeCaches() {
         let compiledPlanCount = 0;
         for (const plan of this.#classPlanByBindingId.values()) {
@@ -70,13 +81,20 @@ export class DependencyResolver {
                 compiledPlanCount += 1;
             }
         }
+        let compiledAsyncPlanCount = 0;
+        for (const plan of this.#asyncPlanByBindingId.values()) {
+            if (plan !== null) {
+                compiledAsyncPlanCount += 1;
+            }
+        }
         return {
             compiledPlanCount,
+            compiledAsyncPlanCount,
             syncContextPoolSize: this.#syncResolutionContextPool.length,
         };
     }
-    // ── Binding lookup ─────────────────────────────────────────────────────────
-    #findBinding(token, options, resolutionPath, resolutionStack) {
+    // ── Binding lookup ─────────────────────────────────────────────────────────────────────────────────────────────────
+    #findBinding(token, options, resolutionStack) {
         if (options === undefined) {
             const fastDefaultBinding = this.#registry.getFastDefault(token);
             if (fastDefaultBinding !== undefined) {
@@ -85,35 +103,49 @@ export class DependencyResolver {
         }
         else if (isNameOnlyOptions(options)) {
             const namedBinding = this.#registry.getSimpleNamed(token, options.name);
-            if (namedBinding !== undefined &&
-                this.#matchesBindingFast(namedBinding, options, resolutionPath, resolutionStack)) {
+            if (namedBinding !== undefined && this.#matchesBindingFast(namedBinding, options, resolutionStack)) {
                 return { binding: namedBinding, 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])) {
+                const tagged = this.#registry.getSimpleTagged(token, singleTag);
+                if (tagged !== undefined && this.#satisfiesPredicate(tagged, options, resolutionStack)) {
                     return { binding: tagged, owner: this };
                 }
             }
+            else if (options.name === undefined &&
+                // 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.getAll(token).length > MULTI_TAG_INDEX_THRESHOLD &&
+                requestedTagKeyMask(options) !== NO_TAG_KEYS) {
+                // A name-less multi-tag request matches only name-less tagged slots, and every such slot
+                // lives in one of the two tag indexes — so their union is the whole candidate set and the
+                // token's full list never needs scanning. Selection still owns predicates and specificity.
+                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);
+            }
         }
         const bindings = this.#registry.getAll(token);
         if (bindings.length > 0) {
             // 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)
+                ? this.#matchesBindingFast(bindings[0], options, resolutionStack)
                     ? bindings[0]
                     : undefined
-                : selectBinding(bindings, options, this.#makeConstraintContext(resolutionPath, resolutionStack, options), tokenName(token));
+                : selectBinding(bindings, options, this.#makeConstraintContext(resolutionStack, options), tokenName(token));
             if (selected !== undefined) {
                 return { binding: selected, owner: this };
             }
         }
         if (this.#parent !== undefined) {
-            return this.#parent.#findBinding(token, options, resolutionPath, resolutionStack);
+            return this.#parent.#findBinding(token, options, resolutionStack);
         }
         return undefined;
     }
@@ -123,10 +155,10 @@ export class DependencyResolver {
      * @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) {
+    #requireBinding(token, options, resolutionStack) {
         let currentToken = token;
         let visitedAliasTokens;
-        let found = this.#findBinding(currentToken, options, resolutionPath, resolutionStack);
+        let found = this.#findBinding(currentToken, options, resolutionStack);
         while (found !== undefined && found.binding.kind === "alias") {
             const target = found.binding.target;
             visitedAliasTokens ??= new Set([currentToken]);
@@ -135,7 +167,7 @@ export class DependencyResolver {
             }
             visitedAliasTokens.add(target);
             currentToken = target;
-            found = this.#findBinding(currentToken, options, resolutionPath, resolutionStack);
+            found = this.#findBinding(currentToken, options, resolutionStack);
         }
         if (found === undefined) {
             // Thrown here rather than from a helper: the error captures this stack, and an error path is
@@ -151,40 +183,42 @@ export class DependencyResolver {
      * Binding lookup aligned with `resolve` — used by `Container.validate` without instantiating.
      */
     peekBindingForValidate(token, options) {
-        return this.#findBinding(token, options, [], []);
+        return this.#findBinding(token, options, []);
     }
     /**
      * Mirrors {@link DependencyResolver.resolveAll} candidate selection only (no instantiation).
      */
     peekCandidateBindingsForValidate(token, options) {
-        return this.#candidateBindings(token, options, [], []);
+        return this.#candidateBindings(token, options, []);
     }
-    // ── Sync resolve ───────────────────────────────────────────────────────────
-    resolveFromContext(token, resolutionPath, resolutionStack) {
+    // ── Sync resolve ───────────────────────────────────────────────────────────────────────────────────────────────────
+    resolveFromContext(token, resolutionStack) {
         // Hot lane: own-registry fast default. Fall back to the chain-versioned memo
         // (parent-chain walk + alias folding) only on miss or alias.
         const fastBinding = this.#registry.getFastDefault(token);
         if (fastBinding !== undefined && fastBinding.kind !== "alias") {
-            return this.#resolveDefaultEntry(fastBinding, this, resolutionPath, resolutionStack);
+            return this.#resolveDefaultEntry(fastBinding, this, resolutionStack);
         }
         const entry = this.#lookup.defaultEntry(token);
         if (entry === null) {
-            return this.resolve(token, undefined, resolutionPath, resolutionStack);
+            return this.resolve(token, undefined, resolutionStack);
         }
-        return this.#resolveDefaultEntry(entry.binding, entry.owner, resolutionPath, resolutionStack);
+        return this.#resolveDefaultEntry(entry.binding, entry.owner, resolutionStack);
     }
-    #resolveDefaultEntry(binding, owner, resolutionPath, resolutionStack) {
+    #resolveDefaultEntry(binding, owner, resolutionStack) {
         const scope = binding.scope;
         if (scope === "transient") {
             if (binding.kind === "dynamic") {
-                const containerHooks = this.#lifecycle.activationVersion === 0 ? undefined : this.#lifecycle.activationHandlersFor(binding.token);
+                // Container-level hooks belong to the binding's owner — a child-registered hook must not
+                // fire for a parent-owned binding, and the owner's must.
+                const containerHooks = owner.#lifecycle.activationVersion === 0 ? undefined : owner.#lifecycle.activationHandlersFor(binding.token);
                 if (binding.onActivation === undefined && (containerHooks === undefined || containerHooks.length === 0)) {
-                    return this.#resolveTransientDynamicSyncFromContext(binding, resolutionPath, resolutionStack);
+                    return this.#resolveTransientDynamicSyncFromContext(binding, resolutionStack);
                 }
-                return this.#resolveTransientDynamicActivatedSync(binding, containerHooks, resolutionPath, resolutionStack);
+                return this.#resolveTransientDynamicActivatedSync(binding, containerHooks, resolutionStack);
             }
             // Compiled plans only run at the top level — inner levels keep the runtime cycle guard.
-            if ((binding.kind === "class" || binding.kind === "resolved") && resolutionPath.length === 0) {
+            if ((binding.kind === "class" || binding.kind === "resolved") && resolutionStack.length === 0) {
                 const plan = this.#getInstantiationPlan(binding);
                 if (plan !== null) {
                     return plan();
@@ -193,7 +227,7 @@ export class DependencyResolver {
         }
         else if (scope === "singleton") {
             // A constant is a singleton that is already its own instance.
-            if (this.#isPlainConstant(binding)) {
+            if (owner.#isPlainConstant(binding)) {
                 return binding.value;
             }
             const cachedSingleton = binding.instance;
@@ -201,7 +235,7 @@ export class DependencyResolver {
                 return cachedSingleton;
             }
             if (owner !== this) {
-                return owner.#resolveBinding(binding, undefined, resolutionPath, resolutionStack);
+                return owner.#resolveBinding(binding, undefined, resolutionStack, owner);
             }
         }
         else {
@@ -210,27 +244,26 @@ export class DependencyResolver {
                 return cachedScoped;
             }
         }
-        return this.#resolveBinding(binding, undefined, resolutionPath, resolutionStack);
+        return this.#resolveBinding(binding, undefined, resolutionStack, owner);
     }
     // Lean lane for an activated transient dynamic binding: same observable behavior as the
     // generic #resolveBinding path (guard, frame, ctx, per-binding then container hooks) with
     // the kind/activation dispatch resolved statically.
-    #resolveTransientDynamicActivatedSync(binding, containerHooks, resolutionPath, resolutionStack) {
+    #resolveTransientDynamicActivatedSync(binding, containerHooks, 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.
+        // *is* exact path membership.
         const frame = this.#getResolutionFrame(binding);
         const tokenDisplayName = frame.tokenName;
         if (binding.inFlight) {
-            throw new CircularDependencyError([...resolutionPath, tokenDisplayName]);
+            throw new CircularDependencyError(cycleNamesOf(resolutionStack, tokenDisplayName));
         }
         binding.inFlight = true;
-        resolutionPath.push(tokenDisplayName);
         resolutionStack.push(frame);
         try {
-            const resolutionCtx = this.#acquireSyncResolutionContext(resolutionPath, resolutionStack, undefined);
+            const resolutionCtx = this.#acquireSyncResolutionContext(resolutionStack, undefined);
             const factoryResult = binding.factory(resolutionCtx);
             if (factoryResult instanceof Promise) {
-                throw new AsyncResolutionError(tokenDisplayName, tokenDisplayName);
+                throw new AsyncResolutionError(resolutionStack[0]?.tokenName ?? tokenDisplayName, tokenDisplayName);
             }
             let activated = factoryResult;
             if (binding.onActivation !== undefined) {
@@ -253,13 +286,20 @@ export class DependencyResolver {
         }
         finally {
             resolutionStack.pop();
-            resolutionPath.pop();
             binding.inFlight = false;
         }
     }
+    /** Chain-summed activation version: a plan can inline a parent-owned binding, so a parent's hook registration must invalidate it. */
+    #chainActivationVersion() {
+        let version = this.#lifecycle.activationVersion;
+        for (let current = this.#parent; current !== undefined; current = current.#parent) {
+            version += current.#lifecycle.activationVersion;
+        }
+        return version;
+    }
     #getInstantiationPlan(binding) {
         const registryVersion = this.#lookup.chainVersion();
-        const activationVersion = this.#lifecycle.activationVersion;
+        const activationVersion = this.#chainActivationVersion();
         if (registryVersion !== this.#classPlanRegistryVersion || activationVersion !== this.#classPlanActivationVersion) {
             this.#classPlanByBindingId.clear();
             this.#classPlanRegistryVersion = registryVersion;
@@ -279,7 +319,7 @@ export class DependencyResolver {
     }
     // Compiler behind #getInstantiationPlan — cold path, so the host indirection costs nothing hot.
     #planCompiler = new InstantiationPlanCompiler({
-        hasActivationHandlers: (token) => this.#lifecycle.hasActivationHandlers(token),
+        hasActivationHandlers: (binding) => this.#ownerOf(binding).#lifecycle.hasActivationHandlers(binding.token),
         knownPostConstruct: (target) => this.#classes.knownPostConstruct(target),
         needsActiveContainer: (target) => this.#classes.needsActiveContainer(target),
         getConstructorMetadata: (target) => this.#classes.constructorMetadata(target),
@@ -287,30 +327,85 @@ export class DependencyResolver {
             const entry = this.#lookup.defaultEntry(token);
             return entry === null ? null : { binding: entry.binding };
         },
+        // Exactly what #findBinding's named lane accepts, minus the half that reads a path: a predicate
+        // is the compiler's cue to leave the selection to the runtime.
+        lookupPathIndependentNamedEntry: (token, options) => {
+            const entry = this.#lookup.namedEntry(token, options.name);
+            if (entry === null || entry.binding.predicate !== undefined || !matchesSlot(entry.binding.slot, options)) {
+                return null;
+            }
+            return { binding: entry.binding };
+        },
+        // The named rule verbatim, on the single-tag lane's memo.
+        lookupPathIndependentTaggedEntry: (token, options) => {
+            const singleTag = singleTagOnlyOf(options);
+            if (singleTag === undefined) {
+                return null;
+            }
+            const entry = this.#lookup.taggedEntry(token, singleTag);
+            if (entry === null || entry.binding.predicate !== undefined || !matchesSlot(entry.binding.slot, options)) {
+                return null;
+            }
+            return { 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) => {
+        resolveEscaped: (token, options, arity, resolutionStack) => {
+            if (arity === "all") {
+                return this.resolveAll(token, options, resolutionStack);
+            }
+            if (arity === "optional") {
+                return this.resolveOptional(token, options, resolutionStack);
+            }
+            if (options === undefined) {
+                return this.resolveFromContext(token, resolutionStack);
+            }
+            return this.resolve(token, options, resolutionStack);
+        },
+        // Dispatches exactly as #resolveDepAsync does, for the async lane's escapes.
+        resolveEscapedAsync: (token, options, arity, resolutionStack) => {
             if (arity === "all") {
-                return this.resolveAll(token, options, resolutionPath, resolutionStack);
+                return this.resolveAllAsync(token, options, resolutionStack, UNOWNED_BRANCH);
             }
             if (arity === "optional") {
-                return this.resolveOptional(token, options, resolutionPath, resolutionStack);
+                return this.resolveOptionalAsync(token, options, resolutionStack, UNOWNED_BRANCH);
             }
             if (options === undefined) {
-                return this.resolveFromContext(token, resolutionPath, resolutionStack);
+                return this.resolveAsyncFromContext(token, resolutionStack, UNOWNED_BRANCH);
             }
-            return this.resolve(token, options, resolutionPath, resolutionStack);
+            return this.resolveAsync(token, options, resolutionStack, UNOWNED_BRANCH);
         },
     });
-    resolve(token, options, resolutionPath, resolutionStack) {
+    /** The async lane's plan for a statically-visible transient binding, mirroring the sync getter. */
+    #getAsyncInstantiationPlan(binding) {
+        const registryVersion = this.#lookup.chainVersion();
+        const activationVersion = this.#chainActivationVersion();
+        if (registryVersion !== this.#asyncPlanRegistryVersion || activationVersion !== this.#asyncPlanActivationVersion) {
+            this.#asyncPlanByBindingId.clear();
+            this.#asyncPlanRegistryVersion = registryVersion;
+            this.#asyncPlanActivationVersion = activationVersion;
+        }
+        const cached = this.#asyncPlanByBindingId.get(binding.id);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const compiled = this.#planCompiler.compileAsync(binding);
+        if (compiled === PLAN_RETRY) {
+            // Lifecycle metadata not discovered yet — the fallback resolve discovers it; retry then.
+            return null;
+        }
+        this.#asyncPlanByBindingId.set(binding.id, compiled);
+        return compiled;
+    }
+    resolve(token, options, resolutionStack) {
         // Name-only fast lane: memoized lookup, dispatching just the shapes whose
         // semantics involve no resolution context (constants, cached singletons).
         if (options !== undefined && isNameOnlyOptions(options)) {
             const namedEntry = this.#lookup.namedEntry(token, options.name);
             if (namedEntry !== null) {
                 const namedBinding = namedEntry.binding;
-                if (this.#isPlainConstant(namedBinding)) {
+                if (namedEntry.owner.#isPlainConstant(namedBinding)) {
                     return namedBinding.value;
                 }
                 if (namedBinding.scope === "singleton" && namedBinding.instance !== NO_INSTANCE) {
@@ -319,15 +414,32 @@ export class DependencyResolver {
                 // Everything else keeps the full path (context, activation, guards).
             }
         }
-        const { binding, owner } = this.#requireBinding(token, options, resolutionPath, resolutionStack);
+        else if (options !== undefined) {
+            // Single-tag fast lane: the named lane's tagged twin, memoizing the chain walk.
+            const singleTag = singleTagOnlyOf(options);
+            if (singleTag !== undefined) {
+                const taggedEntry = this.#lookup.taggedEntry(token, singleTag);
+                if (taggedEntry !== null) {
+                    const taggedBinding = taggedEntry.binding;
+                    if (taggedEntry.owner.#isPlainConstant(taggedBinding)) {
+                        return taggedBinding.value;
+                    }
+                    if (taggedBinding.scope === "singleton" && taggedBinding.instance !== NO_INSTANCE) {
+                        return taggedBinding.instance;
+                    }
+                    // Everything else keeps the full path (context, activation, guards).
+                }
+            }
+        }
+        const { binding, owner } = this.#requireBinding(token, options, 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);
+            return owner.#resolveBinding(binding, options, resolutionStack, owner);
         }
-        return this.#resolveBinding(binding, options, resolutionPath, resolutionStack);
+        return this.#resolveBinding(binding, options, resolutionStack, owner);
     }
-    #resolveBinding(binding, options, resolutionPath, resolutionStack) {
-        if (this.#isPlainConstant(binding)) {
+    #resolveBinding(binding, options, resolutionStack, owner) {
+        if (owner.#isPlainConstant(binding)) {
             return binding.value;
         }
         const scope = binding.scope;
@@ -335,49 +447,70 @@ export class DependencyResolver {
             if (binding.instance !== NO_INSTANCE) {
                 return binding.instance;
             }
+            // An async materialization already in flight must not be raced by a second, sync one.
+            if (this.#scope.getInflight(binding.id) !== undefined) {
+                throw new AsyncResolutionError(resolutionStack[0]?.tokenName ?? tokenName(binding.token), tokenName(binding.token));
+            }
+            if (this.#scope.isClosed) {
+                throw new DisposedContainerError();
+            }
         }
         else if (scope === "scoped") {
             const cachedScoped = this.#readScoped(binding);
             if (cachedScoped !== SCOPED_MISS) {
                 return cachedScoped;
             }
+            if (this.#scope.getInflight(binding.id) !== undefined) {
+                throw new AsyncResolutionError(resolutionStack[0]?.tokenName ?? tokenName(binding.token), tokenName(binding.token));
+            }
+            if (this.#scope.isClosed) {
+                throw new DisposedContainerError();
+            }
         }
         const frame = this.#getResolutionFrame(binding);
         const tokenDisplayName = frame.tokenName;
-        const resolutionSet = enterResolutionPath(resolutionPath, tokenDisplayName);
-        resolutionStack.push(frame);
+        const resolutionSet = enterResolutionPath(resolutionStack, frame);
         try {
-            const needsActivation = this.#activation.needsActivation(binding);
+            const needsActivation = owner.#activation.needsActivation(binding);
             if (!needsActivation && scope === "transient" && binding.kind === "dynamic") {
-                const resolutionCtx = this.#acquireSyncResolutionContext(resolutionPath, resolutionStack, options);
+                const resolutionCtx = this.#acquireSyncResolutionContext(resolutionStack, options);
                 const dynamicResult = binding.factory(resolutionCtx);
                 if (dynamicResult instanceof Promise) {
-                    throw new AsyncResolutionError(tokenDisplayName, tokenDisplayName);
+                    throw new AsyncResolutionError(resolutionStack[0]?.tokenName ?? tokenDisplayName, tokenDisplayName);
                 }
                 return dynamicResult;
             }
             const resolutionCtx = needsActivation || requiresResolutionContext(binding)
-                ? this.#acquireSyncResolutionContext(resolutionPath, resolutionStack, options)
+                ? this.#acquireSyncResolutionContext(resolutionStack, options)
                 : undefined;
-            const instance = this.#instantiateSync(binding, resolutionCtx, resolutionPath, resolutionStack);
-            const activated = this.#activation.refreshAfterFirstInstantiation(binding, needsActivation)
-                ? this.#lifecycle.runActivationSync(resolutionCtx, binding, instance, this.#metadataReader)
+            const instance = this.#instantiateSync(binding, resolutionCtx, resolutionStack);
+            this.#mirrorPostConstructFromOwner(binding, owner);
+            const activated = owner.#activation.refreshAfterFirstInstantiation(binding, needsActivation)
+                ? owner.#lifecycle.runActivationSync(resolutionCtx, binding, instance, owner.#metadataReader)
                 : instance;
             if (scope === "singleton") {
                 this.#scope.setSingleton(binding, activated);
             }
             else if (scope === "scoped") {
-                this.#scope.setScoped(binding.id, activated);
+                this.#scope.setScoped(binding, activated);
             }
             return activated;
         }
         finally {
             resolutionStack.pop();
-            resolutionPath.pop();
-            resolutionSet?.delete(tokenDisplayName);
+            resolutionSet?.delete(frame.bindingId);
         }
     }
-    #instantiateSync(binding, ctx, resolutionPath, resolutionStack) {
+    /** Path-continuing resolution handed to the ambient slot while an accessor class constructs. */
+    #ambientResolutionFor(resolutionStack) {
+        return {
+            resolve: (token, options) => options === undefined
+                ? this.resolveFromContext(token, resolutionStack)
+                : this.resolve(token, options, resolutionStack),
+            resolveOptional: (token, options) => this.resolveOptional(token, options, resolutionStack),
+        };
+    }
+    #instantiateSync(binding, ctx, resolutionStack) {
         switch (binding.kind) {
             case "constant":
                 return binding.value;
@@ -387,26 +520,26 @@ export class DependencyResolver {
                 }
                 const factoryResult = binding.factory(ctx);
                 if (factoryResult instanceof Promise) {
-                    throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+                    throw asyncResolutionErrorFor(binding, resolutionStack);
                 }
                 return factoryResult;
             }
             case "dynamic-async":
-                throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+                throw asyncResolutionErrorFor(binding, resolutionStack);
             case "class": {
-                const deps = this.#resolveDeps(this.#constructorParams(binding.target), resolutionPath, resolutionStack);
-                return this.#classes.instantiate(binding.target, deps);
+                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);
             }
             case "resolved": {
-                const deps = this.#resolveDeps(binding.deps, resolutionPath, resolutionStack);
+                const deps = this.#resolveDeps(binding.deps, resolutionStack);
                 const factoryResult = binding.factory(...deps);
                 if (factoryResult instanceof Promise) {
-                    throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+                    throw asyncResolutionErrorFor(binding, resolutionStack);
                 }
                 return factoryResult;
             }
             case "resolved-async":
-                throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+                throw asyncResolutionErrorFor(binding, resolutionStack);
             case "alias":
                 throw new InternalError("alias should have been followed before instantiation");
         }
@@ -429,66 +562,73 @@ export class DependencyResolver {
     }
     // One dispatch table for both dependency sources — constructor params and `toResolved`
     // descriptors declare the same four things.
-    #resolveDeps(deps, resolutionPath, resolutionStack) {
+    #resolveDeps(deps, resolutionStack) {
         const count = deps.length;
         if (count === 0) {
             return [];
         }
         if (count === 1) {
-            return [this.#resolveDep(deps[0], resolutionPath, resolutionStack)];
+            return [this.#resolveDep(deps[0], resolutionStack)];
         }
         const resolved = new Array(count);
         for (let index = 0; index < count; index += 1) {
-            resolved[index] = this.#resolveDep(deps[index], resolutionPath, resolutionStack);
+            resolved[index] = this.#resolveDep(deps[index], resolutionStack);
         }
         return resolved;
     }
-    #resolveDep(dep, resolutionPath, resolutionStack) {
-        const options = injectionSlotToResolveOptions(dep);
+    #resolveDep(dep, resolutionStack) {
+        const options = resolveOptionsForSlot(dep);
         if (dep.multi) {
-            return this.resolveAll(dep.token, options, resolutionPath, resolutionStack);
+            return this.resolveAll(dep.token, options, resolutionStack);
         }
         if (dep.optional) {
-            return this.resolveOptional(dep.token, options, resolutionPath, resolutionStack);
+            return this.resolveOptional(dep.token, options, resolutionStack);
         }
         if (options === undefined) {
-            return this.resolveFromContext(dep.token, resolutionPath, resolutionStack);
+            return this.resolveFromContext(dep.token, resolutionStack);
         }
-        return this.resolve(dep.token, options, resolutionPath, resolutionStack);
+        return this.resolve(dep.token, options, resolutionStack);
     }
-    resolveOptional(token, options, resolutionPath, resolutionStack) {
-        if (this.#findBinding(token, options, resolutionPath, resolutionStack) === undefined) {
+    resolveOptional(token, options, resolutionStack) {
+        const entry = this.#findBinding(token, options, resolutionStack);
+        if (entry === undefined) {
             return undefined;
         }
-        return this.resolve(token, options, resolutionPath, resolutionStack);
+        // 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);
+        }
+        return this.#resolveBinding(binding, options, resolutionStack, owner);
     }
-    resolveAll(token, options, resolutionPath, resolutionStack) {
-        const candidates = this.#candidateBindings(token, options, resolutionPath, resolutionStack);
+    resolveAll(token, options, resolutionStack) {
+        const candidates = this.#candidateBindings(token, options, 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);
+            resolved[index] = this.#resolveCandidateSync(candidates[index], options, 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;
+    #candidateBindings(token, options, resolutionStack) {
+        if (options !== undefined) {
+            const indexed = this.#indexedCandidates(token, options, resolutionStack);
+            if (indexed !== null) {
+                return indexed;
             }
-            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));
+        return selectAllBindings(allBindings, options, this.#makeConstraintContext(resolutionStack, options));
     }
-    // ── Async resolve ──────────────────────────────────────────────────────────
-    resolveAsyncFromContext(token, resolutionPath, resolutionStack, branchDepth) {
+    // ── Async resolve ──────────────────────────────────────────────────────────────────────────────────────────────────
+    resolveAsyncFromContext(token, 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);
@@ -497,24 +637,24 @@ export class DependencyResolver {
             if ((fastBinding.kind === "dynamic-async" || fastBinding.kind === "dynamic") &&
                 fastBinding.scope === "transient" &&
                 !this.#hasAnyActivation(fastBinding)) {
-                return this.#resolveTransientDynamicAsyncFromContext(fastBinding, resolutionPath, resolutionStack, branchDepth);
+                return this.#resolveTransientDynamicAsyncFromContext(fastBinding, resolutionStack, branchDepth);
             }
-            return this.#resolveAsyncDefaultEntry(fastBinding, this, resolutionPath, resolutionStack, branchDepth);
+            return this.#resolveAsyncDefaultEntry(fastBinding, this, resolutionStack, branchDepth);
         }
         const entry = this.#lookup.defaultEntry(token);
         if (entry === null) {
-            return this.resolveAsync(token, undefined, resolutionPath, resolutionStack, branchDepth);
+            return this.resolveAsync(token, undefined, resolutionStack, branchDepth);
         }
-        return this.#resolveAsyncDefaultEntry(entry.binding, entry.owner, resolutionPath, resolutionStack, branchDepth);
+        return this.#resolveAsyncDefaultEntry(entry.binding, entry.owner, resolutionStack, branchDepth);
     }
-    #resolveAsyncDefaultEntry(binding, owner, resolutionPath, resolutionStack, branchDepth) {
-        if (this.#isPlainConstant(binding)) {
+    #resolveAsyncDefaultEntry(binding, owner, resolutionStack, branchDepth) {
+        if (owner.#isPlainConstant(binding)) {
             return Promise.resolve(binding.value);
         }
         const scope = binding.scope;
         if (scope === "transient") {
-            if ((binding.kind === "dynamic" || binding.kind === "dynamic-async") && !this.#hasAnyActivation(binding)) {
-                return this.#resolveTransientDynamicAsyncFromContext(binding, resolutionPath, resolutionStack, branchDepth);
+            if ((binding.kind === "dynamic" || binding.kind === "dynamic-async") && !owner.#hasAnyActivation(binding)) {
+                return this.#resolveTransientDynamicAsyncFromContext(binding, resolutionStack, branchDepth);
             }
         }
         else if (scope === "singleton") {
@@ -522,29 +662,30 @@ export class DependencyResolver {
                 return Promise.resolve(binding.instance);
             }
             if (owner !== this) {
-                return owner.#resolveBindingAsync(binding, undefined, resolutionPath, resolutionStack, branchDepth);
+                return owner.#resolveBindingAsync(binding, undefined, resolutionStack, branchDepth, owner);
             }
         }
         else if (this.#scope.isChild) {
-            if (this.#scope.hasScoped(binding.id)) {
-                return Promise.resolve(this.#scope.getScoped(binding.id));
+            const cachedScoped = this.#scope.readScoped(binding.id);
+            if (cachedScoped !== SCOPED_MISS) {
+                return Promise.resolve(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, resolutionPath, resolutionStack, branchDepth);
+        return this.#resolveBindingAsync(binding, undefined, resolutionStack, branchDepth, owner);
     }
-    async resolveAsync(token, options, resolutionPath, resolutionStack, branchDepth = UNOWNED_BRANCH) {
-        const { binding, owner } = this.#requireBinding(token, options, resolutionPath, resolutionStack);
+    async resolveAsync(token, options, resolutionStack, branchDepth = UNOWNED_BRANCH) {
+        const { binding, owner } = this.#requireBinding(token, options, resolutionStack);
         if (binding.scope === "singleton" && owner !== this) {
-            return owner.#resolveBindingAsync(binding, options, resolutionPath, resolutionStack, branchDepth);
+            return owner.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
         }
-        return this.#resolveBindingAsync(binding, options, resolutionPath, resolutionStack, branchDepth);
+        return this.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
     }
-    async #resolveBindingAsync(binding, options, resolutionPath, resolutionStack, branchDepth) {
-        if (this.#isPlainConstant(binding)) {
+    async #resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner) {
+        if (owner.#isPlainConstant(binding)) {
             return binding.value;
         }
         const scope = binding.scope;
@@ -557,21 +698,31 @@ export class DependencyResolver {
             if (inflight !== undefined) {
                 return inflight;
             }
+            if (this.#scope.isClosed) {
+                throw new DisposedContainerError();
+            }
         }
         else if (scope === "scoped") {
             const cachedScoped = this.#readScoped(binding);
             if (cachedScoped !== SCOPED_MISS) {
                 return cachedScoped;
             }
+            // In-flight dedup, scoped flavor: one instance per scope even under concurrency.
+            const inflight = this.#scope.getInflight(binding.id);
+            if (inflight !== undefined) {
+                return inflight;
+            }
+            if (this.#scope.isClosed) {
+                throw new DisposedContainerError();
+            }
         }
         const frame = this.#getResolutionFrame(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);
+        // This level appends to its own branch and never unwinds.
+        const levelStack = extendResolutionBranch(resolutionStack, branchDepth, frame);
+        const levelDepth = branchDepthOf(levelStack);
+        const needsActivation = owner.#activation.needsActivation(binding);
         if (!needsActivation && scope === "transient" && (binding.kind === "dynamic" || binding.kind === "dynamic-async")) {
-            const resolutionCtx = new AsyncLevelContext(this, levelPath, levelStack, options);
+            const resolutionCtx = new AsyncLevelContext(this, levelStack, options);
             if (binding.kind === "dynamic-async") {
                 return await binding.factory(resolutionCtx);
             }
@@ -579,11 +730,11 @@ export class DependencyResolver {
             return dynamicResult instanceof Promise ? await dynamicResult : dynamicResult;
         }
         const resolutionCtx = needsActivation || requiresResolutionContext(binding)
-            ? new AsyncLevelContext(this, levelPath, levelStack, options)
+            ? new AsyncLevelContext(this, levelStack, options)
             : undefined;
         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) => {
+            const singletonPromise = this.#instantiateAndActivateAsync(binding, resolutionCtx, levelStack, levelDepth, needsActivation, owner).then((activated) => {
                 this.#scope.setSingleton(binding, activated);
                 this.#scope.clearInflight(binding.id);
                 return activated;
@@ -594,20 +745,42 @@ export class DependencyResolver {
             this.#scope.setInflight(binding.id, singletonPromise);
             return await singletonPromise;
         }
-        const activated = await this.#instantiateAndActivateAsync(binding, resolutionCtx, levelPath, levelStack, levelDepth, needsActivation);
         if (scope === "scoped") {
-            this.#scope.setScoped(binding.id, activated);
+            // 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) => {
+                this.#scope.setScoped(binding, activated);
+                this.#scope.clearInflight(binding.id);
+                return activated;
+            }, (error) => {
+                this.#scope.clearInflight(binding.id);
+                throw error;
+            });
+            this.#scope.setInflight(binding.id, scopedPromise);
+            return await scopedPromise;
         }
-        return activated;
+        return await this.#instantiateAndActivateAsync(binding, resolutionCtx, levelStack, levelDepth, needsActivation, owner);
     }
-    async #instantiateAndActivateAsync(binding, ctx, resolutionPath, resolutionStack, branchDepth, needsActivation) {
-        const instance = await this.#instantiateAsync(binding, ctx, resolutionPath, resolutionStack, branchDepth);
-        if (!this.#activation.refreshAfterFirstInstantiation(binding, needsActivation)) {
+    /**
+     * Settles this resolver's own `postConstruct` answer for a class binding a parent owns.
+     *
+     * @remarks The owner discovers it on first instantiation, but the plan compiler reads the
+     * introspector of whoever is resolving — left unknown, that resolver refuses to compile a plan for
+     * 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);
+        }
+    }
+    async #instantiateAndActivateAsync(binding, ctx, resolutionStack, branchDepth, needsActivation, owner) {
+        const instance = await this.#instantiateAsync(binding, ctx, resolutionStack, branchDepth);
+        this.#mirrorPostConstructFromOwner(binding, owner);
+        if (!owner.#activation.refreshAfterFirstInstantiation(binding, needsActivation)) {
             return instance;
         }
-        return this.#lifecycle.runActivation(ctx, binding, instance, this.#metadataReader);
+        return owner.#lifecycle.runActivation(ctx, binding, instance, owner.#metadataReader);
     }
-    async #instantiateAsync(binding, ctx, resolutionPath, resolutionStack, branchDepth) {
+    async #instantiateAsync(binding, ctx, resolutionStack, branchDepth) {
         switch (binding.kind) {
             case "constant":
                 return binding.value;
@@ -624,69 +797,76 @@ export class DependencyResolver {
                 }
                 return binding.factory(ctx);
             case "class": {
-                const deps = await this.#resolveDepsAsync(this.#constructorParams(binding.target), resolutionPath, resolutionStack, branchDepth);
-                return this.#classes.instantiate(binding.target, deps);
+                const deps = await this.#resolveDepsAsync(this.#constructorParams(binding.target), resolutionStack, branchDepth);
+                // 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);
             }
             case "resolved": {
-                if (ctx === undefined) {
-                    throw new InternalError("resolved binding requires resolution context");
-                }
-                const deps = await this.#resolveDepsAsync(binding.deps, resolutionPath, resolutionStack, branchDepth);
+                const deps = await this.#resolveDepsAsync(binding.deps, resolutionStack, branchDepth);
                 const factoryResult = binding.factory(...deps);
                 return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
             }
             case "resolved-async": {
-                const deps = await this.#resolveDepsAsync(binding.deps, resolutionPath, resolutionStack, branchDepth);
+                const deps = await this.#resolveDepsAsync(binding.deps, resolutionStack, branchDepth);
                 return binding.factory(...deps);
             }
             case "alias":
                 throw new InternalError("alias should have been followed before instantiation");
         }
     }
-    async #resolveDepsAsync(deps, resolutionPath, resolutionStack, branchDepth) {
+    async #resolveDepsAsync(deps, resolutionStack, branchDepth) {
         const count = deps.length;
         if (count === 0) {
             return [];
         }
         if (count === 1) {
-            return [await this.#resolveDepAsync(deps[0], resolutionPath, resolutionStack, branchDepth)];
+            return [await this.#resolveDepAsync(deps[0], 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);
+            pending[index] = this.#resolveDepAsync(deps[index], resolutionStack, branchDepth);
         }
         return Promise.all(pending);
     }
-    #resolveDepAsync(dep, resolutionPath, resolutionStack, branchDepth) {
-        const options = injectionSlotToResolveOptions(dep);
+    #resolveDepAsync(dep, resolutionStack, branchDepth) {
+        const options = resolveOptionsForSlot(dep);
         if (dep.multi) {
-            return this.resolveAllAsync(dep.token, options, resolutionPath, resolutionStack, branchDepth);
+            return this.resolveAllAsync(dep.token, options, resolutionStack, branchDepth);
         }
         if (dep.optional) {
-            return this.resolveOptionalAsync(dep.token, options, resolutionPath, resolutionStack, branchDepth);
+            return this.resolveOptionalAsync(dep.token, options, resolutionStack, branchDepth);
         }
         if (options === undefined) {
-            return this.resolveAsyncFromContext(dep.token, resolutionPath, resolutionStack, branchDepth);
+            return this.resolveAsyncFromContext(dep.token, resolutionStack, branchDepth);
         }
-        return this.resolveAsync(dep.token, options, resolutionPath, resolutionStack, branchDepth);
+        return this.resolveAsync(dep.token, options, resolutionStack, branchDepth);
     }
-    async resolveOptionalAsync(token, options, resolutionPath, resolutionStack, branchDepth = UNOWNED_BRANCH) {
-        if (this.#findBinding(token, options, resolutionPath, resolutionStack) === undefined) {
+    async resolveOptionalAsync(token, options, resolutionStack, branchDepth = UNOWNED_BRANCH) {
+        const entry = this.#findBinding(token, options, resolutionStack);
+        if (entry === undefined) {
             return undefined;
         }
-        return this.resolveAsync(token, options, resolutionPath, resolutionStack, branchDepth);
+        // 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 this.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
     }
-    async resolveAllAsync(token, options, resolutionPath, resolutionStack, branchDepth = UNOWNED_BRANCH) {
-        const candidates = this.#candidateBindings(token, options, resolutionPath, resolutionStack);
+    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, resolutionPath, resolutionStack, branchDepth);
+            pending[index] = this.#resolveCandidateAsync(candidates[index], options, resolutionStack, branchDepth);
         }
         return Promise.all(pending);
     }
-    // ── Helpers ────────────────────────────────────────────────────────────────
+    // ── Helpers ────────────────────────────────────────────────────────────────────────────────────────────────────────
     #allBindingsFromChain(token) {
         const ownBindings = this.#registry.getAll(token);
         if (this.#parent === undefined) {
@@ -718,6 +898,52 @@ export class DependencyResolver {
         }
         return result;
     }
+    /**
+     * The candidates an index can name outright, or `null` when the request needs full selection.
+     *
+     * @remarks Kept off `#candidateBindings` so that method stays the size it was: a request neither
+     * index serves must not pay for the two that do.
+     * An index has matched the slot already, but a hit may still carry a predicate, and evaluating
+     * that is the selection path's job.
+     */
+    #indexedCandidates(token, options, resolutionStack) {
+        if (isNameOnlyOptions(options)) {
+            const named = this.#namedBindingsFromChain(token, options.name);
+            return anyPredicate(named)
+                ? selectAllBindings(named, options, this.#makeConstraintContext(resolutionStack, options))
+                : named;
+        }
+        const singleTag = singleTagOnlyOf(options);
+        if (singleTag === undefined) {
+            return null;
+        }
+        const tagged = this.#taggedBindingsFromChain(token, singleTag);
+        return anyPredicate(tagged)
+            ? selectAllBindings(tagged, options, this.#makeConstraintContext(resolutionStack, options))
+            : tagged;
+    }
+    /**
+     * Every binding the chain's tag indexes hold for one tag, nearest container first.
+     *
+     * @remarks A request for one tag and no name matches exactly the bindings the index keys, so this
+     * is the whole candidate set rather than a prefilter — a named or multi-tag slot cannot satisfy it.
+     */
+    #taggedBindingsFromChain(token, tag) {
+        // A tag matches at most one binding per registry, so a root container's answer is built whole
+        // rather than grown — the shape `#namedBindingsFromChain` takes, for the same reason.
+        const ownBinding = this.#registry.getSimpleTagged(token, tag);
+        if (this.#parent === undefined) {
+            return ownBinding === undefined ? [] : [ownBinding];
+        }
+        const result = ownBinding === undefined ? [] : [ownBinding];
+        for (let current = this.#parent; current !== undefined; current = current.#parent) {
+            const binding = current.#registry.getSimpleTagged(token, tag);
+            if (binding !== undefined) {
+                result.push(binding);
+            }
+        }
+        return result;
+    }
     /** A constant with no activation anywhere resolves to its value with no pipeline at all. */
     #isPlainConstant(binding) {
         return (binding.kind === "constant" &&
@@ -741,70 +967,100 @@ export class DependencyResolver {
         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;
+        return this.#scope.readScoped(binding.id);
     }
-    #makeConstraintContext(resolutionPath, resolutionStack, options) {
-        if (options === undefined && resolutionPath.length === 0 && resolutionStack.length === 0) {
+    // 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.
+    #makeConstraintContext(resolutionStack, options) {
+        if (options === undefined && resolutionStack.length === 0) {
             return ROOT_CONSTRAINT_CONTEXT;
         }
-        return {
-            resolutionPath,
-            resolutionStack,
-            parent: resolutionStack.at(-1),
-            ancestors: resolutionStack.length > 1 ? resolutionStack.slice(0, -1) : [],
-            currentResolveOptions: options,
-        };
+        return buildConstraintContext(resolutionStack, options);
     }
-    #matchesBindingFast(binding, options, resolutionPath, resolutionStack) {
+    /** Selection for a name-less multi-tag request, over the union of the two tag indexes. */
+    #selectMultiTagged(token, options, resolutionStack) {
+        const candidates = [];
+        this.#gatherTagCandidates(token, options.tag, candidates);
+        const listed = options.tags;
+        if (listed !== undefined) {
+            for (let index = 0; index < listed.length; index += 1) {
+                this.#gatherTagCandidates(token, listed[index], candidates);
+            }
+        }
+        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) {
+        if (criterion === undefined) {
+            return;
+        }
+        // The includes probes only guard a request repeating a criterion across its two spellings.
+        const single = this.#registry.getSimpleTagged(token, criterion);
+        if (single !== undefined && !out.includes(single)) {
+            out.push(single);
+        }
+        const bucket = this.#registry.getMultiTagged(token, criterion);
+        if (bucket !== undefined) {
+            for (let index = 0; index < bucket.length; index += 1) {
+                const candidate = bucket[index];
+                if (!out.includes(candidate)) {
+                    out.push(candidate);
+                }
+            }
+        }
+    }
+    #matchesBindingFast(binding, options, resolutionStack) {
         if (!matchesSlot(binding.slot, options)) {
             return false;
         }
-        if (binding.predicate === undefined) {
+        return this.#satisfiesPredicate(binding, options, resolutionStack);
+    }
+    /** The predicate half of a match, for a lane whose index has already settled the slot. */
+    #satisfiesPredicate(binding, options, resolutionStack) {
+        const predicate = binding.predicate;
+        if (predicate === undefined) {
             return true;
         }
-        return binding.predicate(this.#makeConstraintContext(resolutionPath, resolutionStack, options));
+        return predicate(this.#makeConstraintContext(resolutionStack, options));
     }
-    #resolveTransientDynamicSyncFromContext(binding, resolutionPath, resolutionStack) {
+    #resolveTransientDynamicSyncFromContext(binding, resolutionStack) {
         // 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) {
-            throw new CircularDependencyError([...resolutionPath, tokenDisplayName]);
+            throw new CircularDependencyError(cycleNamesOf(resolutionStack, tokenDisplayName));
         }
         binding.inFlight = true;
-        resolutionPath.push(tokenDisplayName);
         resolutionStack.push(frame);
-        const resolutionCtx = this.#acquireSyncResolutionContext(resolutionPath, resolutionStack, undefined);
+        const resolutionCtx = this.#acquireSyncResolutionContext(resolutionStack, undefined);
         try {
             const dynamicResult = binding.factory(resolutionCtx);
             if (dynamicResult instanceof Promise) {
-                throw new AsyncResolutionError(tokenDisplayName, tokenDisplayName);
+                throw new AsyncResolutionError(resolutionStack[0]?.tokenName ?? tokenDisplayName, tokenDisplayName);
             }
             return dynamicResult;
         }
         finally {
             resolutionStack.pop();
-            resolutionPath.pop();
             binding.inFlight = false;
         }
     }
     // Deliberately not `async`: that would allocate a state machine and a promise per level.
-    #resolveTransientDynamicAsyncFromContext(binding, resolutionPath, resolutionStack, branchDepth) {
+    #resolveTransientDynamicAsyncFromContext(binding, resolutionStack, branchDepth) {
         const frame = this.#getResolutionFrame(binding);
-        let levelPath;
+        let levelStack;
         try {
-            levelPath = extendResolutionBranch(resolutionPath, branchDepth, frame.tokenName);
+            levelStack = extendResolutionBranch(resolutionStack, branchDepth, frame);
         }
         catch (cycleError) {
             // This method is not `async`; keep failures as rejections rather than sync throws.
             return Promise.reject(cycleError);
         }
-        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);
+        const ctx = new AsyncLevelContext(this, levelStack, undefined);
         try {
             if (binding.kind === "dynamic-async") {
                 return binding.factory(ctx);
@@ -816,16 +1072,16 @@ export class DependencyResolver {
             return Promise.reject(factoryError);
         }
     }
-    // ── The cascade lane ───────────────────────────────────────────────────────
+    // ── 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`.
+     * are on no call stack — it escapes to the branch lane.
      */
     resolveAsyncFromCascade(token) {
-        if (this.#cascadePath.length === 0) {
-            return this.resolveAsyncFromContext(token, [], [], ROOT_BRANCH);
+        if (this.#cascadeStack.length === 0) {
+            return this.resolveAsyncFromContext(token, [], ROOT_BRANCH);
         }
         return this.#dispatchCascade(token);
     }
@@ -849,10 +1105,39 @@ export class DependencyResolver {
             if (fastBinding.scope === "singleton" && fastBinding.instance !== NO_INSTANCE) {
                 return Promise.resolve(fastBinding.instance);
             }
+            const planned = this.#plannedCascadeAnswer(fastBinding);
+            if (planned !== null) {
+                return planned;
+            }
         }
         // 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);
+        return this.resolveAsyncFromContext(token, [...this.#cascadeStack], UNOWNED_BRANCH);
+    }
+    /**
+     * A statically-visible transient graph at a true root answers from its compiled async plan.
+     *
+     * @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.
+     */
+    #plannedCascadeAnswer(fastBinding) {
+        if (this.#cascadeStack.length !== 0 ||
+            fastBinding.scope !== "transient" ||
+            (fastBinding.kind !== "class" && fastBinding.kind !== "resolved" && fastBinding.kind !== "resolved-async")) {
+            return null;
+        }
+        const plan = this.#getAsyncInstantiationPlan(fastBinding);
+        if (plan === null) {
+            return null;
+        }
+        try {
+            const planned = plan();
+            return planned instanceof Promise ? planned : Promise.resolve(planned);
+        }
+        catch (planError) {
+            // The interpreted lane is async, so a sync throw is a rejection there too.
+            return Promise.reject(planError);
+        }
     }
     #resolveTransientDynamicAsyncCascade(binding) {
         const frame = this.#getResolutionFrame(binding);
@@ -860,11 +1145,10 @@ export class DependencyResolver {
         // 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]));
+            return Promise.reject(new CircularDependencyError(cycleNamesOf(this.#cascadeStack, frame.tokenName)));
         }
-        const ctx = (this.#cascadeContext ??= new AsyncCascadeContext(this, this.#cascadePath, this.#cascadeStack));
+        const ctx = (this.#cascadeContext ??= new AsyncCascadeContext(this, this.#cascadeStack));
         binding.inFlight = true;
-        this.#cascadePath.push(frame.tokenName);
         this.#cascadeStack.push(frame);
         try {
             if (binding.kind === "dynamic-async") {
@@ -878,35 +1162,64 @@ export class DependencyResolver {
         }
         finally {
             this.#cascadeStack.pop();
-            this.#cascadePath.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, resolutionPath, resolutionStack) {
-        if (this.#isPlainConstant(binding)) {
+    #resolveCandidateSync(binding, options, resolutionStack) {
+        // Fan-outs are dominated by constants: with no activation hook anywhere in the chain, a
+        // hook-free constant is plain no matter which container owns it — skip the owner probe.
+        if (binding.kind === "constant" && binding.onActivation === undefined && this.#chainActivationVersion() === 0) {
+            return binding.value;
+        }
+        const owner = this.#ownerOf(binding);
+        if (owner.#isPlainConstant(binding)) {
             return binding.value;
         }
         if (binding.kind === "alias") {
-            return this.resolve(binding.target, options, resolutionPath, resolutionStack);
+            return this.resolve(binding.target, options, resolutionStack);
         }
-        if (binding.scope === "singleton" && binding.instance !== NO_INSTANCE) {
-            return binding.instance;
+        if (binding.scope === "singleton") {
+            if (binding.instance !== NO_INSTANCE) {
+                return binding.instance;
+            }
+            // Owner-routed like `resolve`: the owner materializes and caches its own singleton.
+            return owner.#resolveBinding(binding, options, resolutionStack, owner);
         }
-        return this.#resolveBinding(binding, options, resolutionPath, resolutionStack);
+        return this.#resolveBinding(binding, options, resolutionStack, owner);
     }
-    #resolveCandidateAsync(binding, options, resolutionPath, resolutionStack, branchDepth) {
-        if (this.#isPlainConstant(binding)) {
+    #resolveCandidateAsync(binding, options, resolutionStack, branchDepth) {
+        if (binding.kind === "constant" && binding.onActivation === undefined && this.#chainActivationVersion() === 0) {
+            return Promise.resolve(binding.value);
+        }
+        const owner = this.#ownerOf(binding);
+        if (owner.#isPlainConstant(binding)) {
             return Promise.resolve(binding.value);
         }
         if (binding.kind === "alias") {
-            return this.resolveAsync(binding.target, options, resolutionPath, resolutionStack, branchDepth);
+            return this.resolveAsync(binding.target, options, resolutionStack, branchDepth);
         }
-        if (binding.scope === "singleton" && binding.instance !== NO_INSTANCE) {
-            return Promise.resolve(binding.instance);
+        if (binding.scope === "singleton") {
+            if (binding.instance !== NO_INSTANCE) {
+                return Promise.resolve(binding.instance);
+            }
+            return owner.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
         }
-        return this.#resolveBindingAsync(binding, options, resolutionPath, resolutionStack, branchDepth);
+        return this.#resolveBindingAsync(binding, options, resolutionStack, branchDepth, owner);
+    }
+    /** The resolver whose registry holds `binding` — `this` (the common case) when it is own. */
+    #ownerOf(binding) {
+        // A root resolver can only hold its own bindings, so the per-candidate id probe is chain-only.
+        if (this.#parent === undefined || this.#registry.getById(binding.id) !== undefined) {
+            return this;
+        }
+        for (let current = this.#parent; current !== undefined; current = current.#parent) {
+            if (current.#registry.getById(binding.id) !== undefined) {
+                return current;
+            }
+        }
+        return this;
     }
     #getResolutionFrame(binding) {
         // Memoized on the binding rather than in a per-resolver Map: the frame derives only from
@@ -920,20 +1233,40 @@ export class DependencyResolver {
         binding.frame = frame;
         return frame;
     }
-    #acquireSyncResolutionContext(resolutionPath, resolutionStack, options) {
+    // A pool is keyed by the one array pair its contexts hold, so reuse can never re-point a context
+    // a live frame still reads — a nested top-level resolve reaches the same depth while the outer
+    // factory runs, and it must get its own context, not the outer frame's re-bound.
+    #acquireSyncResolutionContext(resolutionStack, options) {
+        if (resolutionStack === this.rootStack) {
+            const depth = resolutionStack.length;
+            const existing = this.#syncResolutionContextPool[depth];
+            if (existing !== undefined) {
+                existing.reset(this, resolutionStack, options);
+                return existing;
+            }
+            const created = new DefaultResolutionContext(this, resolutionStack, options);
+            this.#syncResolutionContextPool[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 existing = this.#syncResolutionContextPool[depth];
+        const pool = (this.#cascadeContextPool ??= []);
+        const existing = pool[depth];
         if (existing !== undefined) {
-            existing.reset(this, resolutionPath, resolutionStack, options);
+            existing.reset(this, resolutionStack, options);
             return existing;
         }
-        const created = new DefaultResolutionContext(this, resolutionPath, resolutionStack, options);
-        this.#syncResolutionContextPool[depth] = created;
+        const created = new DefaultResolutionContext(this, resolutionStack, options);
+        pool[depth] = created;
         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) {
@@ -942,20 +1275,29 @@ 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,
+    };
+}
+/** 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);
+}
 /** 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