@synergenius/flow-weaver 0.2.0

package/dist/api/manipulation/nodes.js

@@ -0,0 +1,333 @@
+/**
+ * Node instance operations for workflow manipulation
+ */
+import { produce } from "immer";
+import { withoutValidation, assertNodeExists, assertNodeNotExists, } from "../helpers.js";
+/**
+ * Add a node instance to the workflow
+ *
+ * @param ast - Workflow to modify
+ * @param node - Node instance to add
+ * @returns Modified workflow
+ * @throws {Error} If node ID already exists or node type doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const ast = addNode(workflow, {
+ *   type: 'NodeInstance',
+ *   id: 'processor1',
+ *   nodeType: 'dataProcessor'
+ * });
+ * ```
+ */
+export function addNode(ast, node) {
+    // Check for duplicate ID
+    assertNodeNotExists(ast, node.id);
+    // Note: We don't check if node type exists here (eventual consistency model).
+    // Diagnostics will catch INVALID_NODE_TYPE if the type doesn't exist.
+    // Use produce directly with simplified type to avoid excessive type instantiation
+    return produce(ast, (draft) => {
+        draft.instances.push(node);
+    });
+}
+/**
+ * Remove a node instance from the workflow.
+ * Uses minimal validation (only checks node exists) to allow deletion
+ * even when the workflow has other validation errors.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - ID of node to remove
+ * @param options - Remove options
+ * @returns Modified workflow
+ * @throws {Error} If node doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Remove node and all its connections
+ * const ast = removeNode(workflow, 'processor1');
+ *
+ * // Remove node, keep connections (will fail validation)
+ * const ast = removeNode(workflow, 'processor1', { removeConnections: false });
+ * ```
+ */
+export function removeNode(ast, nodeId, options = {}) {
+    const { removeConnections = true, } = options;
+    // First, verify node exists (fail fast with clear error)
+    assertNodeExists(ast, nodeId);
+    return withoutValidation(ast, (draft) => {
+        // Remove node instance
+        const nodeIndex = draft.instances.findIndex((n) => n.id === nodeId);
+        draft.instances.splice(nodeIndex, 1);
+        // Remove connections if requested
+        if (removeConnections) {
+            draft.connections = draft.connections.filter((conn) => conn.from.node !== nodeId && conn.to.node !== nodeId);
+        }
+        // Remove from scopes
+        if (draft.scopes) {
+            Object.keys(draft.scopes).forEach((scopeName) => {
+                draft.scopes[scopeName] = draft.scopes[scopeName].filter((id) => id !== nodeId);
+            });
+        }
+        // Clean up macros referencing the deleted node
+        if (draft.macros) {
+            draft.macros = draft.macros.filter((macro) => {
+                if (macro.type === 'map') {
+                    return macro.instanceId !== nodeId && macro.childId !== nodeId;
+                }
+                if (macro.type === 'path') {
+                    return !macro.steps.some(s => s.node === nodeId);
+                }
+                return true;
+            });
+            if (draft.macros.length === 0) {
+                delete draft.macros;
+            }
+        }
+    });
+}
+/**
+ * Rename a node instance (updates all connections)
+ *
+ * @param ast - Workflow to modify
+ * @param oldId - Current node ID
+ * @param newId - New node ID
+ * @returns Modified workflow
+ * @throws {Error} If old ID doesn't exist or new ID already exists
+ *
+ * @example
+ * ```typescript
+ * const ast = renameNode(workflow, 'processor1', 'dataProcessor');
+ * // All connections updated automatically
+ * ```
+ */
+export function renameNode(ast, oldId, newId) {
+    assertNodeExists(ast, oldId);
+    assertNodeNotExists(ast, newId);
+    return withoutValidation(ast, (draft) => {
+        // Update node instance ID
+        const node = draft.instances.find((n) => n.id === oldId);
+        node.id = newId;
+        // Update all connections
+        draft.connections.forEach((conn) => {
+            if (conn.from.node === oldId) {
+                conn.from.node = newId;
+            }
+            if (conn.to.node === oldId) {
+                conn.to.node = newId;
+            }
+        });
+        // Update scopes
+        if (draft.scopes) {
+            Object.keys(draft.scopes).forEach((scopeName) => {
+                draft.scopes[scopeName] = draft.scopes[scopeName].map((id) => id === oldId ? newId : id);
+            });
+        }
+        // Update macro references
+        if (draft.macros) {
+            for (const macro of draft.macros) {
+                if (macro.type === 'map') {
+                    if (macro.instanceId === oldId)
+                        macro.instanceId = newId;
+                    if (macro.childId === oldId)
+                        macro.childId = newId;
+                }
+                else if (macro.type === 'path') {
+                    macro.steps = macro.steps.map(s => s.node === oldId ? { ...s, node: newId } : s);
+                }
+            }
+        }
+    });
+}
+/**
+ * Update a node instance
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - ID of node to update
+ * @param updates - Partial node instance to merge
+ * @returns Modified workflow
+ * @throws {Error} If node doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const ast = updateNode(workflow, 'processor1', {
+ *   config: { x: 100, y: 200, label: 'Main Processor' }
+ * });
+ * ```
+ */
+export function updateNode(ast, nodeId, updates) {
+    assertNodeExists(ast, nodeId);
+    return withoutValidation(ast, (draft) => {
+        const node = draft.instances.find((n) => n.id === nodeId);
+        Object.assign(node, updates);
+    });
+}
+/**
+ * Add multiple nodes at once.
+ * Uses no validation to allow adding even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param nodes - Array of node instances to add
+ * @returns Modified workflow
+ */
+export function addNodes(ast, nodes) {
+    // Check for duplicate IDs only (eventual consistency model)
+    nodes.forEach((node) => {
+        assertNodeNotExists(ast, node.id);
+    });
+    // Use produce directly with simplified type to avoid excessive type instantiation
+    return produce(ast, (draft) => {
+        nodes.forEach((node) => {
+            draft.instances.push(node);
+        });
+    });
+}
+/**
+ * Remove multiple nodes at once.
+ * Uses minimal validation (only checks nodes exist) to allow deletion
+ * even when the workflow has other validation errors.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeIds - Array of node IDs to remove
+ * @returns Modified workflow
+ */
+export function removeNodes(ast, nodeIds) {
+    // First, verify all nodes exist (fail fast with clear error)
+    nodeIds.forEach((nodeId) => {
+        assertNodeExists(ast, nodeId);
+    });
+    return withoutValidation(ast, (draft) => {
+        // Remove all nodes
+        draft.instances = draft.instances.filter((n) => !nodeIds.includes(n.id));
+        // Remove all connections
+        draft.connections = draft.connections.filter((conn) => !nodeIds.includes(conn.from.node) &&
+            !nodeIds.includes(conn.to.node));
+        // Remove from scopes
+        if (draft.scopes) {
+            Object.keys(draft.scopes).forEach((scopeName) => {
+                draft.scopes[scopeName] = draft.scopes[scopeName].filter((id) => !nodeIds.includes(id));
+            });
+        }
+    });
+}
+/**
+ * Set node configuration
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - ID of node to configure
+ * @param config - Configuration to set
+ * @returns Modified workflow
+ */
+export function setNodeConfig(ast, nodeId, config) {
+    return updateNode(ast, nodeId, { config });
+}
+/**
+ * Set node position (UI coordinates)
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - ID of node to position (including virtual nodes "Start" and "Exit")
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @returns Modified workflow
+ */
+export function setNodePosition(ast, nodeId, x, y) {
+    // Validate before mutation to avoid type instantiation issues inside callback
+    if (nodeId !== "Start" && nodeId !== "Exit") {
+        assertNodeExists(ast, nodeId);
+    }
+    return withoutValidation(ast, (draft) => {
+        // Handle Start/Exit virtual nodes
+        if (nodeId === "Start" || nodeId === "Exit") {
+            const uiField = nodeId === "Start" ? "startNode" : "exitNode";
+            draft.ui = {
+                ...draft.ui,
+                [uiField]: {
+                    ...draft.ui?.[uiField],
+                    x,
+                    y,
+                },
+            };
+            return;
+        }
+        // Regular nodes - find and update
+        const node = draft.instances.find((n) => n.id === nodeId);
+        if (!node)
+            return; // Already validated above
+        if (!node.config) {
+            node.config = {};
+        }
+        node.config.x = x;
+        node.config.y = y;
+    });
+}
+/**
+ * Set node minimized state (UI state)
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - ID of node to minimize/expand
+ * @param minimized - Whether the node is minimized
+ * @returns Modified workflow
+ */
+export function setNodeMinimized(ast, nodeId, minimized) {
+    // Validate before mutation to avoid type instantiation issues inside callback
+    assertNodeExists(ast, nodeId);
+    return withoutValidation(ast, (draft) => {
+        const node = draft.instances.find((n) => n.id === nodeId);
+        if (!node)
+            return; // Already validated above
+        if (!node.config) {
+            node.config = {};
+        }
+        node.config.minimized = minimized;
+    });
+}
+/**
+ * Set node label (UI display name)
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - ID of node to label
+ * @param label - Label to set (empty string or undefined clears the label)
+ * @returns Modified workflow
+ */
+export function setNodeLabel(ast, nodeId, label) {
+    // Validate before mutation to avoid type instantiation issues inside callback
+    assertNodeExists(ast, nodeId);
+    return withoutValidation(ast, (draft) => {
+        const node = draft.instances.find((n) => n.id === nodeId);
+        if (!node)
+            return; // Already validated above
+        if (!node.config) {
+            node.config = {};
+        }
+        // Set or clear the label
+        if (label) {
+            node.config.label = label;
+        }
+        else {
+            delete node.config.label;
+        }
+    });
+}
+/**
+ * Set node size (UI state)
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - ID of node to resize
+ * @param width - Node width
+ * @param height - Node height
+ * @returns Modified workflow
+ */
+export function setNodeSize(ast, nodeId, width, height) {
+    // Validate before mutation to avoid type instantiation issues inside callback
+    assertNodeExists(ast, nodeId);
+    return withoutValidation(ast, (draft) => {
+        const node = draft.instances.find((n) => n.id === nodeId);
+        if (!node)
+            return; // Already validated above
+        if (!node.config) {
+            node.config = {};
+        }
+        node.config.width = width;
+        node.config.height = height;
+    });
+}
+//# sourceMappingURL=nodes.js.map

package/dist/api/manipulation/ports.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Port operations for workflow manipulation
+ */
+import type { TWorkflowAST } from "../../ast/types.js";
+/**
+ * Swap the order of two ports on a node type (Start/Exit only)
+ * For regular instances, use swapNodeInstancePortOrder()
+ *
+ * @param ast - Workflow to modify
+ * @param nodeTypeName - Name of the node type ("Start" or "Exit" only)
+ * @param portName1 - Name of first port
+ * @param portName2 - Name of second port
+ * @returns Modified workflow
+ * @throws {Error} If used with non-Start/Exit nodes or ports are invalid
+ */
+export declare function swapPortOrder(ast: TWorkflowAST, nodeTypeName: string, portName1: string, portName2: string): TWorkflowAST;
+/**
+ * Swap the order of two ports on a specific node instance (instance-level only)
+ *
+ * @param ast - Workflow to modify
+ * @param instanceId - ID of the node instance
+ * @param portName1 - Name of first port
+ * @param portName2 - Name of second port
+ * @returns Modified workflow
+ * @throws {Error} If instance doesn't exist or ports are invalid
+ *
+ * @example
+ * ```typescript
+ * const ast = swapNodeInstancePortOrder(workflow, 'doubler1', 'value', 'execute');
+ * ```
+ */
+export declare function swapNodeInstancePortOrder(ast: TWorkflowAST, instanceId: string, portName1: string, portName2: string): TWorkflowAST;
+/**
+ * Set Start or Exit node ports directly.
+ * Used by worker to persist port configuration changes on virtual nodes.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeType - "Start" or "Exit"
+ * @param ports - The ports object to set
+ * @returns Modified workflow
+ * @throws {Error} If nodeType is not "Start" or "Exit"
+ */
+export declare function setStartExitPorts(ast: TWorkflowAST, nodeType: "Start" | "Exit", ports: Record<string, unknown>): TWorkflowAST;
+/**
+ * Set instance port configs directly.
+ * Used by worker to persist port configuration changes.
+ *
+ * @param ast - Workflow to modify
+ * @param instanceId - ID of the node instance
+ * @param portConfigs - The port configs array to set
+ * @returns Modified workflow
+ * @throws {Error} If instance doesn't exist
+ */
+export declare function setInstancePortConfigs(ast: TWorkflowAST, instanceId: string, portConfigs: Array<{
+    portName: string;
+    direction: "INPUT" | "OUTPUT";
+    order?: number;
+}>): TWorkflowAST;
+//# sourceMappingURL=ports.d.ts.map

package/dist/api/manipulation/ports.js

@@ -0,0 +1,228 @@
+/**
+ * Port operations for workflow manipulation
+ */
+import { produce } from "immer";
+import { withoutValidation } from "../helpers.js";
+/**
+ * Swap the order of two ports on a node type
+ *
+ * @param ast - Workflow to modify
+ * @param nodeTypeName - Name of the node type (or "Start"/"Exit" for workflow interface)
+ * @param portName1 - Name of first port
+ * @param portName2 - Name of second port
+ * @returns Modified workflow
+ * @throws {Error} If node type doesn't exist or ports are invalid
+ *
+ * @example
+ * ```typescript
+ * const ast = swapPortOrder(workflow, 'MyNode', 'input1', 'input2');
+ * ```
+ */
+/**
+ * Helper function to compute implicit port order based on position in the ports object
+ */
+function getImplicitOrder(ports, portName) {
+    const portNames = Object.keys(ports);
+    return portNames.indexOf(portName);
+}
+/**
+ * Swap the order of two ports on a node type (Start/Exit only)
+ * For regular instances, use swapNodeInstancePortOrder()
+ *
+ * @param ast - Workflow to modify
+ * @param nodeTypeName - Name of the node type ("Start" or "Exit" only)
+ * @param portName1 - Name of first port
+ * @param portName2 - Name of second port
+ * @returns Modified workflow
+ * @throws {Error} If used with non-Start/Exit nodes or ports are invalid
+ */
+export function swapPortOrder(ast, nodeTypeName, portName1, portName2) {
+    if (nodeTypeName !== "Start" && nodeTypeName !== "Exit") {
+        throw new Error(`swapPortOrder() only supports Start/Exit nodes. ` +
+            `Use swapNodeInstancePortOrder() for instance "${nodeTypeName}".`);
+    }
+    return withoutValidation(ast, (draft) => {
+        // Handle Start/Exit nodes specially
+        if (nodeTypeName === "Start") {
+            if (!draft.startPorts) {
+                throw new Error("Start ports not found");
+            }
+            const port1 = draft.startPorts[portName1];
+            const port2 = draft.startPorts[portName2];
+            if (!port1)
+                throw new Error(`Port "${portName1}" not found on Start node`);
+            if (!port2)
+                throw new Error(`Port "${portName2}" not found on Start node`);
+            // Use explicit order if present, otherwise compute from position
+            const order1 = port1.metadata?.order ?? getImplicitOrder(draft.startPorts, portName1);
+            const order2 = port2.metadata?.order ?? getImplicitOrder(draft.startPorts, portName2);
+            // Swap orders for all ports (including system ports)
+            port1.metadata = { ...port1.metadata, order: order2 };
+            port2.metadata = { ...port2.metadata, order: order1 };
+        }
+        else if (nodeTypeName === "Exit") {
+            if (!draft.exitPorts) {
+                throw new Error("Exit ports not found");
+            }
+            const port1 = draft.exitPorts[portName1];
+            const port2 = draft.exitPorts[portName2];
+            if (!port1)
+                throw new Error(`Port "${portName1}" not found on Exit node`);
+            if (!port2)
+                throw new Error(`Port "${portName2}" not found on Exit node`);
+            // Use explicit order if present, otherwise compute from position
+            const order1 = port1.metadata?.order ?? getImplicitOrder(draft.exitPorts, portName1);
+            const order2 = port2.metadata?.order ?? getImplicitOrder(draft.exitPorts, portName2);
+            // Swap orders for all ports (including system ports)
+            port1.metadata = { ...port1.metadata, order: order2 };
+            port2.metadata = { ...port2.metadata, order: order1 };
+        }
+    });
+}
+/**
+ * Swap the order of two ports on a specific node instance (instance-level only)
+ *
+ * @param ast - Workflow to modify
+ * @param instanceId - ID of the node instance
+ * @param portName1 - Name of first port
+ * @param portName2 - Name of second port
+ * @returns Modified workflow
+ * @throws {Error} If instance doesn't exist or ports are invalid
+ *
+ * @example
+ * ```typescript
+ * const ast = swapNodeInstancePortOrder(workflow, 'doubler1', 'value', 'execute');
+ * ```
+ */
+export function swapNodeInstancePortOrder(ast, instanceId, portName1, portName2) {
+    return withoutValidation(ast, (draft) => {
+        const instance = draft.instances.find(inst => inst.id === instanceId);
+        if (!instance) {
+            throw new Error(`Instance "${instanceId}" not found`);
+        }
+        // Find node type by matching either name or functionName
+        const nodeType = draft.nodeTypes.find(nt => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+        if (!nodeType) {
+            throw new Error(`Node type "${instance.nodeType}" not found`);
+        }
+        // Helper to get the EFFECTIVE visual order (what user sees in UI)
+        // This calculates order by: explicit order first, then implicit position as tiebreaker
+        const getEffectiveOrder = (portName) => {
+            const isInput = portName in nodeType.inputs;
+            const isOutput = portName in nodeType.outputs;
+            if (!isInput && !isOutput) {
+                throw new Error(`Port "${portName}" not found on node type "${instance.nodeType}"`);
+            }
+            const direction = isInput ? "INPUT" : "OUTPUT";
+            const ports = isInput ? nodeType.inputs : nodeType.outputs;
+            // Get all ports in this direction with their orders
+            const portsWithOrders = Object.keys(ports).map((pName, implicitIndex) => {
+                // Check instance config first
+                const instanceConfig = instance.config?.portConfigs?.find(pc => pc.portName === pName && (pc.direction == null || pc.direction === direction));
+                if (instanceConfig?.order !== undefined) {
+                    return { name: pName, explicitOrder: instanceConfig.order, implicitOrder: implicitIndex };
+                }
+                // Check node type metadata
+                const port = ports[pName];
+                const metadataOrder = port?.metadata?.order;
+                if (typeof metadataOrder === "number") {
+                    return { name: pName, explicitOrder: metadataOrder, implicitOrder: implicitIndex };
+                }
+                // No explicit order
+                return { name: pName, explicitOrder: undefined, implicitOrder: implicitIndex };
+            });
+            // Sort by: explicit order first, then implicit order as tiebreaker
+            const sorted = portsWithOrders.sort((a, b) => {
+                const aExplicit = a.explicitOrder ?? Infinity;
+                const bExplicit = b.explicitOrder ?? Infinity;
+                if (aExplicit !== bExplicit) {
+                    return aExplicit - bExplicit;
+                }
+                // Same explicit order (or both undefined) - use implicit as tiebreaker
+                return a.implicitOrder - b.implicitOrder;
+            });
+            // Find the visual position (index in sorted array)
+            const visualPosition = sorted.findIndex(p => p.name === portName);
+            return { order: visualPosition, direction };
+        };
+        const port1Info = getEffectiveOrder(portName1);
+        const port2Info = getEffectiveOrder(portName2);
+        // Initialize config if needed
+        if (!instance.config) {
+            instance.config = {};
+        }
+        if (!instance.config.portConfigs) {
+            instance.config.portConfigs = [];
+        }
+        // Helper to update or add a port config
+        const updatePortConfig = (portName, direction, order) => {
+            const existingIndex = instance.config.portConfigs.findIndex(pc => pc.portName === portName && (pc.direction == null || pc.direction === direction));
+            if (existingIndex >= 0) {
+                // Update existing config
+                instance.config.portConfigs[existingIndex] = {
+                    ...instance.config.portConfigs[existingIndex],
+                    order,
+                };
+            }
+            else {
+                // Add new config
+                instance.config.portConfigs.push({ portName, direction, order });
+            }
+        };
+        // Swap the orders
+        updatePortConfig(portName1, port1Info.direction, port2Info.order);
+        updatePortConfig(portName2, port2Info.direction, port1Info.order);
+    });
+}
+/**
+ * Set Start or Exit node ports directly.
+ * Used by worker to persist port configuration changes on virtual nodes.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeType - "Start" or "Exit"
+ * @param ports - The ports object to set
+ * @returns Modified workflow
+ * @throws {Error} If nodeType is not "Start" or "Exit"
+ */
+export function setStartExitPorts(ast, nodeType, ports) {
+    if (nodeType !== "Start" && nodeType !== "Exit") {
+        throw new Error(`nodeType must be "Start" or "Exit", got "${nodeType}"`);
+    }
+    // Use produce directly with simplified type to avoid excessive type instantiation
+    return produce(ast, (draft) => {
+        if (nodeType === "Start") {
+            draft.startPorts = ports;
+        }
+        else {
+            draft.exitPorts = ports;
+        }
+    });
+}
+/**
+ * Set instance port configs directly.
+ * Used by worker to persist port configuration changes.
+ *
+ * @param ast - Workflow to modify
+ * @param instanceId - ID of the node instance
+ * @param portConfigs - The port configs array to set
+ * @returns Modified workflow
+ * @throws {Error} If instance doesn't exist
+ */
+export function setInstancePortConfigs(ast, instanceId, portConfigs) {
+    // Validate before mutation to avoid type instantiation issues inside callback
+    const instance = ast.instances.find(inst => inst.id === instanceId);
+    if (!instance) {
+        throw new Error(`Instance "${instanceId}" not found`);
+    }
+    // Use produce directly with simplified type to avoid excessive type instantiation
+    return produce(ast, (draft) => {
+        const draftInstance = draft.instances.find(inst => inst.id === instanceId);
+        if (!draftInstance)
+            return; // Already validated above
+        if (!draftInstance.config) {
+            draftInstance.config = {};
+        }
+        draftInstance.config.portConfigs = portConfigs;
+    });
+}
+//# sourceMappingURL=ports.js.map

package/dist/api/manipulation/scopes.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Scope operations for workflow manipulation
+ */
+import type { TWorkflowAST } from "../../ast/types.js";
+/**
+ * Create a new scope
+ *
+ * @param ast - Workflow to modify
+ * @param scopeName - Name of scope
+ * @param nodeIds - Node IDs in scope
+ * @returns Modified workflow
+ * @throws {Error} If scope already exists
+ */
+export declare function createScope(ast: TWorkflowAST, scopeName: string, nodeIds: string[]): TWorkflowAST;
+/**
+ * Remove a scope.
+ * Uses no validation to allow deletion even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param scopeName - Name of scope to remove
+ * @returns Modified workflow
+ */
+export declare function removeScope(ast: TWorkflowAST, scopeName: string): TWorkflowAST;
+/**
+ * Add node to existing scope
+ *
+ * @param ast - Workflow to modify
+ * @param scopeName - Name of scope
+ * @param nodeId - Node ID to add
+ * @returns Modified workflow
+ */
+export declare function addToScope(ast: TWorkflowAST, scopeName: string, nodeId: string): TWorkflowAST;
+/**
+ * Remove node from scope.
+ * Uses no validation to allow deletion even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param scopeName - Name of scope
+ * @param nodeId - Node ID to remove
+ * @returns Modified workflow
+ */
+export declare function removeFromScope(ast: TWorkflowAST, scopeName: string, nodeId: string): TWorkflowAST;
+/**
+ * Move node to different scope
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - Node ID to move
+ * @param targetScope - Target scope name
+ * @returns Modified workflow
+ */
+export declare function moveToScope(ast: TWorkflowAST, nodeId: string, targetScope: string): TWorkflowAST;
+//# sourceMappingURL=scopes.d.ts.map