@bian-womp/spark-graph 0.2.22 → 0.2.24

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.
@@ -437,7 +446,8 @@ class 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.environment);
+        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);
@@ -510,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) {
@@ -916,6 +929,7 @@ class GraphRuntime {
     // Helper: build map of resolved handles per node from def (prefer def.resolvedHandles, otherwise registry statics)
     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)
@@ -927,11 +941,19 @@ class GraphRuntime {
             let dyn = {};
             try {
                 if (typeof desc.resolveHandles === "function") {
-                    dyn = desc.resolveHandles({
+                    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 {
@@ -955,7 +977,7 @@ class GraphRuntime {
             };
             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) {
@@ -1357,7 +1379,8 @@ class GraphRuntime {
             prevOutTargets.set(e.source.nodeId, tmap);
         }
         // Precompute per-node resolved handles for updated graph (include dynamic)
-        this.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry, this.environment);
+        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
@@ -1516,6 +1539,9 @@ 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) {
@@ -1526,16 +1552,11 @@ class GraphRuntime {
         if (!node)
             return;
         setTimeout(() => {
-            try {
-                this.recomputeHandlesForNode(nodeId);
-            }
-            catch {
-                // ignore recompute errors
-            }
+            void this.recomputeHandlesForNode(nodeId);
         }, 0);
     }
     // Recompute dynamic handles for a single node using current inputs/environment
-    recomputeHandlesForNode(nodeId) {
+    async recomputeHandlesForNode(nodeId) {
         const registry = this.registry;
         const node = this.nodes.get(nodeId);
         if (!node)
@@ -1546,17 +1567,23 @@ class GraphRuntime {
         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 {
-            r = resolveHandles({
+            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 };