@bian-womp/spark-graph 0.3.12 → 0.3.14

package/lib/esm/index.js

@@ -444,6 +444,7 @@ Registry.idCounter = 0;
 
 /**
  * Graph component - manages nodes, edges, and handle resolution
+ * This is the ONLY place where nodes, edges, and resolvedByNode are directly updated.
  */
 class Graph {
     constructor(registry) {
@@ -452,46 +453,423 @@ class Graph {
         this.edges = [];
         this.resolvedByNode = new Map();
     }
-    // Node accessors
+    // ==================== Node Accessors ====================
+    /**
+     * Get a node by ID (readonly to prevent accidental modifications)
+     */
     getNode(nodeId) {
         return this.nodes.get(nodeId);
     }
-    getNodes() {
-        return this.nodes;
+    /**
+     * Get a node by ID (mutable, for internal use only)
+     * @internal
+     */
+    getNodeMutable(nodeId) {
+        return this.nodes.get(nodeId);
+    }
+    /**
+     * Iterate over all nodes safely (readonly to prevent accidental modifications)
+     */
+    forEachNode(callback) {
+        for (const [nodeId, node] of this.nodes.entries()) {
+            callback(node, nodeId);
+        }
+    }
+    /**
+     * Get all node IDs
+     */
+    getNodeIds() {
+        return Array.from(this.nodes.keys());
+    }
+    /**
+     * Check if a node exists
+     */
+    hasNode(nodeId) {
+        return this.nodes.has(nodeId);
     }
+    // ==================== Node Mutators ====================
+    /**
+     * Set a node (creates or replaces)
+     */
     setNode(nodeId, node) {
         this.nodes.set(nodeId, node);
     }
+    /**
+     * Delete a node
+     */
     deleteNode(nodeId) {
         this.nodes.delete(nodeId);
     }
-    hasNode(nodeId) {
-        return this.nodes.has(nodeId);
+    // ==================== Node Property Updates ====================
+    /**
+     * Update node inputs
+     */
+    updateNodeInput(nodeId, handle, value) {
+        const node = this.getNodeMutable(nodeId);
+        if (!node)
+            return;
+        if (value === undefined) {
+            delete node.inputs[handle];
+        }
+        else {
+            node.inputs[handle] = value;
+        }
+    }
+    /**
+     * Delete a node input handle
+     */
+    deleteNodeInput(nodeId, handle) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        delete node.inputs[handle];
+    }
+    /**
+     * Update node outputs
+     */
+    updateNodeOutput(nodeId, handle, value) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.outputs[handle] = value;
+    }
+    /**
+     * Update node state
+     */
+    updateNodeState(nodeId, updates) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        Object.assign(node.state, updates);
+    }
+    /**
+     * Update node params
+     */
+    updateNodeParams(nodeId, params) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.params = params;
+    }
+    /**
+     * Update node policy
+     */
+    updateNodePolicy(nodeId, policy) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.policy = { ...node.policy, ...policy };
+    }
+    /**
+     * Update node stats
+     */
+    updateNodeStats(nodeId, updates) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        Object.assign(node.stats, updates);
+    }
+    /**
+     * Increment node runSeq
+     */
+    incrementNodeRunSeq(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return 0;
+        node.runSeq += 1;
+        return node.runSeq;
+    }
+    /**
+     * Set node latestRunId
+     */
+    setNodeLatestRunId(nodeId, runId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.latestRunId = runId;
+    }
+    /**
+     * Set node lastScheduledAt
+     */
+    setNodeLastScheduledAt(nodeId, timestamp) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.lastScheduledAt = timestamp;
+    }
+    /**
+     * Update node lastInputAt timestamp for a handle
+     */
+    updateNodeLastInputAt(nodeId, handle, timestamp) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        if (!node.lastInputAt) {
+            node.lastInputAt = {};
+        }
+        node.lastInputAt[handle] = timestamp;
+    }
+    /**
+     * Set node lastSuccessAt timestamp
+     */
+    setNodeLastSuccessAt(nodeId, timestamp) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.lastSuccessAt = timestamp;
+    }
+    // ==================== Node Queue Operations ====================
+    /**
+     * Add item to node queue
+     */
+    addToNodeQueue(nodeId, item) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.queue.push(item);
+    }
+    /**
+     * Remove first item from node queue
+     */
+    shiftNodeQueue(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return undefined;
+        return node.queue.shift();
+    }
+    /**
+     * Clear node queue
+     */
+    clearNodeQueue(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.queue = [];
+    }
+    /**
+     * Replace node queue
+     */
+    replaceNodeQueue(nodeId, items) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.queue = items;
+    }
+    // ==================== Node Controller Operations ====================
+    /**
+     * Add controller to node
+     */
+    addNodeController(nodeId, controller, runId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.activeControllers.add(controller);
+        node.controllerRunIds.set(controller, runId);
+    }
+    /**
+     * Remove controller from node
+     */
+    removeNodeController(nodeId, controller) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.activeControllers.delete(controller);
+        node.controllerRunIds.delete(controller);
+    }
+    /**
+     * Clear all controllers from node
+     */
+    clearNodeControllers(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.activeControllers.clear();
+        node.controllerRunIds.clear();
+    }
+    /**
+     * Get all controllers for a node
+     */
+    getNodeControllers(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return new Set();
+        return new Set(node.activeControllers);
+    }
+    // ==================== Node Run Context Operations ====================
+    /**
+     * Add run context ID to node
+     */
+    addNodeRunContextId(nodeId, runContextId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.activeRunContextIds.add(runContextId);
+    }
+    /**
+     * Add multiple run context IDs to node
+     */
+    addNodeRunContextIds(nodeId, runContextIds) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        for (const id of runContextIds) {
+            node.activeRunContextIds.add(id);
+        }
+    }
+    /**
+     * Remove run context ID from node
+     */
+    removeNodeRunContextId(nodeId, runContextId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.activeRunContextIds.delete(runContextId);
+    }
+    /**
+     * Clear all run context IDs from node
+     */
+    clearNodeRunContextIds(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        node.activeRunContextIds.clear();
+    }
+    /**
+     * Get run context IDs for a node
+     */
+    getNodeRunContextIds(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return new Set();
+        return new Set(node.activeRunContextIds);
+    }
+    // ==================== Node Snapshot Cancelled Run IDs ====================
+    /**
+     * Add snapshot cancelled run ID to node
+     */
+    addSnapshotCancelledRunId(nodeId, runId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        if (!node.snapshotCancelledRunIds) {
+            node.snapshotCancelledRunIds = new Set();
+        }
+        node.snapshotCancelledRunIds.add(runId);
+    }
+    // ==================== Edge Accessors ====================
+    /**
+     * Iterate over all edges safely
+     */
+    forEachEdge(callback) {
+        this.edges.forEach(callback);
     }
-    // Edge accessors
-    getEdges() {
-        return this.edges;
+    /**
+     * Find edges matching a predicate
+     */
+    findEdges(predicate) {
+        return this.edges.filter(predicate);
+    }
+    /**
+     * Get edges by source node and handle
+     */
+    getEdgesBySource(srcNodeId, srcHandle) {
+        return this.edges.filter((e) => e.source.nodeId === srcNodeId && e.source.handle === srcHandle);
+    }
+    /**
+     * Get edges by target node and handle
+     */
+    getEdgesByTarget(targetNodeId, targetHandle) {
+        return this.edges.filter((e) => e.target.nodeId === targetNodeId && e.target.handle === targetHandle);
+    }
+    /**
+     * Get inbound edges for a node
+     */
+    getInboundEdges(nodeId) {
+        return this.edges.filter((e) => e.target.nodeId === nodeId);
     }
+    /**
+     * Get outbound edges for a node
+     */
+    getOutboundEdges(nodeId) {
+        return this.edges.filter((e) => e.source.nodeId === nodeId);
+    }
+    // ==================== Edge Mutators ====================
+    /**
+     * Set all edges (replaces existing)
+     */
     setEdges(edges) {
-        this.edges = edges;
+        this.edges = [...edges];
     }
-    // Registry accessor
+    /**
+     * Update an edge by ID
+     */
+    updateEdge(edgeId, updates) {
+        const edge = this.edges.find((e) => e.id === edgeId);
+        if (!edge)
+            return;
+        Object.assign(edge, updates);
+    }
+    /**
+     * Update edge properties (convert, convertAsync, types, etc.)
+     */
+    updateEdgeProperties(edgeId, updates) {
+        const edge = this.edges.find((e) => e.id === edgeId);
+        if (!edge)
+            return;
+        if (updates.effectiveTypeId !== undefined) {
+            edge.effectiveTypeId = updates.effectiveTypeId;
+        }
+        if (updates.dstDeclared !== undefined) {
+            edge.dstDeclared = updates.dstDeclared;
+        }
+        if (updates.srcUnionTypes !== undefined) {
+            edge.srcUnionTypes = updates.srcUnionTypes;
+        }
+        if (updates.convert !== undefined) {
+            edge.convert = updates.convert;
+        }
+        if (updates.convertAsync !== undefined) {
+            edge.convertAsync = updates.convertAsync;
+        }
+    }
+    /**
+     * Update edge stats
+     */
+    updateEdgeStats(edgeId, updates) {
+        const edge = this.edges.find((e) => e.id === edgeId);
+        if (!edge)
+            return;
+        Object.assign(edge.stats, updates);
+    }
+    /**
+     * Get edge by ID
+     */
+    getEdge(edgeId) {
+        return this.edges.find((e) => e.id === edgeId);
+    }
+    // ==================== Registry Accessors ====================
     getRegistry() {
         return this.registry;
     }
     setRegistry(registry) {
         this.registry = registry;
     }
-    // Resolved handles accessors
+    // ==================== Resolved Handles Accessors ====================
     getResolvedHandles(nodeId) {
         return this.resolvedByNode.get(nodeId);
     }
     setResolvedHandles(nodeId, handles) {
         this.resolvedByNode.set(nodeId, handles);
     }
-    getResolvedHandlesMap() {
-        return this.resolvedByNode;
+    /**
+     * Iterate over resolved handles safely
+     */
+    forEachResolvedHandles(callback) {
+        for (const [nodeId, handles] of this.resolvedByNode.entries()) {
+            callback(handles, nodeId);
+        }
     }
+    // ==================== Utility Methods ====================
     /**
      * Check if all inbound edges for a node have values
      */
@@ -508,7 +886,10 @@ class Graph {
         }
         return true;
     }
-    // Clear all data
+    // ==================== Clear Operations ====================
+    /**
+     * Clear all data
+     */
     clear() {
         this.nodes.clear();
         this.edges = [];
@@ -648,9 +1029,9 @@ class RunContextManager {
             return; // Still has pending work
         }
         // Clean up activeRunContexts from all nodes
-        for (const node of this.graph.getNodes().values()) {
-            node.activeRunContextIds.delete(id);
-        }
+        this.graph.forEachNode((node) => {
+            this.graph.removeNodeRunContextId(node.nodeId, id);
+        });
         this.runContexts.delete(id);
         if (ctx.resolve)
             ctx.resolve();
@@ -673,7 +1054,7 @@ class RunContextManager {
                 if (visited.has(cur))
                     continue;
                 visited.add(cur);
-                for (const e of this.graph.getEdges()) {
+                this.graph.forEachEdge((e) => {
                     if (e.source.nodeId === cur) {
                         const targetId = e.target.nodeId;
                         if (!visited.has(targetId)) {
@@ -681,7 +1062,7 @@ class RunContextManager {
                             queue.push(targetId);
                         }
                     }
-                }
+                });
             }
         }
         // Mark nodes as cancelled in all run-contexts
@@ -692,9 +1073,7 @@ class RunContextManager {
         }
         // Clear activeRunContexts for cancelled nodes
         for (const id of toCancel) {
-            const node = this.graph.getNode(id);
-            if (node)
-                node.activeRunContextIds.clear();
+            this.graph.clearNodeRunContextIds(id);
         }
     }
     /**
@@ -972,13 +1351,14 @@ class HandleResolver {
         if (!node)
             return;
         // Track resolver start for all active run-contexts
-        if (node.activeRunContextIds && node.activeRunContextIds.size > 0) {
-            for (const runContextId of node.activeRunContextIds) {
+        const activeRunContextIds = this.graph.getNodeRunContextIds(nodeId);
+        if (activeRunContextIds.size > 0) {
+            for (const runContextId of activeRunContextIds) {
                 this.runContextManager.startHandleResolution(runContextId, nodeId);
             }
         }
         setTimeout(() => {
-            void this.recomputeHandlesForNode(nodeId, node.activeRunContextIds);
+            void this.recomputeHandlesForNode(nodeId, activeRunContextIds.size > 0 ? activeRunContextIds : undefined);
         }, 0);
     }
     // Update resolved handles for a single node and refresh edge converters/types that touch it
@@ -989,30 +1369,33 @@ class HandleResolver {
         if (!node)
             return;
         this.graph.setResolvedHandles(nodeId, handles);
-        const edges = this.graph.getEdges();
-        const resolvedByNode = this.graph.getResolvedHandlesMap();
-        for (const e of edges) {
+        const resolvedByNode = new Map();
+        this.graph.forEachResolvedHandles((handles, nodeId) => {
+            resolvedByNode.set(nodeId, handles);
+        });
+        const registry = this.registry; // Store for use in callback
+        this.graph.forEachEdge((e, _index) => {
             // Only update edges that touch the changed node
             const touchesChangedNode = e.source.nodeId === nodeId || e.target.nodeId === nodeId;
             if (!touchesChangedNode)
-                continue;
+                return;
             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;
+            const conv = buildEdgeConverters(srcDeclared, dstDeclared, registry, `updateNodeHandles: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
+            // Update edge properties via Graph
+            this.graph.updateEdgeProperties(e.id, {
+                effectiveTypeId: !e.typeId ? effectiveTypeId : undefined,
+                dstDeclared,
+                srcUnionTypes: Array.isArray(srcDeclared)
+                    ? [...srcDeclared]
+                    : undefined,
+                convert: conv.convert,
+                convertAsync: conv.convertAsync,
+            });
             if (e.target.nodeId === nodeId &&
                 oldDstDeclared === undefined &&
                 dstDeclared !== undefined) {
@@ -1020,11 +1403,12 @@ class HandleResolver {
                 if (srcNode) {
                     const srcValue = srcNode.outputs[e.source.handle];
                     if (srcValue !== undefined) {
-                        this.edgePropagator.propagate(e.source.nodeId, e.source.handle, srcValue, srcNode.activeRunContextIds);
+                        const activeRunContextIds = this.graph.getNodeRunContextIds(e.source.nodeId);
+                        this.edgePropagator.propagate(e.source.nodeId, e.source.handle, srcValue, activeRunContextIds.size > 0 ? activeRunContextIds : undefined);
                     }
                 }
             }
-        }
+        });
         this.edgePropagator.invalidateDownstream(nodeId);
     }
     /**
@@ -1163,12 +1547,11 @@ class EdgePropagator {
      * Set source output value and emit event
      */
     setSourceOutput(srcNodeId, srcHandle, value) {
-        const srcNode = this.graph.getNode(srcNodeId);
-        if (!srcNode) {
+        if (!this.graph.hasNode(srcNodeId)) {
             // Node was removed (e.g., graph updated) but an async emit arrived late; ignore
             return false;
         }
-        srcNode.outputs[srcHandle] = value;
+        this.graph.updateNodeOutput(srcNodeId, srcHandle, value);
         this.eventEmitter.emit("value", {
             nodeId: srcNodeId,
             handle: srcHandle,
@@ -1182,8 +1565,7 @@ class EdgePropagator {
      * 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);
+        return this.graph.getEdgesBySource(srcNodeId, srcHandle);
     }
     /**
      * Propagate value to a single edge
@@ -1282,9 +1664,12 @@ class EdgePropagator {
         });
         const controller = new AbortController();
         const startAt = Date.now();
-        edge.stats.runs += 1;
-        edge.stats.inFlight = true;
-        edge.stats.progress = 0;
+        const currentStats = edge.stats;
+        this.graph.updateEdgeStats(edge.id, {
+            runs: currentStats.runs + 1,
+            inFlight: true,
+            progress: 0,
+        });
         edge
             .convertAsync(value, controller.signal)
             .then((converted) => {
@@ -1340,10 +1725,7 @@ class EdgePropagator {
         else if (shouldSetValue && !valueChanged) {
             // Even if value didn't change, update timestamp if we're forcing execution
             const now = Date.now();
-            if (!dstNode.lastInputAt) {
-                dstNode.lastInputAt = {};
-            }
-            dstNode.lastInputAt[edge.target.handle] = now;
+            this.graph.updateNodeLastInputAt(edge.target.nodeId, edge.target.handle, now);
         }
         // Schedule downstream execution
         this.executeDownstream(edge.target.nodeId, effectiveRunContexts);
@@ -1369,15 +1751,12 @@ class EdgePropagator {
         }
         forHandle.set(edge.id, toArray(value));
         // Merge all parts for this handle
-        const edges = this.graph.getEdges();
+        const targetEdges = this.graph.getEdgesByTarget(edge.target.nodeId, edge.target.handle);
         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);
-            }
+        for (const ed of targetEdges) {
+            const part = forHandle.get(ed.id);
+            if (part && part.length)
+                merged.push(...part);
         }
         return merged;
     }
@@ -1402,12 +1781,8 @@ class EdgePropagator {
      */
     setTargetInput(edge, dstNode, value) {
         const now = Date.now();
-        dstNode.inputs[edge.target.handle] = value;
-        // Track when this input was set
-        if (!dstNode.lastInputAt) {
-            dstNode.lastInputAt = {};
-        }
-        dstNode.lastInputAt[edge.target.handle] = now;
+        this.graph.updateNodeInput(edge.target.nodeId, edge.target.handle, value);
+        this.graph.updateNodeLastInputAt(edge.target.nodeId, edge.target.handle, now);
         this.eventEmitter.emit("value", {
             nodeId: edge.target.nodeId,
             handle: edge.target.handle,
@@ -1447,9 +1822,13 @@ class EdgePropagator {
      * Update edge stats on successful conversion
      */
     updateEdgeStatsOnSuccess(edge, startAt) {
-        edge.stats.inFlight = false;
         const duration = Date.now() - startAt;
-        edge.stats.lastDurationMs = duration;
+        this.graph.updateEdgeStats(edge.id, {
+            inFlight: false,
+            lastDurationMs: duration,
+            lastEndAt: Date.now(),
+            lastError: undefined,
+        });
         this.eventEmitter.emit("stats", {
             kind: "edge-done",
             edgeId: edge.id,
@@ -1458,15 +1837,15 @@ class EdgePropagator {
             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.graph.updateEdgeStats(edge.id, {
+            inFlight: false,
+            lastError: err,
+        });
         this.eventEmitter.emit("error", {
             kind: "edge-convert",
             edgeId: edge.id,
@@ -1499,10 +1878,11 @@ class EdgePropagator {
             ? new Set(Object.keys(resolved.outputs))
             : new Set();
         // Use node's activeRunContexts to propagate to new nodes that were added
+        const activeRunContextIds = this.graph.getNodeRunContextIds(nodeId);
         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, node.activeRunContextIds);
+                this.propagate(nodeId, handle, value, activeRunContextIds.size > 0 ? activeRunContextIds : undefined);
             }
         }
     }
@@ -1563,10 +1943,8 @@ class NodeExecutor {
         // Start with real inputs only (no defaults)
         const effective = { ...node.inputs };
         // Build set of inbound handles (wired inputs)
-        const edges = this.graph.getEdges();
-        const inbound = new Set(edges
-            .filter((e) => e.target.nodeId === nodeId)
-            .map((e) => e.target.handle));
+        const inboundEdges = this.graph.getInboundEdges(nodeId);
+        const inbound = new Set(inboundEdges.map((e) => e.target.handle));
         // Apply defaults only for:
         // 1. Unbound handles that have no explicit value
         // 2. Static handles (not dynamically resolved)
@@ -1594,7 +1972,9 @@ class NodeExecutor {
             });
         const reportProgress = options?.reportProgress ??
             ((p) => {
-                node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
+                this.graph.updateNodeStats(nodeId, {
+                    progress: Math.max(0, Math.min(1, Number(p) || 0)),
+                });
             });
         // Create log function that respects node's logLevel
         const log = (level, message, context) => {
@@ -1628,7 +2008,7 @@ class NodeExecutor {
         return {
             nodeId,
             state: node.state,
-            setState: (next) => Object.assign(node.state, next),
+            setState: (next) => this.graph.updateNodeState(nodeId, next),
             emit: emitHandler,
             invalidateDownstream: () => {
                 this.edgePropagator.invalidateDownstream(nodeId);
@@ -1688,10 +2068,12 @@ class NodeExecutor {
         if (this.runtime.isPaused())
             return;
         // Attach run-context IDs if provided
-        this.attachRunContexts(node, runContextIds);
+        if (runContextIds) {
+            this.graph.addNodeRunContextIds(nodeId, runContextIds);
+        }
         // Handle debouncing
         const now = Date.now();
-        if (this.shouldDebounce(node, now)) {
+        if (this.shouldDebounce(nodeId, node, now)) {
             this.handleDebouncedSchedule(node, nodeId, now);
             return;
         }
@@ -1700,44 +2082,35 @@ class NodeExecutor {
         // 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) {
+    shouldDebounce(nodeId, node, now) {
         const policy = node.policy ?? {};
+        const lastScheduledAt = node.lastScheduledAt;
         return !!(policy.debounceMs &&
-            node.lastScheduledAt &&
-            now - node.lastScheduledAt < policy.debounceMs);
+            lastScheduledAt &&
+            now - 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 });
+        const runSeq = this.graph.incrementNodeRunSeq(nodeId);
+        const rid = `${nodeId}:${runSeq}:${now}`;
+        this.graph.replaceNodeQueue(nodeId, [
+            { 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;
+        this.graph.setNodeLastScheduledAt(nodeId, now);
+        const runSeq = this.graph.incrementNodeRunSeq(nodeId);
+        const runId = `${nodeId}:${runSeq}:${now}`;
+        this.graph.setNodeLatestRunId(nodeId, runId);
         const effectiveInputs = this.getEffectiveInputs(nodeId);
         // Take a shallow snapshot of the current policy for this run
         const policySnapshot = node.policy ? { ...node.policy } : undefined;
@@ -1784,9 +2157,16 @@ class NodeExecutor {
      */
     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();
+        const currentNode = this.graph.getNode(nodeId);
+        if (!currentNode)
+            return;
+        this.graph.addToNodeQueue(nodeId, {
+            runId: plan.runId,
+            inputs: plan.effectiveInputs,
+        });
+        if (currentNode.queue.length > maxQ) {
+            this.graph.shiftNodeQueue(nodeId);
+        }
         this.processQueue(node, nodeId);
     }
     /**
@@ -1794,17 +2174,21 @@ class NodeExecutor {
      */
     processQueue(node, nodeId) {
         const processNext = () => {
+            const node = this.graph.getNode(nodeId);
+            if (!node)
+                return;
             if (node.activeControllers.size > 0)
                 return;
-            const next = node.queue.shift();
+            const next = this.graph.shiftNodeQueue(nodeId);
             if (!next)
                 return;
-            node.latestRunId = next.runId;
+            this.graph.setNodeLatestRunId(nodeId, next.runId);
             const policySnapshot = node.policy ? { ...node.policy } : undefined;
+            const activeRunContextIds = this.graph.getNodeRunContextIds(nodeId);
             const plan = {
                 runId: next.runId,
                 effectiveInputs: next.inputs,
-                runContextIdsForRun: node.activeRunContextIds,
+                runContextIdsForRun: activeRunContextIds.size > 0 ? activeRunContextIds : undefined,
                 timestamp: Date.now(),
                 policy: policySnapshot,
             };
@@ -1821,9 +2205,9 @@ class NodeExecutor {
         // Track run-contexts
         this.trackRunContextStart(nodeId, plan.runContextIdsForRun);
         // Setup execution controller
-        const controller = this.createExecutionController(node, plan.runId);
+        const controller = this.createExecutionController(nodeId, node, plan.runId);
         // Handle concurrency mode
-        this.applyConcurrencyMode(node, controller, plan);
+        this.applyConcurrencyMode(nodeId, node, controller, plan);
         // Setup timeout if needed
         const timeoutId = this.setupTimeout(node, controller, plan);
         // Create execution context
@@ -1844,23 +2228,26 @@ class NodeExecutor {
     /**
      * Create execution controller and update node stats
      */
-    createExecutionController(node, runId) {
+    createExecutionController(nodeId, 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);
+        const now = Date.now();
+        this.graph.updateNodeStats(nodeId, {
+            runs: node.stats.runs + 1,
+            active: node.stats.active + 1,
+            lastStartAt: now,
+            progress: 0,
+        });
+        this.graph.addNodeController(nodeId, controller, runId);
         return controller;
     }
     /**
      * Apply concurrency mode (switch mode aborts other controllers)
      */
-    applyConcurrencyMode(node, controller, plan) {
+    applyConcurrencyMode(nodeId, node, controller, plan) {
         const mode = plan.policy?.asyncConcurrency ?? "switch";
         if (mode === "switch") {
-            for (const c of Array.from(node.activeControllers)) {
+            const controllers = this.graph.getNodeControllers(nodeId);
+            for (const c of controllers) {
                 if (c !== controller)
                     c.abort("switch");
             }
@@ -1883,6 +2270,9 @@ class NodeExecutor {
         const policy = plan.policy ?? {};
         return {
             emitHandler: (handle, value) => {
+                const node = this.graph.getNode(nodeId);
+                if (!node)
+                    return;
                 const m = policy.asyncConcurrency ?? "switch";
                 // Drop emits from runs that were explicitly cancelled due to a
                 // snapshot/undo/redo operation, regardless of asyncConcurrency.
@@ -1893,13 +2283,17 @@ class NodeExecutor {
                 this.edgePropagator.propagate(nodeId, handle, value, plan.runContextIdsForRun);
             },
             reportProgress: (p) => {
-                node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
+                const progress = Math.max(0, Math.min(1, Number(p) || 0));
+                this.graph.updateNodeStats(nodeId, { progress });
+                const node = this.graph.getNode(nodeId);
+                if (!node)
+                    return;
                 this.eventEmitter.emit("stats", {
                     kind: "node-progress",
                     nodeId,
                     typeId: node.typeId,
                     runId: plan.runId,
-                    progress: node.stats.progress,
+                    progress,
                 });
             },
         };
@@ -1938,7 +2332,7 @@ class NodeExecutor {
                     }
                 }
                 hadError = true;
-                node.stats.lastError = err;
+                this.graph.updateNodeStats(nodeId, { lastError: err });
                 const retry = plan.policy?.retry;
                 if (retry && attempt < (retry.attempts ?? 0)) {
                     const delay = retry.backoffMs ? retry.backoffMs(attempt) : 0;
@@ -1974,38 +2368,53 @@ class NodeExecutor {
         }
         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;
+        this.graph.removeNodeController(nodeId, controller);
+        const currentNode = this.graph.getNode(nodeId);
+        if (!currentNode)
+            return;
+        const controllers = this.graph.getNodeControllers(nodeId);
+        const lastEndAt = Date.now();
+        const lastDurationMs = currentNode.stats.lastStartAt && lastEndAt
+            ? lastEndAt - currentNode.stats.lastStartAt
+            : undefined;
+        this.graph.updateNodeStats(nodeId, {
+            active: Math.max(0, controllers.size),
+            lastEndAt,
+            lastDurationMs,
+            lastError: hadError ? currentNode.stats.lastError : undefined,
+        });
         // Track successful completion time (for detecting stale inputs)
         const isCancelled = controller.signal.aborted &&
             (controller.signal.reason === "snapshot" ||
                 controller.signal.reason === "node-deleted" ||
                 controller.signal.reason === "user-cancelled");
         if (!hadError && !isCancelled) {
-            node.lastSuccessAt = Date.now();
+            this.graph.setNodeLastSuccessAt(nodeId, Date.now());
         }
         // Only emit node-done if not cancelled (cancellation events emitted separately)
         if (!isCancelled) {
-            this.eventEmitter.emit("stats", {
-                kind: "node-done",
-                nodeId,
-                typeId: node.typeId,
-                runId: plan.runId,
-                durationMs: node.stats.lastDurationMs,
+            if (currentNode) {
+                this.eventEmitter.emit("stats", {
+                    kind: "node-done",
+                    nodeId,
+                    typeId: currentNode.typeId,
+                    runId: plan.runId,
+                    durationMs: currentNode.stats.lastDurationMs,
+                });
+            }
+        }
+        if (currentNode) {
+            ctx.log("debug", "node-done", {
+                durationMs: currentNode.stats.lastDurationMs,
+                hadError,
+                inputs: currentNode.inputs
+                    ? structuredClone(currentNode.inputs)
+                    : undefined,
+                outputs: currentNode.outputs
+                    ? structuredClone(currentNode.outputs)
+                    : undefined,
             });
         }
-        ctx.log("debug", "node-done", {
-            durationMs: node.stats.lastDurationMs,
-            hadError,
-        });
         if (onDone)
             onDone();
     }
@@ -2013,22 +2422,24 @@ class NodeExecutor {
      * Cancel all active runs for a node
      */
     cancelNodeActiveRuns(node, reason) {
-        for (const controller of Array.from(node.activeControllers)) {
-            const runId = node.controllerRunIds.get(controller);
+        const nodeId = node.nodeId;
+        const controllers = this.graph.getNodeControllers(nodeId);
+        for (const controller of controllers) {
+            const currentNode = this.graph.getNode(nodeId);
+            if (!currentNode)
+                continue;
+            const runId = currentNode.controllerRunIds.get(controller);
             if (runId) {
                 // Track cancelled runIds for snapshot and user-cancelled operations
                 // (to drop emits from cancelled runs)
                 if (reason === "snapshot" || reason === "user-cancelled") {
-                    if (!node.snapshotCancelledRunIds) {
-                        node.snapshotCancelledRunIds = new Set();
-                    }
-                    node.snapshotCancelledRunIds.add(runId);
+                    this.graph.addSnapshotCancelledRunId(nodeId, runId);
                 }
                 // Emit cancellation event
                 this.eventEmitter.emit("stats", {
                     kind: "node-done",
-                    nodeId: node.nodeId,
-                    typeId: node.typeId,
+                    nodeId: currentNode.nodeId,
+                    typeId: currentNode.typeId,
                     runId,
                     cancelled: true,
                 });
@@ -2040,10 +2451,9 @@ class NodeExecutor {
                 // ignore abort errors
             }
         }
-        node.activeControllers.clear();
-        node.controllerRunIds.clear();
-        node.stats.active = 0;
-        node.queue = [];
+        this.graph.clearNodeControllers(nodeId);
+        this.graph.updateNodeStats(nodeId, { active: 0 });
+        this.graph.clearNodeQueue(nodeId);
     }
     /**
      * Cancel runs for multiple nodes.
@@ -2055,14 +2465,13 @@ class NodeExecutor {
         const toCancel = new Set(nodeIds);
         const visited = new Set();
         const queue = [...nodeIds];
-        const edges = this.graph.getEdges();
         // Collect all downstream nodes to cancel
         for (let i = 0; i < queue.length; i++) {
             const nodeId = queue[i];
             if (visited.has(nodeId))
                 continue;
             visited.add(nodeId);
-            for (const edge of edges) {
+            this.graph.forEachEdge((edge) => {
                 if (edge.source.nodeId === nodeId) {
                     const targetId = edge.target.nodeId;
                     if (!visited.has(targetId)) {
@@ -2070,7 +2479,7 @@ class NodeExecutor {
                         queue.push(targetId);
                     }
                 }
-            }
+            });
         }
         // Cancel runs for all affected nodes
         for (const nodeId of toCancel) {
@@ -2078,10 +2487,10 @@ class NodeExecutor {
             if (!node)
                 continue;
             this.cancelNodeActiveRuns(node, reason);
-            node.runSeq += 1;
+            const runSeq = this.graph.incrementNodeRunSeq(nodeId);
             const now = Date.now();
             const suffix = reason === "snapshot" ? "snapshot" : "cancelled";
-            node.latestRunId = `${nodeId}:${node.runSeq}:${now}:${suffix}`;
+            this.graph.setNodeLatestRunId(nodeId, `${nodeId}:${runSeq}:${now}:${suffix}`);
         }
         // Cancel nodes in run-contexts (exclude them from active run-contexts)
         for (const nodeId of toCancel) {
@@ -2166,7 +2575,11 @@ class GraphRuntime {
             gr.graph.setNode(n.nodeId, rn);
         }
         // Instantiate edges
-        const edges = buildEdges(def, registry, gr.graph.getResolvedHandlesMap());
+        const resolvedByNode = new Map();
+        gr.graph.forEachResolvedHandles((handles, nodeId) => {
+            resolvedByNode.set(nodeId, handles);
+        });
+        const edges = buildEdges(def, registry, resolvedByNode);
         gr.graph.setEdges(edges);
         // Schedule async recompute only for nodes that indicated Promise-based resolveHandles
         for (const nodeId of initial.pending) {
@@ -2182,10 +2595,14 @@ class GraphRuntime {
         if (!node)
             throw new Error(`Node not found: ${nodeId}`);
         let anyChanged = false;
-        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);
+            let hasInbound = false;
+            this.graph.forEachEdge((e) => {
+                if (e.target.nodeId === nodeId && e.target.handle === handle) {
+                    hasInbound = true;
+                }
+            });
             if (hasInbound)
                 continue;
             // Validate input value against declared type
@@ -2219,12 +2636,7 @@ class GraphRuntime {
             const prev = node.inputs[handle];
             const same = valuesEqual(prev, value);
             if (!same) {
-                if (value === undefined) {
-                    delete node.inputs[handle];
-                }
-                else {
-                    node.inputs[handle] = value;
-                }
+                this.graph.updateNodeInput(nodeId, handle, value);
                 // Emit value event for input updates
                 this.eventEmitter.emit("value", { nodeId, handle, value, io: "input" });
                 anyChanged = true;
@@ -2246,7 +2658,7 @@ class GraphRuntime {
         return node?.outputs[output];
     }
     launch(invalidate = false) {
-        for (const node of this.graph.getNodes().values()) {
+        this.graph.forEachNode((node) => {
             const effectiveInputs = this.nodeExecutor.getEffectiveInputs(node.nodeId);
             const ctrl = new AbortController();
             const execCtx = this.nodeExecutor.createExecutionContext(node.nodeId, node, effectiveInputs, `${node.nodeId}:init`, ctrl.signal);
@@ -2256,9 +2668,9 @@ class GraphRuntime {
                 execCtx.log("debug", "prepare-done");
             }
             node.runtime.onActivated?.();
-        }
+        });
         if (this.runMode === "auto" && invalidate) {
-            for (const nodeId of this.graph.getNodes().keys()) {
+            for (const nodeId of this.graph.getNodeIds()) {
                 if (this.graph.allInboundHaveValue(nodeId))
                     this.execute(nodeId);
             }
@@ -2293,7 +2705,7 @@ class GraphRuntime {
         this.nodeExecutor.cancelNodeRuns(nodeIds);
     }
     getNodeIds() {
-        return Array.from(this.graph.getNodes().keys());
+        return this.graph.getNodeIds();
     }
     getNodeData(nodeId) {
         const node = this.graph.getNode(nodeId);
@@ -2314,26 +2726,30 @@ class GraphRuntime {
         this.environment = { ...env };
         this.handleResolver.setEnvironment(this.environment);
         this.nodeExecutor.setEnvironment(this.environment);
-        for (const nodeId of this.graph.getNodes().keys()) {
+        for (const nodeId of this.graph.getNodeIds()) {
             this.handleResolver.scheduleRecomputeHandles(nodeId);
         }
     }
     getGraphDef() {
-        const nodes = Array.from(this.graph.getNodes().values()).map((n) => {
+        const nodes = [];
+        this.graph.forEachNode((n) => {
             const resolved = this.graph.getResolvedHandles(n.nodeId);
-            return {
+            nodes.push({
                 nodeId: n.nodeId,
                 typeId: n.typeId,
                 params: n.params ? { ...n.params } : undefined,
                 resolvedHandles: resolved ? { ...resolved } : undefined,
-            };
+            });
+        });
+        const edges = [];
+        this.graph.forEachEdge((e) => {
+            edges.push({
+                id: e.id,
+                source: { nodeId: e.source.nodeId, handle: e.source.handle },
+                target: { nodeId: e.target.nodeId, handle: e.target.handle },
+                typeId: e.typeId,
+            });
         });
-        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,
-        }));
         return { nodes, edges };
     }
     async whenIdle() {
@@ -2352,13 +2768,13 @@ class GraphRuntime {
             });
         }
         const isIdle = () => {
-            for (const n of this.graph.getNodes().values()) {
-                if (n.activeControllers.size > 0)
-                    return false;
-                if (n.queue.length > 0)
-                    return false;
-            }
-            return true;
+            let idle = true;
+            this.graph.forEachNode((n) => {
+                if (n.activeControllers.size > 0 || n.queue.length > 0) {
+                    idle = false;
+                }
+            });
+            return idle;
         };
         if (isIdle())
             return;
@@ -2378,7 +2794,7 @@ class GraphRuntime {
             return;
         return new Promise((resolve) => {
             const id = this.runContextManager.createRunContext(startNodeId, resolve, options);
-            node.activeRunContextIds.add(id);
+            this.graph.addNodeRunContextId(startNodeId, id);
             this.execute(startNodeId, new Set([id]));
         });
     }
@@ -2412,38 +2828,38 @@ class GraphRuntime {
         try {
             const ins = payload?.inputs || {};
             for (const [nodeId, map] of Object.entries(ins)) {
-                const node = this.graph.getNode(nodeId);
-                if (!node)
+                if (!this.graph.hasNode(nodeId))
                     continue;
                 for (const [h, v] of Object.entries(map || {})) {
-                    node.inputs[h] = structuredClone(v);
+                    const clonedValue = structuredClone(v);
+                    this.graph.updateNodeInput(nodeId, h, clonedValue);
                     this.eventEmitter.emit("value", {
                         nodeId,
                         handle: h,
-                        value: node.inputs[h],
+                        value: clonedValue,
                         io: "input",
-                        runtimeTypeId: getTypedOutputTypeId(node.inputs[h]),
+                        runtimeTypeId: getTypedOutputTypeId(clonedValue),
                     });
                 }
             }
             const outs = payload?.outputs || {};
             for (const [nodeId, map] of Object.entries(outs)) {
-                const node = this.graph.getNode(nodeId);
-                if (!node)
+                if (!this.graph.hasNode(nodeId))
                     continue;
                 for (const [h, v] of Object.entries(map || {})) {
-                    node.outputs[h] = structuredClone(v);
+                    const clonedValue = structuredClone(v);
+                    this.graph.updateNodeOutput(nodeId, h, clonedValue);
                     this.eventEmitter.emit("value", {
                         nodeId,
                         handle: h,
-                        value: node.outputs[h],
+                        value: clonedValue,
                         io: "output",
-                        runtimeTypeId: getTypedOutputTypeId(node.outputs[h]),
+                        runtimeTypeId: getTypedOutputTypeId(clonedValue),
                     });
                 }
             }
             if (opts?.invalidate) {
-                for (const nodeId of this.graph.getNodes().keys()) {
+                for (const nodeId of this.graph.getNodeIds()) {
                     this.invalidateDownstream(nodeId);
                 }
             }
@@ -2456,17 +2872,19 @@ class GraphRuntime {
         {
             // 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());
+            const beforeIds = new Set(this.graph.getNodeIds());
             for (const nodeId of Array.from(beforeIds)) {
                 if (!afterIds.has(nodeId)) {
                     const node = this.graph.getNode(nodeId);
+                    if (!node)
+                        continue;
                     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),
+                        setState: (next) => this.graph.updateNodeState(node.nodeId, next),
                     });
                     this.graph.deleteNode(nodeId);
                     this.edgePropagator.clearArrayBuckets(nodeId);
@@ -2530,43 +2948,43 @@ class GraphRuntime {
                     newNode.runtime.onActivated?.();
                 }
                 else {
-                    existing.params = n.params;
+                    this.graph.updateNodeParams(n.nodeId, n.params);
                     // Re-merge policy when params change (params.policy can override descriptor/category policy)
                     const desc = registry.nodes.get(existing.typeId);
                     const cat = registry.categories.get(desc?.categoryId ?? "");
-                    existing.policy = {
+                    this.graph.updateNodePolicy(n.nodeId, {
                         ...cat?.policy,
                         ...desc?.policy,
                         ...n.params?.policy,
-                    };
+                    });
+                    // Initialize stats if missing
                     if (!existing.stats) {
-                        existing.stats = {
+                        this.graph.updateNodeStats(n.nodeId, {
                             runs: 0,
                             active: 0,
                             queued: 0,
                             progress: 0,
-                        };
+                        });
                     }
                 }
             }
         }
         {
-            const beforeEdges = this.graph.getEdges();
             const beforeInbound = new Map();
-            for (const e of beforeEdges) {
+            const beforeOutTargets = new Map();
+            this.graph.forEachEdge((e) => {
+                // Build beforeInbound map
                 const set = beforeInbound.get(e.target.nodeId) ?? new Set();
                 set.add(e.target.handle);
                 beforeInbound.set(e.target.nodeId, set);
-            }
-            const beforeOutTargets = new Map();
-            for (const e of beforeEdges) {
+                // Build beforeOutTargets map
                 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);
@@ -2581,7 +2999,11 @@ class GraphRuntime {
                 for (const [nodeId, handles] of result.resolved) {
                     this.graph.setResolvedHandles(nodeId, handles);
                 }
-                const afterEdges = buildEdges(def, registry, this.graph.getResolvedHandlesMap());
+                const resolvedByNode = new Map();
+                this.graph.forEachResolvedHandles((handles, nodeId) => {
+                    resolvedByNode.set(nodeId, handles);
+                });
+                const afterEdges = buildEdges(def, registry, resolvedByNode);
                 this.graph.setEdges(afterEdges);
                 for (const nodeId of result.pending) {
                     this.handleResolver.scheduleRecomputeHandles(nodeId);
@@ -2596,23 +3018,22 @@ class GraphRuntime {
             {
                 // Update inputs and propagate changes
                 const afterInbound = new Map();
-                const afterEdges = this.graph.getEdges();
-                for (const e of afterEdges) {
+                this.graph.forEachEdge((e) => {
                     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)
+                    if (!this.graph.hasNode(nodeId))
                         continue;
                     let changed = false;
                     for (const handle of Array.from(beforeSet)) {
                         if (!currSet.has(handle)) {
-                            if (handle in node.inputs) {
-                                delete node.inputs[handle];
+                            const node = this.graph.getNode(nodeId);
+                            if (node && handle in node.inputs) {
+                                this.graph.deleteNodeInput(nodeId, handle);
                                 changed = true;
                             }
                         }
@@ -2627,14 +3048,14 @@ class GraphRuntime {
                 }
                 // Propagate changes on edges added
                 const afterOutTargets = new Map();
-                for (const e of afterEdges) {
+                this.graph.forEachEdge((e) => {
                     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;
@@ -2682,14 +3103,14 @@ class GraphRuntime {
     }
     dispose() {
         this.runContextManager.resolveAll();
-        for (const node of this.graph.getNodes().values()) {
+        this.graph.forEachNode((node) => {
             node.runtime.onDeactivated?.();
             node.runtime.dispose?.();
             node.lifecycle?.dispose?.({
                 state: node.state,
-                setState: (next) => Object.assign(node.state, next),
+                setState: (next) => this.graph.updateNodeState(node.nodeId, next),
             });
-        }
+        });
         this.graph.clear();
     }
     execute(nodeId, runContextIds) {