@bian-womp/spark-workbench 0.3.84 → 0.3.86

package/lib/cjs/index.cjs

@@ -139,6 +139,8 @@ class InMemoryWorkbench extends AbstractWorkbench {
         super(args);
         this._def = { nodes: [], edges: [] };
         this.listeners = new Map();
+        this._batchChanges = null;
+        this._batchDepth = 0;
         this.positions = {};
         this.sizes = {};
         this.selection = {
@@ -410,16 +412,24 @@ class InMemoryWorkbench extends AbstractWorkbench {
      */
     deleteSelection(options) {
         const selection = this.getSelection();
-        // Delete all selected nodes (this will also remove connected edges)
-        for (const nodeId of selection.nodes) {
-            this.removeNode(nodeId);
+        this.beginBatch();
+        let completed = false;
+        try {
+            // Delete all selected nodes (this will also remove connected edges)
+            for (const nodeId of selection.nodes) {
+                this.removeNode(nodeId);
+            }
+            // Delete remaining selected edges (edges not connected to deleted nodes)
+            for (const edgeId of selection.edges) {
+                this.disconnect(edgeId);
+            }
+            // Clear selection
+            this.setSelectionInternal({ nodes: [], edges: [] }, options);
+            completed = true;
         }
-        // Delete remaining selected edges (edges not connected to deleted nodes)
-        for (const edgeId of selection.edges) {
-            this.disconnect(edgeId);
+        finally {
+            this.endBatch(completed ? options : { ...options, commit: false });
         }
-        // Clear selection
-        this.setSelectionInternal({ nodes: [], edges: [] }, options);
     }
     setViewport(viewport) {
         if (lod.isEqual(this.viewport, viewport))
@@ -519,11 +529,69 @@ class InMemoryWorkbench extends AbstractWorkbench {
         return () => set.delete(handler);
     }
     emit(event, payload) {
+        if (this._batchDepth > 0 && this._batchChanges !== null) {
+            if (event === "graphChanged") {
+                const d = payload;
+                if (d.change && d.change.type !== "load" && d.change.type !== "batch") {
+                    this._batchChanges.push(d.change);
+                }
+                return;
+            }
+            if (event === "graphUiChanged") {
+                const d = payload;
+                if (d.commit) {
+                    const stripped = { ...d, commit: undefined };
+                    const set = this.listeners.get(event);
+                    if (set)
+                        for (const h of Array.from(set))
+                            h(stripped);
+                    return;
+                }
+            }
+            if (event === "validationChanged") {
+                return;
+            }
+        }
         const set = this.listeners.get(event);
         if (set)
             for (const h of Array.from(set))
                 h(payload);
     }
+    beginBatch() {
+        if (this._batchDepth === 0) {
+            this._batchChanges = [];
+        }
+        this._batchDepth++;
+    }
+    endBatch(options) {
+        if (this._batchDepth <= 0)
+            return;
+        this._batchDepth--;
+        if (this._batchDepth > 0)
+            return;
+        const changes = this._batchChanges;
+        this._batchChanges = null;
+        if (!changes || changes.length === 0)
+            return;
+        const set = this.listeners.get("graphChanged");
+        if (set) {
+            const payload = {
+                def: this._def,
+                change: { type: "batch", changes },
+                ...options,
+            };
+            for (const h of Array.from(set))
+                h(payload);
+        }
+        this.refreshValidation();
+    }
+    getInboundHandleIds(nodeId, shouldExcludeEdge) {
+        const inboundEdges = this.def.edges.filter((e) => e.target.nodeId === nodeId);
+        return new Set(inboundEdges.filter((e) => shouldExcludeEdge(e)).map((e) => e.target.handle));
+    }
+    excludeHandlesFromInputs(allNodeInputs, excludedHandles) {
+        return Object.fromEntries(Object.entries(allNodeInputs).filter(([handle]) => !excludedHandles.has(handle)));
+    }
     /**
      * Copy selected nodes and their internal edges.
      * Returns data in a format suitable for pasting.
@@ -569,18 +637,12 @@ class InMemoryWorkbench extends AbstractWorkbench {
             const pos = positions[node.nodeId];
             const size = sizes[node.nodeId];
             const customNodeData = this.getCustomNodeData(node.nodeId);
-            // Get all inbound edges for this node
-            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
-                .filter((e) => !selectedEdgeSet.has(e.id)) // Only exclude if edge is not selected
-                .map((e) => e.target.handle));
+            const inboundHandlesToExclude = this.getInboundHandleIds(node.nodeId, (e) => !selectedEdgeSet.has(e.id));
             const allNodeInputs = allInputs[node.nodeId] || {};
             // Include inputs that either:
             // 1. Don't have inbound edges (literal values)
             // 2. Have inbound edges that ARE selected (preserve the value from the edge)
-            const inputsToCopy = Object.fromEntries(Object.entries(allNodeInputs).filter(([handle]) => !inboundHandlesToExclude.has(handle)));
+            const inputsToCopy = this.excludeHandlesFromInputs(allNodeInputs, inboundHandlesToExclude);
             return {
                 typeId: node.typeId,
                 params: node.params,
@@ -621,21 +683,21 @@ class InMemoryWorkbench extends AbstractWorkbench {
      * Returns the ID of the last created node (or undefined if none created).
      */
     async bake(registry, runner, outputValue, outputTypeId, nodePosition, options) {
+        if (!outputTypeId || outputValue === undefined)
+            return undefined;
+        const bakeOpts = options || { commit: true, reason: "bake" };
+        this.beginBatch();
+        let completed = false;
         try {
-            if (!outputTypeId || outputValue === undefined)
-                return undefined;
             const unwrap = (v) => (sparkGraph.isTyped(v) ? sparkGraph.unwrapValue(v) : v);
             const coerceIfNeeded = async (fromType, toTypes, value) => {
                 if (!toTypes)
                     return value;
                 const typesArray = Array.isArray(toTypes) ? toTypes : [toTypes];
-                // If output type matches any input type exactly, no coercion needed
                 if (typesArray.includes(fromType))
                     return value;
-                // If no coercion function available, return as-is
                 if (!runner?.coerce)
                     return value;
-                // Try coercing to each type until one succeeds
                 for (const toType of typesArray) {
                     try {
                         return await runner.coerce(fromType, toType, value);
@@ -644,7 +706,6 @@ class InMemoryWorkbench extends AbstractWorkbench {
                         // Continue to next type
                     }
                 }
-                // If all coercion attempts failed, return value as-is
                 return value;
             };
             const pos = nodePosition;
@@ -699,13 +760,17 @@ class InMemoryWorkbench extends AbstractWorkbench {
                 }
             }
             if (newNodeId) {
-                this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, options || { commit: true, reason: "bake" });
+                this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, bakeOpts);
             }
+            completed = true;
             return newNodeId;
         }
         catch {
             return undefined;
         }
+        finally {
+            this.endBatch(completed ? bakeOpts : { ...bakeOpts, commit: false });
+        }
     }
     /**
      * Duplicate all selected nodes.
@@ -717,88 +782,85 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const selection = this.getSelection();
         if (selection.nodes.length === 0)
             return [];
-        const positions = this.getPositions();
-        const sizes = this.getSizes();
-        const newNodes = [];
-        const nodeIdMap = new Map(); // Map from original nodeId to new nodeId
-        const processedNodes = new Set(); // Track which nodes have been duplicated
-        const selectedNodeSet = new Set(selection.nodes);
-        const allInputs = runner.getInputs(this.def) || {};
-        // Build a map of incoming edges for each selected node
-        const incomingEdgesByNode = new Map();
-        for (const nodeId of selection.nodes) {
-            const incomingEdges = this.def.edges.filter((e) => e.target.nodeId === nodeId);
-            incomingEdgesByNode.set(nodeId, incomingEdges);
-        }
-        // Helper function to check if a node is ready to be processed
-        // (all its dependencies from selected nodes have been processed)
-        const isNodeReady = (nodeId) => {
-            const incomingEdges = incomingEdgesByNode.get(nodeId) || [];
-            for (const edge of incomingEdges) {
-                // If the source is a selected node, it must have been processed
-                if (selectedNodeSet.has(edge.source.nodeId)) {
-                    if (!processedNodes.has(edge.source.nodeId)) {
-                        return false;
+        const reason = options?.reason || "duplicate-selection";
+        const batchOptions = { commit: options?.commit ?? true, reason, dry: true };
+        this.beginBatch();
+        let completed = false;
+        try {
+            const positions = this.getPositions();
+            const sizes = this.getSizes();
+            const newNodes = [];
+            const nodeIdMap = new Map();
+            const processedNodes = new Set();
+            const selectedNodeSet = new Set(selection.nodes);
+            const allInputs = runner.getInputs(this.def) || {};
+            const incomingEdgesByNode = new Map();
+            for (const nodeId of selection.nodes) {
+                const incomingEdges = this.def.edges.filter((e) => e.target.nodeId === nodeId);
+                incomingEdgesByNode.set(nodeId, incomingEdges);
+            }
+            const isNodeReady = (nodeId) => {
+                const incomingEdges = incomingEdgesByNode.get(nodeId) || [];
+                for (const edge of incomingEdges) {
+                    if (selectedNodeSet.has(edge.source.nodeId)) {
+                        if (!processedNodes.has(edge.source.nodeId)) {
+                            return false;
+                        }
                     }
                 }
-            }
-            return true;
-        };
-        // Process nodes in topological order
-        let remainingNodes = new Set(selection.nodes);
-        while (remainingNodes.size > 0) {
-            // Find nodes that are ready to be processed (no unprocessed dependencies)
-            const readyNodes = Array.from(remainingNodes).filter((nodeId) => isNodeReady(nodeId));
-            if (readyNodes.length === 0) {
-                // If no nodes are ready, there might be a cycle. Process remaining nodes anyway.
-                // This shouldn't happen in a DAG, but handle it gracefully.
-                readyNodes.push(...remainingNodes);
-            }
-            // Process each ready node
-            for (const nodeId of readyNodes) {
-                const n = this.def.nodes.find((n) => n.nodeId === nodeId);
-                if (!n) {
-                    remainingNodes.delete(nodeId);
-                    continue;
+                return true;
+            };
+            let remainingNodes = new Set(selection.nodes);
+            while (remainingNodes.size > 0) {
+                const readyNodes = Array.from(remainingNodes).filter((nodeId) => isNodeReady(nodeId));
+                if (readyNodes.length === 0) {
+                    readyNodes.push(...remainingNodes);
                 }
-                const pos = positions[nodeId];
-                const size = sizes[nodeId];
-                // Get all inputs (including those with bindings, since edges will be duplicated)
-                const inputs = allInputs[nodeId] || {};
-                // Create the duplicated node
-                const newNodeId = this.addNode({
-                    typeId: n.typeId,
-                    params: n.params,
-                    resolvedHandles: n.resolvedHandles,
-                }, {
-                    inputs,
-                    position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
-                    size,
-                    copyOutputsFrom: nodeId,
-                    dry: true,
-                });
-                newNodes.push(newNodeId);
-                nodeIdMap.set(nodeId, newNodeId);
-                processedNodes.add(nodeId);
-                // Connect incoming edges for this node
-                const incomingEdges = incomingEdgesByNode.get(nodeId) || [];
-                for (const edge of incomingEdges) {
-                    // Determine the source node: use duplicated node if it was duplicated, otherwise use original
-                    const sourceNodeId = nodeIdMap.get(edge.source.nodeId) || edge.source.nodeId;
-                    this.connect({
-                        source: { nodeId: sourceNodeId, handle: edge.source.handle },
-                        target: { nodeId: newNodeId, handle: edge.target.handle },
-                        typeId: edge.typeId,
-                    }, { dry: true });
+                for (const nodeId of readyNodes) {
+                    const n = this.def.nodes.find((n) => n.nodeId === nodeId);
+                    if (!n) {
+                        remainingNodes.delete(nodeId);
+                        continue;
+                    }
+                    const pos = positions[nodeId];
+                    const size = sizes[nodeId];
+                    const inputs = allInputs[nodeId] || {};
+                    const newNodeId = this.addNode({
+                        typeId: n.typeId,
+                        params: n.params,
+                        resolvedHandles: n.resolvedHandles,
+                    }, {
+                        inputs,
+                        position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
+                        size,
+                        copyOutputsFrom: nodeId,
+                        dry: true,
+                        reason,
+                    });
+                    newNodes.push(newNodeId);
+                    nodeIdMap.set(nodeId, newNodeId);
+                    processedNodes.add(nodeId);
+                    const incomingEdges = incomingEdgesByNode.get(nodeId) || [];
+                    for (const edge of incomingEdges) {
+                        const sourceNodeId = nodeIdMap.get(edge.source.nodeId) || edge.source.nodeId;
+                        this.connect({
+                            source: { nodeId: sourceNodeId, handle: edge.source.handle },
+                            target: { nodeId: newNodeId, handle: edge.target.handle },
+                            typeId: edge.typeId,
+                        }, { dry: true, reason });
+                    }
+                    remainingNodes.delete(nodeId);
                 }
-                remainingNodes.delete(nodeId);
             }
+            if (newNodes.length > 0) {
+                this.setSelectionInternal({ nodes: newNodes, edges: [] }, options || { commit: true, reason });
+            }
+            completed = true;
+            return newNodes;
         }
-        // Select all newly duplicated nodes
-        if (newNodes.length > 0) {
-            this.setSelectionInternal({ nodes: newNodes, edges: [] }, options || { commit: true, reason: "duplicate-selection" });
+        finally {
+            this.endBatch(completed ? batchOptions : { ...batchOptions, commit: false });
         }
-        return newNodes;
     }
     /**
      * Duplicate a node and all its incoming edges.
@@ -810,37 +872,43 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const n = this.def.nodes.find((n) => n.nodeId === nodeId);
         if (!n)
             return undefined;
-        const pos = this.getPositions()[nodeId];
-        const size = this.getSizes()[nodeId];
-        // 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,
-            resolvedHandles: n.resolvedHandles,
-        }, {
-            inputs,
-            position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
-            size,
-            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" });
-        }
-        return newNodeId;
+        const reason = options?.reason || "duplicate-node";
+        const batchOptions = { commit: options?.commit ?? true, reason, dry: true };
+        this.beginBatch();
+        let completed = false;
+        try {
+            const pos = this.getPositions()[nodeId];
+            const size = this.getSizes()[nodeId];
+            const inputs = runner.getInputs(this.def)[nodeId] || {};
+            const newNodeId = this.addNode({
+                typeId: n.typeId,
+                params: n.params,
+                resolvedHandles: n.resolvedHandles,
+            }, {
+                inputs,
+                position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
+                size,
+                copyOutputsFrom: nodeId,
+                dry: true,
+                reason,
+            });
+            const incomingEdges = this.def.edges.filter((e) => e.target.nodeId === nodeId);
+            for (const edge of incomingEdges) {
+                this.connect({
+                    source: edge.source,
+                    target: { nodeId: newNodeId, handle: edge.target.handle },
+                    typeId: edge.typeId,
+                }, { dry: true, reason });
+            }
+            if (newNodeId) {
+                this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, options || { commit: true, reason });
+            }
+            completed = true;
+            return newNodeId;
+        }
+        finally {
+            this.endBatch(completed ? batchOptions : { ...batchOptions, commit: false });
+        }
     }
     /**
      * Paste copied graph data at the specified center position.
@@ -850,54 +918,62 @@ class InMemoryWorkbench extends AbstractWorkbench {
     pasteCopiedData(data, center, options) {
         const nodeIdMap = new Map();
         const edgeIds = [];
-        // Add nodes
-        for (const nodeData of data.nodes) {
-            const newNodeId = this.addNode({
-                typeId: nodeData.typeId,
-                params: nodeData.params,
-                resolvedHandles: nodeData.resolvedHandles,
-            }, {
-                inputs: nodeData.inputs,
-                position: nodeData.position
-                    ? {
-                        x: nodeData.position.x + center.x,
-                        y: nodeData.position.y + center.y,
-                    }
-                    : undefined,
-                size: nodeData.size,
-                copyOutputsFrom: nodeData.originalNodeId,
-                dry: true,
-            });
-            nodeIdMap.set(nodeData.originalNodeId, newNodeId);
-            if (nodeData.customData !== undefined) {
-                this.setCustomNodeData(newNodeId, lod.cloneDeep(nodeData.customData), {
-                    commit: false,
-                    reason: options?.reason,
+        const reason = options?.reason || "paste";
+        const batchOptions = { commit: options?.commit ?? true, reason, dry: true };
+        this.beginBatch();
+        let completed = false;
+        try {
+            for (const nodeData of data.nodes) {
+                const newNodeId = this.addNode({
+                    typeId: nodeData.typeId,
+                    params: nodeData.params,
+                    resolvedHandles: nodeData.resolvedHandles,
+                }, {
+                    inputs: nodeData.inputs,
+                    position: nodeData.position
+                        ? {
+                            x: nodeData.position.x + center.x,
+                            y: nodeData.position.y + center.y,
+                        }
+                        : undefined,
+                    size: nodeData.size,
+                    copyOutputsFrom: nodeData.originalNodeId,
+                    dry: true,
+                    reason,
                 });
+                nodeIdMap.set(nodeData.originalNodeId, newNodeId);
+                if (nodeData.customData !== undefined) {
+                    this.setCustomNodeData(newNodeId, lod.cloneDeep(nodeData.customData), {
+                        commit: false,
+                        reason: options?.reason,
+                    });
+                }
             }
-        }
-        // Add edges
-        for (const edgeData of data.edges) {
-            const newSourceNodeId = nodeIdMap.get(edgeData.sourceNodeId);
-            const newTargetNodeId = nodeIdMap.get(edgeData.targetNodeId);
-            if (newSourceNodeId && newTargetNodeId) {
-                const edgeId = this.connect({
-                    source: {
-                        nodeId: newSourceNodeId,
-                        handle: edgeData.sourceHandle,
-                    },
-                    target: {
-                        nodeId: newTargetNodeId,
-                        handle: edgeData.targetHandle,
-                    },
-                    typeId: edgeData.typeId,
-                }, { dry: true });
-                edgeIds.push(edgeId);
+            for (const edgeData of data.edges) {
+                const newSourceNodeId = nodeIdMap.get(edgeData.sourceNodeId);
+                const newTargetNodeId = nodeIdMap.get(edgeData.targetNodeId);
+                if (newSourceNodeId && newTargetNodeId) {
+                    const edgeId = this.connect({
+                        source: {
+                            nodeId: newSourceNodeId,
+                            handle: edgeData.sourceHandle,
+                        },
+                        target: {
+                            nodeId: newTargetNodeId,
+                            handle: edgeData.targetHandle,
+                        },
+                        typeId: edgeData.typeId,
+                    }, { dry: true, reason });
+                    edgeIds.push(edgeId);
+                }
             }
+            this.setSelectionInternal({ nodes: Array.from(nodeIdMap.values()), edges: edgeIds }, options);
+            completed = true;
+            return { nodeIdMap, edgeIds };
+        }
+        finally {
+            this.endBatch(completed ? batchOptions : { ...batchOptions, commit: false });
         }
-        // Select the newly pasted nodes
-        this.setSelectionInternal({ nodes: Array.from(nodeIdMap.values()), edges: edgeIds }, options);
-        return { nodeIdMap, edgeIds };
     }
     /**
      * Get the currently copied graph data.
@@ -4382,17 +4458,62 @@ function WorkbenchProvider({ wb, runner, overrides, uiVersion, children, }) {
             setRegistryVersion((v) => v + 1);
         });
         const offWbGraphChanged = wb.on("graphChanged", (event) => {
-            // Clear validation errors for removed nodes
             if (event.change?.type === "removeNode") {
                 const removedNodeId = event.change.nodeId;
                 setInputValidationErrors((prev) => prev.filter((err) => err.nodeId !== removedNodeId));
             }
+            else if (event.change?.type === "batch") {
+                const removedIds = event.change.changes
+                    .filter((c) => c.type === "removeNode")
+                    .map((c) => c.nodeId);
+                if (removedIds.length > 0) {
+                    setInputValidationErrors((prev) => prev.filter((err) => !removedIds.includes(err.nodeId)));
+                }
+            }
             return add("workbench", "graphChanged")(event);
         });
         const offWbGraphUiChangedForLog = wb.on("graphUiChanged", add("workbench", "graphUiChanged"));
         const offWbValidationChanged = wb.on("validationChanged", add("workbench", "validationChanged"));
         // Ensure newly added nodes start as invalidated until first evaluation
         const offWbGraphChangedForUpdate = wb.on("graphChanged", async (event) => {
+            // Handle batched compound operations (duplicate, paste, delete, bake)
+            if (event.change?.type === "batch") {
+                const { changes } = event.change;
+                const isDry = !!event.dry;
+                const batchReason = event.reason ?? "batch";
+                try {
+                    if (runner.isRunning()) {
+                        const hasNodeOps = changes.some((c) => c.type === "addNode" && (c.inputs || c.copyOutputsFrom));
+                        await runner.update(event.def, { dry: isDry || hasNodeOps });
+                        for (const change of changes) {
+                            if (change.type === "addNode") {
+                                if (change.inputs) {
+                                    await runner.setInputs(change.nodeId, change.inputs, { dry: isDry });
+                                }
+                                if (change.copyOutputsFrom) {
+                                    await runner.copyOutputs(change.copyOutputsFrom, change.nodeId, { dry: isDry });
+                                }
+                            }
+                            if (change.type === "setInputs") {
+                                await runner.setInputs(change.nodeId, change.inputs, { dry: isDry });
+                            }
+                        }
+                    }
+                    if (event.commit) {
+                        await saveUiRuntimeMetadata(wb, runner);
+                        const history = await runner.commit(batchReason).catch((err) => {
+                            console.error("[WorkbenchContext] Error committing batch:", err);
+                            return undefined;
+                        });
+                        if (history)
+                            wb.setHistory(history);
+                    }
+                }
+                catch (err) {
+                    console.error("[WorkbenchContext] Error processing batch:", err);
+                }
+                return;
+            }
             // Build detailed reason from change type
             let reason = "graph-changed";
             if (event.change) {