@bian-womp/spark-graph 0.2.44 → 0.2.46

package/lib/cjs/index.cjs

@@ -683,6 +683,9 @@ class GraphRuntime {
             }
             const ctx = {
                 state: node.state,
+                environment: this.environment,
+                runId,
+                abortSignal: controller.signal,
                 setState: (next) => Object.assign(node.state, next),
                 emit: (handle, value) => {
                     const m = policy.asyncConcurrency ?? "switch";
@@ -691,11 +694,11 @@ class GraphRuntime {
                     this.propagate(nodeId, handle, value);
                 },
                 invalidateDownstream: () => this.invalidateDownstream(nodeId),
-                getInput: (handle) => capturedInputs[handle],
-                environment: this.environment,
-                runId: runId,
-                abortSignal: controller.signal,
-                createAbortController: () => new AbortController(),
+                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", {
@@ -846,10 +849,7 @@ class GraphRuntime {
             if (dynamicHandles.has(handle))
                 continue; // Skip defaults for dynamic handles
             // Clone to avoid shared references
-            effective[handle] =
-                typeof structuredClone === "function"
-                    ? structuredClone(defaultValue)
-                    : JSON.parse(JSON.stringify(defaultValue));
+            effective[handle] = structuredClone(defaultValue);
         }
         return effective;
     }
@@ -1153,27 +1153,11 @@ class GraphRuntime {
     launch(invalidate = false) {
         // call onActivated for nodes that implement it
         for (const node of this.nodes.values()) {
-            const ctrl = new AbortController();
-            const effectiveInputs = this.getEffectiveInputs(node.nodeId);
-            const ctx = {
-                state: node.state,
-                setState: (next) => Object.assign(node.state, next),
-                emit: (handle, value) => this.propagate(node.nodeId, handle, value),
-                invalidateDownstream: () => this.invalidateDownstream(node.nodeId),
-                getInput: (handle) => effectiveInputs[handle],
-                environment: this.environment,
-                runId: `${node.nodeId}:activation`,
-                abortSignal: ctrl.signal,
-                createAbortController: () => new AbortController(),
-                reportProgress: (p) => {
-                    node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
-                },
-            };
             node.lifecycle?.init?.(node.params ?? {}, {
                 state: node.state,
                 setState: (next) => Object.assign(node.state, next),
             });
-            node.runtime.onActivated?.(ctx);
+            node.runtime.onActivated?.();
         }
         if (invalidate) {
             // After activation, schedule nodes that have all inbound inputs present
@@ -1187,22 +1171,6 @@ class GraphRuntime {
         const node = this.nodes.get(nodeId);
         if (!node)
             return;
-        const ctrl = new AbortController();
-        const effectiveInputs = this.getEffectiveInputs(nodeId);
-        const ctx = {
-            state: node.state,
-            setState: (next) => Object.assign(node.state, next),
-            emit: (handle, value) => this.propagate(nodeId, handle, value),
-            invalidateDownstream: () => this.invalidateDownstream(nodeId),
-            getInput: (handle) => effectiveInputs[handle],
-            environment: this.environment,
-            runId: `${nodeId}:external`,
-            abortSignal: ctrl.signal,
-            createAbortController: () => new AbortController(),
-            reportProgress: (p) => {
-                node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
-            },
-        };
         // Built-in support: invalidate event reruns or re-emits without per-node wiring
         if (event &&
             typeof event === "object" &&
@@ -1213,7 +1181,7 @@ class GraphRuntime {
                 this.invalidateDownstream(nodeId);
         }
         else {
-            node.runtime.onExternalEvent?.(event, ctx);
+            node.runtime.onExternalEvent?.(event, node.state);
         }
     }
     dispose() {
@@ -1266,10 +1234,7 @@ class GraphRuntime {
                 const hasInbound = this.edges.some((e) => e.target.nodeId === n.nodeId && e.target.handle === handle);
                 if (!hasInbound && value !== undefined) {
                     // Clone to avoid shared references
-                    initialInputs[handle] =
-                        typeof structuredClone === "function"
-                            ? structuredClone(value)
-                            : JSON.parse(JSON.stringify(value));
+                    initialInputs[handle] = structuredClone(value);
                 }
             }
             return {
@@ -1328,30 +1293,12 @@ class GraphRuntime {
         this.paused = true;
         try {
             const ins = payload?.inputs || {};
-            const outsPayload = payload?.outputs || {};
             for (const [nodeId, map] of Object.entries(ins)) {
                 const node = this.nodes.get(nodeId);
                 if (!node)
                     continue;
                 for (const [h, v] of Object.entries(map || {})) {
-                    // If this handle has inbound wiring, prefer upstream outputs from snapshot to populate it.
-                    // Fallback: if not all upstream output values are present in the snapshot, hydrate the saved input
-                    // so the initial view matches last saved state (important for array inputs with multiple edges).
-                    const inboundEdges = this.edges.filter((e) => e.target.nodeId === nodeId && e.target.handle === h);
-                    if (inboundEdges.length > 0) {
-                        // Check if ALL upstream outputs exist in snapshot (required for correct array input restoration)
-                        const allUpstreamOutputsExist = inboundEdges.every((e) => {
-                            const srcMap = outsPayload[e.source.nodeId] || {};
-                            return Object.prototype.hasOwnProperty.call(srcMap, e.source.handle);
-                        });
-                        // Only skip input hydration if all upstream outputs are present (re-emit will populate correctly)
-                        if (allUpstreamOutputsExist)
-                            continue;
-                    }
-                    node.inputs[h] =
-                        typeof structuredClone === "function"
-                            ? structuredClone(v)
-                            : JSON.parse(JSON.stringify(v));
+                    node.inputs[h] = structuredClone(v);
                     // emit input value event
                     this.emit("value", {
                         nodeId,
@@ -1368,10 +1315,7 @@ class GraphRuntime {
                 if (!node)
                     continue;
                 for (const [h, v] of Object.entries(map || {})) {
-                    node.outputs[h] =
-                        typeof structuredClone === "function"
-                            ? structuredClone(v)
-                            : JSON.parse(JSON.stringify(v));
+                    node.outputs[h] = structuredClone(v);
                     // emit output value event
                     this.emit("value", {
                         nodeId,
@@ -1455,24 +1399,11 @@ class GraphRuntime {
                 };
                 this.nodes.set(n.nodeId, rn);
                 // Activate new node
-                const ctrl = new AbortController();
-                const effectiveInputs = this.getEffectiveInputs(rn.nodeId);
-                const ctx = {
-                    state: rn.state,
-                    setState: (next) => Object.assign(rn.state, next),
-                    emit: (handle, value) => this.propagate(rn.nodeId, handle, value),
-                    invalidateDownstream: () => this.invalidateDownstream(rn.nodeId),
-                    getInput: (handle) => effectiveInputs[handle],
-                    environment: this.environment,
-                    runId: `${rn.nodeId}:activation`,
-                    abortSignal: ctrl.signal,
-                    createAbortController: () => new AbortController(),
-                };
                 rn.lifecycle?.init?.(rn.params ?? {}, {
                     state: rn.state,
                     setState: (next) => Object.assign(rn.state, next),
                 });
-                rn.runtime.onActivated?.(ctx);
+                rn.runtime.onActivated?.();
             }
             else {
                 // update params/policy and initialInputs
@@ -2115,13 +2046,13 @@ const ComputeCategory = {
                     ctx.emit(h, v);
             }
         },
-        onExternalEvent(event, ctx) {
+        onExternalEvent(event, state) {
             try {
                 const e = event;
-                // Preferred: call a function on ctx.state keyed by e.action
+                // Preferred: call a function on state keyed by e.action
                 const action = e?.action;
-                if (action && typeof ctx.state?.[action] === "function") {
-                    const fn = ctx.state[action];
+                if (action && typeof state?.[action] === "function") {
+                    const fn = state[action];
                     // Normalize args: prefer explicit args array, else wrap single value;
                     let args = [];
                     if (Array.isArray(e?.args))