@bian-womp/spark-workbench 0.3.90 → 0.3.91

package/lib/src/core/InMemoryWorkbench.js

@@ -1,1016 +0,0 @@
-import { GraphBuilder, getInputDeclaredTypes, isTyped, unwrapValue, createSimpleGraphRegistry, } from "@bian-womp/spark-graph";
-import lod from "lodash";
-import { AbstractWorkbench } from "./AbstractWorkbench";
-export class InMemoryWorkbench extends AbstractWorkbench {
-    constructor(args) {
-        super(args);
-        this._def = { nodes: [], edges: [] };
-        this.listeners = new Map();
-        this._batchChanges = null;
-        this._batchDepth = 0;
-        this.positions = {};
-        this.sizes = {};
-        this.selection = {
-            nodes: [],
-            edges: [],
-        };
-        this.nodeNames = {};
-        this.customData = {};
-        this.runtimeState = null;
-        this.viewport = null;
-        this.historyState = undefined;
-        this.copiedData = null;
-        this._registry = createSimpleGraphRegistry();
-    }
-    get def() {
-        return this._def;
-    }
-    get registry() {
-        return this._registry;
-    }
-    setRegistry(registry) {
-        this._registry = registry;
-        this.refreshValidation();
-        this.emit("registryChanged", { registry });
-    }
-    /**
-     * Check if a node should auto run based on registry node description policy or node definition params policy.
-     * @param nodeId - The node ID to check
-     * @returns true if the node has autoRun enabled in either registry or params policy
-     */
-    shouldNodeAutoRun(nodeId) {
-        const node = this._def.nodes.find((n) => n.nodeId === nodeId);
-        if (!node)
-            return false;
-        // Check registry node description policy
-        const desc = this._registry.nodes.get(node.typeId);
-        const registryAutoRun = desc?.policy?.autoRun === true;
-        // Check node definition params policy (takes precedence over registry)
-        const paramsAutoRun = node?.params?.policy?.autoRun === true;
-        // Node has autoRun if either registry or params sets it
-        return registryAutoRun || paramsAutoRun;
-    }
-    async load(def) {
-        this._def = { nodes: [...def.nodes], edges: [...def.edges] };
-        if (this.layout) {
-            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 filteredPositions = Object.fromEntries(Object.entries(this.positions).filter(([id]) => defNodeIds.has(id)));
-        const filteredSizes = Object.fromEntries(Object.entries(this.sizes).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));
-        // Clean up extData for removed nodes/edges
-        if (this.customData.nodes) {
-            const filteredExtNodes = Object.fromEntries(Object.entries(this.customData.nodes).filter(([id]) => defNodeIds.has(id)));
-            this.customData.nodes = Object.keys(filteredExtNodes).length > 0 ? filteredExtNodes : undefined;
-        }
-        if (this.customData.edges) {
-            const filteredExtEdges = Object.fromEntries(Object.entries(this.customData.edges).filter(([id]) => defEdgeIds.has(id)));
-            this.customData.edges = Object.keys(filteredExtEdges).length > 0 ? filteredExtEdges : undefined;
-        }
-        this.positions = filteredPositions;
-        this.sizes = filteredSizes;
-        this.selection = { nodes: filteredNodes, edges: filteredEdges };
-        this.emit("graphChanged", { def: this._def, change: { type: "load" } });
-        this.refreshValidation();
-    }
-    refreshValidation() {
-        this.emit("validationChanged", this.validate());
-    }
-    validate() {
-        if (this.registry) {
-            const builder = new GraphBuilder(this.registry);
-            const report = builder.validate(this._def);
-            return report;
-        }
-        const issues = [];
-        const nodeIds = new Set();
-        for (const n of this._def.nodes) {
-            if (nodeIds.has(n.nodeId)) {
-                issues.push({
-                    level: "error",
-                    code: "NODE_ID_DUP",
-                    message: `Duplicate nodeId ${n.nodeId}`,
-                });
-            }
-            else
-                nodeIds.add(n.nodeId);
-        }
-        const edgeIds = new Set();
-        for (const e of this._def.edges) {
-            if (edgeIds.has(e.id)) {
-                issues.push({
-                    level: "error",
-                    code: "EDGE_ID_DUP",
-                    message: `Duplicate edge id ${e.id}`,
-                });
-            }
-            else
-                edgeIds.add(e.id);
-        }
-        return { ok: issues.every((i) => i.level !== "error"), issues };
-    }
-    setInputs(nodeId, inputs, options) {
-        this.emit("graphChanged", {
-            def: this._def,
-            change: { type: "setInputs", nodeId, inputs },
-            ...options,
-        });
-        this.refreshValidation();
-    }
-    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,
-            resolvedHandles: node.resolvedHandles,
-        });
-        if (options?.position)
-            this.positions[id] = options.position;
-        if (options?.size)
-            this.sizes[id] = options.size;
-        this.emit("graphChanged", {
-            def: this._def,
-            change: {
-                type: "addNode",
-                nodeId: id,
-                inputs: options?.inputs,
-                copyOutputsFrom: options?.copyOutputsFrom,
-            },
-            ...lod.pick(options, ["dry", "commit", "reason"]),
-        });
-        this.refreshValidation();
-        return id;
-    }
-    removeNode(nodeId, options) {
-        const removedEdges = new Set();
-        this._def.nodes = this._def.nodes.filter((n) => n.nodeId !== nodeId);
-        this._def.edges = this._def.edges.filter((e) => {
-            if (e.source.nodeId === nodeId || e.target.nodeId === nodeId) {
-                removedEdges.add(e.id);
-                return false;
-            }
-            return true;
-        });
-        delete this.positions[nodeId];
-        delete this.sizes[nodeId];
-        delete this.nodeNames[nodeId];
-        this.setSelectionInternal({
-            nodes: this.selection.nodes.filter((id) => id !== nodeId),
-            edges: this.selection.edges.filter((id) => !removedEdges.has(id)),
-        }, options);
-        this.emit("graphChanged", {
-            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({
-            id,
-            source: { ...edge.source },
-            target: { ...edge.target },
-            typeId: edge.typeId,
-        });
-        this.emit("graphChanged", {
-            def: this._def,
-            change: { type: "connect", edgeId: id },
-            ...options,
-        });
-        this.refreshValidation();
-        return id;
-    }
-    disconnect(edgeId, options) {
-        this._def.edges = this._def.edges.filter((e) => e.id !== edgeId);
-        this.emit("graphChanged", {
-            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);
-        if (!e)
-            return;
-        if (!typeId)
-            delete e.typeId;
-        else
-            e.typeId = typeId;
-        this.emit("graphChanged", {
-            def: this._def,
-            change: { type: "updateEdgeType", edgeId, typeId },
-        });
-        this.refreshValidation();
-    }
-    updateParams(nodeId, params) {
-        const n = this._def.nodes.find((n) => n.nodeId === nodeId);
-        if (!n)
-            return;
-        n.params = { ...(n.params ?? {}), ...params };
-        this.emit("graphChanged", {
-            def: this._def,
-            change: { type: "updateParams", nodeId },
-        });
-    }
-    updateResolvedHandles(nodeId, resolvedHandles, options) {
-        const n = this._def.nodes.find((n) => n.nodeId === nodeId);
-        if (!n)
-            return;
-        n.resolvedHandles = { ...(n.resolvedHandles ?? {}), ...resolvedHandles };
-        this.emit("graphChanged", {
-            def: this._def,
-            change: { type: "updateResolvedHandles", nodeId },
-            ...options,
-        });
-        this.refreshValidation();
-    }
-    // Position and selection APIs for React Flow bridge
-    setPositions(positions, options) {
-        this.positions = { ...this.positions, ...positions };
-        this.emit("graphUiChanged", { change: { type: "moveNodes" }, ...options });
-    }
-    getPositions() {
-        return { ...this.positions };
-    }
-    setSizes(sizes, options) {
-        const updatedSizes = { ...this.sizes };
-        for (const [nodeId, size] of Object.entries(sizes)) {
-            if (size) {
-                updatedSizes[nodeId] = size;
-            }
-            else {
-                delete updatedSizes[nodeId];
-            }
-        }
-        this.sizes = updatedSizes;
-        this.emit("graphUiChanged", {
-            change: { type: "resizeNodes" },
-            ...options,
-        });
-    }
-    getSizes() {
-        return { ...this.sizes };
-    }
-    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", { change: { type: "selection" }, ...options });
-    }
-    setSelection(sel, options) {
-        this.setSelectionInternal(sel, options);
-    }
-    getSelection() {
-        return {
-            nodes: [...this.selection.nodes],
-            edges: [...this.selection.edges],
-        };
-    }
-    /**
-     * Delete all selected nodes and edges.
-     */
-    deleteSelection(options) {
-        const selection = this.getSelection();
-        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;
-        }
-        finally {
-            this.endBatch(completed ? options : { ...options, commit: false });
-        }
-    }
-    setViewport(viewport) {
-        if (lod.isEqual(this.viewport, viewport))
-            return;
-        const init = this.viewport === null;
-        this.viewport = { ...viewport };
-        this.emit("graphUiChanged", { change: { type: "viewport" }, init });
-    }
-    getViewport() {
-        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 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)));
-        const filteredSizes = Object.fromEntries(Object.entries(this.sizes).filter(([id]) => defNodeIds.has(id)));
-        return {
-            positions: Object.keys(filteredPositions).length > 0 ? filteredPositions : undefined,
-            selection: filteredNodes.length > 0 || filteredEdges.length > 0
-                ? {
-                    nodes: filteredNodes,
-                    edges: filteredEdges,
-                }
-                : undefined,
-            viewport: this.viewport ? { ...this.viewport } : undefined,
-            nodeNames: Object.keys(filteredNodeNames).length > 0 ? filteredNodeNames : undefined,
-            sizes: Object.keys(filteredSizes).length > 0 ? filteredSizes : undefined,
-        };
-    }
-    setUIState(ui) {
-        if (!ui)
-            return;
-        if (ui.positions) {
-            this.positions = { ...ui.positions };
-        }
-        if (ui.selection) {
-            this.selection = {
-                nodes: [...ui.selection.nodes],
-                edges: [...ui.selection.edges],
-            };
-            this.emit("selectionChanged", this.selection);
-            this.emit("graphUiChanged", {
-                change: { type: "selection" },
-                init: true,
-            });
-        }
-        if (ui.viewport) {
-            this.viewport = { ...ui.viewport };
-            this.emit("graphUiChanged", { change: { type: "viewport" }, init: true });
-        }
-        if (ui.nodeNames !== undefined) {
-            this.nodeNames = { ...ui.nodeNames };
-            for (const [nodeId, name] of Object.entries(ui.nodeNames)) {
-                this.emit("graphUiChanged", {
-                    change: { type: "nodeName", nodeId, name },
-                    init: true,
-                });
-            }
-        }
-        if (ui.sizes !== undefined) {
-            const defNodeIds = new Set(this._def.nodes.map((n) => n.nodeId));
-            this.sizes = Object.fromEntries(Object.entries(ui.sizes).filter(([id]) => defNodeIds.has(id)));
-        }
-    }
-    getRuntimeState() {
-        return this.runtimeState ? { ...this.runtimeState } : null;
-    }
-    setRuntimeState(runtime) {
-        this.runtimeState = runtime ? { ...runtime } : null;
-        this.emit("runtimeMetadataChanged", {});
-    }
-    getHistory() {
-        return this.historyState;
-    }
-    setHistory(history) {
-        this.historyState = history;
-        this.emit("historyChanged", { history });
-    }
-    getNodeRuntimeMetadata(nodeId) {
-        return this.runtimeState?.nodes[nodeId];
-    }
-    updateNodeRuntimeMetadata(nodeId, updater) {
-        const current = this.runtimeState ?? { nodes: {} };
-        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))
-            this.listeners.set(event, new Set());
-        const set = this.listeners.get(event);
-        set.add(handler);
-        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.
-     * Positions are normalized relative to the selection bounds center.
-     * Uses the same logic as duplicate: copies inputs without bindings and supports copyOutputsFrom.
-     */
-    copySelection(runner, getNodeSize) {
-        const selection = this.getSelection();
-        if (selection.nodes.length === 0)
-            return null;
-        const positions = this.getPositions();
-        const sizes = this.getSizes();
-        const selectedNodeSet = new Set(selection.nodes);
-        // Collect nodes to copy
-        const nodesToCopy = this.def.nodes.filter((n) => selectedNodeSet.has(n.nodeId));
-        if (nodesToCopy.length === 0)
-            return null;
-        // Calculate bounds
-        let minX = Infinity;
-        let minY = Infinity;
-        let maxX = -Infinity;
-        let maxY = -Infinity;
-        nodesToCopy.forEach((node) => {
-            const pos = positions[node.nodeId];
-            const size = sizes[node.nodeId] || getNodeSize?.(node.nodeId, node.typeId);
-            if (pos) {
-                minX = Math.min(minX, pos.x);
-                minY = Math.min(minY, pos.y);
-                if (size) {
-                    maxX = Math.max(maxX, pos.x + size.width);
-                    maxY = Math.max(maxY, pos.y + size.height);
-                }
-            }
-        });
-        const bounds = { minX, minY, maxX, maxY };
-        const centerX = (bounds.minX + bounds.maxX) / 2;
-        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(this.def);
-        const selectedEdgeSet = new Set(selection.edges);
-        const copiedNodes = nodesToCopy.map((node) => {
-            const pos = positions[node.nodeId];
-            const size = sizes[node.nodeId];
-            const customNodeData = this.getCustomNodeData(node.nodeId);
-            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 = this.excludeHandlesFromInputs(allNodeInputs, inboundHandlesToExclude);
-            return {
-                typeId: node.typeId,
-                params: node.params,
-                resolvedHandles: node.resolvedHandles,
-                position: pos
-                    ? {
-                        x: pos.x - centerX,
-                        y: pos.y - centerY,
-                    }
-                    : undefined,
-                size,
-                inputs: inputsToCopy,
-                customData: customNodeData !== undefined ? lod.cloneDeep(customNodeData) : undefined,
-                originalNodeId: node.nodeId,
-            };
-        });
-        // Collect edges between copied nodes
-        const copiedEdges = this.def.edges
-            .filter((edge) => {
-            return selectedNodeSet.has(edge.source.nodeId) && selectedNodeSet.has(edge.target.nodeId);
-        })
-            .map((edge) => ({
-            sourceNodeId: edge.source.nodeId,
-            sourceHandle: edge.source.handle,
-            targetNodeId: edge.target.nodeId,
-            targetHandle: edge.target.handle,
-            typeId: edge.typeId,
-        }));
-        return {
-            nodes: copiedNodes,
-            edges: copiedEdges,
-            bounds,
-        };
-    }
-    /**
-     * 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) {
-        if (!outputTypeId || outputValue === undefined)
-            return undefined;
-        const bakeOpts = options || { commit: true, reason: "bake" };
-        this.beginBatch();
-        let completed = false;
-        try {
-            const unwrap = (v) => (isTyped(v) ? unwrapValue(v) : v);
-            const coerceIfNeeded = async (fromType, toTypes, value) => {
-                if (!toTypes)
-                    return value;
-                const typesArray = Array.isArray(toTypes) ? toTypes : [toTypes];
-                if (typesArray.includes(fromType))
-                    return value;
-                if (!runner?.coerce)
-                    return value;
-                for (const toType of typesArray) {
-                    try {
-                        return await runner.coerce(fromType, toType, value);
-                    }
-                    catch {
-                        // Continue to next type
-                    }
-                }
-                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 inTypes = getInputDeclaredTypes(nodeDesc?.inputs, singleTarget.inputHandle);
-                const coerced = await coerceIfNeeded(outputTypeId, inTypes, unwrap(outputValue));
-                newNodeId = this.addNode({
-                    typeId: singleTarget.nodeTypeId,
-                }, {
-                    inputs: { [singleTarget.inputHandle]: coerced },
-                    position: { x: pos.x + 180, y: pos.y },
-                });
-            }
-            else if (isArray && arrTarget) {
-                const nodeDesc = registry.nodes.get(arrTarget.nodeTypeId);
-                const inTypes = getInputDeclaredTypes(nodeDesc?.inputs, arrTarget.inputHandle);
-                const coerced = await coerceIfNeeded(outputTypeId, inTypes, 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 inTypes = getInputDeclaredTypes(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, inTypes, 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: [] }, bakeOpts);
-            }
-            completed = true;
-            return newNodeId;
-        }
-        catch {
-            return undefined;
-        }
-        finally {
-            this.endBatch(completed ? bakeOpts : { ...bakeOpts, commit: false });
-        }
-    }
-    /**
-     * 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 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;
-            };
-            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);
-                }
-                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);
-                }
-            }
-            if (newNodes.length > 0) {
-                this.setSelectionInternal({ nodes: newNodes, edges: [] }, options || { commit: true, reason });
-            }
-            completed = true;
-            return newNodes;
-        }
-        finally {
-            this.endBatch(completed ? batchOptions : { ...batchOptions, commit: false });
-        }
-    }
-    /**
-     * 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.
-     */
-    duplicateNode(nodeId, runner, options) {
-        const n = this.def.nodes.find((n) => n.nodeId === nodeId);
-        if (!n)
-            return undefined;
-        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.
-     * Returns the mapping from original node IDs to new node IDs.
-     * Uses copyOutputsFrom to copy outputs from original nodes (like duplicate does).
-     */
-    pasteCopiedData(data, center, options) {
-        const nodeIdMap = new Map();
-        const edgeIds = [];
-        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,
-                    });
-                }
-            }
-            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 });
-        }
-    }
-    /**
-     * Get the currently copied graph data.
-     */
-    getCopiedData() {
-        return this.copiedData;
-    }
-    /**
-     * Set the copied graph data (used for paste functionality).
-     */
-    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", {
-            change: { type: "nodeName", nodeId, name },
-            ...options,
-        });
-    }
-    /**
-     * Get custom data for a specific node.
-     */
-    getCustomNodeData(nodeId) {
-        return this.customData.nodes?.[nodeId];
-    }
-    /**
-     * Set custom data for a specific node (supports partial updates).
-     */
-    setCustomNodeData(nodeId, data, options) {
-        if (!this.customData.nodes) {
-            this.customData.nodes = {};
-        }
-        if (data === undefined) {
-            delete this.customData.nodes[nodeId];
-            if (Object.keys(this.customData.nodes).length === 0) {
-                delete this.customData.nodes;
-            }
-        }
-        else {
-            // If merge is true, merge with existing data; otherwise replace
-            if (options?.merge && this.customData.nodes[nodeId]) {
-                this.customData.nodes[nodeId] = {
-                    ...this.customData.nodes[nodeId],
-                    ...data,
-                };
-            }
-            else {
-                this.customData.nodes[nodeId] = data;
-            }
-        }
-        this.emit("graphUiChanged", {
-            change: {
-                type: "customNodeData",
-                nodeId,
-                data: this.customData.nodes?.[nodeId],
-            },
-            ...options,
-        });
-    }
-    /**
-     * Get custom data for a specific edge.
-     */
-    getCustomEdgeData(edgeId) {
-        return this.customData.edges?.[edgeId];
-    }
-    /**
-     * Set custom data for a specific edge (supports partial updates).
-     */
-    setCustomEdgeData(edgeId, data, options) {
-        if (!this.customData.edges) {
-            this.customData.edges = {};
-        }
-        if (data === undefined) {
-            delete this.customData.edges[edgeId];
-            if (Object.keys(this.customData.edges).length === 0) {
-                delete this.customData.edges;
-            }
-        }
-        else {
-            // If merge is true, merge with existing data; otherwise replace
-            if (options?.merge && this.customData.edges[edgeId]) {
-                this.customData.edges[edgeId] = {
-                    ...this.customData.edges[edgeId],
-                    ...data,
-                };
-            }
-            else {
-                this.customData.edges[edgeId] = data;
-            }
-        }
-        this.emit("graphUiChanged", {
-            change: {
-                type: "customEdgeData",
-                edgeId,
-                data: this.customData.edges?.[edgeId],
-            },
-            ...options,
-        });
-    }
-    /**
-     * Get custom metadata.
-     */
-    getCustomMetaData() {
-        return this.customData.meta;
-    }
-    /**
-     * Set custom metadata (supports partial updates).
-     */
-    setCustomMetaData(meta, options) {
-        if (meta === undefined) {
-            delete this.customData.meta;
-        }
-        else {
-            // If merge is true, merge with existing metadata; otherwise replace
-            if (options?.merge && this.customData.meta) {
-                this.customData.meta = {
-                    ...this.customData.meta,
-                    ...meta,
-                };
-            }
-            else {
-                this.customData.meta = meta;
-            }
-        }
-        this.emit("graphUiChanged", {
-            change: { type: "customMetaData", meta: this.customData.meta },
-            ...options,
-        });
-    }
-    /**
-     * Get all custom data.
-     */
-    getCustomData() {
-        return { ...this.customData };
-    }
-    /**
-     * Set all custom data.
-     */
-    setCustomData(custom, options) {
-        if (custom === undefined) {
-            this.customData = {};
-        }
-        else {
-            this.customData = lod.pick(custom, ["nodes", "edges", "meta"]);
-        }
-        this.emit("graphUiChanged", {
-            change: {
-                type: "customData",
-                nodes: custom?.nodes,
-                edges: custom?.edges,
-                meta: custom?.meta,
-            },
-            ...options,
-        });
-    }
-}
-//# sourceMappingURL=InMemoryWorkbench.js.map