@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/api/manipulation/ports.js

@@ -1,228 +0,0 @@
-/**
- * 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.js

@@ -1,156 +0,0 @@
-/**
- * Scope operations for workflow manipulation
- */
-import { withoutValidation, assertNodeExists } from "../helpers.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 function createScope(ast, scopeName, nodeIds) {
-    // Validate scope doesn't exist
-    if (ast.scopes?.[scopeName]) {
-        throw new Error(`Scope "${scopeName}" already exists`);
-    }
-    // Verify all nodes exist before mutation to avoid type instantiation issues
-    nodeIds.forEach((nodeId) => assertNodeExists(ast, nodeId));
-    return withoutValidation(ast, (draft) => {
-        if (!draft.scopes) {
-            draft.scopes = {};
-        }
-        draft.scopes[scopeName] = nodeIds;
-        // Update node instances to reference scope
-        // scopeName format is "parentNodeId.scopeName"
-        const dotIndex = scopeName.indexOf('.');
-        const parentNodeName = dotIndex > 0 ? scopeName.substring(0, dotIndex) : scopeName;
-        const scope = dotIndex > 0 ? scopeName.substring(dotIndex + 1) : '';
-        nodeIds.forEach((nodeId) => {
-            const node = draft.instances.find((n) => n.id === nodeId);
-            node.parent = { id: parentNodeName, scope };
-        });
-    });
-}
-/**
- * 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 function removeScope(ast, scopeName) {
-    // Verify scope exists
-    if (!ast.scopes?.[scopeName]) {
-        throw new Error(`Scope "${scopeName}" not found`);
-    }
-    return withoutValidation(ast, (draft) => {
-        const nodeIds = draft.scopes[scopeName];
-        // Remove parent from nodes
-        nodeIds.forEach((nodeId) => {
-            const node = draft.instances.find((n) => n.id === nodeId);
-            if (node) {
-                delete node.parent;
-            }
-        });
-        delete draft.scopes[scopeName];
-    });
-}
-/**
- * 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 function addToScope(ast, scopeName, nodeId) {
-    // Validate before mutation to avoid type instantiation issues
-    if (!ast.scopes?.[scopeName]) {
-        throw new Error(`Scope "${scopeName}" not found`);
-    }
-    assertNodeExists(ast, nodeId);
-    return withoutValidation(ast, (draft) => {
-        if (!draft.scopes[scopeName].includes(nodeId)) {
-            draft.scopes[scopeName].push(nodeId);
-        }
-        const node = draft.instances.find((n) => n.id === nodeId);
-        if (!node)
-            return; // Already validated above
-        // scopeName format is "parentNodeId.scopeName"
-        const dotIndex = scopeName.indexOf('.');
-        const parentNodeName = dotIndex > 0 ? scopeName.substring(0, dotIndex) : scopeName;
-        const scope = dotIndex > 0 ? scopeName.substring(dotIndex + 1) : '';
-        node.parent = { id: parentNodeName, scope };
-    });
-}
-/**
- * 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 function removeFromScope(ast, scopeName, nodeId) {
-    // Verify scope exists
-    if (!ast.scopes?.[scopeName]) {
-        throw new Error(`Scope "${scopeName}" not found`);
-    }
-    return withoutValidation(ast, (draft) => {
-        draft.scopes[scopeName] = draft.scopes[scopeName].filter((id) => id !== nodeId);
-        const node = draft.instances.find((n) => n.id === nodeId);
-        if (node && node.parent) {
-            // Match by parent id (simple scope) or full qualified path
-            const matchesScope = node.parent.id === scopeName ||
-                (node.parent.scope && `${node.parent.id}.${node.parent.scope}` === scopeName);
-            if (matchesScope) {
-                delete node.parent;
-            }
-        }
-    });
-}
-/**
- * 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 function moveToScope(ast, nodeId, targetScope) {
-    // Validate before mutation to avoid type instantiation issues
-    assertNodeExists(ast, nodeId);
-    if (!ast.scopes?.[targetScope]) {
-        throw new Error(`Target scope "${targetScope}" not found`);
-    }
-    return withoutValidation(ast, (draft) => {
-        const node = draft.instances.find((n) => n.id === nodeId);
-        if (!node || !draft.scopes)
-            return; // Already validated above
-        // Remove from current scope if any
-        if (node.parent) {
-            // Check for simple scope (just id) or full qualified path
-            const simpleScope = node.parent.id;
-            const fullScope = node.parent.scope ? `${node.parent.id}.${node.parent.scope}` : null;
-            const currentScope = draft.scopes[simpleScope] ? simpleScope : (fullScope && draft.scopes[fullScope] ? fullScope : null);
-            if (currentScope && draft.scopes[currentScope]) {
-                draft.scopes[currentScope] = draft.scopes[currentScope].filter((id) => id !== nodeId);
-            }
-        }
-        // Add to target scope
-        if (!draft.scopes[targetScope].includes(nodeId)) {
-            draft.scopes[targetScope].push(nodeId);
-        }
-        // targetScope format is "parentNodeId.scopeName"
-        const dotIndex = targetScope.indexOf('.');
-        const parentNodeName = dotIndex > 0 ? targetScope.substring(0, dotIndex) : targetScope;
-        const scope = dotIndex > 0 ? targetScope.substring(dotIndex + 1) : '';
-        node.parent = { id: parentNodeName, scope };
-    });
-}
-//# sourceMappingURL=scopes.js.map

package/dist/api/manipulation/workflow.js

@@ -1,116 +0,0 @@
-/**
- * Workflow-level operations for manipulation
- */
-import { produce } from "immer";
-import { withoutValidation } from "../helpers.js";
-/**
- * Clone a workflow (creates deep copy via Immer)
- *
- * @param ast - Workflow to clone
- * @returns New workflow instance
- *
- * @example
- * ```typescript
- * const copy = cloneWorkflow(original);
- * // copy !== original
- * ```
- */
-export function cloneWorkflow(ast) {
-    // Force Immer to create a new object by making changes to nested structures
-    // Without this, Immer returns the same object (structural sharing)
-    return withoutValidation(ast, (draft) => {
-        // Touch nested arrays to force deep cloning
-        draft.nodeTypes = [...draft.nodeTypes];
-        draft.instances = [...draft.instances];
-        draft.connections = [...draft.connections];
-    });
-}
-/**
- * Set workflow description
- *
- * @param ast - Workflow to modify
- * @param description - New description
- * @returns Modified workflow
- */
-export function setWorkflowDescription(ast, description) {
-    return withoutValidation(ast, (draft) => {
-        draft.description = description;
-    });
-}
-/**
- * Set workflow metadata (forceAsync, etc.)
- *
- * @param ast - Workflow to modify
- * @param metadata - Partial metadata to merge
- * @returns Modified workflow
- *
- * @example
- * ```typescript
- * const updated = setWorkflowMetadata(workflow, { forceAsync: true });
- * ```
- */
-export function setWorkflowMetadata(ast, metadata) {
-    return withoutValidation(ast, (draft) => {
-        draft.metadata = { ...draft.metadata, ...metadata };
-    });
-}
-/**
- * Set workflow output file type
- *
- * @param ast - Workflow to modify
- * @param fileType - Target file extension
- * @returns Modified workflow
- *
- * @example
- * ```typescript
- * const updated = setOutputFileType(workflow, "tsx");
- * ```
- */
-export function setOutputFileType(ast, fileType) {
-    return withoutValidation(ast, (draft) => {
-        const baseName = draft.sourceFile.replace(/\.(ts|js|tsx|jsx)$/, "");
-        draft.sourceFile = `${baseName}.${fileType}`;
-    });
-}
-/**
- * Rename workflow export
- *
- * @param ast - Workflow to modify
- * @param newName - New workflow export name
- * @returns Modified workflow
- *
- * @example
- * ```typescript
- * const updated = renameWorkflow(workflow, "myNewWorkflow");
- * ```
- */
-export function renameWorkflow(ast, newName) {
-    if (!newName || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(newName)) {
-        throw new Error(`Invalid workflow name: ${newName}`);
-    }
-    return withoutValidation(ast, (draft) => {
-        draft.functionName = newName;
-    });
-}
-/**
- * Set workflow export interface ports
- *
- * @param ast - Workflow to modify
- * @param ports - New ports configuration
- * @returns Modified workflow
- *
- * @example
- * ```typescript
- * const updated = setWorkflowPorts(workflow, [
- *   { name: "input", type: "String", direction: "input" },
- *   { name: "result", type: "Number", direction: "output" }
- * ]);
- * ```
- */
-export function setWorkflowPorts(ast, ports) {
-    // Use produce directly with non-generic approach to avoid excessive type instantiation
-    return produce(ast, (draft) => {
-        draft.ports = ports;
-    });
-}
-//# sourceMappingURL=workflow.js.map

package/dist/api/modify-operation.js

@@ -1,177 +0,0 @@
-import { z } from 'zod';
-import { addNode as manipAddNode, removeNode as manipRemoveNode, renameNode as manipRenameNode, addConnection as manipAddConnection, removeConnection as manipRemoveConnection, setNodePosition as manipSetNodePosition, setNodeLabel as manipSetNodeLabel, } from './manipulation/index.js';
-import { findIsolatedNodes } from './query.js';
-export const modifyParamsSchemas = {
-    addNode: z.object({
-        nodeId: z.string({ required_error: 'nodeId is required' }),
-        nodeType: z.string({ required_error: 'nodeType is required' }),
-        x: z.number().optional(),
-        y: z.number().optional(),
-    }),
-    removeNode: z.object({
-        nodeId: z.string({ required_error: 'nodeId is required' }),
-    }),
-    renameNode: z.object({
-        oldId: z.string({ required_error: 'oldId is required' }),
-        newId: z.string({ required_error: 'newId is required' }),
-    }),
-    addConnection: z.object({
-        from: z.string({ required_error: 'from is required (format: "node.port")' }),
-        to: z.string({ required_error: 'to is required (format: "node.port")' }),
-    }),
-    removeConnection: z.object({
-        from: z.string({ required_error: 'from is required (format: "node.port")' }),
-        to: z.string({ required_error: 'to is required (format: "node.port")' }),
-    }),
-    setNodePosition: z.object({
-        nodeId: z.string({ required_error: 'nodeId is required' }),
-        x: z.number({ required_error: 'x is required', invalid_type_error: 'x must be a number' }),
-        y: z.number({ required_error: 'y is required', invalid_type_error: 'y must be a number' }),
-    }),
-    setNodeLabel: z.object({
-        nodeId: z.string({ required_error: 'nodeId is required' }),
-        label: z.string({ required_error: 'label is required' }),
-    }),
-};
-export function validateModifyParams(operation, params) {
-    const schema = modifyParamsSchemas[operation];
-    if (!schema) {
-        return { success: false, error: `Unknown operation: ${operation}` };
-    }
-    const result = schema.safeParse(params);
-    if (!result.success) {
-        const messages = result.error.issues.map((i) => i.message).join('; ');
-        return { success: false, error: `${operation} params invalid: ${messages}` };
-    }
-    return { success: true };
-}
-export function applyModifyOperation(ast, operation, params) {
-    const p = params;
-    const warnings = [];
-    const extraData = {};
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- AST manipulation functions use loose typing
-    let modifiedAST = ast;
-    switch (operation) {
-        case 'addNode': {
-            const nodeId = p.nodeId;
-            const nodeType = p.nodeType;
-            const nodeTypeExists = modifiedAST.nodeTypes.some((nt) => nt.name === nodeType || nt.functionName === nodeType);
-            if (!nodeTypeExists) {
-                warnings.push(`Node type "${nodeType}" is not defined in the file. ` +
-                    `The node will be added but may not render until the type is defined.`);
-            }
-            let autoX = typeof p.x === 'number' ? p.x : undefined;
-            let autoY = typeof p.y === 'number' ? p.y : undefined;
-            if (autoX === undefined || autoY === undefined) {
-                const positions = modifiedAST.instances
-                    .map((inst) => inst.config)
-                    .filter((c) => c !== undefined &&
-                    c !== null &&
-                    typeof c.x === 'number' &&
-                    typeof c.y === 'number');
-                if (positions.length > 0) {
-                    const maxX = Math.max(...positions.map((pos) => pos.x));
-                    if (autoX === undefined)
-                        autoX = maxX + 180;
-                    if (autoY === undefined)
-                        autoY = 0;
-                }
-                else {
-                    if (autoX === undefined)
-                        autoX = 0;
-                    if (autoY === undefined)
-                        autoY = 0;
-                }
-            }
-            modifiedAST = manipAddNode(modifiedAST, {
-                type: 'NodeInstance',
-                id: nodeId,
-                nodeType,
-                config: { x: autoX, y: autoY },
-            });
-            break;
-        }
-        case 'removeNode': {
-            const nodeId = p.nodeId;
-            const removedConnections = modifiedAST.connections
-                .filter((c) => c.from.node === nodeId || c.to.node === nodeId)
-                .map((c) => ({
-                from: `${c.from.node}.${c.from.port}`,
-                to: `${c.to.node}.${c.to.port}`,
-            }));
-            modifiedAST = manipRemoveNode(modifiedAST, nodeId);
-            if (removedConnections.length > 0) {
-                extraData.removedConnections = removedConnections;
-            }
-            break;
-        }
-        case 'renameNode': {
-            modifiedAST = manipRenameNode(modifiedAST, p.oldId, p.newId);
-            break;
-        }
-        case 'addConnection': {
-            const from = p.from;
-            const to = p.to;
-            const [fromNode, fromPort] = from.split('.');
-            const [toNode, toPort] = to.split('.');
-            if (!fromPort || !toPort) {
-                throw new Error('Connection format must be "node.port" (e.g., "Start.execute")');
-            }
-            const validNodes = [
-                'Start',
-                'Exit',
-                ...modifiedAST.instances.map((i) => i.id),
-            ];
-            if (!validNodes.includes(fromNode)) {
-                throw new Error(`Source node "${fromNode}" not found. Available: ${validNodes.join(', ')}`);
-            }
-            if (!validNodes.includes(toNode)) {
-                throw new Error(`Target node "${toNode}" not found. Available: ${validNodes.join(', ')}`);
-            }
-            if (fromNode !== 'Start' && fromNode !== 'Exit') {
-                const inst = modifiedAST.instances.find((i) => i.id === fromNode);
-                const nt = modifiedAST.nodeTypes.find((t) => t.name === inst?.nodeType);
-                if (nt && !nt.outputs[fromPort]) {
-                    throw new Error(`Node "${fromNode}" has no output "${fromPort}". Available: ${Object.keys(nt.outputs).join(', ')}`);
-                }
-            }
-            if (toNode !== 'Start' && toNode !== 'Exit') {
-                const inst = modifiedAST.instances.find((i) => i.id === toNode);
-                const nt = modifiedAST.nodeTypes.find((t) => t.name === inst?.nodeType);
-                if (nt && !nt.inputs[toPort]) {
-                    throw new Error(`Node "${toNode}" has no input "${toPort}". Available: ${Object.keys(nt.inputs).join(', ')}`);
-                }
-            }
-            modifiedAST = manipAddConnection(modifiedAST, from, to);
-            if (modifiedAST.options?.autoConnect) {
-                modifiedAST = { ...modifiedAST, options: { ...modifiedAST.options, autoConnect: undefined } };
-                warnings.push('autoConnect was disabled because connections were manually modified');
-            }
-            break;
-        }
-        case 'removeConnection': {
-            modifiedAST = manipRemoveConnection(modifiedAST, p.from, p.to);
-            if (modifiedAST.options?.autoConnect) {
-                modifiedAST = { ...modifiedAST, options: { ...modifiedAST.options, autoConnect: undefined } };
-                warnings.push('autoConnect was disabled because connections were manually modified');
-            }
-            const newlyIsolated = findIsolatedNodes(modifiedAST);
-            if (newlyIsolated.length > 0) {
-                extraData.newlyIsolatedNodes = newlyIsolated;
-            }
-            break;
-        }
-        case 'setNodePosition': {
-            modifiedAST = manipSetNodePosition(modifiedAST, p.nodeId, p.x, p.y);
-            break;
-        }
-        case 'setNodeLabel': {
-            modifiedAST = manipSetNodeLabel(modifiedAST, p.nodeId, p.label);
-            break;
-        }
-        default:
-            throw new Error(`Unknown operation: ${operation}`);
-    }
-    return { ast: modifiedAST, warnings, extraData };
-}
-//# sourceMappingURL=modify-operation.js.map