@bian-womp/spark-workbench 0.2.77 → 0.2.79

package/lib/esm/index.js

@@ -1,4 +1,4 @@
-import { generateId, GraphBuilder, createEngine, StepEngine, PullEngine, BatchedEngine, isTypedOutput, getTypedOutputValue, getTypedOutputTypeId, isInputPrivate, getInputTypeId, createSimpleGraphRegistry, createSimpleGraphDef, createAsyncGraphDef, createAsyncGraphRegistry, createProgressGraphDef, createProgressGraphRegistry, createValidationGraphDef, createValidationGraphRegistry } from '@bian-womp/spark-graph';
+import { generateId, GraphBuilder, getTypedOutputValue, isTypedOutput, getInputTypeId, createEngine, StepEngine, PullEngine, BatchedEngine, getTypedOutputTypeId, isInputPrivate, createSimpleGraphRegistry, createSimpleGraphDef, createAsyncGraphDef, createAsyncGraphRegistry, createProgressGraphDef, createProgressGraphRegistry, createValidationGraphDef, createValidationGraphRegistry } from '@bian-womp/spark-graph';
 import lod from 'lodash';
 import { RuntimeApiClient } from '@bian-womp/spark-remote';
 import { Position, Handle, useUpdateNodeInternals, useReactFlow, ReactFlowProvider, ReactFlow, Background, BackgroundVariant, MiniMap, Controls } from '@xyflow/react';
@@ -121,7 +121,7 @@ class AbstractWorkbench {
 class InMemoryWorkbench extends AbstractWorkbench {
     constructor() {
         super(...arguments);
-        this.def = { nodes: [], edges: [] };
+        this._def = { nodes: [], edges: [] };
         this.listeners = new Map();
         this.positions = {};
         this.selection = {
@@ -133,40 +133,40 @@ class InMemoryWorkbench extends AbstractWorkbench {
         this.historyState = undefined;
         this.copiedData = null;
     }
+    get def() {
+        return this._def;
+    }
     setRegistry(registry) {
         this.registry = registry;
     }
     async load(def) {
-        this.def = { nodes: [...def.nodes], edges: [...def.edges] };
+        this._def = { nodes: [...def.nodes], edges: [...def.edges] };
         if (this.layout) {
-            const { positions } = await this.layout.layout(this.def);
+            const { positions } = await this.layout.layout(this._def);
             this.positions = positions;
         }
-        const defNodeIds = new Set(this.def.nodes.map((n) => n.nodeId));
-        const defEdgeIds = new Set(this.def.edges.map((e) => e.id));
+        const defNodeIds = new Set(this._def.nodes.map((n) => n.nodeId));
+        const defEdgeIds = new Set(this._def.edges.map((e) => e.id));
         const filteredPositions = Object.fromEntries(Object.entries(this.positions).filter(([id]) => defNodeIds.has(id)));
         const filteredNodes = this.selection.nodes.filter((id) => defNodeIds.has(id));
         const filteredEdges = this.selection.edges.filter((id) => defEdgeIds.has(id));
         this.positions = filteredPositions;
         this.selection = { nodes: filteredNodes, edges: filteredEdges };
-        this.emit("graphChanged", { def: this.def });
+        this.emit("graphChanged", { def: this._def });
         this.refreshValidation();
     }
-    export() {
-        return this.def;
-    }
     refreshValidation() {
         this.emit("validationChanged", this.validate());
     }
     validate() {
         if (this.registry) {
             const builder = new GraphBuilder(this.registry);
-            const report = builder.validate(this.def);
+            const report = builder.validate(this._def);
             return report;
         }
         const issues = [];
         const nodeIds = new Set();
-        for (const n of this.def.nodes) {
+        for (const n of this._def.nodes) {
             if (nodeIds.has(n.nodeId)) {
                 issues.push({
                     level: "error",
@@ -178,7 +178,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
                 nodeIds.add(n.nodeId);
         }
         const edgeIds = new Set();
-        for (const e of this.def.edges) {
+        for (const e of this._def.edges) {
             if (edgeIds.has(e.id)) {
                 issues.push({
                     level: "error",
@@ -191,10 +191,17 @@ class InMemoryWorkbench extends AbstractWorkbench {
         }
         return { ok: issues.every((i) => i.level !== "error"), issues };
     }
+    setInputs(nodeId, inputs, options) {
+        this.emit("graphChanged", {
+            def: this._def,
+            change: { type: "setInputs", nodeId, inputs },
+            ...options,
+        });
+    }
     addNode(node, options) {
         const id = node.nodeId ??
-            this.genId("n", new Set(this.def.nodes.map((n) => n.nodeId)));
-        this.def.nodes.push({
+            this.genId("n", new Set(this._def.nodes.map((n) => n.nodeId)));
+        this._def.nodes.push({
             nodeId: id,
             typeId: node.typeId,
             params: node.params,
@@ -203,7 +210,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
         if (node.position)
             this.positions[id] = node.position;
         this.emit("graphChanged", {
-            def: this.def,
+            def: this._def,
             change: {
                 type: "addNode",
                 nodeId: id,
@@ -216,26 +223,26 @@ class InMemoryWorkbench extends AbstractWorkbench {
         return id;
     }
     removeNode(nodeId, options) {
-        this.def.nodes = this.def.nodes.filter((n) => n.nodeId !== nodeId);
-        this.def.edges = this.def.edges.filter((e) => e.source.nodeId !== nodeId && e.target.nodeId !== nodeId);
+        this._def.nodes = this._def.nodes.filter((n) => n.nodeId !== nodeId);
+        this._def.edges = this._def.edges.filter((e) => e.source.nodeId !== nodeId && e.target.nodeId !== nodeId);
         delete this.positions[nodeId];
         this.emit("graphChanged", {
-            def: this.def,
+            def: this._def,
             change: { type: "removeNode", nodeId },
             ...options,
         });
         this.refreshValidation();
     }
     connect(edge, options) {
-        const id = edge.id ?? this.genId("e", new Set(this.def.edges.map((e) => e.id)));
-        this.def.edges.push({
+        const id = edge.id ?? this.genId("e", new Set(this._def.edges.map((e) => e.id)));
+        this._def.edges.push({
             id,
             source: { ...edge.source },
             target: { ...edge.target },
             typeId: edge.typeId,
         });
         this.emit("graphChanged", {
-            def: this.def,
+            def: this._def,
             change: { type: "connect", edgeId: id },
             ...options,
         });
@@ -243,16 +250,16 @@ class InMemoryWorkbench extends AbstractWorkbench {
         return id;
     }
     disconnect(edgeId, options) {
-        this.def.edges = this.def.edges.filter((e) => e.id !== edgeId);
+        this._def.edges = this._def.edges.filter((e) => e.id !== edgeId);
         this.emit("graphChanged", {
-            def: this.def,
+            def: this._def,
             change: { type: "disconnect", edgeId },
             ...options,
         });
         this.emit("validationChanged", this.validate());
     }
     updateEdgeType(edgeId, typeId) {
-        const e = this.def.edges.find((x) => x.id === edgeId);
+        const e = this._def.edges.find((x) => x.id === edgeId);
         if (!e)
             return;
         if (!typeId)
@@ -260,18 +267,18 @@ class InMemoryWorkbench extends AbstractWorkbench {
         else
             e.typeId = typeId;
         this.emit("graphChanged", {
-            def: this.def,
+            def: this._def,
             change: { type: "updateEdgeType", edgeId, typeId },
         });
         this.refreshValidation();
     }
     updateParams(nodeId, params) {
-        const n = this.def.nodes.find((n) => n.nodeId === nodeId);
+        const n = this._def.nodes.find((n) => n.nodeId === nodeId);
         if (!n)
             return;
         n.params = { ...(n.params ?? {}), ...params };
         this.emit("graphChanged", {
-            def: this.def,
+            def: this._def,
             change: { type: "updateParams", nodeId },
         });
     }
@@ -279,7 +286,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
     setPositions(map, options) {
         this.positions = { ...this.positions, ...map };
         this.emit("graphUiChanged", {
-            def: this.def,
+            def: this._def,
             change: { type: "moveNodes" },
             ...options,
         });
@@ -287,17 +294,20 @@ class InMemoryWorkbench extends AbstractWorkbench {
     getPositions() {
         return { ...this.positions };
     }
-    setSelection(sel, options) {
+    setSelectionInternal(sel, options) {
         if (lod.isEqual(this.selection, sel))
             return;
         this.selection = { nodes: [...sel.nodes], edges: [...sel.edges] };
         this.emit("selectionChanged", this.selection);
         this.emit("graphUiChanged", {
-            def: this.def,
+            def: this._def,
             change: { type: "selection" },
             ...options,
         });
     }
+    setSelection(sel, options) {
+        this.setSelectionInternal(sel, options);
+    }
     getSelection() {
         return {
             nodes: [...this.selection.nodes],
@@ -318,14 +328,14 @@ class InMemoryWorkbench extends AbstractWorkbench {
             this.disconnect(edgeId);
         }
         // Clear selection
-        this.setSelection({ nodes: [], edges: [] }, options);
+        this.setSelectionInternal({ nodes: [], edges: [] }, options);
     }
     setViewport(viewport) {
         if (lod.isEqual(this.viewport, viewport))
             return;
         this.viewport = { ...viewport };
         this.emit("graphUiChanged", {
-            def: this.def,
+            def: this._def,
             change: { type: "viewport" },
         });
     }
@@ -333,8 +343,8 @@ class InMemoryWorkbench extends AbstractWorkbench {
         return this.viewport ? { ...this.viewport } : null;
     }
     getUIState() {
-        const defNodeIds = new Set(this.def.nodes.map((n) => n.nodeId));
-        const defEdgeIds = new Set(this.def.edges.map((e) => e.id));
+        const defNodeIds = new Set(this._def.nodes.map((n) => n.nodeId));
+        const defEdgeIds = new Set(this._def.edges.map((e) => e.id));
         const filteredPositions = Object.fromEntries(Object.entries(this.positions).filter(([id]) => defNodeIds.has(id)));
         const filteredNodes = this.selection.nodes.filter((id) => defNodeIds.has(id));
         const filteredEdges = this.selection.edges.filter((id) => defEdgeIds.has(id));
@@ -373,6 +383,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
     }
     setRuntimeState(runtime) {
         this.runtimeState = runtime ? { ...runtime } : null;
+        this.emit("runtimeMetadataChanged", {});
     }
     getHistory() {
         return this.historyState;
@@ -389,6 +400,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const nodeMeta = current.nodes[nodeId] ?? {};
         const updated = updater({ ...nodeMeta });
         this.runtimeState = { nodes: { ...current.nodes, [nodeId]: updated } };
+        this.emit("runtimeMetadataChanged", { nodeId });
     }
     on(event, handler) {
         if (!this.listeners.has(event))
@@ -413,11 +425,10 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const selection = this.getSelection();
         if (selection.nodes.length === 0)
             return null;
-        const def = this.export();
         const positions = this.getPositions();
         const selectedNodeSet = new Set(selection.nodes);
         // Collect nodes to copy
-        const nodesToCopy = def.nodes.filter((n) => selectedNodeSet.has(n.nodeId));
+        const nodesToCopy = this.def.nodes.filter((n) => selectedNodeSet.has(n.nodeId));
         if (nodesToCopy.length === 0)
             return null;
         // Calculate bounds
@@ -441,12 +452,12 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const centerY = (bounds.minY + bounds.maxY) / 2;
         // Get inputs for each node
         // Include values from inbound edges if those edges are selected
-        const allInputs = runner.getInputs(def);
+        const allInputs = runner.getInputs(this.def);
         const selectedEdgeSet = new Set(selection.edges);
         const copiedNodes = nodesToCopy.map((node) => {
             const pos = positions[node.nodeId] || { x: 0, y: 0 };
             // Get all inbound edges for this node
-            const inboundEdges = def.edges.filter((e) => e.target.nodeId === node.nodeId);
+            const inboundEdges = this.def.edges.filter((e) => e.target.nodeId === node.nodeId);
             // Build set of handles that have inbound edges
             // But only exclude handles whose edges are NOT selected
             const inboundHandlesToExclude = new Set(inboundEdges
@@ -470,7 +481,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
             };
         });
         // Collect edges between copied nodes
-        const copiedEdges = def.edges
+        const copiedEdges = this.def.edges
             .filter((edge) => {
             return (selectedNodeSet.has(edge.source.nodeId) &&
                 selectedNodeSet.has(edge.target.nodeId));
@@ -488,6 +499,193 @@ class InMemoryWorkbench extends AbstractWorkbench {
             bounds,
         };
     }
+    /**
+     * Duplicate all selected nodes.
+     * Returns the list of newly created node IDs.
+     * Each duplicated node is offset by 24px in both x and y directions.
+     * Copies inputs without bindings and uses copyOutputsFrom to copy outputs.
+     */
+    duplicateSelection(runner, options) {
+        const selection = this.getSelection();
+        if (selection.nodes.length === 0)
+            return [];
+        const positions = this.getPositions();
+        const newNodes = [];
+        // Get inputs without bindings (literal values only)
+        const allInputs = runner.getInputs(this.def) || {};
+        // Duplicate each selected node
+        for (const nodeId of selection.nodes) {
+            const n = this.def.nodes.find((n) => n.nodeId === nodeId);
+            if (!n)
+                continue;
+            const pos = positions[nodeId] || { x: 0, y: 0 };
+            const inboundHandles = new Set(this.def.edges
+                .filter((e) => e.target.nodeId === nodeId)
+                .map((e) => e.target.handle));
+            const inputsWithoutBindings = Object.fromEntries(Object.entries(allInputs).filter(([handle]) => !inboundHandles.has(handle)));
+            const newNodeId = this.addNode({
+                typeId: n.typeId,
+                params: n.params,
+                position: { x: pos.x + 24, y: pos.y + 24 },
+                resolvedHandles: n.resolvedHandles,
+            }, {
+                inputs: inputsWithoutBindings,
+                copyOutputsFrom: nodeId,
+                dry: true,
+            });
+            newNodes.push(newNodeId);
+        }
+        // Select all newly duplicated nodes
+        if (newNodes.length > 0) {
+            this.setSelectionInternal({ nodes: newNodes, edges: [] }, options || { commit: true, reason: "duplicate-selection" });
+        }
+        return newNodes;
+    }
+    /**
+     * Bake an output value from a node into a new node.
+     * Creates a new node based on the output type's bakeTarget configuration.
+     * Returns the ID of the last created node (or undefined if none created).
+     */
+    async bake(registry, runner, outputValue, outputTypeId, nodePosition, options) {
+        try {
+            if (!outputTypeId || outputValue === undefined)
+                return undefined;
+            const unwrap = (v) => isTypedOutput(v) ? getTypedOutputValue(v) : v;
+            const coerceIfNeeded = async (fromType, toType, value) => {
+                if (!toType || toType === fromType || !runner?.coerce)
+                    return value;
+                try {
+                    return await runner.coerce(fromType, toType, value);
+                }
+                catch {
+                    return value;
+                }
+            };
+            const pos = nodePosition;
+            const isArray = outputTypeId.endsWith("[]");
+            const baseTypeId = isArray ? outputTypeId.slice(0, -2) : outputTypeId;
+            const tArr = isArray ? registry.types.get(outputTypeId) : undefined;
+            const tElem = registry.types.get(baseTypeId);
+            const singleTarget = !isArray ? tElem?.bakeTarget : undefined;
+            const arrTarget = isArray ? tArr?.bakeTarget : undefined;
+            const elemTarget = isArray ? tElem?.bakeTarget : undefined;
+            let newNodeId;
+            if (singleTarget) {
+                const nodeDesc = registry.nodes.get(singleTarget.nodeTypeId);
+                const inType = getInputTypeId(nodeDesc?.inputs, singleTarget.inputHandle);
+                const coerced = await coerceIfNeeded(outputTypeId, inType, unwrap(outputValue));
+                newNodeId = this.addNode({
+                    typeId: singleTarget.nodeTypeId,
+                    position: { x: pos.x + 180, y: pos.y },
+                }, { inputs: { [singleTarget.inputHandle]: coerced } });
+            }
+            else if (isArray && arrTarget) {
+                const nodeDesc = registry.nodes.get(arrTarget.nodeTypeId);
+                const inType = getInputTypeId(nodeDesc?.inputs, arrTarget.inputHandle);
+                const coerced = await coerceIfNeeded(outputTypeId, inType, unwrap(outputValue));
+                newNodeId = this.addNode({
+                    typeId: arrTarget.nodeTypeId,
+                    position: { x: pos.x + 180, y: pos.y },
+                }, { inputs: { [arrTarget.inputHandle]: coerced } });
+            }
+            else if (isArray && elemTarget) {
+                const nodeDesc = registry.nodes.get(elemTarget.nodeTypeId);
+                const inType = getInputTypeId(nodeDesc?.inputs, elemTarget.inputHandle);
+                const src = unwrap(outputValue);
+                const items = Array.isArray(src) ? src : [src];
+                const coercedItems = await Promise.all(items.map((v) => coerceIfNeeded(baseTypeId, inType, v)));
+                const COLS = 4;
+                const DX = 180;
+                const DY = 160;
+                for (let idx = 0; idx < coercedItems.length; idx++) {
+                    const col = idx % COLS;
+                    const row = Math.floor(idx / COLS);
+                    newNodeId = this.addNode({
+                        typeId: elemTarget.nodeTypeId,
+                        position: { x: pos.x + (col + 1) * DX, y: pos.y + row * DY },
+                    }, { inputs: { [elemTarget.inputHandle]: coercedItems[idx] } });
+                }
+            }
+            if (newNodeId) {
+                this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, options || { commit: true, reason: "bake" });
+            }
+            return newNodeId;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Duplicate a single node.
+     * Returns the ID of the newly created node.
+     * The duplicated node is offset by 24px in both x and y directions.
+     * Copies inputs without bindings and uses copyOutputsFrom to copy outputs.
+     */
+    duplicateNode(nodeId, runner, options) {
+        const n = this.def.nodes.find((n) => n.nodeId === nodeId);
+        if (!n)
+            return undefined;
+        const pos = this.getPositions()[nodeId] || { x: 0, y: 0 };
+        // Get inputs without bindings (literal values only)
+        const allInputs = runner.getInputs(this.def)[nodeId] || {};
+        const inboundHandles = new Set(this.def.edges
+            .filter((e) => e.target.nodeId === nodeId)
+            .map((e) => e.target.handle));
+        const inputsWithoutBindings = Object.fromEntries(Object.entries(allInputs).filter(([handle]) => !inboundHandles.has(handle)));
+        const newNodeId = this.addNode({
+            typeId: n.typeId,
+            params: n.params,
+            position: { x: pos.x + 24, y: pos.y + 24 },
+            resolvedHandles: n.resolvedHandles,
+        }, {
+            inputs: inputsWithoutBindings,
+            copyOutputsFrom: nodeId,
+            dry: true,
+        });
+        // Select the newly duplicated node
+        this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, options || { commit: true, reason: "duplicate-node" });
+        return newNodeId;
+    }
+    /**
+     * Duplicate a node and all its incoming edges.
+     * Returns the ID of the newly created node.
+     * The duplicated node is offset by 24px in both x and y directions.
+     * All incoming edges are duplicated to point to the new node.
+     */
+    duplicateNodeWithEdges(nodeId, runner, options) {
+        const n = this.def.nodes.find((n) => n.nodeId === nodeId);
+        if (!n)
+            return undefined;
+        const pos = this.getPositions()[nodeId] || { x: 0, y: 0 };
+        // Get all inputs (including those with bindings, since edges will be duplicated)
+        const inputs = runner.getInputs(this.def)[nodeId] || {};
+        // Add the duplicated node
+        const newNodeId = this.addNode({
+            typeId: n.typeId,
+            params: n.params,
+            position: { x: pos.x + 24, y: pos.y + 24 },
+            resolvedHandles: n.resolvedHandles,
+        }, {
+            inputs,
+            copyOutputsFrom: nodeId,
+            dry: true,
+        });
+        // Find all incoming edges (edges where target is the original node)
+        const incomingEdges = this.def.edges.filter((e) => e.target.nodeId === nodeId);
+        // Duplicate each incoming edge to point to the new node
+        for (const edge of incomingEdges) {
+            this.connect({
+                source: edge.source, // Keep the same source
+                target: { nodeId: newNodeId, handle: edge.target.handle }, // Point to new node
+                typeId: edge.typeId,
+            }, { dry: true });
+        }
+        // Select the newly duplicated node
+        if (newNodeId) {
+            this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, options || { commit: true, reason: "duplicate-node-with-edges" });
+        }
+        return newNodeId;
+    }
     /**
      * Paste copied graph data at the specified center position.
      * Returns the mapping from original node IDs to new node IDs.
@@ -533,7 +731,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
             }
         }
         // Select the newly pasted nodes
-        this.setSelection({ nodes: Array.from(nodeIdMap.values()), edges: edgeIds }, options);
+        this.setSelectionInternal({ nodes: Array.from(nodeIdMap.values()), edges: edgeIds }, options);
         return { nodeIdMap, edgeIds };
     }
     /**
@@ -558,8 +756,8 @@ class CLIWorkbench {
     async load(def) {
         await this.wb.load(def);
     }
-    print(def, options) {
-        const d = def ?? this.wb.export();
+    print(options) {
+        const d = this.wb.def;
         const detail = !!options?.detail;
         const lines = [];
         lines.push(`Nodes (${d.nodes.length})`);
@@ -1928,8 +2126,7 @@ function useWorkbenchBridge(wb) {
         if (!params.sourceHandle || !params.targetHandle)
             return;
         // Prevent duplicate edges between the same endpoints
-        const def = wb.export();
-        const exists = def.edges.some((e) => e.source.nodeId === params.source &&
+        const exists = wb.def.edges.some((e) => e.source.nodeId === params.source &&
             e.source.handle === params.sourceHandle &&
             e.target.nodeId === params.target &&
             e.target.handle === params.targetHandle);
@@ -1979,7 +2176,10 @@ function useWorkbenchBridge(wb) {
             }
         }
         if (selectionChanged) {
-            wb.setSelection({ nodes: Array.from(nextNodeIds), edges: current.edges }, { commit: !(Object.keys(positions).length && commit) });
+            wb.setSelection({
+                nodes: Array.from(nextNodeIds),
+                edges: current.edges,
+            });
         }
         if (Object.keys(positions).length > 0) {
             wb.setPositions(positions, { commit });
@@ -2014,7 +2214,10 @@ function useWorkbenchBridge(wb) {
             }
         }
         if (selectionChanged) {
-            wb.setSelection({ nodes: current.nodes, edges: Array.from(nextEdgeIds) }, { commit: true });
+            wb.setSelection({
+                nodes: current.nodes,
+                edges: Array.from(nextEdgeIds),
+            });
         }
     }, [wb]);
     const onNodesDelete = useCallback((nodes) => {
@@ -2460,7 +2663,6 @@ function isSnapshotPayload(parsed) {
 }
 async function download(wb, runner) {
     try {
-        const def = wb.export();
         const fullUiState = wb.getUIState();
         const uiState = excludeViewportFromUIState(fullUiState);
         const runtimeState = wb.getRuntimeState();
@@ -2469,7 +2671,7 @@ async function download(wb, runner) {
             const fullSnapshot = await runner.snapshotFull();
             snapshot = {
                 ...fullSnapshot,
-                def,
+                def: wb.def,
                 extData: {
                     ...(fullSnapshot.extData || {}),
                     ui: Object.keys(uiState || {}).length > 0 ? uiState : undefined,
@@ -2478,9 +2680,9 @@ async function download(wb, runner) {
             };
         }
         else {
-            const inputs = runner.getInputs(def);
+            const inputs = runner.getInputs(wb.def);
             snapshot = {
-                def,
+                def: wb.def,
                 inputs,
                 outputs: {},
                 environment: {},
@@ -2519,7 +2721,7 @@ async function upload(parsed, wb, runner) {
     }
     if (runner.isRunning()) {
         await runner.applySnapshotFull({
-            def,
+            def: wb.def,
             environment,
             inputs,
             outputs,
@@ -2527,10 +2729,10 @@ async function upload(parsed, wb, runner) {
         });
     }
     else {
-        runner.build(wb.export());
+        runner.build(wb.def);
         if (inputs && typeof inputs === "object") {
             for (const [nodeId, map] of Object.entries(inputs)) {
-                runner.setInputs(nodeId, map);
+                runner.setInputs(nodeId, map, { dry: true });
             }
         }
     }
@@ -2623,14 +2825,13 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
     const versionTick = useWorkbenchVersionTick(runner);
     const valuesTick = versionTick + graphTick + graphUiTick;
     // Def and IO values
-    const def = wb.export();
-    const inputsMap = useMemo(() => runner.getInputs(def), [runner, def, valuesTick]);
-    const inputDefaultsMap = useMemo(() => runner.getInputDefaults(def), [runner, def, valuesTick]);
-    const outputsMap = useMemo(() => runner.getOutputs(def), [runner, def, valuesTick]);
+    const inputsMap = useMemo(() => runner.getInputs(wb.def), [runner, wb, wb.def, valuesTick]);
+    const inputDefaultsMap = useMemo(() => runner.getInputDefaults(wb.def), [runner, wb, wb.def, valuesTick]);
+    const outputsMap = useMemo(() => runner.getOutputs(wb.def), [runner, wb, wb.def, valuesTick]);
     const outputTypesMap = useMemo(() => {
         const out = {};
         // Local: runtimeTypeId is not stored; derive from typed wrapper in outputsMap
-        for (const n of def.nodes) {
+        for (const n of wb.def.nodes) {
             const effectiveHandles = computeEffectiveHandles(n, registry);
             const outputsDecl = effectiveHandles.outputs;
             const handles = Object.keys(outputsDecl);
@@ -2645,14 +2846,14 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                 out[n.nodeId] = cur;
         }
         return out;
-    }, [def, outputsMap, registry]);
+    }, [wb, wb.def, outputsMap, registry]);
     // Initialize nodes and derive invalidated status from persisted metadata
     useEffect(() => {
         const workbenchRuntimeState = wb.getRuntimeState() ?? { nodes: {} };
         setNodeStatus((prev) => {
             const next = { ...prev };
             const metadata = workbenchRuntimeState;
-            for (const n of def.nodes) {
+            for (const n of wb.def.nodes) {
                 const cur = next[n.nodeId] ?? (next[n.nodeId] = {});
                 const nodeMeta = metadata.nodes[n.nodeId];
                 const updates = {};
@@ -2674,18 +2875,17 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             }
             return next;
         });
-    }, [def, wb]);
+    }, [wb.def, wb]);
     // Auto layout (simple layered layout)
     const runAutoLayout = useCallback(() => {
-        const cur = wb.export();
         // Build DAG layers by indegree
         const indegree = {};
         const adj = {};
-        for (const n of cur.nodes) {
+        for (const n of wb.def.nodes) {
             indegree[n.nodeId] = 0;
             adj[n.nodeId] = [];
         }
-        for (const e of cur.edges) {
+        for (const e of wb.def.edges) {
             indegree[e.target.nodeId] = (indegree[e.target.nodeId] ?? 0) + 1;
             adj[e.source.nodeId].push(e.target.nodeId);
         }
@@ -2716,7 +2916,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             let maxWidth = 0;
             const heights = {};
             for (const id of layer) {
-                const node = cur.nodes.find((n) => n.nodeId === id);
+                const node = wb.def.nodes.find((n) => n.nodeId === id);
                 if (!node)
                     continue;
                 // Prefer showValues sizing similar to node rendering
@@ -2742,26 +2942,26 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             curX += maxWidth + H_GAP;
         }
         wb.setPositions(pos, { commit: true, reason: "auto-layout" });
-    }, [wb, registry, overrides?.getDefaultNodeSize]);
+    }, [wb, wb.def, registry, overrides?.getDefaultNodeSize]);
     const updateEdgeType = useCallback((edgeId, typeId) => wb.updateEdgeType(edgeId, typeId), [wb]);
     const triggerExternal = useCallback((nodeId, event) => runner.triggerExternal(nodeId, event), [runner]);
     // Helper to save runtime metadata and UI state to extData
-    const saveUiRuntimeMetadata = useCallback(async () => {
+    const saveUiRuntimeMetadata = useCallback(async (workbench, graphRunner) => {
         try {
-            const current = wb.getRuntimeState() ?? { nodes: {} };
+            const current = workbench.getRuntimeState() ?? { nodes: {} };
             const metadata = { nodes: { ...current.nodes } };
             // Clean up metadata for nodes that no longer exist
-            const nodeIds = new Set(def.nodes.map((n) => n.nodeId));
+            const nodeIds = new Set(workbench.def.nodes.map((n) => n.nodeId));
             for (const nodeId of Object.keys(metadata.nodes)) {
                 if (!nodeIds.has(nodeId)) {
                     delete metadata.nodes[nodeId];
                 }
             }
             // Save cleaned metadata to workbench state
-            wb.setRuntimeState(metadata);
-            const fullUiState = wb.getUIState();
+            workbench.setRuntimeState(metadata);
+            const fullUiState = workbench.getUIState();
             const uiWithoutViewport = excludeViewportFromUIState(fullUiState);
-            await runner.setExtData?.({
+            await graphRunner.setExtData?.({
                 ...(Object.keys(uiWithoutViewport || {}).length > 0
                     ? { ui: uiWithoutViewport }
                     : {}),
@@ -2771,7 +2971,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         catch (err) {
             console.warn("[WorkbenchContext] Failed to save runtime metadata:", err);
         }
-    }, [wb, def, runner]);
+    }, []);
     // Subscribe to runner/workbench events
     useEffect(() => {
         const add = (source, type) => (payload) => setEvents((prev) => {
@@ -2797,9 +2997,8 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         });
         // Helper to apply resolved handles from event payload to workbench
         const applyResolvedHandles = (resolvedHandles) => {
-            const cur = wb.export();
             let changed = false;
-            for (const n of cur.nodes) {
+            for (const n of wb.def.nodes) {
                 const updated = resolvedHandles[n.nodeId];
                 if (updated) {
                     const before = JSON.stringify(n.resolvedHandles || {});
@@ -2826,10 +3025,6 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                         [handle]: now,
                     },
                 }));
-                setNodeStatus((s) => ({
-                    ...s,
-                    [nodeId]: { ...s[nodeId], invalidated: true },
-                }));
                 // Clear validation errors for this input when a valid value is set
                 setInputValidationErrors((prev) => prev.filter((err) => !(err.nodeId === nodeId && err.handle === handle)));
             }
@@ -2935,30 +3130,6 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             // If resolvedHandles are included in the event, use them directly (more efficient)
             if (e?.resolvedHandles && Object.keys(e.resolvedHandles).length > 0) {
                 applyResolvedHandles(e.resolvedHandles);
-                // Mark nodes whose handles changed as invalid
-                const affectedNodeIds = Object.keys(e.resolvedHandles);
-                if (affectedNodeIds.length > 0) {
-                    setNodeStatus((prev) => {
-                        const next = { ...prev };
-                        for (const id of affectedNodeIds) {
-                            const cur = next[id] ?? (next[id] = { activeRuns: 0, activeRunIds: [] });
-                            next[id] = { ...cur, invalidated: true };
-                        }
-                        return next;
-                    });
-                }
-            }
-            // For broader invalidations (e.g. registry-changed, graph-updated), mark all nodes invalid
-            if (e?.reason === "registry-changed" || e?.reason === "graph-updated") {
-                setNodeStatus((prev) => {
-                    const next = { ...prev };
-                    for (const n of def.nodes) {
-                        const cur = next[n.nodeId] ??
-                            (next[n.nodeId] = { activeRuns: 0, activeRunIds: [] });
-                        next[n.nodeId] = { ...cur, invalidated: true };
-                    }
-                    return next;
-                });
             }
             return add("runner", "invalidate")(e);
         });
@@ -2991,7 +3162,6 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                                 ? [...currentRunIds, runId]
                                 : currentRunIds,
                             progress: 0,
-                            invalidated: false,
                         },
                     };
                 });
@@ -3094,16 +3264,6 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         const offWbGraphUiChangedForLog = wb.on("graphUiChanged", add("workbench", "graphUiChanged"));
         const offWbValidationChanged = wb.on("validationChanged", add("workbench", "validationChanged"));
         // Ensure newly added nodes start as invalidated until first evaluation
-        const offWbAddNode = wb.on("graphChanged", (e) => {
-            const change = e.change;
-            if (change?.type === "addNode" && typeof change.nodeId === "string") {
-                const id = change.nodeId;
-                setNodeStatus((s) => ({
-                    ...s,
-                    [id]: { ...s[id], invalidated: true },
-                }));
-            }
-        });
         const offWbGraphChangedForUpdate = wb.on("graphChanged", async (event) => {
             // Build detailed reason from change type
             let reason = "graph-changed";
@@ -3127,17 +3287,23 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                 else if (changeType === "updateEdgeType") {
                     reason = "update-edge-type";
                 }
+                else if (changeType === "setInputs") {
+                    reason = "set-inputs";
+                }
+            }
+            if (event.change?.type === "setInputs") {
+                const { nodeId, inputs } = event.change;
+                await runner.setInputs(nodeId, inputs, { dry: event.dry });
             }
             if (!runner.isRunning()) {
                 if (event.commit) {
-                    await saveUiRuntimeMetadata();
+                    await saveUiRuntimeMetadata(wb, runner);
                     const history = await runner.commit(reason).catch((err) => {
                         console.error("[WorkbenchContext] Error committing:", err);
                         return undefined;
                     });
-                    if (history) {
+                    if (history)
                         wb.setHistory(history);
-                    }
                 }
                 return;
             }
@@ -3160,11 +3326,11 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                         }
                     }
                 }
-                else {
+                else if (event.change?.type !== "setInputs") {
                     await runner.update(event.def, { dry: event.dry });
                 }
                 if (event.commit) {
-                    await saveUiRuntimeMetadata();
+                    await saveUiRuntimeMetadata(wb, runner);
                     const history = await runner
                         .commit(event.reason ?? reason)
                         .catch((err) => {
@@ -3185,7 +3351,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             setSelectedNodeId(sel.nodes?.[0]);
             setSelectedEdgeId(sel.edges?.[0]);
             if (sel.commit) {
-                await saveUiRuntimeMetadata();
+                await saveUiRuntimeMetadata(wb, runner);
                 const history = await runner
                     .commit(sel.reason ?? "selection")
                     .catch((err) => {
@@ -3224,7 +3390,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                         reason = "selection";
                     }
                 }
-                await saveUiRuntimeMetadata();
+                await saveUiRuntimeMetadata(wb, runner);
                 const history = await runner
                     .commit(event.reason ?? reason)
                     .catch((err) => {
@@ -3244,7 +3410,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                 wb.setRegistry(newReg);
                 // Trigger a graph update so the UI revalidates with new types/enums/nodes
                 try {
-                    await runner.update(wb.export());
+                    await runner.update(wb.def);
                 }
                 catch {
                     console.error("Failed to update graph definition after registry changed");
@@ -3267,7 +3433,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                 setNodeStatus(() => {
                     const next = {};
                     const metadata = wb.getRuntimeState() ?? { nodes: {} };
-                    for (const n of def.nodes) {
+                    for (const n of wb.def.nodes) {
                         const nodeMeta = metadata.nodes[n.nodeId];
                         next[n.nodeId] = {
                             activeRuns: 0,
@@ -3282,6 +3448,30 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                 errorRunsRef.current = {};
             }
         });
+        const offWbRuntimeMetadataChanged = wb.on("runtimeMetadataChanged", (event) => {
+            const workbenchRuntimeState = wb.getRuntimeState() ?? { nodes: {} };
+            setNodeStatus((prev) => {
+                const next = { ...prev };
+                const metadata = workbenchRuntimeState;
+                let changed = false;
+                // If nodeId is specified, only update that node; otherwise update all nodes
+                const nodesToUpdate = event.nodeId
+                    ? wb.def.nodes.filter((n) => n.nodeId === event.nodeId)
+                    : wb.def.nodes;
+                for (const n of nodesToUpdate) {
+                    const cur = next[n.nodeId];
+                    if (!cur)
+                        continue;
+                    const nodeMeta = metadata.nodes[n.nodeId];
+                    const newInvalidated = computeInvalidatedFromMetadata(nodeMeta);
+                    if (cur.invalidated !== newInvalidated) {
+                        next[n.nodeId] = { ...cur, invalidated: newInvalidated };
+                        changed = true;
+                    }
+                }
+                return changed ? next : prev;
+            });
+        });
         wb.refreshValidation();
         return () => {
             offRunnerValue();
@@ -3293,20 +3483,20 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             offWbGraphUiChanged();
             offWbValidationChanged();
             offWbError();
-            offWbAddNode();
             offWbGraphChangedForUpdate();
             offWbdSetValidation();
             offWbSelectionChanged();
             offRunnerRegistry();
             offRunnerTransport();
             offFlowViewport();
+            offWbRuntimeMetadataChanged();
         };
     }, [runner, wb, setRegistry]);
     const isRunning = useCallback(() => runner.isRunning(), [runner]);
     const engineKind = useCallback(() => runner.getRunningEngine(), [runner]);
     const start = useCallback((engine) => {
         try {
-            runner.launch(wb.export(), { engine });
+            runner.launch(wb.def, { engine });
         }
         catch { }
     }, [runner, wb]);
@@ -3381,7 +3571,6 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         runner,
         registry,
         setRegistry,
-        def,
         selectedNodeId,
         selectedEdgeId,
         setSelection,
@@ -3422,7 +3611,6 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         runner,
         registry,
         setRegistry,
-        def,
         selectedNodeId,
         selectedEdgeId,
         setSelection,
@@ -3462,137 +3650,23 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
 }
 
 function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap, outputTypesMap, onClose, getDefaultNodeSize, onCopyResult) {
-    const doBake = async (handleId) => {
-        try {
-            const typeId = outputTypesMap?.[nodeId]?.[handleId];
-            const raw = outputsMap?.[nodeId]?.[handleId];
-            let newNodeId;
-            if (!typeId || raw === undefined)
-                return;
-            const unwrap = (v) => isTypedOutput(v) ? getTypedOutputValue(v) : v;
-            const coerceIfNeeded = async (fromType, toType, value) => {
-                if (!toType || toType === fromType || !runner?.coerce)
-                    return value;
-                try {
-                    return await runner.coerce(fromType, toType, value);
-                }
-                catch {
-                    return value;
-                }
-            };
-            const pos = wb.getPositions()[nodeId] || { x: 0, y: 0 };
-            const isArray = typeId.endsWith("[]");
-            const baseTypeId = isArray ? typeId.slice(0, -2) : typeId;
-            const tArr = isArray ? registry.types.get(typeId) : undefined;
-            const tElem = registry.types.get(baseTypeId);
-            const singleTarget = !isArray ? tElem?.bakeTarget : undefined;
-            const arrTarget = isArray ? tArr?.bakeTarget : undefined;
-            const elemTarget = isArray ? tElem?.bakeTarget : undefined;
-            if (singleTarget) {
-                const nodeDesc = registry.nodes.get(singleTarget.nodeTypeId);
-                const inType = getInputTypeId(nodeDesc?.inputs, singleTarget.inputHandle);
-                const coerced = await coerceIfNeeded(typeId, inType, unwrap(raw));
-                newNodeId = wb.addNode({
-                    typeId: singleTarget.nodeTypeId,
-                    position: { x: pos.x + 180, y: pos.y },
-                }, { inputs: { [singleTarget.inputHandle]: coerced } });
-            }
-            else if (isArray && arrTarget) {
-                const nodeDesc = registry.nodes.get(arrTarget.nodeTypeId);
-                const inType = getInputTypeId(nodeDesc?.inputs, arrTarget.inputHandle);
-                const coerced = await coerceIfNeeded(typeId, inType, unwrap(raw));
-                newNodeId = wb.addNode({
-                    typeId: arrTarget.nodeTypeId,
-                    position: { x: pos.x + 180, y: pos.y },
-                }, { inputs: { [arrTarget.inputHandle]: coerced } });
-            }
-            else if (isArray && elemTarget) {
-                const nodeDesc = registry.nodes.get(elemTarget.nodeTypeId);
-                const inType = getInputTypeId(nodeDesc?.inputs, elemTarget.inputHandle);
-                const src = unwrap(raw);
-                const items = Array.isArray(src) ? src : [src];
-                const coercedItems = await Promise.all(items.map((v) => coerceIfNeeded(baseTypeId, inType, v)));
-                const COLS = 4;
-                const DX = 180;
-                const DY = 160;
-                for (let idx = 0; idx < coercedItems.length; idx++) {
-                    const col = idx % COLS;
-                    const row = Math.floor(idx / COLS);
-                    newNodeId = wb.addNode({
-                        typeId: elemTarget.nodeTypeId,
-                        position: { x: pos.x + (col + 1) * DX, y: pos.y + row * DY },
-                    }, { inputs: { [elemTarget.inputHandle]: coercedItems[idx] } });
-                }
-            }
-            if (newNodeId) {
-                wb.setSelection({ nodes: [newNodeId], edges: [] }, { commit: true, reason: "bake" });
-            }
-        }
-        catch { }
-    };
     return {
         onDelete: () => {
             wb.removeNode(nodeId, { commit: true });
             onClose();
         },
         onDuplicate: async () => {
-            const def = wb.export();
-            const n = def.nodes.find((n) => n.nodeId === nodeId);
-            if (!n)
-                return onClose();
-            const pos = wb.getPositions()[nodeId] || { x: 0, y: 0 };
-            const inboundHandles = new Set(def.edges
-                .filter((e) => e.target.nodeId === nodeId)
-                .map((e) => e.target.handle));
-            const allInputs = runner.getInputs(def)[nodeId] || {};
-            const inputsWithoutBindings = Object.fromEntries(Object.entries(allInputs).filter(([handle]) => !inboundHandles.has(handle)));
-            const newNodeId = wb.addNode({
-                typeId: n.typeId,
-                params: n.params,
-                position: { x: pos.x + 24, y: pos.y + 24 },
-                resolvedHandles: n.resolvedHandles,
-            }, {
-                inputs: inputsWithoutBindings,
-                copyOutputsFrom: nodeId,
-                dry: true,
+            wb.duplicateNode(nodeId, runner, {
+                commit: true,
+                reason: "duplicate-node",
             });
-            // Select the newly duplicated node
-            wb.setSelection({ nodes: [newNodeId], edges: [] }, { commit: true, reason: "duplicate" });
             onClose();
         },
         onDuplicateWithEdges: async () => {
-            const def = wb.export();
-            const n = def.nodes.find((n) => n.nodeId === nodeId);
-            if (!n)
-                return onClose();
-            const pos = wb.getPositions()[nodeId] || { x: 0, y: 0 };
-            // Get inputs without bindings (literal values only)
-            const inputs = runner.getInputs(def)[nodeId] || {};
-            // Add the duplicated node
-            const newNodeId = wb.addNode({
-                typeId: n.typeId,
-                params: n.params,
-                position: { x: pos.x + 24, y: pos.y + 24 },
-                resolvedHandles: n.resolvedHandles,
-            }, {
-                inputs,
-                copyOutputsFrom: nodeId,
-                dry: true,
+            wb.duplicateNodeWithEdges(nodeId, runner, {
+                commit: true,
+                reason: "duplicate-node-with-edges",
             });
-            // Find all incoming edges (edges where target is the original node)
-            const incomingEdges = def.edges.filter((e) => e.target.nodeId === nodeId);
-            // Duplicate each incoming edge to point to the new node
-            for (const edge of incomingEdges) {
-                wb.connect({
-                    source: edge.source, // Keep the same source
-                    target: { nodeId: newNodeId, handle: edge.target.handle }, // Point to new node
-                    typeId: edge.typeId,
-                }, { dry: true });
-            }
-            // Select the newly duplicated node and edges
-            if (newNodeId) {
-                wb.setSelection({ nodes: [newNodeId], edges: [] }, { commit: true, reason: "duplicate-with-edges" });
-            }
             onClose();
         },
         onRunPull: async () => {
@@ -3603,7 +3677,13 @@ function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap,
             onClose();
         },
         onBake: async (handleId) => {
-            await doBake(handleId);
+            const nodePosition = wb.getPositions()[nodeId] || { x: 0, y: 0 };
+            const typeId = outputTypesMap?.[nodeId]?.[handleId];
+            const raw = outputsMap?.[nodeId]?.[handleId];
+            await wb.bake(registry, runner, raw, typeId || "", nodePosition, {
+                commit: true,
+                reason: "bake",
+            });
             onClose();
         },
         onCopy: () => {
@@ -3660,42 +3740,10 @@ function createNodeCopyHandler(wb, runner, nodeId, getDefaultNodeSize, onCopyRes
 function createSelectionContextMenuHandlers(wb, onClose, getDefaultNodeSize, onCopyResult, runner) {
     const onDuplicate = runner
         ? () => {
-            const selection = wb.getSelection();
-            if (selection.nodes.length === 0) {
-                onClose();
-                return;
-            }
-            const def = wb.export();
-            const positions = wb.getPositions();
-            const newNodes = [];
-            // Duplicate each selected node
-            for (const nodeId of selection.nodes) {
-                const n = def.nodes.find((n) => n.nodeId === nodeId);
-                if (!n)
-                    continue;
-                const pos = positions[nodeId] || { x: 0, y: 0 };
-                // Get inputs without bindings (literal values only)
-                const allInputs = runner.getInputs(def)[nodeId] || {};
-                const inboundHandles = new Set(def.edges
-                    .filter((e) => e.target.nodeId === nodeId)
-                    .map((e) => e.target.handle));
-                const inputsWithoutBindings = Object.fromEntries(Object.entries(allInputs).filter(([handle]) => !inboundHandles.has(handle)));
-                const newNodeId = wb.addNode({
-                    typeId: n.typeId,
-                    params: n.params,
-                    position: { x: pos.x + 24, y: pos.y + 24 },
-                    resolvedHandles: n.resolvedHandles,
-                }, {
-                    inputs: inputsWithoutBindings,
-                    copyOutputsFrom: nodeId,
-                    dry: true,
-                });
-                newNodes.push(newNodeId);
-            }
-            // Select all newly duplicated nodes
-            if (newNodes.length > 0) {
-                wb.setSelection({ nodes: newNodes, edges: [] }, { commit: true, reason: "duplicate-selection" });
-            }
+            wb.duplicateSelection(runner, {
+                commit: true,
+                reason: "duplicate-selection",
+            });
             onClose();
         }
         : undefined;
@@ -3730,9 +3778,8 @@ function createDefaultContextMenuHandlers(onAddNode, onClose, onPaste, runner, g
     const canRedo = history ? history.redoCount > 0 : undefined;
     const onSelectAll = wb
         ? () => {
-            const def = wb.export();
-            const allNodeIds = def.nodes.map((n) => n.nodeId);
-            const allEdgeIds = def.edges.map((e) => e.id);
+            const allNodeIds = wb.def.nodes.map((n) => n.nodeId);
+            const allEdgeIds = wb.def.edges.map((e) => e.id);
             wb.setSelection({ nodes: allNodeIds, edges: allEdgeIds }, { commit: true, reason: "select-all" });
             onClose();
         }
@@ -3751,8 +3798,7 @@ function createDefaultContextMenuHandlers(onAddNode, onClose, onPaste, runner, g
 }
 function getBakeableOutputs(nodeId, wb, registry, outputTypesMap) {
     try {
-        const def = wb.export();
-        const node = def.nodes.find((n) => n.nodeId === nodeId);
+        const node = wb.def.nodes.find((n) => n.nodeId === nodeId);
         if (!node)
             return [];
         const desc = registry.nodes.get(node.typeId);
@@ -3851,13 +3897,13 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
             return String(value ?? "");
         }
     };
-    const { registry, def, selectedNodeId, selectedEdgeId, inputsMap, inputDefaultsMap, outputsMap, outputTypesMap, nodeStatus, edgeStatus, validationByNode, validationByEdge, validationGlobal, valuesTick, updateEdgeType, systemErrors, registryErrors, inputValidationErrors, clearSystemErrors, clearRegistryErrors, clearInputValidationErrors, removeSystemError, removeRegistryError, removeInputValidationError, } = useWorkbenchContext();
+    const { wb, registry, selectedNodeId, selectedEdgeId, inputsMap, inputDefaultsMap, outputsMap, outputTypesMap, nodeStatus, edgeStatus, validationByNode, validationByEdge, validationGlobal, valuesTick, updateEdgeType, systemErrors, registryErrors, inputValidationErrors, clearSystemErrors, clearRegistryErrors, clearInputValidationErrors, removeSystemError, removeRegistryError, removeInputValidationError, } = useWorkbenchContext();
     const nodeValidationIssues = validationByNode.issues;
     const edgeValidationIssues = validationByEdge.issues;
     const nodeValidationHandles = validationByNode;
     const globalValidationIssues = validationGlobal;
-    const selectedNode = def.nodes.find((n) => n.nodeId === selectedNodeId);
-    const selectedEdge = def.edges.find((e) => e.id === selectedEdgeId);
+    const selectedNode = wb.def.nodes.find((n) => n.nodeId === selectedNodeId);
+    const selectedEdge = wb.def.edges.find((e) => e.id === selectedEdgeId);
     // Use computeEffectiveHandles to merge registry defaults with dynamically resolved handles
     const effectiveHandles = selectedNode
         ? computeEffectiveHandles(selectedNode, registry)
@@ -3989,7 +4035,6 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
             setOriginals(nextOriginals);
     }, [selectedNodeId, selectedNode, registry, valuesTick]);
     const widthClass = debug ? "w-[480px]" : "w-[320px]";
-    const { wb } = useWorkbenchContext();
     const deleteEdgeById = (edgeId) => {
         if (!edgeId)
             return;
@@ -4016,9 +4061,9 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
                                                     selectedNodeStatus.activeRunIds.length > 0 ? (jsxs("div", { className: "mt-1", children: [jsx("div", { className: "text-[10px] text-blue-600", children: "RunIds:" }), jsx("div", { className: "flex flex-wrap gap-1 mt-1", children: selectedNodeStatus.activeRunIds.map((runId, idx) => (jsx("span", { className: "text-[10px] px-1.5 py-0.5 bg-blue-100 border border-blue-300 rounded font-mono", children: runId }, idx))) })] })) : (jsx("div", { className: "text-[10px] text-blue-600 mt-1", children: "RunIds not available (some runs may have started without runId)" }))] })), !!selectedNodeStatus?.lastError && (jsx("div", { className: "mt-2 text-sm text-red-700 bg-red-50 border border-red-200 rounded px-2 py-1 break-words", children: String(selectedNodeStatus.lastError?.message ??
                                                 selectedNodeStatus.lastError) }))] })), jsxs("div", { className: "mb-2", children: [jsx("div", { className: "font-semibold mb-1", children: "Inputs" }), inputHandles.length === 0 ? (jsx("div", { className: "text-gray-500", children: "No inputs" })) : (inputHandles.map((h) => {
                                             const typeId = getInputTypeId(effectiveHandles.inputs, h);
-                                            const isLinked = def.edges.some((e) => e.target.nodeId === selectedNodeId &&
+                                            const isLinked = wb.def.edges.some((e) => e.target.nodeId === selectedNodeId &&
                                                 e.target.handle === h);
-                                            const inbound = new Set(def.edges
+                                            const inbound = new Set(wb.def.edges
                                                 .filter((e) => e.target.nodeId === selectedNodeId &&
                                                 e.target.handle === h)
                                                 .map((e) => e.target.handle));
@@ -4594,10 +4639,9 @@ const WorkbenchCanvas = React.forwardRef(({ showValues, toString, toElement, get
     const { nodeTypes, resolveNodeType } = useMemo(() => {
         // Build nodeTypes map using UI extension registry
         const custom = new Map(); // Include all types present in registry AND current graph to avoid timing issues
-        const def = wb.export();
         const ids = new Set([
             ...Array.from(registry.nodes.keys()),
-            ...def.nodes.map((n) => n.typeId),
+            ...wb.def.nodes.map((n) => n.typeId),
         ]);
         for (const typeId of ids) {
             const renderer = ui.getNodeRenderer(typeId);
@@ -4616,14 +4660,13 @@ const WorkbenchCanvas = React.forwardRef(({ showValues, toString, toElement, get
         // Include uiVersion to recompute when custom renderers are registered
     }, [wb, registry, uiVersion, ui]);
     const { nodes, edges } = useMemo(() => {
-        const def = wb.export();
         const sel = wb.getSelection();
         // Merge defaults with inputs for node display (defaults shown in lighter gray)
         const inputsWithDefaults = {};
-        for (const n of def.nodes) {
+        for (const n of wb.def.nodes) {
             const nodeInputs = inputsMap[n.nodeId] ?? {};
             const nodeDefaults = inputDefaultsMap[n.nodeId] ?? {};
-            const inbound = new Set(def.edges
+            const inbound = new Set(wb.def.edges
                 .filter((e) => e.target.nodeId === n.nodeId)
                 .map((e) => e.target.handle));
             const merged = { ...nodeInputs };
@@ -4636,7 +4679,7 @@ const WorkbenchCanvas = React.forwardRef(({ showValues, toString, toElement, get
                 inputsWithDefaults[n.nodeId] = merged;
             }
         }
-        const out = toReactFlow(def, wb.getPositions(), registry, {
+        const out = toReactFlow(wb.def, wb.getPositions(), registry, {
             showValues,
             inputs: inputsWithDefaults,
             inputDefaults: inputDefaultsMap,
@@ -5160,11 +5203,11 @@ const WorkbenchCanvas = React.forwardRef(({ showValues, toString, toElement, get
 });
 
 function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, example, onExampleChange, engine, onEngineChange, backendKind, onBackendKindChange, httpBaseUrl, onHttpBaseUrlChange, wsUrl, onWsUrlChange, debug, onDebugChange, showValues, onShowValuesChange, hideWorkbench, onHideWorkbenchChange, overrides, onInit, onChange, }) {
-    const { wb, runner, registry, def, selectedNodeId, runAutoLayout } = useWorkbenchContext();
+    const { wb, runner, registry, selectedNodeId, runAutoLayout } = useWorkbenchContext();
     const [transportStatus, setTransportStatus] = useState({
         state: "local",
     });
-    const selectedNode = def.nodes.find((n) => n.nodeId === selectedNodeId);
+    const selectedNode = wb.def.nodes.find((n) => n.nodeId === selectedNodeId);
     const effectiveHandles = selectedNode
         ? computeEffectiveHandles(selectedNode, registry)
         : { inputs: {}, outputs: {}, inputDefaults: {} };
@@ -5192,7 +5235,7 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
                 if (evt.shiftKey && !confirm("Invalidate and re-run graph?"))
                     return;
                 try {
-                    runner.launch(wb.export(), {
+                    runner.launch(wb.def, {
                         engine: kind,
                         invalidate: evt.shiftKey,
                     });
@@ -5260,12 +5303,12 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
         const setInitialGraph = async (d, inputs) => {
             await wb.load(d);
             try {
-                runner.build(wb.export());
+                runner.build(wb.def);
             }
             catch { }
             if (inputs) {
                 for (const [nodeId, map] of Object.entries(inputs)) {
-                    runner.setInputs(nodeId, map);
+                    runner.setInputs(nodeId, map, { dry: true });
                 }
             }
         };
@@ -5275,36 +5318,27 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
     useEffect(() => {
         if (!onChange)
             return;
-        const off1 = wb.on("graphChanged", () => {
-            try {
-                const cur = wb.export();
-                const inputs = runner.getInputs(cur);
-                onChange({ def: cur, inputs });
-            }
-            catch { }
-        });
-        const off2 = runner.on("value", () => {
+        const offGraphChanged = wb.on("graphChanged", () => {
             try {
-                const cur = wb.export();
+                const cur = wb.def;
                 const inputs = runner.getInputs(cur);
                 onChange({ def: cur, inputs });
             }
             catch { }
         });
-        const off3 = wb.on("graphUiChanged", (evt) => {
+        const offGraphUiChanged = wb.on("graphUiChanged", (evt) => {
             if (!evt.commit)
                 return;
             try {
-                const cur = wb.export();
+                const cur = wb.def;
                 const inputs = runner.getInputs(cur);
                 onChange({ def: cur, inputs });
             }
             catch { }
         });
         return () => {
-            off1();
-            off2();
-            off3();
+            offGraphChanged();
+            offGraphUiChanged();
         };
     }, [wb, runner, onChange]);
     const applyExample = useCallback(async (key) => {
@@ -5327,11 +5361,11 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
         }
         await wb.load(def);
         // Build a local runtime so seeded defaults are visible pre-run
-        runner.build(wb.export());
+        runner.build(wb.def);
         // Set initial inputs if provided
         if (inputs) {
             for (const [nodeId, map] of Object.entries(inputs)) {
-                runner.setInputs(nodeId, map);
+                runner.setInputs(nodeId, map, { dry: true });
             }
         }
         runAutoLayout();
@@ -5412,11 +5446,10 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
         // Only auto-launch for local backend; require explicit Start for remote
         if (backendKind !== "local")
             return;
-        const d = wb.export();
-        if (!d.nodes || d.nodes.length === 0)
+        if (!wb.def.nodes || wb.def.nodes.length === 0)
             return;
         try {
-            runner.launch(d, { engine: engine });
+            runner.launch(wb.def, { engine: engine });
         }
         catch {
             // ignore
@@ -5426,12 +5459,12 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
         if (!selectedNodeId)
             return;
         // If selected input is wired (has inbound edge), ignore user input to respect runtime value
-        const isLinked = def.edges.some((e) => e.target.nodeId === selectedNodeId && e.target.handle === handle);
+        const isLinked = wb.def.edges.some((e) => e.target.nodeId === selectedNodeId && e.target.handle === handle);
         if (isLinked)
             return;
         // If raw is undefined, pass it through to delete the input value
         if (raw === undefined) {
-            runner.setInputs(selectedNodeId, { [handle]: undefined });
+            wb.setInputs(selectedNodeId, { [handle]: undefined }, { commit: true });
             return;
         }
         const typeId = getInputTypeId(effectiveHandles.inputs, handle);
@@ -5510,8 +5543,8 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
                 value = raw;
             }
         }
-        runner.setInputs(selectedNodeId, { [handle]: value });
-    }, [selectedNodeId, def.edges, effectiveHandles, runner]);
+        wb.setInputs(selectedNodeId, { [handle]: value }, { commit: true });
+    }, [selectedNodeId, wb.def.edges, effectiveHandles, wb]);
     const setInput = useMemo(() => {
         if (overrides?.setInput) {
             return overrides.setInput(baseSetInput, {