@bian-womp/spark-graph 0.3.1 → 0.3.3

package/lib/cjs/index.cjs

@@ -405,48 +405,14 @@ class Registry {
 Registry.idCounter = 0;
 
 /**
- * Shared utility functions for runtime components
- */
-/**
- * Type guard to check if a value is a Promise
- */
-function isPromise(value) {
-    return !!value && typeof value.then === "function";
-}
-/**
- * Unwrap a value that might be a Promise
- */
-async function unwrapMaybePromise(value) {
-    return isPromise(value) ? await value : value;
-}
-/**
- * Shallow/deep-ish equality check to avoid unnecessary runs on identical values
- */
-function valuesEqual(a, b) {
-    if (a === b)
-        return true;
-    if (typeof a !== typeof b)
-        return false;
-    if (a && b && typeof a === "object") {
-        try {
-            return JSON.stringify(a) === JSON.stringify(b);
-        }
-        catch {
-            return false;
-        }
-    }
-    return false;
-}
-
-/**
- * GraphStructure component - manages nodes, edges, and handle resolution
+ * Graph component - manages nodes, edges, and handle resolution
  */
-class GraphStructure {
+class Graph {
     constructor(registry) {
+        this.registry = registry;
         this.nodes = new Map();
         this.edges = [];
         this.resolvedByNode = new Map();
-        this.registry = registry;
     }
     // Node accessors
     getNode(nodeId) {
@@ -488,99 +454,21 @@ class GraphStructure {
     getResolvedHandlesMap() {
         return this.resolvedByNode;
     }
-    // Static factory methods
-    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)
-                continue;
-            const overrideInputs = n.resolvedHandles?.inputs;
-            const overrideOutputs = n.resolvedHandles?.outputs;
-            const overrideDefaults = n.resolvedHandles?.inputDefaults;
-            // Resolve dynamic handles if available (initial pass: inputs may be undefined)
-            let dyn = {};
-            try {
-                if (typeof desc.resolveHandles === "function") {
-                    const maybe = desc.resolveHandles({
-                        nodeId: n.nodeId,
-                        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 });
+    /**
+     * Check if all inbound edges for a node have values
+     */
+    allInboundHaveValue(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return false;
+        const inbound = this.edges.filter((e) => e.target.nodeId === nodeId);
+        if (inbound.length === 0)
+            return true;
+        for (const e of inbound) {
+            if (!(e.target.handle in node.inputs))
+                return false;
         }
-        return { map: out, pending };
-    }
-    static buildEdges(def, registry, resolvedByNode) {
-        return def.edges.map((e) => {
-            const srcNode = def.nodes.find((n) => n.nodeId === e.source.nodeId);
-            const dstNode = def.nodes.find((n) => n.nodeId === e.target.nodeId);
-            let effectiveTypeId = e.typeId; // Start with original
-            let srcDeclared;
-            let dstDeclared;
-            if (srcNode) {
-                const resolved = resolvedByNode.get(srcNode.nodeId);
-                if (resolved)
-                    srcDeclared = resolved.outputs[e.source.handle];
-            }
-            if (!effectiveTypeId) {
-                // Infer if not explicitly set
-                effectiveTypeId = Array.isArray(srcDeclared)
-                    ? srcDeclared[0]
-                    : srcDeclared;
-            }
-            if (dstNode) {
-                const resolved = resolvedByNode.get(dstNode.nodeId);
-                if (resolved)
-                    dstDeclared = getInputTypeId(resolved.inputs, e.target.handle);
-            }
-            const { convert, convertAsync } = GraphStructure.buildEdgeConverters(srcDeclared, dstDeclared, registry, `buildEdges: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
-            return {
-                id: e.id,
-                source: { ...e.source },
-                target: { ...e.target },
-                typeId: e.typeId, // Preserve original (may be undefined)
-                effectiveTypeId: effectiveTypeId ?? "untyped", // Always present
-                convert,
-                convertAsync,
-                srcUnionTypes: Array.isArray(srcDeclared)
-                    ? [...srcDeclared]
-                    : undefined,
-                dstDeclared,
-                stats: { runs: 0, inFlight: false, progress: 0 },
-            };
-        });
+        return true;
     }
     // Clear all data
     clear() {
@@ -588,70 +476,6 @@ class GraphStructure {
         this.edges = [];
         this.resolvedByNode.clear();
     }
-    // Static helper: build edge converters for type coercion
-    static buildEdgeConverters(srcDeclared, dstDeclared, registry, edgeLabel) {
-        if (!dstDeclared || !srcDeclared) {
-            return {};
-        }
-        const isUnion = Array.isArray(srcDeclared);
-        const srcTypes = isUnion ? srcDeclared : [srcDeclared];
-        // Helper to get the coercion for a specific type
-        const getCoercion = (typeId) => {
-            return registry.resolveCoercion(typeId, dstDeclared);
-        };
-        // Resolve coercions for all source types
-        const coercions = srcTypes.map(getCoercion);
-        const hasAsync = coercions.some((r) => r?.kind === "async");
-        // Helper to extract and validate typed output for unions
-        const extractPayload = (v) => {
-            const typeId = getTypedOutputTypeId(v);
-            const payload = getTypedOutputValue(v);
-            if (isUnion) {
-                if (!typeId) {
-                    throw new Error(`Typed output required for union source (${edgeLabel}); allowed: ${srcTypes.join("|")}`);
-                }
-                if (!srcTypes.includes(typeId)) {
-                    throw new Error(`Invalid typed output ${typeId} (${edgeLabel}); allowed: ${srcTypes.join("|")}`);
-                }
-            }
-            else if (typeId) {
-                // Warn if typed output is used for non-union source
-                console.warn(`Typed output ${typeId} is fed even though source is not union (${edgeLabel}): ${srcDeclared} -> ${dstDeclared}`);
-            }
-            return { typeId: typeId || srcTypes[0], payload };
-        };
-        if (hasAsync) {
-            return {
-                convertAsync: async (v, signal) => {
-                    const { typeId, payload } = extractPayload(v);
-                    const res = getCoercion(typeId);
-                    if (!res)
-                        return payload;
-                    if (res.kind === "async") {
-                        return await res.convertAsync(payload, signal);
-                    }
-                    return res.convert(payload);
-                },
-            };
-        }
-        // Sync path
-        const firstCoercion = coercions.find((r) => r?.kind === "sync");
-        if (!firstCoercion) {
-            return {};
-        }
-        return {
-            convert: (v) => {
-                const { typeId, payload } = extractPayload(v);
-                const res = getCoercion(typeId);
-                if (!res)
-                    return payload;
-                if (res.kind === "async") {
-                    throw new Error(`Async coercion required but convert used (${edgeLabel})`);
-                }
-                return res.convert(payload);
-            },
-        };
-    }
 }
 
 /**
@@ -691,25 +515,30 @@ class EventEmitter {
  * RunContextManager component - manages run-context lifecycle
  */
 class RunContextManager {
-    constructor() {
+    constructor(graph) {
+        this.graph = graph;
         this.runContexts = new Map();
         this.runContextCounter = 0;
+        this.graph = graph;
     }
     /**
      * Create a new run-context for runFromHere
      */
-    createRunContext(startNodeId, options) {
+    createRunContext(startNodeId, resolve, options) {
         const id = `rc-${++this.runContextCounter}`;
         const ctx = {
             id,
             startNodes: new Set([startNodeId]),
             cancelledNodes: new Set(),
-            pending: 0,
+            pendingNodes: 0,
+            pendingEdges: 0,
+            pendingResolvers: 0,
             skipPropagateValues: options?.skipPropagateValues ?? false,
             propagate: options?.propagate ?? true,
+            resolve,
         };
         this.runContexts.set(id, ctx);
-        return ctx;
+        return id;
     }
     /**
      * Get a run-context by ID
@@ -729,18 +558,60 @@ class RunContextManager {
     hasActiveRunContexts() {
         return this.runContexts.size > 0;
     }
+    startNodeRun(id, nodeId) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx)
+            return;
+        ctx.pendingNodes++;
+    }
+    finishNodeRun(id, nodeId) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx)
+            return;
+        ctx.pendingNodes--;
+        this.finishRunContextIfPossible(id);
+    }
+    startEdgeConversion(id, edgeId) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx)
+            return;
+        ctx.pendingEdges++;
+    }
+    finishEdgeConversion(id, edgeId) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx)
+            return;
+        ctx.pendingEdges--;
+        this.finishRunContextIfPossible(id);
+    }
+    startHandleResolution(id, nodeId) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx)
+            return;
+        ctx.pendingResolvers++;
+    }
+    finishHandleResolution(id, nodeId) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx)
+            return;
+        ctx.pendingResolvers--;
+        this.finishRunContextIfPossible(id);
+    }
     /**
-     * Finish and remove a run-context when its pending count reaches zero
+     * Finish and remove a run-context when all pending operations reach zero
      */
-    finishRunContext(id, nodes) {
+    finishRunContextIfPossible(id) {
         const ctx = this.runContexts.get(id);
         if (!ctx)
             return;
-        if (ctx.pending > 0)
+        if (ctx.pendingNodes > 0 ||
+            ctx.pendingEdges > 0 ||
+            ctx.pendingResolvers > 0) {
             return; // Still has pending work
+        }
         // Clean up activeRunContexts from all nodes
-        for (const node of nodes.values()) {
-            node.activeRunContexts.delete(id);
+        for (const node of this.graph.getNodes().values()) {
+            node.activeRunContextIds.delete(id);
         }
         this.runContexts.delete(id);
         if (ctx.resolve)
@@ -753,7 +624,7 @@ class RunContextManager {
      * @param edges - All edges in the graph (for downstream traversal)
      * @param nodes - All nodes in the graph (for clearing activeRunContexts)
      */
-    cancelNodeInRunContexts(nodeId, includeDownstream, edges, nodes) {
+    cancelNodeInRunContexts(nodeId, includeDownstream) {
         const toCancel = new Set([nodeId]);
         if (includeDownstream) {
             // Collect all downstream nodes
@@ -764,7 +635,7 @@ class RunContextManager {
                 if (visited.has(cur))
                     continue;
                 visited.add(cur);
-                for (const e of edges) {
+                for (const e of this.graph.getEdges()) {
                     if (e.source.nodeId === cur) {
                         const targetId = e.target.nodeId;
                         if (!visited.has(targetId)) {
@@ -783,9 +654,9 @@ class RunContextManager {
         }
         // Clear activeRunContexts for cancelled nodes
         for (const id of toCancel) {
-            const node = nodes.get(id);
+            const node = this.graph.getNode(id);
             if (node)
-                node.activeRunContexts.clear();
+                node.activeRunContextIds.clear();
         }
     }
     /**
@@ -813,17 +684,214 @@ const LOG_LEVEL_VALUES = {
     silent: 4,
 };
 
+/**
+ * Shared utility functions for runtime components
+ */
+/**
+ * Type guard to check if a value is a Promise
+ */
+function isPromise(value) {
+    return !!value && typeof value.then === "function";
+}
+/**
+ * Unwrap a value that might be a Promise
+ */
+async function unwrapMaybePromise(value) {
+    return isPromise(value) ? await value : value;
+}
+/**
+ * Shallow/deep-ish equality check to avoid unnecessary runs on identical values
+ */
+function valuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a && b && typeof a === "object") {
+        try {
+            return JSON.stringify(a) === JSON.stringify(b);
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+
+function tryHandleResolving(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)
+            continue;
+        const overrideInputs = n.resolvedHandles?.inputs;
+        const overrideOutputs = n.resolvedHandles?.outputs;
+        const overrideDefaults = n.resolvedHandles?.inputDefaults;
+        // Resolve dynamic handles if available (initial pass: inputs may be undefined)
+        let dyn = {};
+        try {
+            if (typeof desc.resolveHandles === "function") {
+                const maybe = desc.resolveHandles({
+                    nodeId: n.nodeId,
+                    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 { resolved: out, pending };
+}
+function buildEdges(def, registry, resolvedByNode) {
+    return def.edges.map((e) => {
+        const srcNode = def.nodes.find((n) => n.nodeId === e.source.nodeId);
+        const dstNode = def.nodes.find((n) => n.nodeId === e.target.nodeId);
+        const { srcDeclared, dstDeclared, effectiveTypeId } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, resolvedByNode, e.typeId);
+        const { convert, convertAsync } = buildEdgeConverters(srcDeclared, dstDeclared, registry, `buildEdges: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
+        return {
+            id: e.id,
+            source: { ...e.source },
+            target: { ...e.target },
+            typeId: e.typeId, // Preserve original (may be undefined)
+            effectiveTypeId, // Always present
+            convert,
+            convertAsync,
+            srcUnionTypes: Array.isArray(srcDeclared) ? [...srcDeclared] : undefined,
+            dstDeclared,
+            stats: { runs: 0, inFlight: false, progress: 0 },
+        };
+    });
+}
+/**
+ * Extract edge type information from resolved handles
+ * Used by both buildEdges and updateNodeHandles to avoid duplication
+ */
+function extractEdgeTypes(sourceNodeId, sourceHandle, targetNodeId, targetHandle, resolvedByNode, explicitTypeId) {
+    const srcResolved = resolvedByNode.get(sourceNodeId);
+    const dstResolved = resolvedByNode.get(targetNodeId);
+    const srcDeclared = srcResolved
+        ? srcResolved.outputs[sourceHandle]
+        : undefined;
+    const dstDeclared = dstResolved
+        ? getInputTypeId(dstResolved.inputs, targetHandle)
+        : undefined;
+    let effectiveTypeId = explicitTypeId;
+    if (!effectiveTypeId) {
+        // Infer if not explicitly set
+        effectiveTypeId = Array.isArray(srcDeclared) ? srcDeclared[0] : srcDeclared;
+    }
+    return {
+        srcDeclared,
+        dstDeclared,
+        effectiveTypeId: effectiveTypeId ?? "untyped",
+    };
+}
+// Static helper: build edge converters for type coercion
+function buildEdgeConverters(srcDeclared, dstDeclared, registry, edgeLabel) {
+    if (!dstDeclared || !srcDeclared) {
+        return {};
+    }
+    const isUnion = Array.isArray(srcDeclared);
+    const srcTypes = isUnion ? srcDeclared : [srcDeclared];
+    // Helper to get the coercion for a specific type
+    const getCoercion = (typeId) => {
+        return registry.resolveCoercion(typeId, dstDeclared);
+    };
+    // Resolve coercions for all source types
+    const coercions = srcTypes.map(getCoercion);
+    const hasAsync = coercions.some((r) => r?.kind === "async");
+    // Helper to extract and validate typed output for unions
+    const extractPayload = (v) => {
+        const typeId = getTypedOutputTypeId(v);
+        const payload = getTypedOutputValue(v);
+        if (isUnion) {
+            if (!typeId) {
+                throw new Error(`Typed output required for union source (${edgeLabel}); allowed: ${srcTypes.join("|")}`);
+            }
+            if (!srcTypes.includes(typeId)) {
+                throw new Error(`Invalid typed output ${typeId} (${edgeLabel}); allowed: ${srcTypes.join("|")}`);
+            }
+        }
+        else if (typeId) {
+            // Warn if typed output is used for non-union source
+            console.warn(`Typed output ${typeId} is fed even though source is not union (${edgeLabel}): ${srcDeclared} -> ${dstDeclared}`);
+        }
+        return { typeId: typeId || srcTypes[0], payload };
+    };
+    if (hasAsync) {
+        return {
+            convertAsync: async (v, signal) => {
+                const { typeId, payload } = extractPayload(v);
+                const res = getCoercion(typeId);
+                if (!res)
+                    return payload;
+                if (res.kind === "async") {
+                    return await res.convertAsync(payload, signal);
+                }
+                return res.convert(payload);
+            },
+        };
+    }
+    // Sync path
+    const firstCoercion = coercions.find((r) => r?.kind === "sync");
+    if (!firstCoercion) {
+        return {};
+    }
+    return {
+        convert: (v) => {
+            const { typeId, payload } = extractPayload(v);
+            const res = getCoercion(typeId);
+            if (!res)
+                return payload;
+            if (res.kind === "async") {
+                throw new Error(`Async coercion required but convert used (${edgeLabel})`);
+            }
+            return res.convert(payload);
+        },
+    };
+}
+
 /**
  * HandleResolver component - manages dynamic handle resolution
  */
 class HandleResolver {
-    constructor(graphStructure, eventEmitter, runtimeCoordinator, registry, environment) {
-        this.recomputeTokenByNode = new Map();
-        this.environment = {};
-        this.graphStructure = graphStructure;
+    constructor(graph, eventEmitter, runContextManager, edgePropagator, registry, environment) {
+        this.graph = graph;
         this.eventEmitter = eventEmitter;
-        this.runtimeCoordinator = runtimeCoordinator;
+        this.runContextManager = runContextManager;
+        this.edgePropagator = edgePropagator;
         this.registry = registry;
+        this.recomputeTokenByNode = new Map();
+        this.environment = {};
         this.environment = environment ?? {};
     }
     setRegistry(registry) {
@@ -839,106 +907,162 @@ class HandleResolver {
         // If no registry or node not found, skip
         if (!this.registry)
             return;
-        const node = this.graphStructure.getNode(nodeId);
+        const node = this.graph.getNode(nodeId);
         if (!node)
             return;
+        // Track resolver start for all active run-contexts
+        if (node.activeRunContextIds && node.activeRunContextIds.size > 0) {
+            for (const runContextId of node.activeRunContextIds) {
+                this.runContextManager.startHandleResolution(runContextId, nodeId);
+            }
+        }
         setTimeout(() => {
-            void this.recomputeHandlesForNode(nodeId);
+            void this.recomputeHandlesForNode(nodeId, node.activeRunContextIds);
         }, 0);
     }
-    /**
-     * Recompute dynamic handles for a single node using current inputs/environment
-     */
-    async recomputeHandlesForNode(nodeId) {
-        const registry = this.registry;
-        const node = this.graphStructure.getNode(nodeId);
-        if (!node)
-            return;
-        const desc = registry.nodes.get(node.typeId);
-        if (!desc)
+    // Update resolved handles for a single node and refresh edge converters/types that touch it
+    updateNodeHandles(nodeId, handles) {
+        if (!this.registry)
             return;
-        const resolveHandles = desc.resolveHandles;
-        if (typeof resolveHandles !== "function")
+        const node = this.graph.getNode(nodeId);
+        if (!node)
             return;
-        const token = (this.recomputeTokenByNode.get(nodeId) ?? 0) + 1;
-        this.recomputeTokenByNode.set(nodeId, token);
-        // Log resolveHandles-start
-        const nodeLogLevel = node.logLevel ?? "info";
-        const nodeLogValue = LOG_LEVEL_VALUES[nodeLogLevel] ?? 1;
-        const shouldLog = nodeLogValue <= LOG_LEVEL_VALUES.debug && nodeLogLevel !== "silent";
-        if (shouldLog) {
-            console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-start`);
-        }
-        let r;
-        try {
-            const res = resolveHandles({
-                nodeId,
-                environment: this.environment || {},
-                params: node.params,
-                inputs: node.inputs || {},
-            });
-            r = await unwrapMaybePromise(res);
-        }
-        catch {
-            // Log resolveHandles-done even on error
-            if (shouldLog) {
-                console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-done (error)`);
+        this.graph.setResolvedHandles(nodeId, handles);
+        const edges = this.graph.getEdges();
+        const resolvedByNode = this.graph.getResolvedHandlesMap();
+        for (const e of edges) {
+            // Only update edges that touch the changed node
+            const touchesChangedNode = e.source.nodeId === nodeId || e.target.nodeId === nodeId;
+            if (!touchesChangedNode)
+                continue;
+            const srcNode = this.graph.getNode(e.source.nodeId);
+            const dstNode = this.graph.getNode(e.target.nodeId);
+            const oldDstDeclared = e.dstDeclared;
+            // Extract edge types using shared helper (handles both source and target updates)
+            const { srcDeclared, dstDeclared, effectiveTypeId } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, resolvedByNode, e.typeId);
+            // Update edge properties
+            if (!e.typeId) {
+                e.effectiveTypeId = effectiveTypeId;
+            }
+            e.dstDeclared = dstDeclared;
+            e.srcUnionTypes = Array.isArray(srcDeclared)
+                ? [...srcDeclared]
+                : undefined;
+            // Update converters
+            const conv = buildEdgeConverters(srcDeclared, dstDeclared, this.registry, `updateNodeHandles: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
+            e.convert = conv.convert;
+            e.convertAsync = conv.convertAsync;
+            if (e.target.nodeId === nodeId &&
+                oldDstDeclared === undefined &&
+                dstDeclared !== undefined) {
+                const srcNode = this.graph.getNode(e.source.nodeId);
+                if (srcNode) {
+                    const srcValue = srcNode.outputs[e.source.handle];
+                    if (srcValue !== undefined) {
+                        this.edgePropagator.propagate(e.source.nodeId, e.source.handle, srcValue, srcNode.activeRunContextIds);
+                    }
+                }
+            }
+        }
+        this.edgePropagator.invalidateDownstream(nodeId);
+    }
+    /**
+     * Recompute dynamic handles for a single node using current inputs/environment
+     */
+    async recomputeHandlesForNode(nodeId, activeRunContextIds) {
+        try {
+            if (!this.registry)
+                return;
+            const node = this.graph.getNode(nodeId);
+            if (!node)
+                return;
+            const desc = this.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);
+            // Log resolveHandles-start
+            const nodeLogLevel = node.logLevel ?? "info";
+            const nodeLogValue = LOG_LEVEL_VALUES[nodeLogLevel] ?? 1;
+            const shouldLog = nodeLogValue <= LOG_LEVEL_VALUES.debug && nodeLogLevel !== "silent";
+            if (shouldLog) {
+                console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-start`);
+            }
+            let resolved;
+            try {
+                const res = resolveHandles({
+                    nodeId,
+                    environment: this.environment || {},
+                    params: node.params,
+                    inputs: node.inputs || {},
+                });
+                resolved = await unwrapMaybePromise(res);
+            }
+            catch {
+                // Log resolveHandles-done even on error
+                if (shouldLog) {
+                    console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-done (error)`);
+                }
+                return;
+            }
+            // Log resolveHandles-done
+            if (shouldLog) {
+                console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-done`);
+            }
+            // If a newer recompute was scheduled, drop this result
+            if ((this.recomputeTokenByNode.get(nodeId) ?? 0) !== token)
+                return;
+            const before = this.graph.getResolvedHandles(nodeId);
+            if (!before)
+                return;
+            // Re-fetch desc to ensure we have the latest (node might have been updated)
+            const nodeDesc = this.registry.nodes.get(node.typeId);
+            if (!nodeDesc)
+                return;
+            const inputs = { ...nodeDesc.inputs, ...resolved?.inputs };
+            const outputs = { ...nodeDesc.outputs, ...resolved?.outputs };
+            const inputDefaults = {
+                ...nodeDesc.inputDefaults,
+                ...resolved?.inputDefaults,
+            };
+            const after = { inputs, outputs, inputDefaults };
+            // Compare shallow-structurally via JSON
+            if (JSON.stringify(before) === JSON.stringify(after))
+                return;
+            // Call GraphRuntime's updateNodeHandles to update edges and re-propagate values
+            // Note: updateNodeHandles will set the resolved handles internally
+            this.updateNodeHandles(nodeId, after);
+            // Notify graph updated with the changed handles
+            this.eventEmitter.emit("invalidate", {
+                reason: "graph-updated",
+                resolvedHandles: { [nodeId]: after },
+            });
+        }
+        finally {
+            // Track resolver finish after successful completion
+            if (activeRunContextIds && activeRunContextIds.size > 0) {
+                for (const runContextId of activeRunContextIds) {
+                    this.runContextManager.finishHandleResolution(runContextId, nodeId);
+                }
             }
-            return;
-        }
-        // Log resolveHandles-done
-        if (shouldLog) {
-            console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-done`);
         }
-        // If a newer recompute was scheduled, drop this result
-        if ((this.recomputeTokenByNode.get(nodeId) ?? 0) !== token)
-            return;
-        const resolved = this.graphStructure.getResolvedHandles(nodeId);
-        if (!resolved)
-            return; // Node was deleted
-        // Re-fetch desc to ensure we have the latest (node might have been updated)
-        const nodeDesc = registry.nodes.get(node.typeId);
-        if (!nodeDesc)
-            return;
-        const inputs = { ...nodeDesc.inputs, ...r?.inputs };
-        const outputs = { ...nodeDesc.outputs, ...r?.outputs };
-        const inputDefaults = {
-            ...nodeDesc.inputDefaults,
-            ...r?.inputDefaults,
-        };
-        const next = { inputs, outputs, inputDefaults };
-        const before = resolved;
-        // Compare shallow-structurally via JSON
-        if (JSON.stringify(before) === JSON.stringify(next))
-            return;
-        this.graphStructure.setResolvedHandles(nodeId, next);
-        // Call GraphRuntime's updateNodeHandles to update edges and re-propagate values
-        this.runtimeCoordinator.updateNodeHandles(nodeId, next, registry);
-        // Notify graph updated with the changed handles
-        this.eventEmitter.emit("invalidate", {
-            reason: "graph-updated",
-            resolvedHandles: { [nodeId]: next },
-        });
     }
 }
 
 /**
- * ValuePropagator component - handles value propagation through edges
+ * EdgePropagator component - handles value propagation through edges
  */
-class ValuePropagator {
-    constructor(graphStructure, eventEmitter, runContextManager, handleResolver, runtimeCoordinator) {
-        this.arrayInputBuckets = new Map();
-        this.graphStructure = graphStructure;
+class EdgePropagator {
+    constructor(graph, eventEmitter, runContextManager, handleResolver, nodeExecutor) {
+        this.graph = graph;
         this.eventEmitter = eventEmitter;
         this.runContextManager = runContextManager;
         this.handleResolver = handleResolver;
-        this.runtimeCoordinator = runtimeCoordinator;
-    }
-    /**
-     * Set the execution scheduler (called after construction to resolve circular dependency)
-     */
-    setExecutionScheduler(executionScheduler) {
-        this.executionScheduler = executionScheduler;
+        this.nodeExecutor = nodeExecutor;
+        this.arrayInputBuckets = new Map();
     }
     /**
      * Propagate value through edges
@@ -947,10 +1071,24 @@ class ValuePropagator {
      */
     propagate(srcNodeId, srcHandle, value, runContextIds) {
         // Set source output
-        const srcNode = this.graphStructure.getNode(srcNodeId);
+        if (!this.setSourceOutput(srcNodeId, srcHandle, value)) {
+            return; // Node was removed
+        }
+        // Find outgoing edges
+        const outEdges = this.findOutgoingEdges(srcNodeId, srcHandle);
+        // Process each edge
+        for (const edge of outEdges) {
+            this.propagateToEdge(edge, value, srcNodeId, runContextIds);
+        }
+    }
+    /**
+     * Set source output value and emit event
+     */
+    setSourceOutput(srcNodeId, srcHandle, value) {
+        const srcNode = this.graph.getNode(srcNodeId);
         if (!srcNode) {
             // Node was removed (e.g., graph updated) but an async emit arrived late; ignore
-            return;
+            return false;
         }
         srcNode.outputs[srcHandle] = value;
         this.eventEmitter.emit("value", {
@@ -960,221 +1098,306 @@ class ValuePropagator {
             io: "output",
             runtimeTypeId: getTypedOutputTypeId(value),
         });
-        // Fan-out along all edges from this output
-        const edges = this.graphStructure.getEdges();
-        const outEdges = edges.filter((e) => e.source.nodeId === srcNodeId && e.source.handle === srcHandle);
-        const isRunContextAware = runContextIds !== undefined && runContextIds.size > 0;
-        for (const e of outEdges) {
-            // Filter run-contexts: skip any where src or dst is cancelled (only in run-context mode)
-            let effectiveRunContexts;
-            if (isRunContextAware) {
-                effectiveRunContexts = new Set();
-                for (const id of runContextIds) {
-                    const ctx = this.runContextManager.getRunContext(id);
-                    if (!ctx)
-                        continue;
-                    if (ctx.cancelledNodes.has(srcNodeId))
-                        continue;
-                    if (ctx.cancelledNodes.has(e.target.nodeId))
-                        continue;
-                    effectiveRunContexts.add(id);
-                }
-                if (effectiveRunContexts.size === 0)
-                    continue; // No valid run-contexts for this edge
-            }
-            // If source declares a union for this handle, require typed output
-            const isUnion = Array.isArray(e.srcUnionTypes);
-            const isTyped = isTypedOutput(value);
-            if (isUnion && !isTyped) {
-                const err = new Error(`Output ${srcNodeId}.${srcHandle} requires typed value for union output (allowed: ${e.srcUnionTypes.join("|")})`);
-                this.eventEmitter.emit("error", {
-                    kind: "edge-convert",
-                    edgeId: e.id,
-                    source: { nodeId: e.source.nodeId, handle: e.source.handle },
-                    target: { nodeId: e.target.nodeId, handle: e.target.handle },
-                    err,
-                });
+        return true;
+    }
+    /**
+     * Find all outgoing edges from a source node handle
+     */
+    findOutgoingEdges(srcNodeId, srcHandle) {
+        const edges = this.graph.getEdges();
+        return edges.filter((e) => e.source.nodeId === srcNodeId && e.source.handle === srcHandle);
+    }
+    /**
+     * Propagate value to a single edge
+     */
+    propagateToEdge(edge, value, srcNodeId, runContextIds) {
+        // Filter run-contexts
+        const effectiveRunContexts = runContextIds && runContextIds.size > 0
+            ? this.filterEffectiveRunContexts(edge, srcNodeId, runContextIds)
+            : undefined;
+        if (runContextIds &&
+            runContextIds.size > 0 &&
+            !(effectiveRunContexts && effectiveRunContexts.size > 0)) {
+            return; // No valid run-contexts for this edge
+        }
+        // Validate union types
+        if (!this.validateUnionType(edge, value, srcNodeId)) {
+            return;
+        }
+        // Clone value per edge to isolate conversions
+        let nextVal = structuredClone(value);
+        // Apply conversion and propagate
+        if (edge.convertAsync) {
+            this.handleAsyncConversion(edge, nextVal, effectiveRunContexts);
+        }
+        else {
+            this.handleSyncConversion(edge, nextVal, effectiveRunContexts);
+        }
+    }
+    /**
+     * Filter run-contexts to exclude cancelled nodes
+     */
+    filterEffectiveRunContexts(edge, srcNodeId, runContextIds) {
+        const effectiveRunContexts = new Set();
+        for (const id of runContextIds) {
+            const ctx = this.runContextManager.getRunContext(id);
+            if (!ctx)
                 continue;
+            if (ctx.cancelledNodes.has(srcNodeId))
+                continue;
+            if (ctx.cancelledNodes.has(edge.target.nodeId))
+                continue;
+            effectiveRunContexts.add(id);
+        }
+        return effectiveRunContexts.size > 0 ? effectiveRunContexts : undefined;
+    }
+    /**
+     * Validate union type requirements
+     */
+    validateUnionType(edge, value, srcNodeId) {
+        const isUnion = Array.isArray(edge.srcUnionTypes);
+        const isTyped = isTypedOutput(value);
+        if (isUnion && !isTyped) {
+            const err = new Error(`Output ${srcNodeId}.${edge.source.handle} requires typed value for union output (allowed: ${edge.srcUnionTypes.join("|")})`);
+            this.eventEmitter.emit("error", {
+                kind: "edge-convert",
+                edgeId: edge.id,
+                source: { nodeId: edge.source.nodeId, handle: edge.source.handle },
+                target: { nodeId: edge.target.nodeId, handle: edge.target.handle },
+                err,
+            });
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Handle synchronous conversion
+     */
+    handleSyncConversion(edge, value, effectiveRunContexts) {
+        let convertedValue = value;
+        if (edge.convert) {
+            convertedValue = edge.convert(value);
+        }
+        this.applyToTarget(edge, convertedValue, effectiveRunContexts);
+    }
+    /**
+     * Handle asynchronous conversion
+     */
+    handleAsyncConversion(edge, value, effectiveRunContexts) {
+        if (!edge.convertAsync)
+            return;
+        // Track edge run-context IDs for pendingEdges tracking
+        const edgeRunContextIds = effectiveRunContexts
+            ? Array.from(effectiveRunContexts)
+            : undefined;
+        if (edgeRunContextIds) {
+            for (const id of edgeRunContextIds) {
+                this.runContextManager.startEdgeConversion(id, edge.id);
             }
-            // Clone per edge to isolate conversions
-            let nextVal = structuredClone(value);
-            const applyToTarget = (v) => {
-                const dstNode = this.graphStructure.getNode(e.target.nodeId);
-                if (!dstNode)
-                    return;
-                // Skip writing to unresolved handles
-                if (e.dstDeclared === undefined)
-                    return;
-                const dstIsArray = typeof e.dstDeclared === "string" && e.dstDeclared.endsWith("[]");
-                let next = v;
-                // Handle array types
-                if (dstIsArray) {
-                    const toArray = (x) => Array.isArray(x) ? x : x === undefined ? [] : [x];
-                    let forNode = this.arrayInputBuckets.get(e.target.nodeId);
-                    if (!forNode) {
-                        forNode = new Map();
-                        this.arrayInputBuckets.set(e.target.nodeId, forNode);
-                    }
-                    let forHandle = forNode.get(e.target.handle);
-                    if (!forHandle) {
-                        forHandle = new Map();
-                        forNode.set(e.target.handle, forHandle);
-                    }
-                    forHandle.set(e.id, toArray(v));
-                    const merged = [];
-                    for (const ed of edges) {
-                        if (ed.target.nodeId === e.target.nodeId &&
-                            ed.target.handle === e.target.handle) {
-                            const part = forHandle.get(ed.id);
-                            if (part && part.length)
-                                merged.push(...part);
-                        }
-                    }
-                    next = merged;
-                }
-                const prev = dstNode.inputs[e.target.handle];
-                const same = valuesEqual(prev, next);
-                if (!same) {
-                    // Check skipPropagateValues (only in run-context mode)
-                    let shouldSkipPropagateValues = false;
-                    if (isRunContextAware && effectiveRunContexts) {
-                        for (const id of effectiveRunContexts) {
-                            const ctx = this.runContextManager.getRunContext(id);
-                            if (ctx && ctx.skipPropagateValues) {
-                                shouldSkipPropagateValues = true;
-                                break;
-                            }
-                        }
-                    }
-                    // Set input values unless skipPropagateValues is enabled
-                    if (!shouldSkipPropagateValues) {
-                        dstNode.inputs[e.target.handle] = next;
-                        this.eventEmitter.emit("value", {
-                            nodeId: e.target.nodeId,
-                            handle: e.target.handle,
-                            value: next,
-                            io: "input",
-                            runtimeTypeId: getTypedOutputTypeId(next),
-                        });
-                        this.handleResolver.scheduleRecomputeHandles(e.target.nodeId);
-                    }
-                    // Check propagate flag (only in run-context mode; auto mode always propagates)
-                    let shouldPropagate = true; // Default: always propagate in auto mode
-                    if (isRunContextAware && effectiveRunContexts) {
-                        shouldPropagate = false;
-                        for (const id of effectiveRunContexts) {
-                            const ctx = this.runContextManager.getRunContext(id);
-                            if (ctx && ctx.propagate) {
-                                shouldPropagate = true;
-                                break;
-                            }
-                        }
-                    }
-                    // Schedule downstream execution if propagation is enabled
-                    if (!this.runtimeCoordinator.isPaused() &&
-                        shouldPropagate &&
-                        this.executionScheduler.allInboundHaveValue(e.target.nodeId)) {
-                        if (isRunContextAware && effectiveRunContexts) {
-                            this.executionScheduler.scheduleInputsChangedWithRunContexts(e.target.nodeId, effectiveRunContexts);
-                        }
-                        else {
-                            this.executionScheduler.scheduleInputsChanged(e.target.nodeId);
-                        }
-                    }
-                }
-            };
-            // Handle async conversion
-            if (e.convertAsync) {
-                this.eventEmitter.emit("stats", {
-                    kind: "edge-start",
-                    edgeId: e.id,
-                    typeId: e.typeId,
-                    source: { nodeId: e.source.nodeId, handle: e.source.handle },
-                    target: { nodeId: e.target.nodeId, handle: e.target.handle },
-                });
-                const controller = new AbortController();
-                const startAt = Date.now();
-                e.stats.runs += 1;
-                e.stats.inFlight = true;
-                if (!isRunContextAware) {
-                    // Only track progress in auto mode
-                    e.stats.progress = 0;
-                }
-                const sig = controller.signal;
-                e.convertAsync(nextVal, sig)
-                    .then((converted) => {
-                    if (!sig.aborted) {
-                        applyToTarget(converted);
-                        e.stats.inFlight = false;
-                        const duration = Date.now() - startAt;
-                        e.stats.lastDurationMs = duration;
-                        if (!isRunContextAware) {
-                            // More detailed stats in auto mode
-                            e.stats.lastEndAt = Date.now();
-                            e.stats.lastError = undefined;
-                            this.eventEmitter.emit("stats", {
-                                kind: "edge-done",
-                                edgeId: e.id,
-                                typeId: e.typeId,
-                                source: { nodeId: e.source.nodeId, handle: e.source.handle },
-                                target: { nodeId: e.target.nodeId, handle: e.target.handle },
-                                durationMs: duration,
-                            });
-                        }
-                    }
-                })
-                    .catch((err) => {
-                    if (sig.aborted)
-                        return;
-                    e.stats.inFlight = false;
-                    if (!isRunContextAware) {
-                        e.stats.lastError = err;
-                    }
-                    this.eventEmitter.emit("error", {
-                        kind: "edge-convert",
-                        edgeId: e.id,
-                        source: { nodeId: e.source.nodeId, handle: e.source.handle },
-                        target: { nodeId: e.target.nodeId, handle: e.target.handle },
-                        err,
-                    });
-                });
+        }
+        this.eventEmitter.emit("stats", {
+            kind: "edge-start",
+            edgeId: edge.id,
+            typeId: edge.typeId,
+            source: { nodeId: edge.source.nodeId, handle: edge.source.handle },
+            target: { nodeId: edge.target.nodeId, handle: edge.target.handle },
+        });
+        const controller = new AbortController();
+        const startAt = Date.now();
+        edge.stats.runs += 1;
+        edge.stats.inFlight = true;
+        edge.stats.progress = 0;
+        edge
+            .convertAsync(value, controller.signal)
+            .then((converted) => {
+            if (!controller.signal.aborted) {
+                this.applyToTarget(edge, converted, effectiveRunContexts);
+                this.updateEdgeStatsOnSuccess(edge, startAt);
             }
-            else {
-                // Synchronous conversion
-                if (e.convert) {
-                    nextVal = e.convert(nextVal);
-                }
-                applyToTarget(nextVal);
+        })
+            .catch((err) => {
+            if (controller.signal.aborted)
+                return;
+            this.handleEdgeConversionError(edge, err);
+        })
+            .finally(() => {
+            this.finishEdgeConversion(edgeRunContextIds, edge.id);
+        });
+    }
+    /**
+     * Apply value to target node input
+     */
+    applyToTarget(edge, value, effectiveRunContexts) {
+        const dstNode = this.graph.getNode(edge.target.nodeId);
+        if (!dstNode)
+            return;
+        // Skip writing to unresolved handles
+        if (edge.dstDeclared === undefined)
+            return;
+        // Handle array types
+        const processedValue = this.processArrayInput(edge, value);
+        // Check if value changed
+        const prev = dstNode.inputs[edge.target.handle];
+        if (valuesEqual(prev, processedValue)) {
+            return; // No change
+        }
+        // Set input value (respecting skipPropagateValues)
+        const shouldSetValue = this.shouldSetInputValue(effectiveRunContexts);
+        if (shouldSetValue) {
+            this.setTargetInput(edge, dstNode, processedValue);
+        }
+        // Schedule downstream execution
+        this.executeDownstream(edge.target.nodeId, effectiveRunContexts);
+    }
+    /**
+     * Process array input by merging values from all edges
+     */
+    processArrayInput(edge, value) {
+        const dstIsArray = typeof edge.dstDeclared === "string" && edge.dstDeclared.endsWith("[]");
+        if (!dstIsArray) {
+            return value;
+        }
+        const toArray = (x) => Array.isArray(x) ? x : x === undefined ? [] : [x];
+        let forNode = this.arrayInputBuckets.get(edge.target.nodeId);
+        if (!forNode) {
+            forNode = new Map();
+            this.arrayInputBuckets.set(edge.target.nodeId, forNode);
+        }
+        let forHandle = forNode.get(edge.target.handle);
+        if (!forHandle) {
+            forHandle = new Map();
+            forNode.set(edge.target.handle, forHandle);
+        }
+        forHandle.set(edge.id, toArray(value));
+        // Merge all parts for this handle
+        const edges = this.graph.getEdges();
+        const merged = [];
+        for (const ed of edges) {
+            if (ed.target.nodeId === edge.target.nodeId &&
+                ed.target.handle === edge.target.handle) {
+                const part = forHandle.get(ed.id);
+                if (part && part.length)
+                    merged.push(...part);
             }
         }
+        return merged;
     }
     /**
-     * Propagate value in run-context aware mode (convenience method)
+     * Check if input value should be set (respecting skipPropagateValues)
      */
-    propagateInRunContexts(srcNodeId, srcHandle, value, runContextIds) {
-        this.propagate(srcNodeId, srcHandle, value, runContextIds);
+    shouldSetInputValue(effectiveRunContexts) {
+        if (!effectiveRunContexts) {
+            return true; // Auto mode always sets values
+        }
+        // Check skipPropagateValues (only in run-context mode)
+        for (const id of effectiveRunContexts) {
+            const ctx = this.runContextManager.getRunContext(id);
+            if (ctx && ctx.skipPropagateValues) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Set target input value and emit event
+     */
+    setTargetInput(edge, dstNode, value) {
+        dstNode.inputs[edge.target.handle] = value;
+        this.eventEmitter.emit("value", {
+            nodeId: edge.target.nodeId,
+            handle: edge.target.handle,
+            value,
+            io: "input",
+            runtimeTypeId: getTypedOutputTypeId(value),
+        });
+        this.handleResolver.scheduleRecomputeHandles(edge.target.nodeId);
+    }
+    /**
+     * Execute downstream if conditions are met
+     */
+    executeDownstream(targetNodeId, effectiveRunContexts) {
+        // Determine if we should propagate
+        const shouldPropagate = this.shouldPropagateExecution(effectiveRunContexts);
+        if (shouldPropagate && this.graph.allInboundHaveValue(targetNodeId)) {
+            this.nodeExecutor.execute(targetNodeId, effectiveRunContexts);
+        }
+    }
+    /**
+     * Check if execution should propagate
+     */
+    shouldPropagateExecution(effectiveRunContexts) {
+        if (!effectiveRunContexts) {
+            return true; // Auto mode always propagates
+        }
+        // Check propagate flag (only in run-context mode)
+        for (const id of effectiveRunContexts) {
+            const ctx = this.runContextManager.getRunContext(id);
+            if (ctx && ctx.propagate) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Update edge stats on successful conversion
+     */
+    updateEdgeStatsOnSuccess(edge, startAt) {
+        edge.stats.inFlight = false;
+        const duration = Date.now() - startAt;
+        edge.stats.lastDurationMs = duration;
+        this.eventEmitter.emit("stats", {
+            kind: "edge-done",
+            edgeId: edge.id,
+            typeId: edge.typeId,
+            source: { nodeId: edge.source.nodeId, handle: edge.source.handle },
+            target: { nodeId: edge.target.nodeId, handle: edge.target.handle },
+            durationMs: duration,
+        });
+        edge.stats.lastEndAt = Date.now();
+        edge.stats.lastError = undefined;
+    }
+    /**
+     * Handle edge conversion error
+     */
+    handleEdgeConversionError(edge, err) {
+        edge.stats.inFlight = false;
+        edge.stats.lastError = err;
+        this.eventEmitter.emit("error", {
+            kind: "edge-convert",
+            edgeId: edge.id,
+            source: { nodeId: edge.source.nodeId, handle: edge.source.handle },
+            target: { nodeId: edge.target.nodeId, handle: edge.target.handle },
+            err,
+        });
+    }
+    /**
+     * Finish edge conversion and decrement pending edges
+     */
+    finishEdgeConversion(edgeRunContextIds, edgeId) {
+        if (!edgeRunContextIds)
+            return;
+        for (const id of edgeRunContextIds) {
+            this.runContextManager.finishEdgeConversion(id, edgeId);
+        }
     }
     /**
      * Re-emit all outputs from a node (used when graph updates)
      * Only re-emits outputs that are valid according to resolved handles
      */
-    reemitNodeOutputs(nodeId) {
-        const node = this.graphStructure.getNode(nodeId);
+    invalidateDownstream(nodeId) {
+        const node = this.graph.getNode(nodeId);
         if (!node)
             return;
         // Get resolved handles to filter out invalid outputs
-        const resolved = this.graphStructure.getResolvedHandles(nodeId);
+        const resolved = this.graph.getResolvedHandles(nodeId);
         const validOutputHandles = resolved?.outputs
             ? new Set(Object.keys(resolved.outputs))
             : new Set();
         // Use node's activeRunContexts to propagate to new nodes that were added
-        const runContextIds = node.activeRunContexts.size > 0
-            ? new Set(node.activeRunContexts)
-            : undefined;
         for (const [handle, value] of Object.entries(node.outputs)) {
             // Only re-emit if this handle is still valid
             if (validOutputHandles.has(handle)) {
-                this.propagate(nodeId, handle, value, runContextIds);
+                this.propagate(nodeId, handle, value, node.activeRunContextIds);
             }
         }
     }
@@ -1193,52 +1416,35 @@ class ValuePropagator {
 }
 
 /**
- * ExecutionScheduler component - handles node execution scheduling and lifecycle
+ * NodeExecutor component - handles node execution scheduling and lifecycle
  */
-class ExecutionScheduler {
-    constructor(graphStructure, eventEmitter, runContextManager, valuePropagator, runtimeCoordinator, environment) {
-        this.environment = {};
-        this.graphStructure = graphStructure;
+class NodeExecutor {
+    constructor(graph, eventEmitter, runContextManager, edgePropagator, runtime, environment) {
+        this.graph = graph;
         this.eventEmitter = eventEmitter;
         this.runContextManager = runContextManager;
-        this.valuePropagator = valuePropagator;
-        this.runtimeCoordinator = runtimeCoordinator;
+        this.edgePropagator = edgePropagator;
+        this.runtime = runtime;
+        this.environment = {};
         this.environment = environment ?? {};
     }
     setEnvironment(environment) {
         this.environment = environment;
     }
-    /**
-     * Check if all inbound edges for a node have values
-     */
-    allInboundHaveValue(nodeId) {
-        const node = this.graphStructure.getNode(nodeId);
-        if (!node)
-            return false;
-        const edges = this.graphStructure.getEdges();
-        const inbound = edges.filter((e) => e.target.nodeId === nodeId);
-        if (inbound.length === 0)
-            return true;
-        for (const e of inbound) {
-            if (!(e.target.handle in node.inputs))
-                return false;
-        }
-        return true;
-    }
     /**
      * Compute effective inputs for a node by merging real inputs with defaults
      */
     getEffectiveInputs(nodeId) {
-        const node = this.graphStructure.getNode(nodeId);
+        const node = this.graph.getNode(nodeId);
         if (!node)
             return {};
-        const registry = this.graphStructure.getRegistry();
+        const registry = this.graph.getRegistry();
         if (!registry)
             return {};
         const desc = registry.nodes.get(node.typeId);
         if (!desc)
             return {};
-        const resolved = this.graphStructure.getResolvedHandles(nodeId);
+        const resolved = this.graph.getResolvedHandles(nodeId);
         const regDefaults = desc.inputDefaults ?? {};
         const dynDefaults = resolved?.inputDefaults ?? {};
         // Identify which handles are dynamically resolved (not in registry statics)
@@ -1252,7 +1458,7 @@ class ExecutionScheduler {
         // Start with real inputs only (no defaults)
         const effective = { ...node.inputs };
         // Build set of inbound handles (wired inputs)
-        const edges = this.graphStructure.getEdges();
+        const edges = this.graph.getEdges();
         const inbound = new Set(edges
             .filter((e) => e.target.nodeId === nodeId)
             .map((e) => e.target.handle));
@@ -1279,7 +1485,7 @@ class ExecutionScheduler {
     createExecutionContext(nodeId, node, inputs, runId, abortSignal, runContextIds, options) {
         const emitHandler = options?.emitHandler ??
             ((handle, value) => {
-                this.valuePropagator.propagate(nodeId, handle, value, runContextIds);
+                this.edgePropagator.propagate(nodeId, handle, value, runContextIds);
             });
         const reportProgress = options?.reportProgress ??
             ((p) => {
@@ -1314,20 +1520,18 @@ class ExecutionScheduler {
                 }
             }
         };
-        // Store run-context IDs for use in scheduleInputsChanged
-        const storedRunContextIds = runContextIds;
         return {
             nodeId,
             state: node.state,
             setState: (next) => Object.assign(node.state, next),
             emit: emitHandler,
             invalidateDownstream: () => {
-                this.runtimeCoordinator.invalidateDownstream(nodeId);
+                this.edgePropagator.invalidateDownstream(nodeId);
             },
-            scheduleInputsChanged: () => {
-                if (this.allInboundHaveValue(nodeId)) {
+            execute: () => {
+                if (this.graph.allInboundHaveValue(nodeId)) {
                     // Preserve run-context IDs when scheduling from execution context
-                    this.scheduleInputsChangedInternal(nodeId, storedRunContextIds);
+                    this.execute(nodeId, runContextIds);
                 }
             },
             getInput: (handle) => inputs[handle],
@@ -1339,232 +1543,345 @@ class ExecutionScheduler {
         };
     }
     /**
-     * Schedule a node for execution when its inputs change
+     * Internal method for executing inputs changed (also used by GraphRuntime)
+     */
+    execute(nodeId, runContextIds) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            return;
+        const runMode = this.runtime.getRunMode();
+        if (!runMode) {
+            console.warn("NodeExecutor.execute: no runMode, skipping execution");
+            return;
+        }
+        if (runMode === "manual" && (!runContextIds || runContextIds.size === 0)) {
+            console.warn("NodeExecutor.execute: no runContextIds provided, skipping execution");
+            return;
+        }
+        if (runMode === "auto" && runContextIds && runContextIds.size > 0) {
+            console.warn("NodeExecutor.execute: runContextIds provided in auto-mode, ignoring");
+            runContextIds = undefined;
+        }
+        // Early validation for auto-mode paused state
+        if (this.runtime.isPaused())
+            return;
+        // Attach run-context IDs if provided
+        this.attachRunContexts(node, runContextIds);
+        // Handle debouncing
+        const now = Date.now();
+        if (this.shouldDebounce(node, now)) {
+            this.handleDebouncedSchedule(node, nodeId, now);
+            return;
+        }
+        // Prepare execution plan
+        const executionPlan = this.prepareExecutionPlan(node, nodeId, runContextIds, now);
+        // Route to appropriate concurrency handler
+        this.routeToConcurrencyHandler(node, nodeId, executionPlan);
+    }
+    /**
+     * Attach run-context IDs to the node
+     */
+    attachRunContexts(node, runContextIds) {
+        if (!runContextIds)
+            return;
+        node.activeRunContextIds = new Set([
+            ...node.activeRunContextIds,
+            ...runContextIds,
+        ]);
+    }
+    /**
+     * Check if execution should be debounced
+     */
+    shouldDebounce(node, now) {
+        const policy = node.policy ?? {};
+        return !!(policy.debounceMs &&
+            node.lastScheduledAt &&
+            now - node.lastScheduledAt < policy.debounceMs);
+    }
+    /**
+     * Handle debounced scheduling by replacing the latest queued item
+     */
+    handleDebouncedSchedule(node, nodeId, now) {
+        const effectiveInputs = this.getEffectiveInputs(nodeId);
+        node.queue.splice(0, node.queue.length);
+        node.runSeq += 1;
+        const rid = `${nodeId}:${node.runSeq}:${now}`;
+        node.queue.push({ runId: rid, inputs: effectiveInputs });
+    }
+    /**
+     * Prepare execution plan with all necessary information
+     */
+    prepareExecutionPlan(node, nodeId, runContextIds, now) {
+        node.lastScheduledAt = now;
+        node.runSeq += 1;
+        const runId = `${nodeId}:${node.runSeq}:${now}`;
+        node.latestRunId = runId;
+        const effectiveInputs = this.getEffectiveInputs(nodeId);
+        // Take a shallow snapshot of the current policy for this run
+        const policySnapshot = node.policy ? { ...node.policy } : undefined;
+        return {
+            runId,
+            effectiveInputs,
+            runContextIdsForRun: runContextIds,
+            timestamp: now,
+            policy: policySnapshot,
+        };
+    }
+    /**
+     * Route execution to appropriate concurrency handler
+     */
+    routeToConcurrencyHandler(node, nodeId, plan) {
+        const mode = plan.policy?.asyncConcurrency ?? "switch";
+        switch (mode) {
+            case "drop":
+                this.handleDropMode(node, nodeId, plan);
+                break;
+            case "queue":
+                this.handleQueueMode(node, nodeId, plan);
+                break;
+            case "switch":
+            case "merge":
+            default:
+                this.startRun(node, nodeId, plan);
+                break;
+        }
+    }
+    /**
+     * Handle drop mode - drop execution if node is already running, otherwise start run
+     */
+    handleDropMode(node, nodeId, plan) {
+        // Drop if node is already running
+        if (node.activeControllers.size > 0) {
+            return; // Don't increment pendingCount if we're dropping this run
+        }
+        // Start run if node is not running
+        this.startRun(node, nodeId, plan);
+    }
+    /**
+     * Handle queue mode - add to queue and process sequentially
+     */
+    handleQueueMode(node, nodeId, plan) {
+        const maxQ = plan.policy?.maxQueue ?? 8;
+        node.queue.push({ runId: plan.runId, inputs: plan.effectiveInputs });
+        if (node.queue.length > maxQ)
+            node.queue.shift();
+        this.processQueue(node, nodeId);
+    }
+    /**
+     * Process queued executions sequentially
+     */
+    processQueue(node, nodeId) {
+        const processNext = () => {
+            if (node.activeControllers.size > 0)
+                return;
+            const next = node.queue.shift();
+            if (!next)
+                return;
+            node.latestRunId = next.runId;
+            const policySnapshot = node.policy ? { ...node.policy } : undefined;
+            const plan = {
+                runId: next.runId,
+                effectiveInputs: next.inputs,
+                runContextIdsForRun: node.activeRunContextIds,
+                timestamp: Date.now(),
+                policy: policySnapshot,
+            };
+            this.startRun(node, nodeId, plan, () => {
+                setTimeout(processNext, 0);
+            });
+        };
+        processNext();
+    }
+    /**
+     * Start a node execution run
+     */
+    startRun(node, nodeId, plan, onDone) {
+        // Track run-contexts
+        this.trackRunContextStart(nodeId, plan.runContextIdsForRun);
+        // Setup execution controller
+        const controller = this.createExecutionController(node, plan.runId);
+        // Handle concurrency mode
+        this.applyConcurrencyMode(node, controller, plan);
+        // Setup timeout if needed
+        const timeoutId = this.setupTimeout(node, controller, plan);
+        // Create execution context
+        const ctx = this.createExecutionContext(nodeId, node, plan.effectiveInputs, plan.runId, controller.signal, plan.runContextIdsForRun, this.createEmitAndProgressHandlers(node, nodeId, plan));
+        // Execute
+        this.executeNode(node, nodeId, ctx, plan, controller, timeoutId, onDone);
+    }
+    /**
+     * Track run-context start for pending nodes
+     */
+    trackRunContextStart(nodeId, runContextIdsForRun) {
+        if (runContextIdsForRun && runContextIdsForRun.size > 0) {
+            for (const id of runContextIdsForRun) {
+                this.runContextManager.startNodeRun(id, nodeId);
+            }
+        }
+    }
+    /**
+     * Create execution controller and update node stats
+     */
+    createExecutionController(node, runId) {
+        const controller = new AbortController();
+        node.stats.runs += 1;
+        node.stats.active += 1;
+        node.stats.lastStartAt = Date.now();
+        node.stats.progress = 0;
+        node.activeControllers.add(controller);
+        node.controllerRunIds.set(controller, runId);
+        return controller;
+    }
+    /**
+     * Apply concurrency mode (switch mode aborts other controllers)
+     */
+    applyConcurrencyMode(node, controller, plan) {
+        const mode = plan.policy?.asyncConcurrency ?? "switch";
+        if (mode === "switch") {
+            for (const c of Array.from(node.activeControllers)) {
+                if (c !== controller)
+                    c.abort("switch");
+            }
+        }
+    }
+    /**
+     * Setup timeout for execution if configured
+     */
+    setupTimeout(node, controller, plan) {
+        const policy = plan.policy ?? {};
+        if (policy.timeoutMs && policy.timeoutMs > 0) {
+            return setTimeout(() => controller.abort("timeout"), policy.timeoutMs);
+        }
+        return undefined;
+    }
+    /**
+     * Create emit and progress handlers for execution context
+     */
+    createEmitAndProgressHandlers(node, nodeId, plan) {
+        const policy = plan.policy ?? {};
+        return {
+            emitHandler: (handle, value) => {
+                const m = policy.asyncConcurrency ?? "switch";
+                // Drop emits from runs that were explicitly cancelled due to a
+                // snapshot/undo/redo operation, regardless of asyncConcurrency.
+                if (node.snapshotCancelledRunIds?.has(plan.runId))
+                    return;
+                if (m !== "merge" && plan.runId !== node.latestRunId)
+                    return;
+                this.edgePropagator.propagate(nodeId, handle, value, plan.runContextIdsForRun);
+            },
+            reportProgress: (p) => {
+                node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
+                this.eventEmitter.emit("stats", {
+                    kind: "node-progress",
+                    nodeId,
+                    typeId: node.typeId,
+                    runId: plan.runId,
+                    progress: node.stats.progress,
+                });
+            },
+        };
+    }
+    /**
+     * Execute the node with retry logic and cleanup
+     */
+    executeNode(node, nodeId, ctx, plan, controller, timeoutId, onDone) {
+        // Fire node-start event
+        this.eventEmitter.emit("stats", {
+            kind: "node-start",
+            nodeId,
+            typeId: node.typeId,
+            runId: plan.runId,
+        });
+        ctx.log("debug", "node-start");
+        const exec = async (attempt) => {
+            let hadError = false;
+            try {
+                if (node.lifecycle?.prepare) {
+                    ctx.log("debug", "prepare-start");
+                    node.lifecycle.prepare(node.params ?? {}, ctx);
+                    ctx.log("debug", "prepare-done");
+                }
+                await node.runtime.onInputsChanged?.(plan.effectiveInputs, ctx);
+            }
+            catch (err) {
+                // Suppress errors caused by expected cancellations
+                if (controller.signal.aborted) {
+                    const reason = controller.signal.reason;
+                    if (reason === "switch" ||
+                        reason === "snapshot" ||
+                        reason === "node-deleted" ||
+                        reason === "user-cancelled") {
+                        return; // Cancellation events are emitted separately, skip error handling
+                    }
+                }
+                hadError = true;
+                node.stats.lastError = err;
+                const retry = plan.policy?.retry;
+                if (retry && attempt < (retry.attempts ?? 0)) {
+                    const delay = retry.backoffMs ? retry.backoffMs(attempt) : 0;
+                    await new Promise((r) => setTimeout(r, delay));
+                    return exec(attempt + 1);
+                }
+                this.eventEmitter.emit("error", {
+                    kind: "node-run",
+                    nodeId,
+                    runId: plan.runId,
+                    err,
+                });
+            }
+            finally {
+                this.cleanupExecution(node, nodeId, ctx, plan, controller, timeoutId, hadError, onDone);
+            }
+        };
+        exec(0);
+    }
+    /**
+     * Cleanup after execution completes
      */
-    scheduleInputsChanged(nodeId) {
-        this.scheduleInputsChangedInternal(nodeId);
-    }
-    /**
-     * Schedule a node for execution with run-context IDs
-     */
-    scheduleInputsChangedWithRunContexts(nodeId, runContextIds) {
-        this.scheduleInputsChangedInternal(nodeId, runContextIds);
-    }
-    /**
-     * Internal method for scheduling (also used by GraphRuntime)
-     */
-    scheduleInputsChangedInternal(nodeId, runContextIds) {
-        const node = this.graphStructure.getNode(nodeId);
-        if (!node)
-            return;
-        if (this.runtimeCoordinator.isPaused())
-            return;
-        // If run-context IDs are provided, attach them to the node
-        if (runContextIds) {
-            for (const id of runContextIds) {
-                node.activeRunContexts.add(id);
+    cleanupExecution(node, nodeId, ctx, plan, controller, timeoutId, hadError, onDone) {
+        // Decrement pendingNodes count for all relevant run-contexts
+        if (plan.runContextIdsForRun && plan.runContextIdsForRun.size > 0) {
+            for (const id of plan.runContextIdsForRun) {
+                this.runContextManager.finishNodeRun(id, nodeId);
             }
         }
-        const now = Date.now();
-        const policy = node.policy ?? {};
-        // Compute effective inputs (real inputs + defaults) for this execution
-        const effectiveInputs = this.getEffectiveInputs(nodeId);
-        if (policy.debounceMs &&
-            node.lastScheduledAt &&
-            now - node.lastScheduledAt < policy.debounceMs) {
-            // debounce: replace latest queued
-            node.queue.splice(0, node.queue.length);
-            node.runSeq += 1;
-            const rid = `${nodeId}:${node.runSeq}:${now}`;
-            node.queue.push({ runId: rid, inputs: effectiveInputs });
+        // Skip cleanup if node was deleted (cleanup already handled)
+        if (!this.graph.hasNode(nodeId)) {
             return;
         }
-        node.lastScheduledAt = now;
-        node.runSeq += 1;
-        const rid = `${nodeId}:${node.runSeq}:${now}`;
-        node.latestRunId = rid;
-        // Get run-context IDs for this node (use provided or from node's activeRunContexts)
-        const runContextIdsForRun = runContextIds ||
-            (node.activeRunContexts.size > 0
-                ? new Set(node.activeRunContexts)
-                : undefined);
-        const startRun = (runId, capturedInputs, runContextIdsForRun, onDone) => {
-            // Increment pending count for all relevant run-contexts (node will run)
-            if (runContextIdsForRun && runContextIdsForRun.size > 0) {
-                for (const id of runContextIdsForRun) {
-                    const ctx = this.runContextManager.getRunContext(id);
-                    if (ctx)
-                        ctx.pending++;
-                }
-            }
-            const controller = new AbortController();
-            node.stats.runs += 1;
-            node.stats.active += 1;
-            node.stats.lastStartAt = now;
-            node.stats.progress = 0;
-            node.activeControllers.add(controller);
-            node.controllerRunIds.set(controller, runId);
-            const mode = policy.asyncConcurrency ?? "switch";
-            if (mode === "switch") {
-                for (const c of Array.from(node.activeControllers)) {
-                    if (c !== controller)
-                        c.abort("switch");
-                }
-            }
-            let timeoutId;
-            if (policy.timeoutMs && policy.timeoutMs > 0) {
-                timeoutId = setTimeout(() => controller.abort("timeout"), policy.timeoutMs);
-            }
-            const ctx = this.createExecutionContext(nodeId, node, capturedInputs, runId, controller.signal, runContextIdsForRun, {
-                emitHandler: (handle, value) => {
-                    const m = policy.asyncConcurrency ?? "switch";
-                    // Drop emits from runs that were explicitly cancelled due to a
-                    // snapshot/undo/redo operation, regardless of asyncConcurrency.
-                    if (node.snapshotCancelledRunIds?.has(runId))
-                        return;
-                    if (m !== "merge" && runId !== node.latestRunId)
-                        return;
-                    this.valuePropagator.propagate(nodeId, handle, value, runContextIdsForRun);
-                },
-                reportProgress: (p) => {
-                    node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
-                    this.eventEmitter.emit("stats", {
-                        kind: "node-progress",
-                        nodeId,
-                        typeId: node.typeId,
-                        runId,
-                        progress: node.stats.progress,
-                    });
-                },
-            });
-            const exec = async (attempt) => {
-                let hadError = false;
-                try {
-                    if (node.lifecycle?.prepare) {
-                        ctx.log("debug", "prepare-start");
-                        node.lifecycle.prepare(node.params ?? {}, ctx);
-                        ctx.log("debug", "prepare-done");
-                    }
-                    await node.runtime.onInputsChanged?.(capturedInputs, ctx);
-                }
-                catch (err) {
-                    // Suppress errors caused by expected cancellations
-                    if (controller.signal.aborted) {
-                        const reason = controller.signal.reason;
-                        if (reason === "switch" ||
-                            reason === "snapshot" ||
-                            reason === "node-deleted" ||
-                            reason === "user-cancelled") {
-                            return; // Cancellation events are emitted separately, skip error handling
-                        }
-                    }
-                    hadError = true;
-                    node.stats.lastError = err;
-                    const retry = policy.retry;
-                    if (retry && attempt < (retry.attempts ?? 0)) {
-                        const delay = retry.backoffMs ? retry.backoffMs(attempt) : 0;
-                        await new Promise((r) => setTimeout(r, delay));
-                        return exec(attempt + 1);
-                    }
-                    this.eventEmitter.emit("error", {
-                        kind: "node-run",
-                        nodeId,
-                        runId,
-                        err,
-                    });
-                }
-                finally {
-                    // Skip cleanup if node was deleted (cleanup already handled)
-                    if (!this.graphStructure.hasNode(nodeId)) {
-                        return;
-                    }
-                    if (timeoutId)
-                        clearTimeout(timeoutId);
-                    node.activeControllers.delete(controller);
-                    node.controllerRunIds.delete(controller);
-                    node.stats.active = Math.max(0, node.activeControllers.size);
-                    node.stats.lastEndAt = Date.now();
-                    node.stats.lastDurationMs =
-                        node.stats.lastStartAt && node.stats.lastEndAt
-                            ? node.stats.lastEndAt - node.stats.lastStartAt
-                            : undefined;
-                    if (!hadError)
-                        node.stats.lastError = undefined;
-                    // Only emit node-done if not cancelled (cancellation events emitted separately)
-                    const isCancelled = controller.signal.aborted &&
-                        (controller.signal.reason === "snapshot" ||
-                            controller.signal.reason === "node-deleted" ||
-                            controller.signal.reason === "user-cancelled");
-                    if (!isCancelled) {
-                        this.eventEmitter.emit("stats", {
-                            kind: "node-done",
-                            nodeId,
-                            typeId: node.typeId,
-                            runId,
-                            durationMs: node.stats.lastDurationMs,
-                        });
-                    }
-                    ctx.log("debug", "node-done", {
-                        durationMs: node.stats.lastDurationMs,
-                        hadError,
-                    });
-                    // Decrement pending count for all relevant run-contexts
-                    if (runContextIdsForRun && runContextIdsForRun.size > 0) {
-                        for (const id of runContextIdsForRun) {
-                            const ctx = this.runContextManager.getRunContext(id);
-                            if (ctx) {
-                                ctx.pending--;
-                                if (ctx.pending === 0) {
-                                    this.runContextManager.finishRunContext(id, this.graphStructure.getNodes());
-                                }
-                            }
-                        }
-                    }
-                    if (onDone)
-                        onDone();
-                }
-            };
-            // Fire node-start event
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        node.activeControllers.delete(controller);
+        node.controllerRunIds.delete(controller);
+        node.stats.active = Math.max(0, node.activeControllers.size);
+        node.stats.lastEndAt = Date.now();
+        node.stats.lastDurationMs =
+            node.stats.lastStartAt && node.stats.lastEndAt
+                ? node.stats.lastEndAt - node.stats.lastStartAt
+                : undefined;
+        if (!hadError)
+            node.stats.lastError = undefined;
+        // Only emit node-done if not cancelled (cancellation events emitted separately)
+        const isCancelled = controller.signal.aborted &&
+            (controller.signal.reason === "snapshot" ||
+                controller.signal.reason === "node-deleted" ||
+                controller.signal.reason === "user-cancelled");
+        if (!isCancelled) {
             this.eventEmitter.emit("stats", {
-                kind: "node-start",
+                kind: "node-done",
                 nodeId,
                 typeId: node.typeId,
-                runId,
+                runId: plan.runId,
+                durationMs: node.stats.lastDurationMs,
             });
-            ctx.log("debug", "node-start");
-            exec(0);
-        };
-        const mode = policy.asyncConcurrency ?? "switch";
-        if (mode === "drop" && node.activeControllers.size > 0) {
-            // Don't increment pendingCount if we're dropping this run
-            return;
-        }
-        if (mode === "queue") {
-            const maxQ = policy.maxQueue ?? 8;
-            node.queue.push({ runId: rid, inputs: effectiveInputs });
-            if (node.queue.length > maxQ)
-                node.queue.shift();
-            const processNext = () => {
-                if (node.activeControllers.size > 0)
-                    return;
-                const next = node.queue.shift();
-                if (!next)
-                    return;
-                node.latestRunId = next.runId;
-                // Use node's activeRunContexts for queued items
-                const queuedRunContextIds = node.activeRunContexts.size > 0
-                    ? new Set(node.activeRunContexts)
-                    : undefined;
-                startRun(next.runId, next.inputs, queuedRunContextIds, () => {
-                    // After finishing, schedule next
-                    setTimeout(processNext, 0);
-                });
-            };
-            processNext();
-            return;
         }
-        // switch or merge
-        startRun(rid, effectiveInputs, runContextIdsForRun);
+        ctx.log("debug", "node-done", {
+            durationMs: node.stats.lastDurationMs,
+            hadError,
+        });
+        if (onDone)
+            onDone();
     }
     /**
      * Cancel all active runs for a node
@@ -1612,7 +1929,7 @@ class ExecutionScheduler {
         const toCancel = new Set(nodeIds);
         const visited = new Set();
         const queue = [...nodeIds];
-        const edges = this.graphStructure.getEdges();
+        const edges = this.graph.getEdges();
         // Collect all downstream nodes to cancel
         for (let i = 0; i < queue.length; i++) {
             const nodeId = queue[i];
@@ -1631,7 +1948,7 @@ class ExecutionScheduler {
         }
         // Cancel runs for all affected nodes
         for (const nodeId of toCancel) {
-            const node = this.graphStructure.getNode(nodeId);
+            const node = this.graph.getNode(nodeId);
             if (!node)
                 continue;
             this.cancelNodeActiveRuns(node, reason);
@@ -1642,8 +1959,8 @@ class ExecutionScheduler {
         }
         // Cancel nodes in run-contexts (exclude them from active run-contexts)
         for (const nodeId of toCancel) {
-            this.runContextManager.cancelNodeInRunContexts(nodeId, false, // includeDownstream = false (already collected above)
-            edges, this.graphStructure.getNodes());
+            // includeDownstream = false (already collected above)
+            this.runContextManager.cancelNodeInRunContexts(nodeId, false);
         }
     }
 }
@@ -1652,45 +1969,30 @@ class ExecutionScheduler {
 class GraphRuntime {
     constructor() {
         // State
-        this.paused = false;
         this.environment = {};
+        this.runMode = null;
+        this.pauseRefCount = 0;
         // Initialize components
-        this.graphStructure = new GraphStructure();
+        this.graph = new Graph();
         this.eventEmitter = new EventEmitter();
-        this.runContextManager = new RunContextManager();
-        // Initialize components with interface-based dependencies
-        // HandleResolver only needs IRuntimeCoordinator (this)
-        this.handleResolver = new HandleResolver(this.graphStructure, this.eventEmitter, this, // IRuntimeCoordinator
-        undefined, // registry set later
-        undefined // environment set later
-        );
-        // ValuePropagator needs IHandleResolver and IRuntimeCoordinator
-        // ExecutionScheduler needs IValuePropagator - circular dependency!
-        // Solution: Create ValuePropagator first (without executionScheduler),
-        // then create ExecutionScheduler with ValuePropagator,
-        // then wire ValuePropagator with ExecutionScheduler via setExecutionScheduler
-        this.valuePropagator = new ValuePropagator(this.graphStructure, this.eventEmitter, this.runContextManager, this.handleResolver, // IHandleResolver
-        this // IRuntimeCoordinator
-        );
-        // Create ExecutionScheduler with ValuePropagator
-        this.executionScheduler = new ExecutionScheduler(this.graphStructure, this.eventEmitter, this.runContextManager, this.valuePropagator, // IValuePropagator
-        this, // IRuntimeCoordinator
-        this.environment);
-        // Wire ValuePropagator with ExecutionScheduler to resolve circular dependency
-        this.valuePropagator.setExecutionScheduler(this.executionScheduler);
+        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);
     }
     static create(def, registry, opts) {
         const gr = new GraphRuntime();
         gr.environment = opts?.environment ?? {};
         // Set registry and environment on components
-        gr.graphStructure.setRegistry(registry);
+        gr.graph.setRegistry(registry);
         gr.handleResolver.setRegistry(registry);
         gr.handleResolver.setEnvironment(gr.environment);
-        gr.executionScheduler.setEnvironment(gr.environment);
+        gr.nodeExecutor.setEnvironment(gr.environment);
         // Precompute per-node resolved handles (use def-provided overrides; do not compute dynamically here)
-        const initial = GraphStructure.computeResolvedHandleMap(def, registry, gr.environment);
-        for (const [nodeId, handles] of initial.map) {
-            gr.graphStructure.setResolvedHandles(nodeId, handles);
+        const initial = tryHandleResolving(def, registry, gr.environment);
+        for (const [nodeId, handles] of initial.resolved) {
+            gr.graph.setResolvedHandles(nodeId, handles);
         }
         // Instantiate nodes
         for (const n of def.nodes) {
@@ -1731,13 +2033,13 @@ class GraphRuntime {
                     queued: 0,
                     progress: 0,
                 },
-                activeRunContexts: new Set(),
+                activeRunContextIds: new Set(),
             };
-            gr.graphStructure.setNode(n.nodeId, rn);
+            gr.graph.setNode(n.nodeId, rn);
         }
         // Instantiate edges
-        const edges = GraphStructure.buildEdges(def, registry, gr.graphStructure.getResolvedHandlesMap());
-        gr.graphStructure.setEdges(edges);
+        const edges = buildEdges(def, registry, gr.graph.getResolvedHandlesMap());
+        gr.graph.setEdges(edges);
         // Schedule async recompute only for nodes that indicated Promise-based resolveHandles
         for (const nodeId of initial.pending) {
             gr.handleResolver.scheduleRecomputeHandles(nodeId);
@@ -1748,12 +2050,12 @@ class GraphRuntime {
         return this.eventEmitter.on(event, handler);
     }
     setInputs(nodeId, inputs) {
-        const node = this.graphStructure.getNode(nodeId);
+        const node = this.graph.getNode(nodeId);
         if (!node)
             throw new Error(`Node not found: ${nodeId}`);
         let anyChanged = false;
-        const edges = this.graphStructure.getEdges();
-        const registry = this.graphStructure.getRegistry();
+        const edges = this.graph.getEdges();
+        const registry = this.graph.getRegistry();
         for (const [handle, value] of Object.entries(inputs)) {
             const hasInbound = edges.some((e) => e.target.nodeId === nodeId && e.target.handle === handle);
             if (hasInbound)
@@ -1761,7 +2063,7 @@ class GraphRuntime {
             // Validate input value against declared type
             if (value !== undefined && registry) {
                 const desc = registry.nodes.get(node.typeId);
-                const resolved = this.graphStructure.getResolvedHandles(nodeId);
+                const resolved = this.graph.getResolvedHandles(nodeId);
                 // Get typeId from resolved handles first, then registry statics
                 const typeId = resolved
                     ? getInputTypeId(resolved.inputs, handle)
@@ -1800,100 +2102,23 @@ class GraphRuntime {
                 anyChanged = true;
             }
         }
-        if (!this.paused) {
-            // Only schedule if all inbound inputs are present (or there are none)
-            if (anyChanged && this.executionScheduler.allInboundHaveValue(nodeId))
-                this.executionScheduler.scheduleInputsChangedInternal(nodeId);
-            // Recompute dynamic handles for this node when its direct inputs change
-            if (anyChanged)
-                this.handleResolver.scheduleRecomputeHandles(nodeId);
+        // In auto mode, input updates can trigger execution; in manual mode they never should.
+        if (anyChanged) {
+            this.handleResolver.scheduleRecomputeHandles(nodeId);
+            if (this.runMode === "auto" && this.graph.allInboundHaveValue(nodeId)) {
+                this.execute(nodeId);
+            }
         }
     }
     getOutput(nodeId, output) {
-        const node = this.graphStructure.getNode(nodeId);
+        const node = this.graph.getNode(nodeId);
         return node?.outputs[output];
     }
-    // Update resolved handles for a single node and refresh edge converters/types that touch it
-    updateNodeHandles(nodeId, handles, registry) {
-        const node = this.graphStructure.getNode(nodeId);
-        if (!node)
-            return;
-        const oldResolved = this.graphStructure.getResolvedHandles(nodeId);
-        this.graphStructure.setResolvedHandles(nodeId, handles);
-        // Clear outputs that are no longer valid handles
-        const oldOutputs = oldResolved?.outputs ?? {};
-        const newOutputs = handles.outputs ?? {};
-        const oldOutputHandles = new Set(Object.keys(oldOutputs));
-        const newOutputHandles = new Set(Object.keys(newOutputs));
-        for (const handle of oldOutputHandles) {
-            if (!newOutputHandles.has(handle)) {
-                // Output handle was removed - clear it and emit undefined to invalidate downstream
-                delete node.outputs[handle];
-                this.eventEmitter.emit("value", {
-                    nodeId,
-                    handle,
-                    value: undefined,
-                    io: "output",
-                });
-            }
-        }
-        const edges = this.graphStructure.getEdges();
-        // Recompute edge converter/type for edges where this node is source or target
-        for (const e of edges) {
-            const srcNode = this.graphStructure.getNode(e.source.nodeId);
-            const dstNode = this.graphStructure.getNode(e.target.nodeId);
-            let srcDeclared = e.effectiveTypeId; // Use effectiveTypeId as fallback
-            let dstDeclared = e.dstDeclared;
-            const oldDstDeclared = dstDeclared; // Track old value to detect resolution
-            if (e.source.nodeId === nodeId) {
-                const resolved = this.graphStructure.getResolvedHandles(nodeId);
-                srcDeclared = resolved
-                    ? resolved.outputs[e.source.handle]
-                    : srcDeclared;
-                // Update effectiveTypeId if original wasn't explicit
-                if (!e.typeId) {
-                    e.effectiveTypeId = Array.isArray(srcDeclared)
-                        ? srcDeclared?.[0] ?? "untyped"
-                        : srcDeclared ?? "untyped";
-                }
-            }
-            if (e.target.nodeId === nodeId) {
-                const resolved = this.graphStructure.getResolvedHandles(nodeId);
-                if (resolved) {
-                    dstDeclared = getInputTypeId(resolved.inputs, e.target.handle);
-                    e.dstDeclared = dstDeclared;
-                }
-            }
-            const conv = GraphStructure.buildEdgeConverters(srcDeclared, dstDeclared, registry, `updateNodeHandles: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
-            e.convert = conv.convert;
-            e.convertAsync = conv.convertAsync;
-            // If target handle was just resolved (was undefined, now has a type), re-propagate values
-            if (e.target.nodeId === nodeId &&
-                oldDstDeclared === undefined &&
-                dstDeclared !== undefined) {
-                const srcNode = this.graphStructure.getNode(e.source.nodeId);
-                if (srcNode) {
-                    const srcValue = srcNode.outputs[e.source.handle];
-                    if (srcValue !== undefined) {
-                        // Re-propagate through the now-resolved edge converter
-                        // Preserve run-contexts if source node has them
-                        const runContextIds = srcNode.activeRunContexts.size > 0
-                            ? new Set(srcNode.activeRunContexts)
-                            : undefined;
-                        this.valuePropagator.propagate(e.source.nodeId, e.source.handle, srcValue, runContextIds);
-                    }
-                }
-            }
-        }
-        // Re-emit only valid outputs (after clearing removed ones)
-        this.valuePropagator.reemitNodeOutputs(nodeId);
-    }
     launch(invalidate = false) {
-        // call onActivated for nodes that implement it
-        for (const node of this.graphStructure.getNodes().values()) {
-            const effectiveInputs = this.executionScheduler.getEffectiveInputs(node.nodeId);
+        for (const node of this.graph.getNodes().values()) {
+            const effectiveInputs = this.nodeExecutor.getEffectiveInputs(node.nodeId);
             const ctrl = new AbortController();
-            const ctx = this.executionScheduler.createExecutionContext(node.nodeId, node, effectiveInputs, `${node.nodeId}:init`, ctrl.signal);
+            const ctx = this.nodeExecutor.createExecutionContext(node.nodeId, node, effectiveInputs, `${node.nodeId}:init`, ctrl.signal);
             if (node.lifecycle?.prepare) {
                 ctx.log("debug", "prepare-start");
                 node.lifecycle.prepare(node.params ?? {}, ctx);
@@ -1901,40 +2126,27 @@ class GraphRuntime {
             }
             node.runtime.onActivated?.();
         }
-        if (invalidate) {
-            // After activation, schedule nodes that have all inbound inputs present
-            for (const nodeId of this.graphStructure.getNodes().keys()) {
-                if (this.executionScheduler.allInboundHaveValue(nodeId))
-                    this.executionScheduler.scheduleInputsChangedInternal(nodeId);
+        if (this.runMode === "auto" && invalidate) {
+            for (const nodeId of this.graph.getNodes().keys()) {
+                if (this.graph.allInboundHaveValue(nodeId))
+                    this.execute(nodeId);
             }
         }
     }
     triggerExternal(nodeId, event) {
-        const node = this.graphStructure.getNode(nodeId);
+        const node = this.graph.getNode(nodeId);
         if (!node)
             return;
-        // Forward event to node's onExternalEvent handler for custom actions
         node.runtime.onExternalEvent?.(event, node.state);
     }
-    dispose() {
-        // Resolve all pending run-context promises before cleanup
-        this.runContextManager.resolveAll();
-        for (const node of this.graphStructure.getNodes().values()) {
-            node.runtime.onDeactivated?.();
-            node.runtime.dispose?.();
-            node.lifecycle?.dispose?.({
-                state: node.state,
-                setState: (next) => Object.assign(node.state, next),
-            });
-        }
-        this.graphStructure.clear();
+    cancelNodeRuns(nodeIds) {
+        this.nodeExecutor.cancelNodeRuns(nodeIds);
     }
     getNodeIds() {
-        return Array.from(this.graphStructure.getNodes().keys());
+        return Array.from(this.graph.getNodes().keys());
     }
-    // Unsafe helpers for serializer: read-only accessors and hydration
     getNodeData(nodeId) {
-        const node = this.graphStructure.getNode(nodeId);
+        const node = this.graph.getNode(nodeId);
         if (!node)
             return undefined;
         return {
@@ -1951,16 +2163,14 @@ class GraphRuntime {
     setEnvironment(env) {
         this.environment = { ...env };
         this.handleResolver.setEnvironment(this.environment);
-        this.executionScheduler.setEnvironment(this.environment);
-        // Recompute dynamic handles for all nodes when environment changes
-        for (const nodeId of this.graphStructure.getNodes().keys()) {
+        this.nodeExecutor.setEnvironment(this.environment);
+        for (const nodeId of this.graph.getNodes().keys()) {
             this.handleResolver.scheduleRecomputeHandles(nodeId);
         }
     }
-    // Export a GraphDefinition reflecting the current runtime view
     getGraphDef() {
-        const nodes = Array.from(this.graphStructure.getNodes().values()).map((n) => {
-            const resolved = this.graphStructure.getResolvedHandles(n.nodeId);
+        const nodes = Array.from(this.graph.getNodes().values()).map((n) => {
+            const resolved = this.graph.getResolvedHandles(n.nodeId);
             return {
                 nodeId: n.nodeId,
                 typeId: n.typeId,
@@ -1968,18 +2178,15 @@ class GraphRuntime {
                 resolvedHandles: resolved ? { ...resolved } : undefined,
             };
         });
-        const edges = this.graphStructure
-            .getEdges()
-            .map((e) => ({
+        const edges = this.graph.getEdges().map((e) => ({
             id: e.id,
             source: { nodeId: e.source.nodeId, handle: e.source.handle },
             target: { nodeId: e.target.nodeId, handle: e.target.handle },
-            typeId: e.typeId, // Only export original typeId (may be undefined)
+            typeId: e.typeId,
         }));
         return { nodes, edges };
     }
     async whenIdle() {
-        // If we have active run-contexts, wait for all of them to complete
         const allRunContexts = this.runContextManager.getAllRunContexts();
         if (allRunContexts.size > 0) {
             await new Promise((resolve) => {
@@ -1995,7 +2202,7 @@ class GraphRuntime {
             });
         }
         const isIdle = () => {
-            for (const n of this.graphStructure.getNodes().values()) {
+            for (const n of this.graph.getNodes().values()) {
                 if (n.activeControllers.size > 0)
                     return false;
                 if (n.queue.length > 0)
@@ -2015,97 +2222,51 @@ class GraphRuntime {
             setTimeout(check, 10);
         });
     }
-    /**
-     * Run this node and optionally all dynamically reachable downstream nodes as a run-context.
-     * Includes nodes added later behind the same path (via re-emits).
-     * @param startNodeId - The node to start execution from
-     * @param options - Execution options
-     * @param options.skipPropagateValues - If true, don't set inputs of linked nodes (default: false)
-     * @param options.propagate - If false, don't schedule downstream nodes (default: true)
-     */
     async runFromHereContext(startNodeId, options) {
-        const node = this.graphStructure.getNode(startNodeId);
-        if (!node) {
-            // Node doesn't exist - resolve immediately
-            return;
-        }
-        const ctx = this.runContextManager.createRunContext(startNodeId, options);
-        // Create promise that resolves when context finishes
-        const promise = new Promise((resolve) => {
-            ctx.resolve = resolve;
-        });
-        // Temporarily unpause if needed
-        const wasPaused = this.paused;
-        if (wasPaused) {
-            this.paused = false;
-        }
-        try {
-            // Seed the start node with this run-context
-            node.activeRunContexts.add(ctx.id);
-            this.scheduleInputsChangedWithRunContexts(startNodeId, new Set([ctx.id]));
-            await promise;
-        }
-        finally {
-            // Restore pause state if it was paused and no other run-contexts are active
-            if (wasPaused && this.runContextManager.getAllRunContexts().size === 0) {
-                this.paused = true;
-            }
-        }
-    }
-    /**
-     * Schedule a node with run-context IDs attached
-     */
-    scheduleInputsChangedWithRunContexts(nodeId, runContextIds) {
-        const node = this.graphStructure.getNode(nodeId);
+        const node = this.graph.getNode(startNodeId);
         if (!node)
             return;
-        // Attach run-contexts to the node
-        for (const id of runContextIds) {
-            node.activeRunContexts.add(id);
-        }
-        this.executionScheduler.scheduleInputsChangedInternal(nodeId, runContextIds);
-    }
-    pause() {
-        this.paused = true;
-    }
-    isPaused() {
-        return this.paused;
+        return new Promise((resolve) => {
+            const id = this.runContextManager.createRunContext(startNodeId, resolve, options);
+            node.activeRunContextIds.add(id);
+            this.execute(startNodeId, new Set([id]));
+        });
     }
-    resume() {
-        this.paused = false;
+    setRunMode(runMode) {
+        this.runMode = runMode;
     }
-    invalidateDownstream(nodeId) {
-        this.valuePropagator.reemitNodeOutputs(nodeId);
+    getRunMode() {
+        return this.runMode;
     }
-    scheduleInputsChanged(nodeId) {
-        this.executionScheduler.scheduleInputsChangedInternal(nodeId);
+    requestPause() {
+        this.pauseRefCount++;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.pauseRefCount--;
+        };
     }
-    cancelNodeRuns(nodeIds) {
-        this.executionScheduler.cancelNodeRuns(nodeIds);
+    isPaused() {
+        return this.pauseRefCount > 0;
     }
     copyOutputs(fromNodeId, toNodeId, options) {
-        // Get outputs from source node
         const fromNode = this.getNodeData(fromNodeId);
         if (!fromNode?.outputs)
             return;
-        // Copy outputs to target node using hydrate
-        // hydrate already pauses internally, so we don't need to handle dry option here
-        // reemit: !options?.dry means don't propagate downstream if dry mode
-        this.hydrate({ outputs: { [toNodeId]: { ...fromNode.outputs } } }, { reemit: !options?.dry });
+        this.hydrate({ outputs: { [toNodeId]: { ...fromNode.outputs } } }, { invalidate: !options?.dry });
     }
-    // Hydrate inputs/outputs without triggering computation; optionally re-emit outputs downstream
     hydrate(payload, opts) {
-        const prevPaused = this.paused;
-        this.paused = true;
+        const releasePause = this.requestPause();
         try {
             const ins = payload?.inputs || {};
             for (const [nodeId, map] of Object.entries(ins)) {
-                const node = this.graphStructure.getNode(nodeId);
+                const node = this.graph.getNode(nodeId);
                 if (!node)
                     continue;
                 for (const [h, v] of Object.entries(map || {})) {
                     node.inputs[h] = structuredClone(v);
-                    // emit input value event
                     this.eventEmitter.emit("value", {
                         nodeId,
                         handle: h,
@@ -2117,12 +2278,11 @@ class GraphRuntime {
             }
             const outs = payload?.outputs || {};
             for (const [nodeId, map] of Object.entries(outs)) {
-                const node = this.graphStructure.getNode(nodeId);
+                const node = this.graph.getNode(nodeId);
                 if (!node)
                     continue;
                 for (const [h, v] of Object.entries(map || {})) {
                     node.outputs[h] = structuredClone(v);
-                    // emit output value event
                     this.eventEmitter.emit("value", {
                         nodeId,
                         handle: h,
@@ -2132,238 +2292,245 @@ class GraphRuntime {
                     });
                 }
             }
-            if (opts?.reemit) {
-                for (const nodeId of this.graphStructure.getNodes().keys()) {
-                    this.valuePropagator.reemitNodeOutputs(nodeId);
+            if (opts?.invalidate) {
+                for (const nodeId of this.graph.getNodes().keys()) {
+                    this.invalidateDownstream(nodeId);
                 }
             }
         }
         finally {
-            this.paused = prevPaused;
+            releasePause();
         }
     }
-    // Incrementally update nodes/edges to match new definition without full rebuild
     update(def, registry) {
-        // Handle node additions and removals
-        const desiredIds = new Set(def.nodes.map((n) => n.nodeId));
-        const currentIds = new Set(this.graphStructure.getNodes().keys());
-        // Remove nodes not present
-        for (const nodeId of Array.from(currentIds)) {
-            if (!desiredIds.has(nodeId)) {
-                const node = this.graphStructure.getNode(nodeId);
-                // Cancel all active runs and emit cancellation events
-                this.executionScheduler.cancelNodeActiveRuns(node, "node-deleted");
-                // Cancel node in all run-contexts (marks it as cancelled and clears activeRunContexts)
-                this.runContextManager.cancelNodeInRunContexts(nodeId, 
-                /* includeDownstream */ true, this.graphStructure.getEdges(), this.graphStructure.getNodes());
-                // Check for run-context completion (they may finish if pending reaches 0)
-                const allRunContexts = this.runContextManager.getAllRunContexts();
-                for (const ctx of Array.from(allRunContexts.values())) {
-                    if (ctx.pending === 0) {
-                        this.runContextManager.finishRunContext(ctx.id, this.graphStructure.getNodes());
-                    }
+        {
+            // Delete nodes that are no longer in the definition
+            const afterIds = new Set(def.nodes.map((n) => n.nodeId));
+            const beforeIds = new Set(this.graph.getNodes().keys());
+            for (const nodeId of Array.from(beforeIds)) {
+                if (!afterIds.has(nodeId)) {
+                    const node = this.graph.getNode(nodeId);
+                    this.nodeExecutor.cancelNodeActiveRuns(node, "node-deleted");
+                    this.runContextManager.cancelNodeInRunContexts(nodeId, true);
+                    node.runtime.onDeactivated?.();
+                    node.runtime.dispose?.();
+                    node.lifecycle?.dispose?.({
+                        state: node.state,
+                        setState: (next) => Object.assign(node.state, next),
+                    });
+                    this.graph.deleteNode(nodeId);
+                    this.edgePropagator.clearArrayBuckets(nodeId);
                 }
-                // Cleanup node resources
-                node.runtime.onDeactivated?.();
-                node.runtime.dispose?.();
-                node.lifecycle?.dispose?.({
-                    state: node.state,
-                    setState: (next) => Object.assign(node.state, next),
-                });
-                this.graphStructure.deleteNode(nodeId);
-                this.valuePropagator.clearArrayBuckets(nodeId);
             }
         }
-        // Add or update existing nodes
-        for (const n of def.nodes) {
-            const existing = this.graphStructure.getNode(n.nodeId);
-            if (!existing) {
-                // create new runtime node
-                const desc = registry.nodes.get(n.typeId);
-                if (!desc)
-                    throw new Error(`Unknown node type: ${n.typeId}`);
-                const cat = registry.categories.get(desc.categoryId);
-                if (!cat)
-                    throw new Error(`Unknown category: ${desc.categoryId}`);
-                if (cat.validateImpl)
-                    cat.validateImpl(desc.impl);
-                const runtime = cat.createRuntime({
-                    nodeId: n.nodeId,
-                    impl: desc.impl,
-                });
-                const rn = {
-                    typeId: n.typeId,
-                    nodeId: n.nodeId,
-                    lifecycle: desc.lifecycle,
-                    inputs: {},
-                    outputs: {},
-                    state: {},
-                    runtime,
-                    params: n.params,
-                    policy: {
-                        ...cat.policy,
-                        ...desc.policy,
-                        ...n.params?.policy,
-                    },
-                    runSeq: 0,
-                    activeControllers: new Set(),
-                    controllerRunIds: new Map(),
-                    queue: [],
-                    stats: {
-                        runs: 0,
-                        active: 0,
-                        queued: 0,
-                        progress: 0,
-                    },
-                    activeRunContexts: new Set(),
-                };
-                this.graphStructure.setNode(n.nodeId, rn);
-                // Activate new node
-                const effectiveInputs = this.executionScheduler.getEffectiveInputs(rn.nodeId);
-                const ctrl = new AbortController();
-                const ctx = this.executionScheduler.createExecutionContext(rn.nodeId, rn, effectiveInputs, `${rn.nodeId}:init`, ctrl.signal);
-                if (rn.lifecycle?.prepare) {
-                    ctx.log("debug", "prepare-start");
-                    rn.lifecycle.prepare(rn.params ?? {}, ctx);
-                    ctx.log("debug", "prepare-done");
-                }
-                rn.runtime.onActivated?.();
-            }
-            else {
-                // update params/policy
-                existing.params = n.params;
-                if (!existing.stats) {
-                    existing.stats = {
-                        runs: 0,
-                        active: 0,
-                        queued: 0,
-                        progress: 0,
+        {
+            // Add or update nodes that are in the definition
+            for (const n of def.nodes) {
+                const existing = this.graph.getNode(n.nodeId);
+                if (!existing) {
+                    const desc = registry.nodes.get(n.typeId);
+                    if (!desc)
+                        throw new Error(`Unknown node type: ${n.typeId}`);
+                    const cat = registry.categories.get(desc.categoryId);
+                    if (!cat)
+                        throw new Error(`Unknown category: ${desc.categoryId}`);
+                    if (cat.validateImpl)
+                        cat.validateImpl(desc.impl);
+                    const runtime = cat.createRuntime({
+                        nodeId: n.nodeId,
+                        impl: desc.impl,
+                    });
+                    const newNode = {
+                        typeId: n.typeId,
+                        nodeId: n.nodeId,
+                        lifecycle: desc.lifecycle,
+                        inputs: {},
+                        outputs: {},
+                        state: {},
+                        runtime,
+                        params: n.params,
+                        policy: {
+                            ...cat.policy,
+                            ...desc.policy,
+                            ...n.params?.policy,
+                        },
+                        runSeq: 0,
+                        activeControllers: new Set(),
+                        controllerRunIds: new Map(),
+                        queue: [],
+                        stats: {
+                            runs: 0,
+                            active: 0,
+                            queued: 0,
+                            progress: 0,
+                        },
+                        activeRunContextIds: new Set(),
                     };
+                    this.graph.setNode(n.nodeId, newNode);
+                    const effectiveInputs = this.nodeExecutor.getEffectiveInputs(newNode.nodeId);
+                    const ctrl = new AbortController();
+                    const ctx = this.nodeExecutor.createExecutionContext(newNode.nodeId, newNode, effectiveInputs, `${newNode.nodeId}:init`, ctrl.signal);
+                    if (newNode.lifecycle?.prepare) {
+                        ctx.log("debug", "prepare-start");
+                        newNode.lifecycle.prepare(newNode.params ?? {}, ctx);
+                        ctx.log("debug", "prepare-done");
+                    }
+                    newNode.runtime.onActivated?.();
+                }
+                else {
+                    existing.params = n.params;
+                    if (!existing.stats) {
+                        existing.stats = {
+                            runs: 0,
+                            active: 0,
+                            queued: 0,
+                            progress: 0,
+                        };
+                    }
                 }
             }
         }
-        // Capture previous inbound map before rebuilding edges
-        const edges = this.graphStructure.getEdges();
-        const prevInbound = new Map();
-        for (const e of edges) {
-            const set = prevInbound.get(e.target.nodeId) ?? new Set();
-            set.add(e.target.handle);
-            prevInbound.set(e.target.nodeId, set);
-        }
-        // Capture previous per-handle target sets before rebuilding edges
-        const prevOutTargets = new Map();
-        for (const e of edges) {
-            const tmap = prevOutTargets.get(e.source.nodeId) ?? new Map();
-            const tset = tmap.get(e.source.handle) ?? new Set();
-            tset.add(`${e.target.nodeId}.${e.target.handle}`);
-            tmap.set(e.source.handle, tset);
-            prevOutTargets.set(e.source.nodeId, tmap);
-        }
-        // Precompute per-node resolved handles for updated graph (include dynamic)
-        const resolved = GraphStructure.computeResolvedHandleMap(def, registry, this.environment);
-        // Check which handles changed and emit events for those
-        const changedHandles = {};
-        for (const [nodeId, newHandles] of resolved.map) {
-            const oldHandles = this.graphStructure.getResolvedHandles(nodeId);
-            if (!oldHandles ||
-                JSON.stringify(oldHandles) !== JSON.stringify(newHandles)) {
-                changedHandles[nodeId] = newHandles;
+        {
+            const beforeEdges = this.graph.getEdges();
+            const beforeInbound = new Map();
+            for (const e of beforeEdges) {
+                const set = beforeInbound.get(e.target.nodeId) ?? new Set();
+                set.add(e.target.handle);
+                beforeInbound.set(e.target.nodeId, set);
             }
-        }
-        // Update resolved handles
-        for (const [nodeId, handles] of resolved.map) {
-            this.graphStructure.setResolvedHandles(nodeId, handles);
-        }
-        // Rebuild edges mapping with coercions
-        const newEdges = GraphStructure.buildEdges(def, registry, this.graphStructure.getResolvedHandlesMap());
-        this.graphStructure.setEdges(newEdges);
-        // Build new inbound map
-        const nextInbound = new Map();
-        const updatedEdges = this.graphStructure.getEdges();
-        for (const e of updatedEdges) {
-            const set = nextInbound.get(e.target.nodeId) ?? new Set();
-            set.add(e.target.handle);
-            nextInbound.set(e.target.nodeId, set);
-        }
-        // For inputs that lost inbound connections, clear and schedule recompute
-        for (const [nodeId, prevSet] of prevInbound) {
-            const currSet = nextInbound.get(nodeId) ?? new Set();
-            const node = this.graphStructure.getNode(nodeId);
-            if (!node)
-                continue;
-            let changed = false;
-            for (const handle of Array.from(prevSet)) {
-                if (!currSet.has(handle)) {
-                    if (handle in node.inputs) {
-                        delete node.inputs[handle];
-                        changed = true;
+            const beforeOutTargets = new Map();
+            for (const e of beforeEdges) {
+                const tmap = beforeOutTargets.get(e.source.nodeId) ??
+                    new Map();
+                const tset = tmap.get(e.source.handle) ?? new Set();
+                tset.add(`${e.target.nodeId}.${e.target.handle}`);
+                tmap.set(e.source.handle, tset);
+                beforeOutTargets.set(e.source.nodeId, tmap);
+            }
+            {
+                // Update handles and edges
+                const result = tryHandleResolving(def, registry, this.environment);
+                const changedHandles = {};
+                for (const [nodeId, newHandles] of result.resolved) {
+                    const oldHandles = this.graph.getResolvedHandles(nodeId);
+                    if (!oldHandles ||
+                        JSON.stringify(oldHandles) !== JSON.stringify(newHandles)) {
+                        changedHandles[nodeId] = newHandles;
                     }
                 }
+                for (const [nodeId, handles] of result.resolved) {
+                    this.graph.setResolvedHandles(nodeId, handles);
+                }
+                const afterEdges = buildEdges(def, registry, this.graph.getResolvedHandlesMap());
+                this.graph.setEdges(afterEdges);
+                for (const nodeId of result.pending) {
+                    this.handleResolver.scheduleRecomputeHandles(nodeId);
+                }
+                if (Object.keys(changedHandles).length > 0) {
+                    this.eventEmitter.emit("invalidate", {
+                        reason: "graph-updated",
+                        resolvedHandles: changedHandles,
+                    });
+                }
             }
-            if (changed) {
-                // Clear buckets for handles that lost inbound (handled by ValuePropagator)
-                this.valuePropagator.clearArrayBuckets(nodeId);
-                this.executionScheduler.scheduleInputsChangedInternal(nodeId);
-            }
-        }
-        // Re-emit outputs when per-handle target sets change (precise and simple)
-        const nextOutTargets = new Map();
-        for (const e of updatedEdges) {
-            const tmap = nextOutTargets.get(e.source.nodeId) ?? new Map();
-            const tset = tmap.get(e.source.handle) ?? new Set();
-            tset.add(`${e.target.nodeId}.${e.target.handle}`);
-            tmap.set(e.source.handle, tset);
-            nextOutTargets.set(e.source.nodeId, tmap);
-        }
-        const setsEqualStr = (a, b) => {
-            if (!a && !b)
-                return true;
-            if (!a || !b)
-                return false;
-            if (a.size !== b.size)
-                return false;
-            for (const v of a)
-                if (!b.has(v))
-                    return false;
-            return true;
-        };
-        const nodesToCheck = new Set([
-            ...Array.from(prevOutTargets.keys()),
-            ...Array.from(nextOutTargets.keys()),
-        ]);
-        for (const nodeId of nodesToCheck) {
-            const pmap = prevOutTargets.get(nodeId) ?? new Map();
-            const nmap = nextOutTargets.get(nodeId) ?? new Map();
-            const handles = new Set([
-                ...Array.from(pmap.keys()),
-                ...Array.from(nmap.keys()),
-            ]);
-            for (const handle of handles) {
-                const pset = pmap.get(handle) ?? new Set();
-                const nset = nmap.get(handle) ?? new Set();
-                if (!setsEqualStr(pset, nset)) {
-                    const val = this.getOutput(nodeId, handle);
-                    if (val !== undefined)
-                        this.valuePropagator.propagate(nodeId, handle, val);
-                    else if (this.executionScheduler.allInboundHaveValue(nodeId))
-                        this.executionScheduler.scheduleInputsChangedInternal(nodeId);
+            {
+                // Update inputs and propagate changes
+                const afterInbound = new Map();
+                const afterEdges = this.graph.getEdges();
+                for (const e of afterEdges) {
+                    const set = afterInbound.get(e.target.nodeId) ?? new Set();
+                    set.add(e.target.handle);
+                    afterInbound.set(e.target.nodeId, set);
+                }
+                // Propagate changes on edges removed
+                for (const [nodeId, beforeSet] of beforeInbound) {
+                    const currSet = afterInbound.get(nodeId) ?? new Set();
+                    const node = this.graph.getNode(nodeId);
+                    if (!node)
+                        continue;
+                    let changed = false;
+                    for (const handle of Array.from(beforeSet)) {
+                        if (!currSet.has(handle)) {
+                            if (handle in node.inputs) {
+                                delete node.inputs[handle];
+                                changed = true;
+                            }
+                        }
+                    }
+                    if (changed) {
+                        this.edgePropagator.clearArrayBuckets(nodeId);
+                        if (this.runMode === "auto" &&
+                            this.graph.allInboundHaveValue(nodeId)) {
+                            this.execute(nodeId);
+                        }
+                    }
+                }
+                // Propagate changes on edges added
+                const afterOutTargets = new Map();
+                for (const e of afterEdges) {
+                    const targetMap = afterOutTargets.get(e.source.nodeId) ??
+                        new Map();
+                    const targetSet = targetMap.get(e.source.handle) ?? new Set();
+                    targetSet.add(`${e.target.nodeId}.${e.target.handle}`);
+                    targetMap.set(e.source.handle, targetSet);
+                    afterOutTargets.set(e.source.nodeId, targetMap);
+                }
+                const setsEqual = (a, b) => {
+                    if (!a && !b)
+                        return true;
+                    if (!a || !b)
+                        return false;
+                    if (a.size !== b.size)
+                        return false;
+                    for (const v of a)
+                        if (!b.has(v))
+                            return false;
+                    return true;
+                };
+                const nodesToCheck = new Set([
+                    ...Array.from(beforeOutTargets.keys()),
+                    ...Array.from(afterOutTargets.keys()),
+                ]);
+                for (const nodeId of nodesToCheck) {
+                    const beforeMap = beforeOutTargets.get(nodeId) ?? new Map();
+                    const afterMap = afterOutTargets.get(nodeId) ?? new Map();
+                    const handles = new Set([
+                        ...Array.from(beforeMap.keys()),
+                        ...Array.from(afterMap.keys()),
+                    ]);
+                    for (const handle of handles) {
+                        const beforeTargetSet = beforeMap.get(handle) ?? new Set();
+                        const afterTargetSet = afterMap.get(handle) ?? new Set();
+                        if (!setsEqual(beforeTargetSet, afterTargetSet)) {
+                            const val = this.getOutput(nodeId, handle);
+                            if (val !== undefined)
+                                this.propagate(nodeId, handle, val);
+                        }
+                    }
                 }
             }
         }
-        // Prune array bucket contributions for edges that no longer exist
-        // This is handled by ValuePropagator - array buckets are managed there
-        // The buckets will be cleaned up automatically when edges are removed
-        // Schedule async recompute for nodes that indicated Promise-based resolveHandles in this update
-        // Emit event for changed handles (if any)
-        if (Object.keys(changedHandles).length > 0) {
-            this.eventEmitter.emit("invalidate", {
-                reason: "graph-updated",
-                resolvedHandles: changedHandles,
+    }
+    dispose() {
+        this.runContextManager.resolveAll();
+        for (const node of this.graph.getNodes().values()) {
+            node.runtime.onDeactivated?.();
+            node.runtime.dispose?.();
+            node.lifecycle?.dispose?.({
+                state: node.state,
+                setState: (next) => Object.assign(node.state, next),
             });
         }
-        for (const nodeId of resolved.pending) {
-            this.handleResolver.scheduleRecomputeHandles(nodeId);
-        }
+        this.graph.clear();
+    }
+    execute(nodeId, runContextIds) {
+        this.nodeExecutor.execute(nodeId, runContextIds);
+    }
+    propagate(srcNodeId, srcHandle, value, runContextIds) {
+        this.edgePropagator.propagate(srcNodeId, srcHandle, value, runContextIds);
+    }
+    invalidateDownstream(nodeId) {
+        this.edgePropagator.invalidateDownstream(nodeId);
     }
 }
 
@@ -2585,21 +2752,25 @@ class GraphBuilder {
     }
 }
 
-class AbstractEngine {
-    constructor(graphRuntime) {
+/**
+ * Unified Engine implementation that handles both manual and auto run modes.
+ * - Manual mode: Nodes execute only when explicitly called via computeNode/runFromHere (unless paused)
+ * - Auto mode: Nodes automatically execute when inputs change (unless paused)
+ */
+class LocalEngine {
+    constructor(graphRuntime, runMode) {
         this.graphRuntime = graphRuntime;
+        this.setRunMode(runMode ?? "manual");
     }
     setInputs(nodeId, inputs, options) {
         if (options?.dry) {
-            const wasPaused = this.graphRuntime.isPaused();
-            if (!wasPaused)
-                this.graphRuntime.pause();
+            // Use requestPause to temporarily pause without affecting base run mode
+            const releasePause = this.graphRuntime.requestPause();
             try {
                 this.graphRuntime.setInputs(nodeId, inputs);
             }
             finally {
-                if (!wasPaused)
-                    this.graphRuntime.resume();
+                releasePause();
             }
         }
         else {
@@ -2608,15 +2779,13 @@ class AbstractEngine {
     }
     triggerExternal(nodeId, event, options) {
         if (options?.dry) {
-            const wasPaused = this.graphRuntime.isPaused();
-            if (!wasPaused)
-                this.graphRuntime.pause();
+            // Use requestPause to temporarily pause without affecting base run mode
+            const releasePause = this.graphRuntime.requestPause();
             try {
                 this.graphRuntime.triggerExternal(nodeId, event);
             }
             finally {
-                if (!wasPaused)
-                    this.graphRuntime.resume();
+                releasePause();
             }
         }
         else {
@@ -2641,19 +2810,6 @@ class AbstractEngine {
     dispose() {
         // this.graphRuntime.dispose();
     }
-}
-
-/**
- * Unified Engine implementation that handles both manual and auto run modes.
- * - Manual mode: Runtime is paused, nodes execute only when explicitly called via computeNode/runFromHere
- * - Auto mode: Runtime is resumed, nodes automatically execute when inputs change
- */
-class UnifiedEngine extends AbstractEngine {
-    constructor(graphRuntime, runMode) {
-        super(graphRuntime);
-        this.runMode = "manual";
-        this.setRunMode(runMode ?? "manual");
-    }
     launch(invalidate, runMode) {
         if (runMode)
             this.setRunMode(runMode);
@@ -2680,20 +2836,8 @@ class UnifiedEngine extends AbstractEngine {
     async runFromHere(nodeId) {
         await this.graphRuntime.runFromHereContext(nodeId);
     }
-    getRunMode() {
-        return this.runMode;
-    }
     setRunMode(runMode) {
-        if (this.runMode === runMode)
-            return;
-        this.runMode = runMode;
-        // Update runtime pause/resume state based on new mode
-        if (runMode === "manual") {
-            this.graphRuntime.pause();
-        }
-        else {
-            this.graphRuntime.resume();
-        }
+        this.graphRuntime.setRunMode(runMode);
     }
 }
 
@@ -4240,6 +4384,58 @@ function setValueAtPath(obj, pathSegments, newValue) {
     }
     return true;
 }
+/**
+ * Sets a value at a path, creating intermediate objects as needed.
+ * Mutates the root object in place.
+ * @param root - The root object to modify (must be an object, will be initialized if needed)
+ * @param pathSegments - The path segments to traverse
+ * @param value - The value to set, or null to delete the path
+ * @throws Error if path cannot be created (e.g., array indices not supported, invalid parent types)
+ */
+function setValueAtPathWithCreation(root, pathSegments, value) {
+    if (value === null) {
+        const result = getValueAtPath(root, pathSegments);
+        if (result && result.parent !== null && !Array.isArray(result.parent)) {
+            delete result.parent[result.key];
+        }
+        return;
+    }
+    if (!root || typeof root !== "object" || Array.isArray(root)) {
+        throw new Error("Root must be an object");
+    }
+    let current = root;
+    for (let i = 0; i < pathSegments.length - 1; i++) {
+        const segment = pathSegments[i];
+        if (typeof segment === "string") {
+            if (!current ||
+                typeof current !== "object" ||
+                Array.isArray(current) ||
+                !(segment in current) ||
+                typeof current[segment] !== "object" ||
+                current[segment] === null ||
+                Array.isArray(current[segment])) {
+                if (!current || typeof current !== "object" || Array.isArray(current)) {
+                    throw new Error(`Cannot create path: parent at segment ${i} is not an object`);
+                }
+                current[segment] = {};
+            }
+            current = current[segment];
+        }
+        else {
+            throw new Error("Array indices not supported in extData paths");
+        }
+    }
+    const lastSegment = pathSegments[pathSegments.length - 1];
+    if (typeof lastSegment === "string") {
+        if (!current || typeof current !== "object" || Array.isArray(current)) {
+            throw new Error(`Cannot set value: parent at final segment is not an object`);
+        }
+        current[lastSegment] = value;
+    }
+    else {
+        throw new Error("Array indices not supported in extData paths");
+    }
+}
 function findMatchingPaths(obj, pathSegments, currentPath = []) {
     if (pathSegments.length === 0) {
         return [{ path: currentPath, value: obj }];
@@ -4781,8 +4977,8 @@ exports.CompositeCategory = CompositeCategory;
 exports.ComputeCategory = ComputeCategory;
 exports.GraphBuilder = GraphBuilder;
 exports.GraphRuntime = GraphRuntime;
+exports.LocalEngine = LocalEngine;
 exports.Registry = Registry;
-exports.UnifiedEngine = UnifiedEngine;
 exports.buildValueConverter = buildValueConverter;
 exports.computeGraphCenter = computeGraphCenter;
 exports.createAsyncGraphDef = createAsyncGraphDef;
@@ -4811,5 +5007,6 @@ exports.parseJsonPath = parseJsonPath;
 exports.registerDelayNode = registerDelayNode;
 exports.registerProgressNodes = registerProgressNodes;
 exports.setValueAtPath = setValueAtPath;
+exports.setValueAtPathWithCreation = setValueAtPathWithCreation;
 exports.typed = typed;
 //# sourceMappingURL=index.cjs.map