@bian-womp/spark-workbench 0.2.61 → 0.2.63

package/lib/esm/index.js

@@ -188,21 +188,26 @@ class InMemoryWorkbench extends AbstractWorkbench {
         }
         return { ok: issues.every((i) => i.level !== "error"), issues };
     }
-    addNode(node) {
+    addNode(node, options) {
         const id = node.nodeId ??
             this.genId("n", new Set(this.def.nodes.map((n) => n.nodeId)));
         this.def.nodes.push({
             nodeId: id,
             typeId: node.typeId,
             params: node.params,
-            initialInputs: node.initialInputs,
             resolvedHandles: node.resolvedHandles,
         });
         if (node.position)
             this.positions[id] = node.position;
         this.emit("graphChanged", {
             def: this.def,
-            change: { type: "addNode", nodeId: id },
+            change: {
+                type: "addNode",
+                nodeId: id,
+                inputs: options?.inputs,
+                copyOutputsFrom: options?.copyOutputsFrom,
+            },
+            dry: options?.dry,
         });
         this.refreshValidation();
         return id;
@@ -217,7 +222,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
         });
         this.refreshValidation();
     }
-    connect(edge) {
+    connect(edge, options) {
         const id = edge.id ?? this.genId("e", new Set(this.def.edges.map((e) => e.id)));
         this.def.edges.push({
             id,
@@ -228,6 +233,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
         this.emit("graphChanged", {
             def: this.def,
             change: { type: "connect", edgeId: id },
+            dry: options?.dry,
         });
         this.refreshValidation();
         return id;
@@ -425,35 +431,6 @@ class AbstractGraphRunner {
             this.stop();
         }
     }
-    triggerExternal(nodeId, event) {
-        this.engine?.triggerExternal(nodeId, event);
-    }
-    // Batch update multiple inputs on a node and trigger a single run
-    setInputs(nodeId, inputs) {
-        if (!inputs)
-            return;
-        if (!this.stagedInputs[nodeId])
-            this.stagedInputs[nodeId] = {};
-        for (const [handle, value] of Object.entries(inputs)) {
-            if (value === undefined) {
-                delete this.stagedInputs[nodeId][handle];
-            }
-            else {
-                this.stagedInputs[nodeId][handle] = value;
-            }
-        }
-        if (this.engine) {
-            // Running: set all inputs
-            this.engine.setInputs(nodeId, inputs);
-        }
-        else {
-            // Not running: emit a single synthetic value event per handle; UI will coalesce
-            console.warn("Engine does not exists");
-            for (const [handle, value] of Object.entries(inputs)) {
-                this.emit("value", { nodeId, handle, value, io: "input" });
-            }
-        }
-    }
     async whenIdle() {
         await this.engine?.whenIdle();
     }
@@ -494,10 +471,8 @@ class AbstractGraphRunner {
         const out = {};
         for (const n of def.nodes) {
             const dynDefaults = n.resolvedHandles?.inputDefaults ?? {};
-            const graphDefaults = n.initialInputs ?? {};
-            const merged = { ...dynDefaults, ...graphDefaults };
-            if (Object.keys(merged).length > 0) {
-                out[n.nodeId] = merged;
+            if (Object.keys(dynDefaults).length > 0) {
+                out[n.nodeId] = dynDefaults;
             }
         }
         return out;
@@ -541,13 +516,22 @@ class LocalGraphRunner extends AbstractGraphRunner {
         this.setEnvironment = (env, opts) => {
             if (!this.runtime)
                 return;
-            if (opts?.merge) {
-                const current = this.runtime.getEnvironment();
-                const next = { ...(current || {}), ...(env || {}) };
-                this.runtime.setEnvironment(next);
+            const wasPaused = this.runtime.isPaused();
+            if (opts?.dry && !wasPaused)
+                this.runtime.pause();
+            try {
+                if (opts?.merge) {
+                    const current = this.runtime.getEnvironment();
+                    const next = { ...(current || {}), ...(env || {}) };
+                    this.runtime.setEnvironment(next);
+                }
+                else {
+                    this.runtime.setEnvironment(env);
+                }
             }
-            else {
-                this.runtime.setEnvironment(env);
+            finally {
+                if (opts?.dry && !wasPaused)
+                    this.runtime.resume();
             }
         };
         this.getEnvironment = () => {
@@ -565,14 +549,24 @@ class LocalGraphRunner extends AbstractGraphRunner {
         // Signal UI that freshly built graph should be considered invalidated
         this.emit("invalidate", { reason: "graph-built" });
     }
-    update(def) {
+    update(def, options) {
         if (!this.runtime)
             return;
-        // Prevent mid-run churn while wiring changes are applied
-        this.runtime.pause();
-        this.runtime.update(def, this.registry);
-        this.runtime.resume();
-        this.emit("invalidate", { reason: "graph-updated" });
+        const wasPaused = this.runtime.isPaused();
+        // Pause runtime if dry option is set (to prevent execution) or if not paused already
+        if (options?.dry && !wasPaused) {
+            this.runtime.pause();
+        }
+        try {
+            this.runtime.update(def, this.registry);
+            this.emit("invalidate", { reason: "graph-updated" });
+        }
+        finally {
+            // Resume only if we paused it due to dry option
+            if (options?.dry && !wasPaused) {
+                this.runtime.resume();
+            }
+        }
     }
     launch(def, opts) {
         super.launch(def, opts);
@@ -663,6 +657,70 @@ class LocalGraphRunner extends AbstractGraphRunner {
         }
         return out;
     }
+    triggerExternal(nodeId, event, options) {
+        // Handle dry option: pause runtime before triggering, resume after
+        const wasPaused = this.runtime?.isPaused() ?? false;
+        if (options?.dry && !wasPaused && this.runtime) {
+            this.runtime.pause();
+        }
+        try {
+            this.engine?.triggerExternal(nodeId, event);
+        }
+        finally {
+            if (options?.dry && !wasPaused && this.runtime) {
+                this.runtime.resume();
+            }
+        }
+    }
+    // Batch update multiple inputs on a node and trigger a single run
+    setInputs(nodeId, inputs, options) {
+        if (!inputs)
+            return;
+        if (!this.stagedInputs[nodeId])
+            this.stagedInputs[nodeId] = {};
+        for (const [handle, value] of Object.entries(inputs)) {
+            if (value === undefined) {
+                delete this.stagedInputs[nodeId][handle];
+            }
+            else {
+                this.stagedInputs[nodeId][handle] = value;
+            }
+        }
+        // Handle dry option: pause runtime before setting inputs, resume after
+        const wasPaused = this.runtime?.isPaused() ?? false;
+        if (options?.dry && !wasPaused && this.runtime) {
+            this.runtime.pause();
+        }
+        try {
+            if (this.engine) {
+                this.engine.setInputs(nodeId, inputs);
+            }
+            else {
+                // Not running: emit a single synthetic value event per handle; UI will coalesce
+                console.warn("Engine does not exists");
+                for (const [handle, value] of Object.entries(inputs)) {
+                    this.emit("value", { nodeId, handle, value, io: "input" });
+                }
+            }
+        }
+        finally {
+            if (options?.dry && !wasPaused && this.runtime) {
+                this.runtime.resume();
+            }
+        }
+    }
+    copyOutputs(fromNodeId, toNodeId, options) {
+        if (!this.runtime)
+            return;
+        // Get outputs from source node
+        const fromNode = this.runtime.getNodeData(fromNodeId);
+        if (!fromNode?.outputs)
+            return;
+        // Copy outputs to target node using hydrate
+        // hydrate already pauses internally, so we don't need to handle dry option here
+        // reemit: !options?.dry means don't propagate downstream if dry mode
+        this.runtime.hydrate({ outputs: { [toNodeId]: { ...fromNode.outputs } } }, { reemit: !options?.dry });
+    }
     async snapshotFull() {
         const def = undefined; // UI will supply def/positions on download for local
         const inputs = this.getInputs(this.runtime
@@ -687,7 +745,7 @@ class LocalGraphRunner extends AbstractGraphRunner {
         return { def, environment, inputs, outputs };
     }
     async applySnapshotFull(payload, options) {
-        if (payload.def && options?.skipBuild !== true) {
+        if (payload.def && !options?.skipBuild) {
             this.build(payload.def);
         }
         this.setEnvironment?.(payload.environment || {}, { merge: false });
@@ -985,7 +1043,7 @@ class RemoteGraphRunner extends AbstractGraphRunner {
                             // Trigger update so validation/UI refreshes using last known graph
                             try {
                                 if (this.lastDef)
-                                    this.update(this.lastDef);
+                                    await this.update(this.lastDef);
                             }
                             catch {
                                 console.error("Failed to update graph definition after registry changed");
@@ -1000,16 +1058,18 @@ class RemoteGraphRunner extends AbstractGraphRunner {
         });
     }
     build(def) { }
-    update(def) {
-        // Remote: forward update; ignore errors (fire-and-forget)
-        this.ensureClient().then(async (client) => {
-            try {
-                await client.update(def);
-                this.emit("invalidate", { reason: "graph-updated" });
-                this.lastDef = def;
-            }
-            catch { }
-        });
+    async update(def, options) {
+        // Remote: forward update and await completion
+        const client = await this.ensureClient();
+        try {
+            await client.update(def, options);
+            this.emit("invalidate", { reason: "graph-updated" });
+            this.lastDef = def;
+        }
+        catch (err) {
+            // Log error but don't throw to maintain compatibility
+            console.error("[RemoteGraphRunner] Error updating graph:", err);
+        }
     }
     launch(def, opts) {
         super.launch(def, opts);
@@ -1130,13 +1190,53 @@ class RemoteGraphRunner extends AbstractGraphRunner {
         const client = await this.ensureClient();
         await client.flush();
     }
-    triggerExternal(nodeId, event) {
-        this.ensureClient().then(async (client) => {
-            try {
-                await client.getEngine().triggerExternal(nodeId, event);
+    setInputs(nodeId, inputs, options) {
+        // Update staged inputs (for getInputs to work correctly)
+        if (!this.stagedInputs[nodeId])
+            this.stagedInputs[nodeId] = {};
+        for (const [handle, value] of Object.entries(inputs)) {
+            if (value === undefined) {
+                delete this.stagedInputs[nodeId][handle];
             }
-            catch { }
-        });
+            else {
+                this.stagedInputs[nodeId][handle] = value;
+            }
+        }
+        // If engine exists, call directly; otherwise ensure client (fire-and-forget)
+        if (this.engine) {
+            this.engine.setInputs(nodeId, inputs, options);
+        }
+        else {
+            this.ensureClient()
+                .then((client) => {
+                client.getEngine().setInputs(nodeId, inputs, options);
+            })
+                .catch(() => {
+                // Emit synthetic events if connection fails
+                for (const [handle, value] of Object.entries(inputs)) {
+                    this.emit("value", { nodeId, handle, value, io: "input" });
+                }
+            });
+        }
+    }
+    async copyOutputs(fromNodeId, toNodeId, options) {
+        const client = await this.ensureClient();
+        await client.copyOutputs(fromNodeId, toNodeId, options);
+    }
+    triggerExternal(nodeId, event, options) {
+        // If engine exists, call directly; otherwise ensure client (fire-and-forget)
+        if (this.engine) {
+            this.engine.triggerExternal(nodeId, event, options);
+        }
+        else {
+            this.ensureClient()
+                .then((client) => {
+                client.getEngine().triggerExternal(nodeId, event, options);
+            })
+                .catch(() => {
+                // Silently fail if connection not available
+            });
+        }
     }
     async coerce(from, to, value) {
         const client = await this.ensureClient();
@@ -1194,18 +1294,19 @@ class RemoteGraphRunner extends AbstractGraphRunner {
             }
         }
     }
-    setEnvironment(env, opts) {
+    async setEnvironment(env, opts) {
         // Use client if available, otherwise ensure client and then set environment
         if (this.client) {
-            this.client.setEnvironment(env, opts).catch(() => { });
+            await this.client.setEnvironment(env, opts);
         }
         else {
-            // If client not ready yet, ensure it and then set environment
-            this.ensureClient()
-                .then((client) => {
-                client.setEnvironment(env, opts).catch(() => { });
-            })
-                .catch(() => { });
+            try {
+                const client = await this.ensureClient();
+                await client.setEnvironment(env, opts);
+            }
+            catch {
+                // Silently fail if connection not available
+            }
         }
     }
     getEnvironment() {
@@ -1266,7 +1367,7 @@ class RemoteGraphRunner extends AbstractGraphRunner {
         }
         return out;
     }
-    dispose() {
+    async dispose() {
         // Idempotent: allow multiple calls safely
         if (this.disposed)
             return;
@@ -1287,9 +1388,12 @@ class RemoteGraphRunner extends AbstractGraphRunner {
         this.registryFetched = false; // Reset so registry is fetched again on reconnect
         this.registryFetching = false; // Reset fetching state
         if (clientToDispose) {
-            clientToDispose.dispose().catch((err) => {
+            try {
+                await clientToDispose.dispose();
+            }
+            catch (err) {
                 console.warn("[RemoteGraphRunner] Error disposing client:", err);
-            });
+            }
         }
         const disconnectedStatus = {
             state: "disconnected",
@@ -2612,6 +2716,36 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
                 }));
             }
         });
+        const offWbGraphChangedForUpdate = wb.on("graphChanged", async (event) => {
+            if (!runner.isRunning())
+                return;
+            try {
+                if (event.change?.type === "addNode") {
+                    const { nodeId, inputs, copyOutputsFrom } = event.change;
+                    if (event.dry) {
+                        await runner.update(event.def, { dry: true });
+                        if (inputs) {
+                            runner.setInputs(nodeId, inputs, { dry: true });
+                        }
+                        if (copyOutputsFrom) {
+                            runner.copyOutputs(copyOutputsFrom, nodeId, { dry: true });
+                        }
+                    }
+                    else {
+                        await runner.update(event.def, { dry: !!inputs });
+                        if (inputs) {
+                            runner.setInputs(nodeId, inputs, { dry: false });
+                        }
+                    }
+                }
+                else {
+                    await runner.update(event.def, { dry: event.dry });
+                }
+            }
+            catch (err) {
+                console.error("[WorkbenchContext] Error updating graph:", err);
+            }
+        });
         const offWbdSetValidation = wb.on("validationChanged", (r) => setValidation(r));
         const offWbSelectionChanged = wb.on("selectionChanged", (sel) => {
             setSelectedNodeId(sel.nodes?.[0]);
@@ -2619,13 +2753,13 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
         });
         const offWbError = wb.on("error", add("workbench", "error"));
         // Registry updates: swap registry and refresh graph validation/UI
-        const offRunnerRegistry = runner.on("registry", (newReg) => {
+        const offRunnerRegistry = runner.on("registry", async (newReg) => {
             try {
                 setRegistry(newReg);
                 wb.setRegistry(newReg);
                 // Trigger a graph update so the UI revalidates with new types/enums/nodes
                 try {
-                    runner.update(wb.export());
+                    await runner.update(wb.export());
                 }
                 catch {
                     console.error("Failed to update graph definition after registry changed");
@@ -2656,6 +2790,7 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
             offWbValidationChanged();
             offWbError();
             offWbAddNode();
+            offWbGraphChangedForUpdate();
             offWbdSetValidation();
             offWbSelectionChanged();
             offRunnerRegistry();
@@ -2673,16 +2808,6 @@ function WorkbenchProvider({ wb, runner, registry, setRegistry, overrides, uiVer
     const stop = useCallback(() => runner.stop(), [runner]);
     const step = useCallback(() => runner.step(), [runner]);
     const flush = useCallback(() => runner.flush(), [runner]);
-    // Push incremental updates into running engine without full reload
-    const isGraphRunning = isRunning();
-    useEffect(() => {
-        if (isGraphRunning) {
-            try {
-                runner.update(def);
-            }
-            catch { }
-        }
-    }, [runner, isGraphRunning, def, graphTick]);
     const validationByNode = useMemo(() => {
         const inputs = {};
         const outputs = {};
@@ -3434,7 +3559,7 @@ function NodeContextMenu({ open, clientPos, nodeId, handlers, canRunPull, bakeab
     return (jsxs("div", { ref: ref, tabIndex: -1, className: "fixed z-[1000] bg-white border border-gray-300 rounded-lg shadow-lg p-1 min-w-[180px] text-sm text-gray-700", style: { left: x, top: y }, onClick: (e) => e.stopPropagation(), onMouseDown: (e) => e.stopPropagation(), onWheel: (e) => e.stopPropagation(), onContextMenu: (e) => {
             e.preventDefault();
             e.stopPropagation();
-        }, children: [jsxs("div", { className: "px-2 py-1 font-semibold text-gray-700", children: ["Node (", nodeId, ")"] }), jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onDelete, children: "Delete" }), jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onDuplicate, children: "Duplicate" }), canRunPull && (jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onRunPull, children: "Run (pull)" })), jsx("div", { className: "h-px bg-gray-200 my-1" }), bakeableOutputs.length > 0 && (jsxs(Fragment, { children: [jsx("div", { className: "px-2 py-1 font-semibold text-gray-700", children: "Bake" }), bakeableOutputs.map((h) => (jsxs("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: () => handlers.onBake(h), children: ["Bake: ", h] }, h))), jsx("div", { className: "h-px bg-gray-200 my-1" })] })), jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onCopyId, children: "Copy Node ID" })] }));
+        }, children: [jsxs("div", { className: "px-2 py-1 font-semibold text-gray-700", children: ["Node (", nodeId, ")"] }), jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onDelete, children: "Delete" }), jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onDuplicate, children: "Duplicate" }), jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onDuplicateWithEdges, children: "Duplicate with edges" }), canRunPull && (jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onRunPull, children: "Run (pull)" })), jsx("div", { className: "h-px bg-gray-200 my-1" }), bakeableOutputs.length > 0 && (jsxs(Fragment, { children: [jsx("div", { className: "px-2 py-1 font-semibold text-gray-700", children: "Bake" }), bakeableOutputs.map((h) => (jsxs("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: () => handlers.onBake(h), children: ["Bake: ", h] }, h))), jsx("div", { className: "h-px bg-gray-200 my-1" })] })), jsx("button", { className: "block w-full text-left px-2 py-1 hover:bg-gray-100", onClick: handlers.onCopyId, children: "Copy Node ID" })] }));
 }
 
 function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap, outputTypesMap, onClose) {
@@ -3467,26 +3592,20 @@ function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap,
                 const nodeDesc = registry.nodes.get(singleTarget.nodeTypeId);
                 const inType = getInputTypeId(nodeDesc?.inputs, singleTarget.inputHandle);
                 const coerced = await coerceIfNeeded(typeId, inType, unwrap(raw));
-                const newId = wb.addNode({
+                wb.addNode({
                     typeId: singleTarget.nodeTypeId,
                     position: { x: pos.x + 180, y: pos.y },
-                });
-                runner.update(wb.export());
-                await runner.whenIdle();
-                runner.setInputs(newId, { [singleTarget.inputHandle]: coerced });
+                }, { inputs: { [singleTarget.inputHandle]: coerced } });
                 return;
             }
             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));
-                const newId = wb.addNode({
+                wb.addNode({
                     typeId: arrTarget.nodeTypeId,
                     position: { x: pos.x + 180, y: pos.y },
-                });
-                runner.update(wb.export());
-                await runner.whenIdle();
-                runner.setInputs(newId, { [arrTarget.inputHandle]: coerced });
+                }, { inputs: { [arrTarget.inputHandle]: coerced } });
                 return;
             }
             if (isArray && elemTarget) {
@@ -3498,24 +3617,13 @@ function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap,
                 const COLS = 4;
                 const DX = 180;
                 const DY = 160;
-                const nodeIds = [];
                 for (let idx = 0; idx < coercedItems.length; idx++) {
                     const col = idx % COLS;
                     const row = Math.floor(idx / COLS);
-                    const newId = wb.addNode({
+                    wb.addNode({
                         typeId: elemTarget.nodeTypeId,
                         position: { x: pos.x + (col + 1) * DX, y: pos.y + row * DY },
-                    });
-                    nodeIds.push(newId);
-                }
-                if (nodeIds.length > 0) {
-                    runner.update(wb.export());
-                    await runner.whenIdle();
-                    for (let idx = 0; idx < coercedItems.length; idx++) {
-                        runner.setInputs(nodeIds[idx], {
-                            [elemTarget.inputHandle]: coercedItems[idx],
-                        });
-                    }
+                    }, { inputs: { [elemTarget.inputHandle]: coercedItems[idx] } });
                 }
                 return;
             }
@@ -3533,15 +3641,52 @@ function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap,
             if (!n)
                 return onClose();
             const pos = wb.getPositions?.()[nodeId] || { x: 0, y: 0 };
-            const newId = wb.addNode({
+            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)));
+            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,
+            });
+            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 },
-                initialInputs: n.initialInputs,
                 resolvedHandles: n.resolvedHandles,
+            }, {
+                inputs,
+                copyOutputsFrom: nodeId,
+                dry: true,
             });
-            await runner.whenIdle();
-            runner.setInputs(newId, { ...runner.getInputs(def)[nodeId] });
+            // 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 });
+            }
             onClose();
         },
         onRunPull: async () => {
@@ -3860,18 +4005,7 @@ const WorkbenchCanvas = React.forwardRef(({ showValues, toString, toElement, get
             setNodeMenuOpen(false);
         }
     };
-    const addNodeAt = useCallback(async (typeId, opts) => {
-        const nodeId = wb.addNode({
-            typeId,
-            initialInputs: opts.initialInputs,
-            position: opts.position,
-        });
-        if (opts.inputs) {
-            runner.update(wb.export());
-            await runner.whenIdle();
-            runner.setInputs(nodeId, opts.inputs);
-        }
-    }, [wb, runner]);
+    const addNodeAt = useCallback(async (typeId, opts) => wb.addNode({ typeId, position: opts.position }, { inputs: opts.inputs }), [wb]);
     const onCloseMenu = useCallback(() => {
         setMenuOpen(false);
     }, []);
@@ -4115,7 +4249,7 @@ function WorkbenchStudioCanvas({ setRegistry, autoScroll, onAutoScrollChange, ex
         const ex = examples.find((e) => e.id === key) ?? examples[0];
         if (!ex)
             return;
-        const { registry: r, def } = await ex.load();
+        const { registry: r, def, inputs } = await ex.load();
         // Keep registry consistent with backend:
         // - For local backend, allow example to provide its own registry
         // - For remote backend, registry is automatically managed by RemoteGraphRunner
@@ -4128,6 +4262,12 @@ 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());
+        // Set initial inputs if provided
+        if (inputs) {
+            for (const [nodeId, map] of Object.entries(inputs)) {
+                runner.setInputs(nodeId, map);
+            }
+        }
         runAutoLayout();
         setExampleState(key);
         onExampleChange?.(key);