@bian-womp/spark-graph 0.2.21 → 0.2.23

package/lib/cjs/index.cjs

@@ -402,6 +402,13 @@ class Registry {
     }
 }
 
+// Helper: typed promise detection and unwrapping for T | Promise<T>
+function isPromise(value) {
+    return !!value && typeof value.then === "function";
+}
+async function unwrapMaybePromise(value) {
+    return isPromise(value) ? await value : value;
+}
 class GraphRuntime {
     constructor() {
         this.nodes = new Map();
@@ -410,6 +417,8 @@ class GraphRuntime {
         this.resolvedByNode = new Map();
         this.listeners = new Map();
         this.environment = {};
+        // Token to guard async resolveHandles recomputes per node
+        this.recomputeTokenByNode = new Map();
         this.paused = false;
         // For array-typed target inputs, keep per-edge contributions so successive runs
         // from the same source replace their slice instead of accumulating forever.
@@ -434,9 +443,11 @@ 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);
+        const initial = GraphRuntime.computeResolvedHandleMap(def, registry, gr.environment);
+        gr.resolvedByNode = initial.map;
         // Instantiate nodes
         for (const n of def.nodes) {
             const desc = registry.nodes.get(n.typeId);
@@ -462,8 +473,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: {
@@ -507,6 +520,9 @@ class GraphRuntime {
                         : JSON.parse(JSON.stringify(value));
             }
         }
+        // Schedule async recompute only for nodes that indicated Promise-based resolveHandles
+        for (const nodeId of initial.pending)
+            gr.scheduleRecomputeHandles(nodeId);
         return gr;
     }
     on(event, handler) {
@@ -547,6 +563,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 +638,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 +868,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,8 +927,9 @@ 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();
+        const pending = new Set();
         for (const n of def.nodes) {
             const desc = registry.nodes.get(n.typeId);
             if (!desc)
@@ -913,13 +937,47 @@ 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") {
+                    const maybe = desc.resolveHandles({
+                        environment: environment || {},
+                        params: n.params,
+                        inputs: undefined,
+                    });
+                    // Only use sync results here; async results are applied via recompute later
+                    if (isPromise(maybe)) {
+                        // mark node as pending async recompute
+                        pending.add(n.nodeId);
+                    }
+                    else {
+                        dyn = maybe || {};
+                    }
+                }
+            }
+            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;
+        return { map: out, pending };
     }
     // Helper: build runtime edges with coercions using resolved handles
     static buildEdges(def, registry, resolvedByNode) {
@@ -1098,6 +1156,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 +1316,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 +1378,9 @@ 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)
+        const resolved = GraphRuntime.computeResolvedHandleMap(def, registry, this.environment);
+        this.resolvedByNode = resolved.map;
         // Rebuild edges mapping with coercions
         this.edges = GraphRuntime.buildEdges(def, registry, this.resolvedByNode);
         // Build new inbound map
@@ -1474,6 +1539,87 @@ class GraphRuntime {
             if (byHandle.size === 0)
                 this.arrayInputBuckets.delete(nodeId);
         }
+        // Schedule async recompute for nodes that indicated Promise-based resolveHandles in this update
+        for (const nodeId of resolved.pending)
+            this.scheduleRecomputeHandles(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(() => {
+            void this.recomputeHandlesForNode(nodeId);
+        }, 0);
+    }
+    // Recompute dynamic handles for a single node using current inputs/environment
+    async 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;
+        const token = (this.recomputeTokenByNode.get(nodeId) ?? 0) + 1;
+        this.recomputeTokenByNode.set(nodeId, token);
+        let r;
+        try {
+            const res = resolveHandles({
+                environment: this.environment || {},
+                params: node.params,
+                inputs: node.inputs || {},
+            });
+            r = await unwrapMaybePromise(res);
+        }
+        catch {
+            return;
+        }
+        // If a newer recompute was scheduled, drop this result
+        if ((this.recomputeTokenByNode.get(nodeId) ?? 0) !== token)
+            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" });
     }
 }
 
@@ -1950,7 +2096,7 @@ const ComputeCategory = {
             }
         },
     }),
-    policy: { mode: "push", asyncConcurrency: "switch" },
+    policy: { asyncConcurrency: "switch" },
 };
 
 const CompositeCategory = (registry) => ({
@@ -2006,7 +2152,6 @@ const CompositeCategory = (registry) => ({
             },
         };
     },
-    policy: { mode: "hybrid" },
 });
 
 // Helpers
@@ -3100,6 +3245,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 +3481,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;