@bian-womp/spark-graph 0.2.46 → 0.2.47

package/lib/cjs/index.cjs

@@ -639,6 +639,30 @@ class GraphRuntime {
             },
         };
     }
+    createExecutionContext(nodeId, node, inputs, runId, abortSignal, options) {
+        const emitHandler = options?.emitHandler ??
+            ((handle, value) => this.propagate(nodeId, handle, value));
+        const reportProgress = options?.reportProgress ??
+            ((p) => {
+                node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
+            });
+        return {
+            state: node.state,
+            setState: (next) => Object.assign(node.state, next),
+            emit: emitHandler,
+            invalidateDownstream: () => this.invalidateDownstream(nodeId),
+            scheduleInputsChanged: () => {
+                if (this.allInboundHaveValue(nodeId)) {
+                    this.scheduleInputsChanged(nodeId);
+                }
+            },
+            getInput: (handle) => inputs[handle],
+            environment: this.environment,
+            runId,
+            abortSignal,
+            reportProgress,
+        };
+    }
     scheduleInputsChanged(nodeId) {
         const node = this.nodes.get(nodeId);
         if (!node)
@@ -681,24 +705,13 @@ class GraphRuntime {
             if (policy.timeoutMs && policy.timeoutMs > 0) {
                 timeoutId = setTimeout(() => controller.abort("timeout"), policy.timeoutMs);
             }
-            const ctx = {
-                state: node.state,
-                environment: this.environment,
-                runId,
-                abortSignal: controller.signal,
-                setState: (next) => Object.assign(node.state, next),
-                emit: (handle, value) => {
+            const ctx = this.createExecutionContext(nodeId, node, capturedInputs, runId, controller.signal, {
+                emitHandler: (handle, value) => {
                     const m = policy.asyncConcurrency ?? "switch";
                     if (m !== "merge" && runId !== node.latestRunId)
                         return;
                     this.propagate(nodeId, handle, value);
                 },
-                invalidateDownstream: () => this.invalidateDownstream(nodeId),
-                scheduleInputsChanged: () => {
-                    if (this.allInboundHaveValue(nodeId)) {
-                        this.scheduleInputsChanged(nodeId);
-                    }
-                },
                 reportProgress: (p) => {
                     node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
                     this.emit("stats", {
@@ -708,10 +721,11 @@ class GraphRuntime {
                         progress: node.stats.progress,
                     });
                 },
-            };
+            });
             const exec = async (attempt) => {
                 let hadError = false;
                 try {
+                    node.lifecycle?.prepare?.(node.params ?? {}, ctx);
                     await node.runtime.onInputsChanged?.(capturedInputs, ctx);
                 }
                 catch (err) {
@@ -1153,10 +1167,10 @@ class GraphRuntime {
     launch(invalidate = false) {
         // call onActivated for nodes that implement it
         for (const node of this.nodes.values()) {
-            node.lifecycle?.init?.(node.params ?? {}, {
-                state: node.state,
-                setState: (next) => Object.assign(node.state, next),
-            });
+            const effectiveInputs = this.getEffectiveInputs(node.nodeId);
+            const ctrl = new AbortController();
+            const ctx = this.createExecutionContext(node.nodeId, node, effectiveInputs, `${node.nodeId}:init`, ctrl.signal);
+            node.lifecycle?.prepare?.(node.params ?? {}, ctx);
             node.runtime.onActivated?.();
         }
         if (invalidate) {
@@ -1399,10 +1413,10 @@ class GraphRuntime {
                 };
                 this.nodes.set(n.nodeId, rn);
                 // Activate new node
-                rn.lifecycle?.init?.(rn.params ?? {}, {
-                    state: rn.state,
-                    setState: (next) => Object.assign(rn.state, next),
-                });
+                const effectiveInputs = this.getEffectiveInputs(rn.nodeId);
+                const ctrl = new AbortController();
+                const ctx = this.createExecutionContext(rn.nodeId, rn, effectiveInputs, `${rn.nodeId}:init`, ctrl.signal);
+                rn.lifecycle?.prepare?.(rn.params ?? {}, ctx);
                 rn.runtime.onActivated?.();
             }
             else {