@bian-womp/spark-graph 0.2.21 → 0.2.22

package/lib/cjs/index.cjs

@@ -434,9 +434,10 @@ class GraphRuntime {
     }
     static create(def, registry, opts) {
         const gr = new GraphRuntime();
+        gr.registry = registry;
         gr.environment = opts?.environment ?? {};
         // Precompute per-node resolved handles (use def-provided overrides; do not compute dynamically here)
-        gr.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
+        gr.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry, gr.environment);
         // Instantiate nodes
         for (const n of def.nodes) {
             const desc = registry.nodes.get(n.typeId);
@@ -462,8 +463,10 @@ class GraphRuntime {
                 params: n.params,
                 policy: {
                     ...cat.policy,
-                    ...(n.params && n.params.policy ? n.params.policy : {}),
+                    ...desc.policy,
+                    ...n.params?.policy,
                 },
+                runSeq: 0,
                 activeControllers: new Set(),
                 queue: [],
                 stats: {
@@ -547,6 +550,9 @@ class GraphRuntime {
             // Only schedule if all inbound inputs are present (or there are none)
             if (anyChanged && this.allInboundHaveValue(nodeId))
                 this.scheduleInputsChanged(nodeId);
+            // Recompute dynamic handles for this node when its direct inputs change
+            if (anyChanged)
+                this.scheduleRecomputeHandles(nodeId);
         }
     }
     getOutput(nodeId, output) {
@@ -619,12 +625,14 @@ class GraphRuntime {
             now - node.lastScheduledAt < policy.debounceMs) {
             // debounce: replace latest queued
             node.queue.splice(0, node.queue.length);
-            const rid = `${nodeId}:${now}`;
+            node.runSeq += 1;
+            const rid = `${nodeId}:${node.runSeq}:${now}`;
             node.queue.push({ runId: rid, inputs: { ...node.inputs } });
             return;
         }
         node.lastScheduledAt = now;
-        const rid = `${nodeId}:${now}:${Math.random().toString(36).slice(2, 8)}`;
+        node.runSeq += 1;
+        const rid = `${nodeId}:${node.runSeq}:${now}`;
         node.latestRunId = rid;
         const startRun = (runId, capturedInputs, onDone) => {
             const controller = new AbortController();
@@ -847,6 +855,8 @@ class GraphRuntime {
                         io: "input",
                         runtimeTypeId: getTypedOutputTypeId(next),
                     });
+                    // Recompute dynamic handles for the destination node on input change
+                    this.scheduleRecomputeHandles(e.target.nodeId);
                     if (!this.paused && this.allInboundHaveValue(e.target.nodeId))
                         this.scheduleInputsChanged(e.target.nodeId);
                 }
@@ -904,7 +914,7 @@ class GraphRuntime {
         }
     }
     // Helper: build map of resolved handles per node from def (prefer def.resolvedHandles, otherwise registry statics)
-    static computeResolvedHandleMap(def, registry) {
+    static computeResolvedHandleMap(def, registry, environment) {
         const out = new Map();
         for (const n of def.nodes) {
             const desc = registry.nodes.get(n.typeId);
@@ -913,10 +923,36 @@ class GraphRuntime {
             const overrideInputs = n.resolvedHandles?.inputs;
             const overrideOutputs = n.resolvedHandles?.outputs;
             const overrideDefaults = n.resolvedHandles?.inputDefaults;
-            // Merge base with overrides (allow partial resolvedHandles)
-            const inputs = { ...desc.inputs, ...overrideInputs };
-            const outputs = { ...desc.outputs, ...overrideOutputs };
-            const inputDefaults = { ...desc.inputDefaults, ...overrideDefaults };
+            // Resolve dynamic handles if available (initial pass: inputs may be undefined)
+            let dyn = {};
+            try {
+                if (typeof desc.resolveHandles === "function") {
+                    dyn = desc.resolveHandles({
+                        environment: environment || {},
+                        params: n.params,
+                        inputs: undefined,
+                    });
+                }
+            }
+            catch {
+                // ignore dynamic resolution errors at this stage
+            }
+            // Merge base with dynamic and overrides (allow partial resolvedHandles)
+            const inputs = {
+                ...desc.inputs,
+                ...dyn.inputs,
+                ...overrideInputs,
+            };
+            const outputs = {
+                ...desc.outputs,
+                ...dyn.outputs,
+                ...overrideOutputs,
+            };
+            const inputDefaults = {
+                ...desc.inputDefaults,
+                ...dyn.inputDefaults,
+                ...overrideDefaults,
+            };
             out.set(n.nodeId, { inputs, outputs, inputDefaults });
         }
         return out;
@@ -1098,6 +1134,10 @@ class GraphRuntime {
     }
     setEnvironment(env) {
         this.environment = { ...env };
+        // Recompute dynamic handles for all nodes when environment changes
+        for (const nodeId of this.nodes.keys()) {
+            this.scheduleRecomputeHandles(nodeId);
+        }
     }
     // Export a GraphDefinition reflecting the current runtime view
     getGraphDef() {
@@ -1254,8 +1294,10 @@ class GraphRuntime {
                     params: n.params,
                     policy: {
                         ...cat.policy,
-                        ...(n.params && n.params.policy ? n.params.policy : {}),
+                        ...desc.policy,
+                        ...n.params?.policy,
                     },
+                    runSeq: 0,
                     activeControllers: new Set(),
                     queue: [],
                     stats: {
@@ -1314,8 +1356,8 @@ class GraphRuntime {
             tmap.set(e.source.handle, tset);
             prevOutTargets.set(e.source.nodeId, tmap);
         }
-        // Precompute per-node resolved handles for updated graph
-        this.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
+        // Precompute per-node resolved handles for updated graph (include dynamic)
+        this.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry, this.environment);
         // Rebuild edges mapping with coercions
         this.edges = GraphRuntime.buildEdges(def, registry, this.resolvedByNode);
         // Build new inbound map
@@ -1475,6 +1517,83 @@ class GraphRuntime {
                 this.arrayInputBuckets.delete(nodeId);
         }
     }
+    // Schedule a recomputation of dynamic handles for a node (async to avoid mutating during propagation)
+    scheduleRecomputeHandles(nodeId) {
+        // If no registry or node not found, skip
+        if (!this.registry)
+            return;
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        setTimeout(() => {
+            try {
+                this.recomputeHandlesForNode(nodeId);
+            }
+            catch {
+                // ignore recompute errors
+            }
+        }, 0);
+    }
+    // Recompute dynamic handles for a single node using current inputs/environment
+    recomputeHandlesForNode(nodeId) {
+        const registry = this.registry;
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        const desc = registry.nodes.get(node.typeId);
+        if (!desc)
+            return;
+        const resolveHandles = desc.resolveHandles;
+        if (typeof resolveHandles !== "function")
+            return;
+        let r;
+        try {
+            r = resolveHandles({
+                environment: this.environment || {},
+                params: node.params,
+                inputs: node.inputs || {},
+            });
+        }
+        catch {
+            return;
+        }
+        const inputs = { ...desc.inputs, ...r?.inputs };
+        const outputs = { ...desc.outputs, ...r?.outputs };
+        const inputDefaults = { ...desc.inputDefaults, ...r?.inputDefaults };
+        const next = { inputs, outputs, inputDefaults };
+        const before = this.resolvedByNode.get(nodeId);
+        // Compare shallow-structurally via JSON
+        if (JSON.stringify(before) === JSON.stringify(next))
+            return;
+        this.resolvedByNode.set(nodeId, next);
+        this.updateNodeHandles(nodeId, next, registry);
+        // Seed defaults for newly introduced inputs that are not inbound
+        const inbound = this.edges
+            .filter((e) => e.target.nodeId === nodeId)
+            .map((e) => e.target.handle);
+        for (const [handle, value] of Object.entries(inputDefaults)) {
+            if (value === undefined)
+                continue;
+            if (inbound.includes(handle))
+                continue;
+            if (node.inputs[handle] === undefined) {
+                node.inputs[handle] =
+                    typeof structuredClone === "function"
+                        ? structuredClone(value)
+                        : JSON.parse(JSON.stringify(value));
+                // Emit input value event for seeded defaults
+                this.emit("value", {
+                    nodeId,
+                    handle,
+                    value: node.inputs[handle],
+                    io: "input",
+                    runtimeTypeId: getTypedOutputTypeId(node.inputs[handle]),
+                });
+            }
+        }
+        // Notify graph updated for UI parity
+        this.emit("invalidate", { reason: "graph-updated" });
+    }
 }
 
 class GraphBuilder {
@@ -1950,7 +2069,7 @@ const ComputeCategory = {
             }
         },
     }),
-    policy: { mode: "push", asyncConcurrency: "switch" },
+    policy: { asyncConcurrency: "switch" },
 };
 
 const CompositeCategory = (registry) => ({
@@ -2006,7 +2125,6 @@ const CompositeCategory = (registry) => ({
             },
         };
     },
-    policy: { mode: "hybrid" },
 });
 
 // Helpers
@@ -3100,6 +3218,39 @@ function registerProgressNodes(registry) {
     });
 }
 
+function installLogging(engine) {
+    engine.on("value", (e) => {
+        const t = e.runtimeTypeId ? ` <${e.runtimeTypeId}>` : "";
+        console.log(`[value:${e.io}]`, `${e.nodeId}.${e.handle}`, e.value, t);
+    });
+    engine.on("stats", (s) => {
+        if (s.kind === "node-progress") {
+            const pct = Math.round((s.progress ?? 0) * 100);
+            console.log(`[progress] ${s.runId || s.nodeId}: ${pct}%`);
+        }
+        else if (s.kind === "node-done") {
+            console.log(`[done] ${s.runId || s.nodeId} in ${s.durationMs ?? 0}ms`);
+        }
+        else if (s.kind === "node-start") {
+            console.log(`[start] ${s.runId || s.nodeId}`);
+        }
+        else if (s.kind === "edge-start") {
+            console.log(`[edge] ${s.source.nodeId}.${s.source.handle} -> ${s.target.nodeId}.${s.target.handle}`);
+        }
+        else if (s.kind === "edge-done") {
+            console.log(`[edge] ${s.source.nodeId}.${s.source.handle} -> ${s.target.nodeId}.${s.target.handle} in ${s.durationMs ?? 0}ms`);
+        }
+    });
+    engine.on("error", (e) => {
+        if (e.kind === "node-run") {
+            console.warn(`[error] ${e.runId || e.nodeId}`, e.err?.message ?? e.err);
+        }
+        else if (e.kind === "edge-convert") {
+            console.warn(`[error] ${e.edgeId} ${e.source.nodeId}.${e.source.handle} -> ${e.target.nodeId}.${e.target.handle}`, e.err?.message ?? e.err);
+        }
+    });
+}
+
 function makeBasicGraphDefinition() {
     return {
         nodes: [
@@ -3303,6 +3454,7 @@ exports.createValidationGraphRegistry = createValidationGraphRegistry;
 exports.getInputTypeId = getInputTypeId;
 exports.getTypedOutputTypeId = getTypedOutputTypeId;
 exports.getTypedOutputValue = getTypedOutputValue;
+exports.installLogging = installLogging;
 exports.isInputPrivate = isInputPrivate;
 exports.isTypedOutput = isTypedOutput;
 exports.registerDelayNode = registerDelayNode;