@bian-womp/spark-graph 0.3.14 → 0.3.16

package/lib/cjs/index.cjs

@@ -1334,6 +1334,8 @@ class HandleResolver {
         this.registry = registry;
         this.recomputeTokenByNode = new Map();
         this.environment = {};
+        this.pendingResolutions = new Map();
+        this.pendingResolutionRunContexts = new Map();
         this.environment = environment ?? {};
     }
     setRegistry(registry) {
@@ -1342,6 +1344,33 @@ class HandleResolver {
     setEnvironment(environment) {
         this.environment = environment;
     }
+    /**
+     * Check if handle resolution is pending for a node
+     */
+    isResolvingHandles(nodeId) {
+        return this.pendingResolutions.has(nodeId);
+    }
+    /**
+     * Get the promise for pending handle resolution, or null if none
+     */
+    getPendingResolution(nodeId) {
+        return this.pendingResolutions.get(nodeId) || null;
+    }
+    /**
+     * Track additional run contexts for a pending resolution
+     */
+    trackRunContextsForPendingResolution(nodeId, runContextIds) {
+        if (!this.pendingResolutions.has(nodeId))
+            return;
+        const tracked = this.pendingResolutionRunContexts.get(nodeId) ?? new Set();
+        for (const runContextId of runContextIds) {
+            if (!tracked.has(runContextId)) {
+                this.runContextManager.startHandleResolution(runContextId, nodeId);
+                tracked.add(runContextId);
+            }
+        }
+        this.pendingResolutionRunContexts.set(nodeId, tracked);
+    }
     /**
      * Schedule async recomputation of handles for a node
      */
@@ -1354,14 +1383,25 @@ class HandleResolver {
             return;
         // Track resolver start for all active run-contexts
         const activeRunContextIds = this.graph.getNodeRunContextIds(nodeId);
+        const trackedRunContextIds = new Set(activeRunContextIds);
         if (activeRunContextIds.size > 0) {
             for (const runContextId of activeRunContextIds) {
                 this.runContextManager.startHandleResolution(runContextId, nodeId);
             }
         }
-        setTimeout(() => {
-            void this.recomputeHandlesForNode(nodeId, activeRunContextIds.size > 0 ? activeRunContextIds : undefined);
-        }, 0);
+        // Create and track the resolution promise
+        const resolutionPromise = new Promise((resolve) => {
+            setTimeout(async () => {
+                // Get all tracked run contexts (including any added during pending state)
+                const allTracked = this.pendingResolutionRunContexts.get(nodeId) ?? trackedRunContextIds;
+                await this.recomputeHandlesForNode(nodeId, allTracked.size > 0 ? allTracked : undefined);
+                this.pendingResolutions.delete(nodeId);
+                this.pendingResolutionRunContexts.delete(nodeId);
+                resolve();
+            }, 0);
+        });
+        this.pendingResolutions.set(nodeId, resolutionPromise);
+        this.pendingResolutionRunContexts.set(nodeId, trackedRunContextIds);
     }
     // Update resolved handles for a single node and refresh edge converters/types that touch it
     updateNodeHandles(nodeId, handles) {
@@ -1906,10 +1946,11 @@ class EdgePropagator {
  * NodeExecutor component - handles node execution scheduling and lifecycle
  */
 class NodeExecutor {
-    constructor(graph, eventEmitter, runContextManager, edgePropagator, runtime, environment) {
+    constructor(graph, eventEmitter, runContextManager, handleResolver, edgePropagator, runtime, environment) {
         this.graph = graph;
         this.eventEmitter = eventEmitter;
         this.runContextManager = runContextManager;
+        this.handleResolver = handleResolver;
         this.edgePropagator = edgePropagator;
         this.runtime = runtime;
         this.environment = {};
@@ -2069,10 +2110,31 @@ class NodeExecutor {
         // Early validation for auto-mode paused state
         if (this.runtime.isPaused())
             return;
-        // Attach run-context IDs if provided
+        // Attach run-context IDs if provided - do this BEFORE checking for pending resolution
+        // so that handle resolution can track these run contexts
         if (runContextIds) {
             this.graph.addNodeRunContextIds(nodeId, runContextIds);
         }
+        // Check if handles are being resolved - wait for resolution before executing
+        // Do this AFTER setting up run contexts so handle resolution can track them
+        if (this.handleResolver && this.handleResolver.isResolvingHandles(nodeId)) {
+            // Track run contexts for the pending resolution
+            if (runContextIds && runContextIds.size > 0) {
+                this.handleResolver.trackRunContextsForPendingResolution(nodeId, runContextIds);
+            }
+            const pendingResolution = this.handleResolver.getPendingResolution(nodeId);
+            if (pendingResolution) {
+                // Wait for resolution to complete, then re-execute
+                pendingResolution.then(() => {
+                    // Re-check node still exists and conditions
+                    const nodeAfter = this.graph.getNode(nodeId);
+                    if (nodeAfter) {
+                        this.execute(nodeId, runContextIds);
+                    }
+                });
+                return;
+            }
+        }
         // Handle debouncing
         const now = Date.now();
         if (this.shouldDebounce(nodeId, node, now)) {
@@ -2515,8 +2577,8 @@ class GraphRuntime {
         this.runContextManager = new RunContextManager(this.graph);
         this.handleResolver = new HandleResolver(this.graph, this.eventEmitter, this.runContextManager, this);
         this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this);
-        // Create NodeExecutor with EdgePropagator
-        this.nodeExecutor = new NodeExecutor(this.graph, this.eventEmitter, this.runContextManager, this, this);
+        // Create NodeExecutor with EdgePropagator and HandleResolver
+        this.nodeExecutor = new NodeExecutor(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this, this);
     }
     static create(def, registry, opts) {
         const gr = new GraphRuntime();
@@ -2829,19 +2891,30 @@ class GraphRuntime {
         const releasePause = this.requestPause();
         try {
             const ins = payload?.inputs || {};
+            const nodesWithChangedInputs = new Set();
             for (const [nodeId, map] of Object.entries(ins)) {
                 if (!this.graph.hasNode(nodeId))
                     continue;
+                let nodeChanged = false;
                 for (const [h, v] of Object.entries(map || {})) {
+                    const node = this.graph.getNode(nodeId);
+                    const prev = node?.inputs[h];
                     const clonedValue = structuredClone(v);
-                    this.graph.updateNodeInput(nodeId, h, clonedValue);
-                    this.eventEmitter.emit("value", {
-                        nodeId,
-                        handle: h,
-                        value: clonedValue,
-                        io: "input",
-                        runtimeTypeId: getTypedOutputTypeId(clonedValue),
-                    });
+                    const same = valuesEqual(prev, clonedValue);
+                    if (!same) {
+                        this.graph.updateNodeInput(nodeId, h, clonedValue);
+                        this.eventEmitter.emit("value", {
+                            nodeId,
+                            handle: h,
+                            value: clonedValue,
+                            io: "input",
+                            runtimeTypeId: getTypedOutputTypeId(clonedValue),
+                        });
+                        nodeChanged = true;
+                    }
+                }
+                if (nodeChanged) {
+                    nodesWithChangedInputs.add(nodeId);
                 }
             }
             const outs = payload?.outputs || {};
@@ -2860,6 +2933,10 @@ class GraphRuntime {
                     });
                 }
             }
+            // Trigger handle resolution for nodes with changed inputs
+            for (const nodeId of nodesWithChangedInputs) {
+                this.handleResolver.scheduleRecomputeHandles(nodeId);
+            }
             if (opts?.invalidate) {
                 for (const nodeId of this.graph.getNodeIds()) {
                     this.invalidateDownstream(nodeId);
@@ -3042,6 +3119,8 @@ class GraphRuntime {
                     }
                     if (changed) {
                         this.edgePropagator.clearArrayBuckets(nodeId);
+                        // Trigger handle resolution when inputs are removed
+                        this.handleResolver.scheduleRecomputeHandles(nodeId);
                         if (this.runMode === "auto" &&
                             this.graph.allInboundHaveValue(nodeId)) {
                             this.execute(nodeId);
@@ -3162,6 +3241,17 @@ class GraphBuilder {
             const arr = Array.isArray(from) ? from : [from];
             return arr.every((s) => s === to || !!this.registry.canCoerce(s, to));
         };
+        // Helper to validate enum value
+        const validateEnumValue = (typeId, value, nodeId, handle) => {
+            if (!typeId.startsWith("enum:"))
+                return true; // Not an enum type
+            const enumDef = this.registry.enums.get(typeId);
+            if (!enumDef)
+                return true; // Enum not registered, skip validation
+            if (typeof value !== "number")
+                return false; // Enum values must be numbers
+            return enumDef.valueToLabel.has(value);
+        };
         const pushIssue = (level, code, message, data) => {
             issues.push({ level, code, message, data });
         };
@@ -3185,6 +3275,51 @@ class GraphBuilder {
             if (!this.registry.categories.has(nodeType.categoryId)) {
                 pushIssue("error", "CATEGORY_MISSING", `Unknown category ${nodeType.categoryId} for node type ${n.typeId}`);
             }
+            // Validate enum values in node params
+            if (n.params) {
+                const effectiveHandles = getEffectiveHandles(n);
+                for (const [paramKey, paramValue] of Object.entries(n.params)) {
+                    // Skip policy and other non-input params
+                    if (paramKey === "policy")
+                        continue;
+                    // Check if this param corresponds to an input handle
+                    const inputTypeId = getInputTypeId(effectiveHandles.inputs, paramKey);
+                    if (inputTypeId && inputTypeId.startsWith("enum:")) {
+                        if (!validateEnumValue(inputTypeId, paramValue, n.nodeId)) {
+                            const enumDef = this.registry.enums.get(inputTypeId);
+                            const validValues = enumDef
+                                ? Array.from(enumDef.valueToLabel.keys()).join(", ")
+                                : "unknown";
+                            pushIssue("error", "ENUM_VALUE_INVALID", `Node ${n.nodeId} param ${paramKey} has invalid enum value ${paramValue}. Valid values: ${validValues}`, {
+                                nodeId: n.nodeId,
+                                input: paramKey,
+                                typeId: inputTypeId,
+                            });
+                        }
+                    }
+                }
+            }
+            // Validate enum values in input defaults
+            const resolved = n.resolvedHandles;
+            if (resolved?.inputDefaults) {
+                const effectiveHandles = getEffectiveHandles(n);
+                for (const [handle, defaultValue] of Object.entries(resolved.inputDefaults)) {
+                    const inputTypeId = getInputTypeId(effectiveHandles.inputs, handle);
+                    if (inputTypeId && inputTypeId.startsWith("enum:")) {
+                        if (!validateEnumValue(inputTypeId, defaultValue, n.nodeId)) {
+                            const enumDef = this.registry.enums.get(inputTypeId);
+                            const validValues = enumDef
+                                ? Array.from(enumDef.valueToLabel.keys()).join(", ")
+                                : "unknown";
+                            pushIssue("warning", "ENUM_DEFAULT_INVALID", `Node ${n.nodeId} input default ${handle} has invalid enum value ${defaultValue}. Valid values: ${validValues}`, {
+                                nodeId: n.nodeId,
+                                input: handle,
+                                typeId: inputTypeId,
+                            });
+                        }
+                    }
+                }
+            }
         }
         // edges validation: nodes exist, handles exist, type exists
         const inboundCounts = new Map();