@codefast/di 0.5.0 → 0.6.1

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

@@ -0,0 +1,94 @@
+import type { BindingIdentifier, ResolutionFrame } from "#/core/types";
+/**
+ * Where the cycle check switches from a linear frame scan to an attached Set.
+ *
+ * @remarks Measured rather than guessed: below this depth the linear scan wins, above it the Set does.
+ *
+ * @since 0.5.0-canary.7
+ */
+export declare const RESOLUTION_SET_THRESHOLD = 32;
+/**
+ * The token names along a stack plus the frame that closed the cycle — built only to throw.
+ *
+ * @since 0.6.0
+ */
+export declare function cycleNamesOf(resolutionStack: ReadonlyArray<ResolutionFrame>, closingName: string): Array<string>;
+/**
+ * Marks a level as in-flight on this stack, throwing if its binding is already an ancestor.
+ *
+ * @remarks The check keys on binding identity — two distinct tokens may share a display name — and
+ * the names an error prints are derived from the frames at the throw site. Unmark by popping the
+ * stack plus `set?.delete(frame.bindingId)`. Sync only — the async lane never removes an entry, so
+ * it extends a branch instead; see {@link extendResolutionBranch}.
+ *
+ * @returns the membership set once the stack is deep enough to carry one, else `undefined`.
+ *
+ * @since 0.5.0-canary.7
+ */
+export declare function enterResolutionPath(resolutionStack: Array<ResolutionFrame>, frame: ResolutionFrame): Set<BindingIdentifier> | undefined;
+declare const BRANCH_BRAND: unique symbol;
+/**
+ * A resolution stack one async branch owns, so appending to it cannot disturb another branch.
+ *
+ * @remarks Only {@link extendResolutionBranch} mints one. That is what makes "may this lane append
+ * to this array" a question the compiler answers instead of a rule in a doc — a sync frame's stack,
+ * which that frame will pop, is a plain `Array<ResolutionFrame>` and cannot reach a level that owns
+ * its own.
+ *
+ * @since 0.5.0-canary.9
+ */
+export type OwnedBranchStack = Array<ResolutionFrame> & {
+    readonly [BRANCH_BRAND]: true;
+};
+declare const BRANCH_DEPTH_BRAND: unique symbol;
+/**
+ * How many leading entries of a stack belong to one async branch.
+ *
+ * @remarks Branded so a bare number cannot be passed: a depth from anywhere but this branch silently
+ * re-parents a level.
+ *
+ * @since 0.5.0-canary.9
+ */
+export type OwnedBranchDepth = number & {
+    readonly [BRANCH_DEPTH_BRAND]: true;
+};
+/**
+ * A stack no async branch owns yet, so its first extension must copy rather than append.
+ *
+ * @since 0.5.0-canary.9
+ */
+export declare const UNOWNED_BRANCH = -1;
+/**
+ * How far into a stack one extension may reach: this branch's own depth, or nobody's.
+ *
+ * @remarks A union rather than a sentinel hidden inside the branded number, so the two cases are
+ * visible at every signature that takes one and `=== UNOWNED_BRANCH` narrows to the owned case.
+ *
+ * @since 0.5.0-canary.9
+ */
+export type BranchDepth = OwnedBranchDepth | typeof UNOWNED_BRANCH;
+/**
+ * The depth a chain's first level extends from, over an array its caller just minted.
+ *
+ * @since 0.5.0-canary.9
+ */
+export declare const ROOT_BRANCH: OwnedBranchDepth;
+/**
+ * A branch's own depth: the length its stack had when this level took it.
+ *
+ * @since 0.5.0-canary.9
+ */
+export declare function branchDepthOf(branch: OwnedBranchStack): OwnedBranchDepth;
+/**
+ * Extends one branch of an append-only stack, throwing if the binding is already an ancestor.
+ *
+ * @remarks The check compares binding ids on the frames; the names an error prints are derived at
+ * the throw site. Appends in place while this branch still owns the next slot, and copies its own
+ * prefix once a sibling has claimed it. Nothing is ever removed, so no async level has to observe
+ * its own settlement to unwind.
+ *
+ * @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

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolution-path.d.ts","sourceRoot":"","sources":["../../../src/resolution/path/resolution-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAKvE;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAG3C;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,eAAe,EAAE,aAAa,CAAC,eAAe,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAOhH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,eAAe,EAAE,KAAK,CAAC,eAAe,CAAC,EACvC,KAAK,EAAE,eAAe,GACrB,GAAG,CAAC,iBAAiB,CAAC,GAAG,SAAS,CA6BpC;AAED,OAAO,CAAC,MAAM,YAAY,EAAE,OAAO,MAAM,CAAC;AAE1C;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,eAAe,CAAC,GAAG;IAAE,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAE1F,OAAO,CAAC,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,kBAAkB,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAEhF;;;;GAIG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,OAAO,cAAc,CAAC;AAEnE;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAQ,gBAAgB,CAAC;AAEjD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAExE;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,eAAe,EAAE,KAAK,CAAC,eAAe,CAAC,EACvC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,eAAe,GACrB,gBAAgB,CAkBlB"}

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

@@ -0,0 +1,117 @@
+/** Cycle-detection bookkeeping carried on the resolution stack itself. */
+import { CircularDependencyError } from "#/errors/errors";
+const RESOLUTION_SET_KEY = Symbol("di:resolution-set");
+/**
+ * Where the cycle check switches from a linear frame scan to an attached Set.
+ *
+ * @remarks Measured rather than guessed: below this depth the linear scan wins, above it the Set does.
+ *
+ * @since 0.5.0-canary.7
+ */
+export const RESOLUTION_SET_THRESHOLD = 32;
+/**
+ * The token names along a stack plus the frame that closed the cycle — built only to throw.
+ *
+ * @since 0.6.0
+ */
+export function cycleNamesOf(resolutionStack, closingName) {
+    const names = new Array(resolutionStack.length + 1);
+    for (let index = 0; index < resolutionStack.length; index += 1) {
+        names[index] = resolutionStack[index].tokenName;
+    }
+    names[resolutionStack.length] = closingName;
+    return names;
+}
+/**
+ * Marks a level as in-flight on this stack, throwing if its binding is already an ancestor.
+ *
+ * @remarks The check keys on binding identity — two distinct tokens may share a display name — and
+ * the names an error prints are derived from the frames at the throw site. Unmark by popping the
+ * stack plus `set?.delete(frame.bindingId)`. Sync only — the async lane never removes an entry, so
+ * it extends a branch instead; see {@link extendResolutionBranch}.
+ *
+ * @returns the membership set once the stack is deep enough to carry one, else `undefined`.
+ *
+ * @since 0.5.0-canary.7
+ */
+export function enterResolutionPath(resolutionStack, frame) {
+    const stackWithSet = resolutionStack;
+    let resolutionSet = stackWithSet[RESOLUTION_SET_KEY];
+    // A live set mirrors the stack exactly, so a size that disagrees means it is holding ids of
+    // frames that unwound: the ones already on the stack when it attached were handed no set to
+    // delete from. Dropped rather than repaired, because the next deep frame rebuilds it.
+    if (resolutionSet !== undefined && resolutionSet.size !== resolutionStack.length) {
+        resolutionSet = undefined;
+        stackWithSet[RESOLUTION_SET_KEY] = undefined;
+    }
+    if (resolutionSet === undefined && resolutionStack.length >= RESOLUTION_SET_THRESHOLD) {
+        resolutionSet = new Set();
+        for (let index = 0; index < resolutionStack.length; index += 1) {
+            resolutionSet.add(resolutionStack[index].bindingId);
+        }
+        stackWithSet[RESOLUTION_SET_KEY] = resolutionSet;
+    }
+    if (resolutionSet === undefined) {
+        for (let index = 0; index < resolutionStack.length; index += 1) {
+            if (resolutionStack[index].bindingId === frame.bindingId) {
+                throw new CircularDependencyError(cycleNamesOf(resolutionStack, frame.tokenName));
+            }
+        }
+    }
+    else if (resolutionSet.has(frame.bindingId)) {
+        throw new CircularDependencyError(cycleNamesOf(resolutionStack, frame.tokenName));
+    }
+    resolutionStack.push(frame);
+    resolutionSet?.add(frame.bindingId);
+    return resolutionSet;
+}
+/**
+ * A stack no async branch owns yet, so its first extension must copy rather than append.
+ *
+ * @since 0.5.0-canary.9
+ */
+export const UNOWNED_BRANCH = -1;
+/**
+ * The depth a chain's first level extends from, over an array its caller just minted.
+ *
+ * @since 0.5.0-canary.9
+ */
+export const ROOT_BRANCH = 0;
+/**
+ * A branch's own depth: the length its stack had when this level took it.
+ *
+ * @since 0.5.0-canary.9
+ */
+export function branchDepthOf(branch) {
+    return branch.length;
+}
+/**
+ * Extends one branch of an append-only stack, throwing if the binding is already an ancestor.
+ *
+ * @remarks The check compares binding ids on the frames; the names an error prints are derived at
+ * the throw site. Appends in place while this branch still owns the next slot, and copies its own
+ * prefix once a sibling has claimed it. Nothing is ever removed, so no async level has to observe
+ * its own settlement to unwind.
+ *
+ * @since 0.5.0-canary.9
+ */
+export function extendResolutionBranch(resolutionStack, branchDepth, frame) {
+    const depth = branchDepth === UNOWNED_BRANCH ? resolutionStack.length : branchDepth;
+    for (let index = 0; index < depth; index += 1) {
+        if (resolutionStack[index].bindingId === frame.bindingId) {
+            throw new CircularDependencyError(cycleNamesOf(resolutionStack.slice(0, depth), frame.tokenName));
+        }
+    }
+    // An unowned array belongs to a sync frame that will pop it, or carries a membership Set this
+    // lane cannot keep true; copying is what makes the branch's own appends safe.
+    if (branchDepth === resolutionStack.length) {
+        // The sole mint: appending in place needs a depth that came from a branch already owned, or
+        // ROOT_BRANCH over an array its caller minted for this chain alone.
+        resolutionStack.push(frame);
+        return resolutionStack;
+    }
+    const branch = resolutionStack.slice(0, depth);
+    branch.push(frame);
+    return branch;
+}
+//# sourceMappingURL=resolution-path.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolution-path.js","sourceRoot":"","sources":["../../../src/resolution/path/resolution-path.ts"],"names":[],"mappings":"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"}

package/dist/resolution/{instantiation-plan.d.ts → plan/instantiation-plan.d.ts}

@@ -1,12 +1,13 @@
 /**
  * Compiles a transient class or resolved-factory binding into a nested-constructor closure.
  *
- * @see `ARCHITECTURE.md` — the escape contract every dependency the compiler cannot inline must honour.
+ * @remarks A dependency the compiler cannot inline escapes to a resolver callback instead; the
+ * closure must stay callable for it, which is what bounds what may be inlined.
  */
-import type { Binding } from "#/binding";
+import type { Binding } from "#/core/binding";
+import type { Token } from "#/core/token";
+import type { Constructor, ResolutionFrame, ResolveOptions } from "#/core/types";
 import type { ConstructorMetadata } from "#/metadata/metadata-types";
-import type { Token } from "#/token";
-import type { Constructor, ResolutionFrame, ResolveOptions } from "#/types";
 /**
  * Compilation asked to retry later (class lifecycle metadata not discovered yet).
  *
@@ -35,17 +36,36 @@ export interface InstantiationPlanDependencyEntry {
  * @since 0.5.0-canary.7
  */
 export interface InstantiationPlanHost {
-    hasActivationHandlers(token: Token<unknown> | Constructor): boolean;
+    /** Owner-aware: container-level hooks belong to the binding's owner, which may be a parent. */
+    hasActivationHandlers(binding: Binding): boolean;
     /** Cached postConstruct presence — `undefined` until a runtime resolve discovers it. */
     knownPostConstruct(target: Constructor): boolean | undefined;
     needsActiveContainer(target: Constructor): boolean;
     getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
     /** 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.
+     *
+     * @remarks Selection for a named 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;
     /** 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 ancestors above it. */
-    resolveEscaped(token: Token<unknown> | Constructor, options: ResolveOptions | undefined, arity: EscapeArity, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): unknown;
+    /** Runtime resolve for an escaped dependency, seeded with the ancestor frames above it. */
+    resolveEscaped(token: Token<unknown> | Constructor, options: ResolveOptions | undefined, arity: EscapeArity, resolutionStack: Array<ResolutionFrame>): unknown;
+    /** The async counterpart of {@link InstantiationPlanHost.resolveEscaped}, replaying the async dispatch. */
+    resolveEscapedAsync(token: Token<unknown> | Constructor, options: ResolveOptions | undefined, arity: EscapeArity, resolutionStack: Array<ResolutionFrame>): Promise<unknown>;
 }
 /**
  * Which resolve an escaped dependency replays — mirrors how the interpreted path dispatches
@@ -63,5 +83,15 @@ export declare class InstantiationPlanCompiler {
     compile(binding: Binding & {
         kind: "class" | "resolved";
     }): InstantiationPlanCompileResult;
+    /**
+     * Compiles a transient binding whose graph is statically visible, for the async entry point.
+     *
+     * @remarks Same gates as the sync lane; the differences are downstream — escapes replay the async
+     * dispatch, and a node whose dependencies may yield promises awaits them together, exactly as the
+     * interpreted async path does.
+     */
+    compileAsync(binding: Binding & {
+        kind: "class" | "resolved" | "resolved-async";
+    }): InstantiationPlanCompileResult;
 }
 //# sourceMappingURL=instantiation-plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instantiation-plan.d.ts","sourceRoot":"","sources":["../../../src/resolution/plan/instantiation-plan.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAIjF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAMrE;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,MAAgC,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,IAAI,GAAG,OAAO,UAAU,CAAC;AA0DxF;;;;GAIG;AACH,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,+FAA+F;IAC/F,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;IACjD,wFAAwF;IACxF,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,GAAG,SAAS,CAAC;IAC7D,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;IACnD,sBAAsB,CAAC,MAAM,EAAE,WAAW,GAAG,mBAAmB,GAAG,SAAS,CAAC;IAC7E,0FAA0F;IAC1F,qBAAqB,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,WAAW,GAAG,gCAAgC,GAAG,IAAI,CAAC;IACpG;;;;;OAKG;IACH,+BAA+B,CAC7B,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,WAAW,EACnC,OAAO,EAAE,cAAc,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GACzC,gCAAgC,GAAG,IAAI,CAAC;IAC3C;;;;;OAKG;IACH,gCAAgC,CAAC,CAC/B,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,WAAW,EACnC,OAAO,EAAE,cAAc,GACtB,gCAAgC,GAAG,IAAI,CAAC;IAC3C,wFAAwF;IACxF,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe,CAAC;IACtD,2FAA2F;IAC3F,cAAc,CACZ,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,WAAW,EACnC,OAAO,EAAE,cAAc,GAAG,SAAS,EACnC,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,KAAK,CAAC,eAAe,CAAC,GACtC,OAAO,CAAC;IACX,2GAA2G;IAC3G,mBAAmB,CACjB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,WAAW,EACnC,OAAO,EAAE,cAAc,GAAG,SAAS,EACnC,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,KAAK,CAAC,eAAe,CAAC,GACtC,OAAO,CAAC,OAAO,CAAC,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,UAAU,GAAG,QAAQ,CAAC;AAExD;;GAEG;AACH,qBAAa,yBAAyB;;IAGpC,YAAY,IAAI,EAAE,qBAAqB,EAEtC;IAED,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG;QAAE,IAAI,EAAE,OAAO,GAAG,UAAU,CAAA;KAAE,GAAG,8BAA8B,CAIzF;IA8ND;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG;QAAE,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,gBAAgB,CAAA;KAAE,GAAG,8BAA8B,CASjH;CAwMF"}