@codefast/di 0.7.1 → 0.8.1

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

@@ -6,13 +6,9 @@ import { getOrInsertComputed } from "#/core/map-upsert";
  * @since 0.5.0-canary.8
  */
 export const ALIAS_HOP_LIMIT = 32;
-/**
- * @since 0.5.0-canary.8
- */
-const newNameToEntryMap = () => new Map();
 const newTagToEntryMap = () => new Map();
 /**
- * A version-stamped cache of binding lookups by token, name, and tag across the container chain.
+ * A version-stamped cache of binding lookups by token and criterion across the container chain.
  *
  * @since 0.5.0-canary.9
  */
@@ -24,8 +20,6 @@ export class BindingLookupCache {
     // is tracked by the token slot rather than by the entry.
     #lastToken;
     #lastEntry = null;
-    #byTokenAndName = new Map();
-    #namedVersion = -1;
     #byTokenAndTag = new Map();
     #taggedVersion = -1;
     // One entry in front of the tag map, and the map is not written until a second distinct request
@@ -70,23 +64,6 @@ export class BindingLookupCache {
         this.#lastEntry = entry;
         return entry;
     }
-    /** `null` when the name's shape needs the full selection path. */
-    namedEntry(token, name) {
-        const version = this.chainVersion();
-        if (version !== this.#namedVersion) {
-            this.#byTokenAndName.clear();
-            this.#namedVersion = version;
-        }
-        // Computed, not eager: this runs on every named resolve, and the eager form would allocate a
-        // Map per call only to discard it on the hit that follows.
-        const byName = getOrInsertComputed(this.#byTokenAndName, token, newNameToEntryMap);
-        let entry = byName.get(name);
-        if (entry === undefined) {
-            entry = this.#findNamedInChain(token, name);
-            byName.set(name, entry);
-        }
-        return entry;
-    }
     /** `null` when the tag's shape needs the full selection path. */
     taggedEntry(token, tag) {
         const version = this.chainVersion();
@@ -144,20 +121,6 @@ export class BindingLookupCache {
         }
         return this.#parent === undefined ? null : this.#parent.#findDefaultInChain(token);
     }
-    #findNamedInChain(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.#owner };
-        }
-        if (this.#registry.has(token)) {
-            return null;
-        }
-        return this.#parent === undefined ? null : this.#parent.#findNamedInChain(token, name);
-    }
     #findTaggedInChain(token, tag) {
         const tagged = this.#registry.getSimpleTagged(token, tag);
         if (tagged !== undefined) {
@@ -172,5 +135,4 @@ export class BindingLookupCache {
         }
         return this.#parent === undefined ? null : this.#parent.#findTaggedInChain(token, tag);
     }
-}
-//# sourceMappingURL=binding-lookup-cache.js.map
+}

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

@@ -64,5 +64,4 @@ export declare class ClassIntrospector {
     /** True when the class has accessor injection, which reads the container during construction. */
     needsActiveContainer(target: Constructor): boolean;
     instantiate(target: Constructor, deps: Array<unknown>, resolution?: AmbientResolution): unknown;
-}
-//# sourceMappingURL=class-introspector.d.ts.map
+}

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

@@ -192,5 +192,4 @@ export class ClassIntrospector {
         }
         return runWithAmbientResolution(this.#container, resolution, () => new invokable(...deps));
     }
-}
-//# sourceMappingURL=class-introspector.js.map
+}

package/dist/resolution/context.d.ts

@@ -86,5 +86,4 @@ export declare class AsyncCascadeContext implements ResolutionContext {
  *
  * @since 0.3.16-canary.0
  */
-export declare function buildResolutionFrame(tokenName: string, scope: BindingScope, bindingId: BindingIdentifier, kind: BindingKind, slot: ResolutionFrame["slot"]): ResolutionFrame;
-//# sourceMappingURL=context.d.ts.map
+export declare function buildResolutionFrame(tokenName: string, scope: BindingScope, bindingId: BindingIdentifier, kind: BindingKind, slot: ResolutionFrame["slot"]): ResolutionFrame;

package/dist/resolution/context.js

@@ -203,5 +203,4 @@ class DefaultConstraintContext {
  */
 export function buildResolutionFrame(tokenName, scope, bindingId, kind, slot) {
     return { tokenName, scope, bindingId, kind, slot };
-}
-//# sourceMappingURL=context.js.map
+}

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

@@ -90,5 +90,4 @@ export declare function branchDepthOf(branch: OwnedBranchStack): OwnedBranchDept
  * @since 0.5.0-canary.9
  */
 export declare function extendResolutionBranch(resolutionStack: Array<ResolutionFrame>, branchDepth: BranchDepth, frame: ResolutionFrame): OwnedBranchStack;
-export {};
-//# sourceMappingURL=resolution-path.d.ts.map
+export {};

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

@@ -113,5 +113,4 @@ export function extendResolutionBranch(resolutionStack, branchDepth, frame) {
     const branch = resolutionStack.slice(0, depth);
     branch.push(frame);
     return branch;
-}
-//# sourceMappingURL=resolution-path.js.map
+}

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

@@ -45,21 +45,13 @@ export interface InstantiationPlanHost {
     /** Options-less lookup with alias hops folded; `null` when the fast lane can't answer. */
     lookupDependencyEntry(token: Token<unknown> | Constructor): InstantiationPlanDependencyEntry | null;
     /**
-     * A name-only lookup a plan may bake in, or `null` when the answer is not the compiler's to make.
+     * A single-criterion lookup a plan may bake in, or `null` when the answer is not the compiler's
+     * to make.
      *
-     * @remarks Selection for a named request is an index hit *and* a predicate, and a predicate reads
+     * @remarks Selection for such a request is an index hit *and* a predicate, and a predicate reads
      * the resolution path — so only a candidate carrying none of one can be decided ahead of time.
      */
-    lookupPathIndependentNamedEntry(token: Token<unknown> | Constructor, options: ResolveOptions & {
-        name: string;
-    }): InstantiationPlanDependencyEntry | null;
-    /**
-     * The named lookup's single-tag twin, or `null` under the same rule.
-     *
-     * @remarks Optional so a host predating it stays a valid host — a compiler given none simply
-     * escapes the dependency, which is exactly the pre-settlement behavior.
-     */
-    lookupPathIndependentTaggedEntry?(token: Token<unknown> | Constructor, options: ResolveOptions): InstantiationPlanDependencyEntry | null;
+    lookupPathIndependentEntry(token: Token<unknown> | Constructor, options: ResolveOptions): InstantiationPlanDependencyEntry | null;
     /** The frame the interpreted path pushes for this binding, so escapes can replay it. */
     getResolutionFrame(binding: Binding): ResolutionFrame;
     /** Runtime resolve for an escaped dependency, seeded with the ancestor frames above it. */
@@ -95,5 +87,4 @@ export declare class InstantiationPlanCompiler {
     compileAsync(binding: Binding & {
         kind: "class" | "resolved" | "resolved-async";
     }): InstantiationPlanCompileResult;
-}
-//# sourceMappingURL=instantiation-plan.d.ts.map
+}

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

@@ -1,7 +1,7 @@
 import { NO_INSTANCE } from "#/core/binding";
 import { tokenName } from "#/core/token";
 import { AsyncResolutionError } from "#/errors/errors";
-import { injectionSlotToResolveOptions, isNameOnlyOptions } from "#/injection/resolve-options";
+import { injectionSlotToResolveOptions } from "#/injection/resolve-options";
 // Past this depth a dependency escapes to the runtime path rather than inlining further —
 // compiled closures nest one JS frame per level, and pathological graphs are the runtime's job.
 const PLAN_DEPTH_LIMIT = 32;
@@ -126,20 +126,11 @@ export class InstantiationPlanCompiler {
             return this.#compileEscapeThunk(token, ancestors, "optional", options);
         }
         if (options !== undefined) {
-            // A name the registry can settle without reading a path is a dependency like any other: it
-            // escapes only because it carries a criterion, not because anything about it is opaque.
-            if (isNameOnlyOptions(options)) {
-                const named = this.#host.lookupPathIndependentNamedEntry(token, options);
-                if (named !== null) {
-                    return this.#compileDepThunk(named, compileStack, depth, ancestors, options);
-                }
-            }
-            else {
-                // The host owns the whole single-tag decision, including whether the options qualify.
-                const tagged = this.#host.lookupPathIndependentTaggedEntry?.(token, options);
-                if (tagged !== null && tagged !== undefined) {
-                    return this.#compileDepThunk(tagged, compileStack, depth, ancestors, options);
-                }
+            // A criterion the registry can settle without reading a path is a dependency like any other:
+            // it escapes only because the host cannot decide it ahead of time.
+            const indexed = this.#host.lookupPathIndependentEntry(token, options);
+            if (indexed !== null) {
+                return this.#compileDepThunk(indexed, compileStack, depth, ancestors, options);
             }
             return this.#compileEscapeThunk(token, ancestors, "single", options);
         }
@@ -359,18 +350,9 @@ export class InstantiationPlanCompiler {
             return this.#compileAsyncEscapeThunk(token, ancestors, "optional", options);
         }
         if (options !== undefined) {
-            if (isNameOnlyOptions(options)) {
-                const named = this.#host.lookupPathIndependentNamedEntry(token, options);
-                if (named !== null) {
-                    return this.#compileAsyncDepThunk(named, compileStack, depth, ancestors, options);
-                }
-            }
-            else {
-                // The host owns the whole single-tag decision, including whether the options qualify.
-                const tagged = this.#host.lookupPathIndependentTaggedEntry?.(token, options);
-                if (tagged !== null && tagged !== undefined) {
-                    return this.#compileAsyncDepThunk(tagged, compileStack, depth, ancestors, options);
-                }
+            const indexed = this.#host.lookupPathIndependentEntry(token, options);
+            if (indexed !== null) {
+                return this.#compileAsyncDepThunk(indexed, compileStack, depth, ancestors, options);
             }
             return this.#compileAsyncEscapeThunk(token, ancestors, "single", options);
         }
@@ -417,5 +399,4 @@ export class InstantiationPlanCompiler {
         }
         return this.#compileAsyncEscapeThunk(binding.token, ancestors, "single", options);
     }
-}
-//# sourceMappingURL=instantiation-plan.js.map
+}

package/dist/resolution/resolver.d.ts

@@ -2,7 +2,7 @@ import type { Container } from "#/container/container";
 import type { Binding } from "#/core/binding";
 import type { BindingRegistry } from "#/core/registry";
 import type { Token } from "#/core/token";
-import type { Constructor, ResolutionFrame, ResolveOptions } from "#/core/types";
+import type { BindingTag, Constructor, ResolutionFrame, ResolveOptions } from "#/core/types";
 import type { ResolutionDiagnostics } from "#/errors/diagnostics";
 import type { LifecycleManager } from "#/lifecycle/lifecycle-manager";
 import type { ScopeManager } from "#/lifecycle/scope-manager";
@@ -40,12 +40,19 @@ export declare class DependencyResolver implements ResolverCallbacks {
      */
     peekCandidateBindingsForValidate(token: Token<unknown> | Constructor, options: ResolveOptions | undefined): ReadonlyArray<Binding>;
     resolveFromContext<Value>(token: Token<Value> | Constructor<Value>, resolutionStack: Array<ResolutionFrame>): Value;
-    resolve<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Value;
-    resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Value | undefined;
+    resolve<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>, precomputedCriterion?: BindingTag | null): Value;
+    resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>, precomputedCriterion?: BindingTag | null): Value | undefined;
     resolveAll<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>): Array<Value>;
     resolveAsyncFromContext<Value>(token: Token<Value> | Constructor<Value>, resolutionStack: Array<ResolutionFrame>, branchDepth: BranchDepth): Promise<Value>;
-    resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>, branchDepth?: BranchDepth): Promise<Value>;
-    resolveOptionalAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>, branchDepth?: BranchDepth): Promise<Value | undefined>;
+    /**
+     * Instantiates one owned binding directly, bypassing selection.
+     *
+     * @remarks Warm-up must build the binding it inspected: re-selecting by the slot's own criteria
+     * could pick a different candidate whose criteria are a subset of them.
+     */
+    warmBindingAsync(binding: Binding, options: ResolveOptions | undefined): Promise<unknown>;
+    resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>, branchDepth?: BranchDepth, precomputedCriterion?: BindingTag | null): Promise<Value>;
+    resolveOptionalAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>, branchDepth?: BranchDepth, precomputedCriterion?: BindingTag | null): Promise<Value | undefined>;
     resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionStack: Array<ResolutionFrame>, branchDepth?: BranchDepth): Promise<Array<Value>>;
     /**
      * Entry for a request a factory makes from inside an open synchronous cascade.
@@ -56,5 +63,4 @@ export declare class DependencyResolver implements ResolverCallbacks {
     resolveAsyncFromCascade(token: Token<unknown> | Constructor): Promise<unknown>;
     /** Entry for a resolve the container starts, which opens the cascade rather than joining one. */
     resolveAsyncFromRoot(token: Token<unknown> | Constructor): Promise<unknown>;
-}
-//# sourceMappingURL=resolver.d.ts.map
+}