@codefast/di 0.10.1 → 0.11.0

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

@@ -1,13 +1,16 @@
 import { NO_INSTANCE } from "#core/binding";
+import { settleInOrder } from "#resolution/async-fan-out";
 /**
  * The number of runs a plan's closure makes before the plan is generated as its own function.
  *
- * @remarks Below it a plan stays a closure, which is all a cold container or a per-request child
- * ever runs; above it a plan pays one compile for call sites nothing else feeds.
+ * @remarks A measured policy, not a machine width, a contract value or bind-time data: generating
+ * costs some fifty closure runs and the new function runs cold for thirty more, so it repays only
+ * over runs in the thousands. Below it a plan stays a closure, which is all a cold container or a
+ * per-request child ever runs.
  *
  * @since 0.10.0
  */
-export const PLAN_CODEGEN_THRESHOLD = 32;
+export const PLAN_CODEGEN_THRESHOLD = 1024;
 const rejectWith = (error) => Promise.reject(error);
 let codegenAvailable;
 let generatedCount = 0;
@@ -59,10 +62,10 @@ export function generateAsyncPlan(node) {
     const emitter = new PlanEmitter();
     return compileRendered(emitter, emitter.asyncExpression(node));
 }
-function compileRendered(emitter, expression) {
+function compileRendered(emitter, result) {
     generatedCount += 1;
     const locals = emitter.locals.length === 0 ? "" : `let ${emitter.locals.join(", ")};`;
-    const body = `"use strict";/* plan ${String(generatedCount)} */${emitter.hoisted.join("")}return () => {${locals}return ${expression};};`;
+    const body = `"use strict";/* plan ${String(generatedCount)} */${emitter.hoisted.join("")}return () => {${locals}${emitter.statements.join("")}return ${result};};`;
     try {
         // Compiling from source is the mechanism: one function literal per plan is what gives it its own feedback.
         // oxlint-disable-next-line typescript/no-implied-eval
@@ -74,40 +77,50 @@ function compileRendered(emitter, expression) {
     }
 }
 /**
- * Renders a plan tree as one expression over parameters that carry every value the plan closes over.
+ * Renders a plan tree as a flat sequence of statements over parameters that carry every value the plan closes over.
  *
- * @remarks A node that awaits its dependencies renders as an inner function of the same source, so
- * every plan's awaiting nodes have call sites of their own too.
+ * @remarks Each node becomes one assignment to a local after its dependencies' assignments, in declaration
+ * order, so the generated function evaluates exactly as the nested closure did while nesting nothing: a
+ * graph of any depth renders as that many statements, never as an expression that deep. A node that awaits
+ * its dependencies renders as an inner function of the same shape, so every plan's awaiting nodes have call
+ * sites of their own too.
  */
 class PlanEmitter {
     names = [];
     values = [];
     hoisted = [];
-    #localsByFunction = [[]];
+    #frames = [
+        { locals: [], statements: [] },
+    ];
     #hoistedCount = 0;
     #slotByValue = new Map();
     /** The plan function's own temporaries. */
     get locals() {
-        return this.#localsByFunction[0];
+        return this.#frames[0].locals;
     }
+    /** The plan function's statements, in evaluation order. */
+    get statements() {
+        return this.#frames[0].statements;
+    }
+    /** Emits a node's statements and returns the reference that holds its value. */
     expression(node) {
         switch (node.kind) {
             case "construct":
-                return `new ${this.#slot(node.target, "C")}(${this.#list(node.deps)})`;
+                return this.#define(`new ${this.#slot(node.target, "C")}(${this.#list(node.deps)})`);
             case "accessors":
-                return `${this.#slot(node.construct, "A")}([${this.#list(node.deps)}])`;
+                return this.#define(`${this.#slot(node.construct, "A")}([${this.#list(node.deps)}])`);
             case "call": {
-                // The settle only ever throws, so it runs on the promise branch alone and the plain result returns as is.
-                const local = this.#local();
-                const call = `${this.#slot(node.factory, "F")}(${this.#list(node.deps)})`;
-                return `((${local} = ${call}) instanceof ${this.#slot(Promise, "P")} ? ${this.#slot(node.settle, "S")}(${local}) : ${local})`;
+                // The settle only ever throws, so it runs on the promise branch alone and the plain result stands.
+                const local = this.#define(`${this.#slot(node.factory, "F")}(${this.#list(node.deps)})`);
+                this.#statement(`if (${local} instanceof ${this.#slot(Promise, "P")}) ${local} = ${this.#slot(node.settle, "S")}(${local});`);
+                return local;
             }
             case "value":
                 return this.#slot(node.value, "V");
             case "singleton":
                 return this.#singletonRead(node.binding, node.escape);
             case "thunk":
-                return `${this.#slot(node.run, "T")}()`;
+                return this.#define(`${this.#slot(node.run, "T")}()`);
         }
     }
     asyncExpression(node) {
@@ -116,20 +129,20 @@ class PlanEmitter {
                 const target = this.#slot(node.target, "C");
                 return node.awaits
                     ? this.#settled(node.deps, (values) => `new ${target}(${values})`)
-                    : `new ${target}(${this.#asyncList(node.deps)})`;
+                    : this.#define(`new ${target}(${this.#asyncList(node.deps)})`);
             }
             case "call": {
                 const factory = this.#slot(node.factory, "F");
                 return node.awaits
                     ? this.#settled(node.deps, (values) => `${factory}(${values})`)
-                    : `${factory}(${this.#asyncList(node.deps)})`;
+                    : this.#define(`${factory}(${this.#asyncList(node.deps)})`);
             }
             case "value":
                 return this.#slot(node.value, "V");
             case "singleton":
                 return this.#singletonRead(node.binding, node.escape);
             case "thunk":
-                return `${this.#slot(node.run, "T")}()`;
+                return this.#define(`${this.#slot(node.run, "T")}()`);
         }
     }
     #list(deps) {
@@ -146,30 +159,45 @@ class PlanEmitter {
         const name = `n${String(index)}`;
         const applyName = `a${String(index)}`;
         const reject = this.#slot(rejectWith, "R");
-        const promise = this.#slot(Promise, "P");
-        this.#localsByFunction.push([]);
+        const frame = { locals: [], statements: [] };
+        this.#frames.push(frame);
         const pendings = [];
-        const statements = [];
         for (let position = 0; position < deps.length; position += 1) {
             const pending = `p${String(position)}`;
             pendings.push(pending);
-            statements.push(`try{${pending}=${this.asyncExpression(deps[position])};}catch(e){${pending}=${reject}(e);}`);
+            // A dependency's own statements run inside its try, so its sync throw is its rejection alone.
+            const mark = frame.statements.length;
+            const reference = this.asyncExpression(deps[position]);
+            const inner = frame.statements.splice(mark).join("");
+            frame.statements.push(`try{${inner}${pending}=${reference};}catch(e){${pending}=${reject}(e);}`);
         }
-        const locals = [...pendings, ...this.#localsByFunction.pop()];
-        const values = deps.map((_dep, position) => `v[${String(position)}]`).join(",");
-        this.hoisted.push(`const ${applyName}=(v)=>${apply(values)};const ${name}=()=>{let ${locals.join(",")};${statements.join("")}return ${promise}.all([${pendings.join(",")}]).then(${applyName});};`);
-        return `${name}()`;
+        this.#frames.pop();
+        const locals = [...pendings, ...frame.locals];
+        // One dependency has one outcome, so there is nothing to order and no fan-out to settle.
+        const settled = deps.length === 1
+            ? `const ${applyName}=(v0)=>${apply("v0")};const ${name}=()=>{let ${locals.join(",")};${frame.statements.join("")}return ${this.#slot(Promise, "P")}.resolve(p0).then(${applyName});};`
+            : `const ${applyName}=(v)=>${apply(deps.map((_dep, position) => `v[${String(position)}]`).join(","))};const ${name}=()=>{let ${locals.join(",")};${frame.statements.join("")}return ${this.#slot(settleInOrder, "W")}([${pendings.join(",")}],${applyName});};`;
+        this.hoisted.push(settled);
+        return this.#define(`${name}()`);
+    }
+    #define(expression) {
+        const local = this.#local();
+        this.#statement(`${local} = ${expression};`);
+        return local;
+    }
+    #statement(statement) {
+        this.#frames.at(-1).statements.push(statement);
     }
     #local() {
-        const locals = this.#localsByFunction.at(-1);
+        const locals = this.#frames.at(-1).locals;
         const local = `t${String(locals.length)}`;
         locals.push(local);
         return local;
     }
     #singletonRead(binding, escape) {
-        const local = this.#local();
-        const slot = this.#slot(binding, "B");
-        return `((${local} = ${slot}.instance) === ${this.#slot(NO_INSTANCE, "N")} ? ${this.#slot(escape, "E")}() : ${local})`;
+        const local = this.#define(`${this.#slot(binding, "B")}.instance`);
+        this.#statement(`if (${local} === ${this.#slot(NO_INSTANCE, "N")}) ${local} = ${this.#slot(escape, "E")}();`);
+        return local;
     }
     // One parameter per distinct value, so a class constructed four times is one constructor with four sites.
     #slot(value, prefix) {

package/dist/resolution/resolver.d.ts

@@ -65,12 +65,11 @@ export declare class DependencyResolver implements ResolverCallbacks {
     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<ReadonlyArray<Value>>;
     /**
-     * Entry for a request a factory makes from inside an open synchronous cascade.
+     * Entry for an options-less resolve the container starts: the root of a branch of its own.
      *
-     * @remarks A request arriving with no cascade open came out of a continuation, so its ancestors
-     * are on no call stack — it escapes to the branch lane.
+     * @remarks A statically-visible transient graph answers from its compiled async plan; everything
+     * else opens a branch over a fresh array, so every level's context keeps its own ancestors for as
+     * long as the factory holds it — across an `await` included.
      */
-    resolveAsyncFromCascade(token: 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>;
 }