@bian-womp/spark-workbench 0.2.78 → 0.2.80

package/lib/cjs/index.cjs

@@ -123,52 +123,53 @@ 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 = {
             nodes: [],
             edges: [],
         };
-        this.viewport = null;
+        this.nodeNames = {};
         this.runtimeState = null;
+        this.viewport = null;
         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 sparkGraph.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",
@@ -180,7 +181,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",
@@ -195,15 +196,15 @@ class InMemoryWorkbench extends AbstractWorkbench {
     }
     setInputs(nodeId, inputs, options) {
         this.emit("graphChanged", {
-            def: this.def,
+            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,
@@ -212,7 +213,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,
@@ -225,26 +226,27 @@ 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];
+        delete this.nodeNames[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,
         });
@@ -252,16 +254,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)
@@ -269,18 +271,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 },
         });
     }
@@ -288,7 +290,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,
         });
@@ -296,17 +298,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],
@@ -327,14 +332,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" },
         });
     }
@@ -342,11 +347,12 @@ 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));
+        const filteredNodeNames = Object.fromEntries(Object.entries(this.nodeNames).filter(([id]) => defNodeIds.has(id)));
         return {
             positions: Object.keys(filteredPositions).length > 0
                 ? filteredPositions
@@ -358,6 +364,9 @@ class InMemoryWorkbench extends AbstractWorkbench {
                 }
                 : undefined,
             viewport: this.viewport ? { ...this.viewport } : undefined,
+            nodeNames: Object.keys(filteredNodeNames).length > 0
+                ? filteredNodeNames
+                : undefined,
         };
     }
     setUIState(ui) {
@@ -376,12 +385,16 @@ class InMemoryWorkbench extends AbstractWorkbench {
         if (ui.viewport) {
             this.viewport = { ...ui.viewport };
         }
+        if (ui.nodeNames !== undefined) {
+            this.nodeNames = { ...ui.nodeNames };
+        }
     }
     getRuntimeState() {
         return this.runtimeState ? { ...this.runtimeState } : null;
     }
     setRuntimeState(runtime) {
         this.runtimeState = runtime ? { ...runtime } : null;
+        this.emit("runtimeMetadataChanged", {});
     }
     getHistory() {
         return this.historyState;
@@ -398,6 +411,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))
@@ -422,11 +436,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
@@ -450,12 +463,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
@@ -479,7 +492,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));
@@ -497,6 +510,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) => sparkGraph.isTypedOutput(v) ? sparkGraph.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 = sparkGraph.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 = sparkGraph.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 = sparkGraph.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.
@@ -542,7 +742,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 };
     }
     /**
@@ -557,6 +757,29 @@ class InMemoryWorkbench extends AbstractWorkbench {
     setCopiedData(data) {
         this.copiedData = data;
     }
+    /**
+     * Get the custom name for a node, if set.
+     */
+    getNodeName(nodeId) {
+        return this.nodeNames[nodeId];
+    }
+    /**
+     * Set a custom name for a node. Empty string or undefined removes the custom name.
+     * This is included in undo/redo history via extData.ui.
+     */
+    setNodeName(nodeId, name, options) {
+        if (name === undefined || name.trim() === "") {
+            delete this.nodeNames[nodeId];
+        }
+        else {
+            this.nodeNames[nodeId] = name.trim();
+        }
+        this.emit("graphUiChanged", {
+            def: this._def,
+            change: { type: "nodeName", nodeId },
+            ...options,
+        });
+    }
 }
 
 class CLIWorkbench {
@@ -567,8 +790,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})`);
@@ -1937,8 +2160,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);
@@ -1988,7 +2210,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 });
@@ -2023,7 +2248,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 = React.useCallback((nodes) => {
@@ -2469,7 +2697,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();
@@ -2478,7 +2705,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,
@@ -2487,9 +2714,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: {},
@@ -2528,7 +2755,7 @@ async function upload(parsed, wb, runner) {
     }
     if (runner.isRunning()) {
         await runner.applySnapshotFull({
-            def,
+            def: wb.def,
             environment,
             inputs,
             outputs,
@@ -2536,7 +2763,7 @@ 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, { dry: true });
@@ -2632,14 +2859,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 = React.useMemo(() => runner.getInputs(def), [runner, def, valuesTick]);
-    const inputDefaultsMap = React.useMemo(() => runner.getInputDefaults(def), [runner, def, valuesTick]);
-    const outputsMap = React.useMemo(() => runner.getOutputs(def), [runner, def, valuesTick]);
+    const inputsMap = React.useMemo(() => runner.getInputs(wb.def), [runner, wb, wb.def, valuesTick]);
+    const inputDefaultsMap = React.useMemo(() => runner.getInputDefaults(wb.def), [runner, wb, wb.def, valuesTick]);
+    const outputsMap = React.useMemo(() => runner.getOutputs(wb.def), [runner, wb, wb.def, valuesTick]);
     const outputTypesMap = React.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);
@@ -2654,14 +2880,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
     React.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 = {};
@@ -2683,18 +2909,17 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             }
             return next;
         });
-    }, [def, wb]);
+    }, [wb.def, wb]);
     // Auto layout (simple layered layout)
     const runAutoLayout = React.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);
         }
@@ -2725,7 +2950,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
@@ -2751,26 +2976,39 @@ 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 = React.useCallback((edgeId, typeId) => wb.updateEdgeType(edgeId, typeId), [wb]);
     const triggerExternal = React.useCallback((nodeId, event) => runner.triggerExternal(nodeId, event), [runner]);
+    const getNodeDisplayName = React.useCallback((nodeId) => {
+        const customName = wb.getNodeName(nodeId);
+        if (customName)
+            return customName;
+        const node = wb.def.nodes.find((n) => n.nodeId === nodeId);
+        if (!node)
+            return nodeId;
+        const desc = registry.nodes.get(node.typeId);
+        return desc?.displayName || node.typeId;
+    }, [wb, registry]);
+    const setNodeName = React.useCallback((nodeId, name) => {
+        wb.setNodeName(nodeId, name, { commit: true, reason: "rename-node" });
+    }, [wb]);
     // Helper to save runtime metadata and UI state to extData
-    const saveUiRuntimeMetadata = React.useCallback(async () => {
+    const saveUiRuntimeMetadata = React.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 }
                     : {}),
@@ -2780,7 +3018,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
     React.useEffect(() => {
         const add = (source, type) => (payload) => setEvents((prev) => {
@@ -2806,9 +3044,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 || {});
@@ -3097,6 +3334,9 @@ 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;
@@ -3104,7 +3344,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             }
             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;
@@ -3137,7 +3377,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                     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) => {
@@ -3158,7 +3398,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) => {
@@ -3197,7 +3437,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) => {
@@ -3217,7 +3457,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");
@@ -3240,7 +3480,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,
@@ -3255,6 +3495,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();
@@ -3272,13 +3536,14 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             offRunnerRegistry();
             offRunnerTransport();
             offFlowViewport();
+            offWbRuntimeMetadataChanged();
         };
     }, [runner, wb, setRegistry]);
     const isRunning = React.useCallback(() => runner.isRunning(), [runner]);
     const engineKind = React.useCallback(() => runner.getRunningEngine(), [runner]);
     const start = React.useCallback((engine) => {
         try {
-            runner.launch(wb.export(), { engine });
+            runner.launch(wb.def, { engine });
         }
         catch { }
     }, [runner, wb]);
@@ -3353,7 +3618,6 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         runner,
         registry,
         setRegistry,
-        def,
         selectedNodeId,
         selectedEdgeId,
         setSelection,
@@ -3389,12 +3653,13 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         triggerExternal,
         uiVersion,
         overrides,
+        getNodeDisplayName,
+        setNodeName,
     }), [
         wb,
         runner,
         registry,
         setRegistry,
-        def,
         selectedNodeId,
         selectedEdgeId,
         setSelection,
@@ -3429,142 +3694,30 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         runner,
         uiVersion,
         overrides,
+        getNodeDisplayName,
+        setNodeName,
     ]);
     return (jsxRuntime.jsx(WorkbenchContext.Provider, { value: value, children: children }));
 }
 
 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) => sparkGraph.isTypedOutput(v) ? sparkGraph.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 = sparkGraph.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 = sparkGraph.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 = sparkGraph.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 () => {
@@ -3575,7 +3728,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: () => {
@@ -3632,42 +3791,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;
@@ -3702,9 +3829,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();
         }
@@ -3723,8 +3849,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);
@@ -3823,13 +3948,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)
@@ -3961,7 +4086,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;
@@ -3988,9 +4112,9 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
                                                     selectedNodeStatus.activeRunIds.length > 0 ? (jsxRuntime.jsxs("div", { className: "mt-1", children: [jsxRuntime.jsx("div", { className: "text-[10px] text-blue-600", children: "RunIds:" }), jsxRuntime.jsx("div", { className: "flex flex-wrap gap-1 mt-1", children: selectedNodeStatus.activeRunIds.map((runId, idx) => (jsxRuntime.jsx("span", { className: "text-[10px] px-1.5 py-0.5 bg-blue-100 border border-blue-300 rounded font-mono", children: runId }, idx))) })] })) : (jsxRuntime.jsx("div", { className: "text-[10px] text-blue-600 mt-1", children: "RunIds not available (some runs may have started without runId)" }))] })), !!selectedNodeStatus?.lastError && (jsxRuntime.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) }))] })), jsxRuntime.jsxs("div", { className: "mb-2", children: [jsxRuntime.jsx("div", { className: "font-semibold mb-1", children: "Inputs" }), inputHandles.length === 0 ? (jsxRuntime.jsx("div", { className: "text-gray-500", children: "No inputs" })) : (inputHandles.map((h) => {
                                             const typeId = sparkGraph.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));
@@ -4160,11 +4284,27 @@ const DefaultNode = React.memo(function DefaultNode({ id, data, selected, isConn
             position: "relative",
             minWidth: typeof data.renderWidth === "number" ? data.renderWidth : undefined,
             minHeight: typeof data.renderHeight === "number" ? data.renderHeight : undefined,
-        }, children: [jsxRuntime.jsx(DefaultNodeHeader, { id: id, title: typeId, validation: validation, showId: data.showValues }), jsxRuntime.jsx(DefaultNodeContent, { data: data, isConnectable: isConnectable })] }));
+        }, children: [jsxRuntime.jsx(DefaultNodeHeader, { id: id, typeId: typeId, validation: validation, showId: data.showValues }), jsxRuntime.jsx(DefaultNodeContent, { data: data, isConnectable: isConnectable })] }));
 });
 DefaultNode.displayName = "DefaultNode";
-function DefaultNodeHeader({ id, title, validation, right, showId, onInvalidate, }) {
+function DefaultNodeHeader({ id, typeId, title, validation, right, showId, onInvalidate, }) {
     const ctx = useWorkbenchContext();
+    const [isEditing, setIsEditing] = React.useState(false);
+    const [editValue, setEditValue] = React.useState("");
+    const inputRef = React.useRef(null);
+    // Use getNodeDisplayName if typeId is provided, otherwise use title prop
+    const displayName = typeId ? ctx.getNodeDisplayName(id) : (title ?? id);
+    const effectiveTypeId = typeId ?? title ?? id;
+    // Get the default display name (without custom name) for comparison
+    const getDefaultDisplayName = React.useCallback(() => {
+        if (!typeId)
+            return title ?? id;
+        const node = ctx.wb.def.nodes.find((n) => n.nodeId === id);
+        if (!node)
+            return id;
+        const desc = ctx.registry.nodes.get(node.typeId);
+        return desc?.displayName || node.typeId;
+    }, [ctx, id, typeId, title]);
     const handleInvalidate = React.useCallback(() => {
         try {
             if (onInvalidate)
@@ -4177,10 +4317,51 @@ function DefaultNodeHeader({ id, title, validation, right, showId, onInvalidate,
         }
         catch { }
     }, [ctx, id, onInvalidate]);
+    const handleDoubleClick = React.useCallback((e) => {
+        // Only allow editing if typeId is provided (enables renaming)
+        if (!typeId)
+            return;
+        e.stopPropagation();
+        setIsEditing(true);
+        setEditValue(displayName);
+    }, [typeId, displayName]);
+    const handleSave = React.useCallback(() => {
+        if (!typeId)
+            return;
+        const trimmed = editValue.trim();
+        const defaultDisplayName = getDefaultDisplayName();
+        // If the trimmed value matches the default display name or typeId, clear the custom name
+        ctx.setNodeName(id, trimmed === defaultDisplayName || trimmed === effectiveTypeId
+            ? undefined
+            : trimmed);
+        setIsEditing(false);
+    }, [ctx, id, editValue, getDefaultDisplayName, effectiveTypeId, typeId]);
+    const handleCancel = React.useCallback(() => {
+        setIsEditing(false);
+        setEditValue(displayName);
+    }, [displayName]);
+    const handleKeyDown = React.useCallback((e) => {
+        if (e.key === "Enter") {
+            e.preventDefault();
+            e.stopPropagation();
+            handleSave();
+        }
+        else if (e.key === "Escape") {
+            e.preventDefault();
+            e.stopPropagation();
+            handleCancel();
+        }
+    }, [handleSave, handleCancel]);
+    React.useEffect(() => {
+        if (isEditing && inputRef.current) {
+            inputRef.current.focus();
+            inputRef.current.select();
+        }
+    }, [isEditing]);
     return (jsxRuntime.jsxs("div", { className: "flex items-center justify-center px-2 border-b border-solid border-gray-500 dark:border-gray-400 text-gray-600 dark:text-gray-300", style: {
             maxHeight: NODE_HEADER_HEIGHT_PX,
             minHeight: NODE_HEADER_HEIGHT_PX,
-        }, children: [jsxRuntime.jsx("strong", { className: "flex-1 h-full text-sm", style: { lineHeight: `${NODE_HEADER_HEIGHT_PX}px` }, children: title }), jsxRuntime.jsxs("div", { className: "flex items-center gap-1", children: [jsxRuntime.jsx("button", { className: "w-4 h-4 border border-gray-400 rounded text-[10px] leading-3 flex items-center justify-center", title: "Invalidate and re-run", onClick: (e) => {
+        }, children: [isEditing ? (jsxRuntime.jsx("input", { ref: inputRef, type: "text", value: editValue, onChange: (e) => setEditValue(e.target.value), onBlur: handleSave, onKeyDown: handleKeyDown, onClick: (e) => e.stopPropagation(), onMouseDown: (e) => e.stopPropagation(), className: "flex-1 h-full text-sm bg-transparent border border-blue-500 rounded px-1 outline-none wb-nodrag", style: { lineHeight: `${NODE_HEADER_HEIGHT_PX}px` } })) : (jsxRuntime.jsx("strong", { className: `flex-1 h-full text-sm select-none truncate ${typeId ? "cursor-text" : ""}`, style: { lineHeight: `${NODE_HEADER_HEIGHT_PX}px` }, onDoubleClick: handleDoubleClick, title: typeId ? "Double-click to rename" : undefined, children: displayName })), jsxRuntime.jsxs("div", { className: "flex items-center gap-1", children: [jsxRuntime.jsx("button", { className: "w-4 h-4 border border-gray-400 rounded text-[10px] leading-3 flex items-center justify-center", title: "Invalidate and re-run", onClick: (e) => {
                             e.stopPropagation();
                             handleInvalidate();
                         }, children: jsxRuntime.jsx(react$1.ArrowClockwiseIcon, { size: 10 }) }), right, validation.issues && validation.issues.length > 0 && (jsxRuntime.jsx(IssueBadge, { level: validation.issues.some((i) => i.level === "error")
@@ -4566,10 +4747,9 @@ const WorkbenchCanvas = React.forwardRef(({ showValues, toString, toElement, get
     const { nodeTypes, resolveNodeType } = React.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);
@@ -4588,14 +4768,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 } = React.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 };
@@ -4608,7 +4787,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,
@@ -5132,11 +5311,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] = React.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: {} };
@@ -5164,7 +5343,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,
                     });
@@ -5232,7 +5411,7 @@ 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) {
@@ -5247,36 +5426,27 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
     React.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 = React.useCallback(async (key) => {
@@ -5299,7 +5469,7 @@ 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)) {
@@ -5384,11 +5554,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
@@ -5398,7 +5567,7 @@ 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
@@ -5483,7 +5652,7 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
             }
         }
         wb.setInputs(selectedNodeId, { [handle]: value }, { commit: true });
-    }, [selectedNodeId, def.edges, effectiveHandles, wb]);
+    }, [selectedNodeId, wb.def.edges, effectiveHandles, wb]);
     const setInput = React.useMemo(() => {
         if (overrides?.setInput) {
             return overrides.setInput(baseSetInput, {