@synergenius/flow-weaver 0.2.0

package/dist/api/manipulation/connections.js

@@ -0,0 +1,151 @@
+/**
+ * Connection operations for workflow manipulation
+ */
+import { withoutValidation, validatePortReference, portReferencesEqual, } from "../helpers.js";
+/**
+ * Add a connection between two ports
+ *
+ * @param ast - Workflow to modify
+ * @param from - Source port reference (string "node.port" or object)
+ * @param to - Target port reference (string "node.port" or object)
+ * @returns Modified workflow
+ * @throws {Error} If connection already exists
+ *
+ * @example
+ * ```typescript
+ * // Using string format
+ * const ast = addConnection(workflow, 'Start.input', 'processor.input');
+ *
+ * // Using object format
+ * const ast = addConnection(
+ *   workflow,
+ *   { node: 'Start', port: 'input' },
+ *   { node: 'processor', port: 'input' }
+ * );
+ * ```
+ */
+export function addConnection(ast, from, to) {
+    const fromRef = validatePortReference(from);
+    const toRef = validatePortReference(to);
+    // Check for duplicate connection
+    const exists = ast.connections.some((conn) => portReferencesEqual(conn.from, fromRef) &&
+        portReferencesEqual(conn.to, toRef));
+    if (exists) {
+        throw new Error(`Connection already exists: ${fromRef.node}.${fromRef.port} → ${toRef.node}.${toRef.port}`);
+    }
+    return withoutValidation(ast, (draft) => {
+        draft.connections.push({
+            type: "Connection",
+            from: fromRef,
+            to: toRef,
+        });
+    });
+}
+/**
+ * Remove a connection.
+ * Uses no validation to allow deletion even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param from - Source port reference
+ * @param to - Target port reference
+ * @returns Modified workflow
+ * @throws {Error} If connection doesn't exist
+ */
+export function removeConnection(ast, from, to) {
+    const fromRef = validatePortReference(from);
+    const toRef = validatePortReference(to);
+    // Verify connection exists first
+    const connIndex = ast.connections.findIndex((conn) => portReferencesEqual(conn.from, fromRef) &&
+        portReferencesEqual(conn.to, toRef));
+    if (connIndex === -1) {
+        throw new Error(`Connection not found: ${fromRef.node}.${fromRef.port} → ${toRef.node}.${toRef.port}`);
+    }
+    return withoutValidation(ast, (draft) => {
+        const idx = draft.connections.findIndex((conn) => portReferencesEqual(conn.from, fromRef) &&
+            portReferencesEqual(conn.to, toRef));
+        draft.connections.splice(idx, 1);
+    });
+}
+/**
+ * Remove all connections for a node (or specific port).
+ * Uses no validation to allow deletion even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - Node ID
+ * @param portName - Optional port name to filter
+ * @returns Modified workflow
+ */
+export function removeAllConnections(ast, nodeId, portName) {
+    return withoutValidation(ast, (draft) => {
+        draft.connections = draft.connections.filter((conn) => {
+            const matchesFrom = conn.from.node === nodeId &&
+                (!portName || conn.from.port === portName);
+            const matchesTo = conn.to.node === nodeId && (!portName || conn.to.port === portName);
+            return !matchesFrom && !matchesTo;
+        });
+    });
+}
+/**
+ * Reconnect (change target of existing connection).
+ * Uses no validation to allow reconnecting even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param from - Source port reference (identifies connection)
+ * @param oldTo - Old target port reference
+ * @param newTo - New target port reference
+ * @returns Modified workflow
+ */
+export function reconnect(ast, from, oldTo, newTo) {
+    const fromRef = validatePortReference(from);
+    const oldToRef = validatePortReference(oldTo);
+    const newToRef = validatePortReference(newTo);
+    // Verify connection exists
+    const connExists = ast.connections.find((c) => portReferencesEqual(c.from, fromRef) &&
+        portReferencesEqual(c.to, oldToRef));
+    if (!connExists) {
+        throw new Error(`Connection not found: ${fromRef.node}.${fromRef.port} → ${oldToRef.node}.${oldToRef.port}`);
+    }
+    return withoutValidation(ast, (draft) => {
+        const conn = draft.connections.find((c) => portReferencesEqual(c.from, fromRef) &&
+            portReferencesEqual(c.to, oldToRef));
+        conn.to = newToRef;
+    });
+}
+/**
+ * Add multiple connections at once.
+ * Uses no validation to allow adding even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param connections - Array of connections to add
+ * @returns Modified workflow
+ */
+export function addConnections(ast, connections) {
+    return withoutValidation(ast, (draft) => {
+        connections.forEach((conn) => {
+            // Check for duplicates
+            const exists = draft.connections.some((c) => portReferencesEqual(c.from, conn.from) &&
+                portReferencesEqual(c.to, conn.to));
+            if (!exists) {
+                draft.connections.push(conn);
+            }
+        });
+    });
+}
+/**
+ * Replace all connections for a node.
+ * Uses no validation to allow replacing even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - Node ID
+ * @param connections - New connections
+ * @returns Modified workflow
+ */
+export function replaceConnections(ast, nodeId, connections) {
+    return withoutValidation(ast, (draft) => {
+        // Remove existing connections
+        draft.connections = draft.connections.filter((conn) => conn.from.node !== nodeId && conn.to.node !== nodeId);
+        // Add new connections
+        draft.connections.push(...connections);
+    });
+}
+//# sourceMappingURL=connections.js.map

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

@@ -0,0 +1,34 @@
+/**
+ * @module api/manipulation
+ *
+ * # Manipulation API
+ *
+ * Immutable operations for programmatic workflow modification.
+ * All functions return a new AST (never mutate the original).
+ *
+ * ## Operation Categories
+ *
+ * | Category    | Functions |
+ * |-------------|-----------|
+ * | Workflow    | `cloneWorkflow`, `renameWorkflow`, `setWorkflowPorts` |
+ * | Node Types  | `addNodeType`, `removeNodeType`, `updateNodeType` |
+ * | Nodes       | `addNode`, `removeNode`, `renameNode`, `setNodePosition` |
+ * | Connections | `addConnection`, `removeConnection`, `reconnect` |
+ * | Ports       | `swapPortOrder`, `swapNodeInstancePortOrder` |
+ * | Scopes      | `createScope`, `removeScope`, `addToScope` |
+ *
+ * ## Validation Options
+ *
+ * Operations validate by default. Use wrappers for control:
+ * - `withValidation(workflow)` - Full validation (default)
+ * - `withMinimalValidation(workflow)` - Skip expensive checks
+ * - `withoutValidation(workflow)` - No validation (use with caution)
+ */
+export { withoutValidation, type RemoveOptions, type NodeFilter, type OperationResult, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeExists, assertNodeNotExists, } from "./validation.js";
+export { cloneWorkflow, setWorkflowDescription, setWorkflowMetadata, setOutputFileType, renameWorkflow, setWorkflowPorts, } from "./workflow.js";
+export { addNodeType, removeNodeType, updateNodeType, getNodeType, hasNodeType, listNodeTypes, renameNodeType, replaceNodeTypes, } from "./node-types.js";
+export { addNode, removeNode, renameNode, updateNode, addNodes, removeNodes, setNodeConfig, setNodePosition, setNodeMinimized, setNodeSize, setNodeLabel, } from "./nodes.js";
+export { addConnection, removeConnection, removeAllConnections, reconnect, addConnections, replaceConnections, } from "./connections.js";
+export { swapPortOrder, swapNodeInstancePortOrder, setStartExitPorts, setInstancePortConfigs, } from "./ports.js";
+export { createScope, removeScope, addToScope, removeFromScope, moveToScope, } from "./scopes.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/api/manipulation/index.js

@@ -0,0 +1,41 @@
+/**
+ * @module api/manipulation
+ *
+ * # Manipulation API
+ *
+ * Immutable operations for programmatic workflow modification.
+ * All functions return a new AST (never mutate the original).
+ *
+ * ## Operation Categories
+ *
+ * | Category    | Functions |
+ * |-------------|-----------|
+ * | Workflow    | `cloneWorkflow`, `renameWorkflow`, `setWorkflowPorts` |
+ * | Node Types  | `addNodeType`, `removeNodeType`, `updateNodeType` |
+ * | Nodes       | `addNode`, `removeNode`, `renameNode`, `setNodePosition` |
+ * | Connections | `addConnection`, `removeConnection`, `reconnect` |
+ * | Ports       | `swapPortOrder`, `swapNodeInstancePortOrder` |
+ * | Scopes      | `createScope`, `removeScope`, `addToScope` |
+ *
+ * ## Validation Options
+ *
+ * Operations validate by default. Use wrappers for control:
+ * - `withValidation(workflow)` - Full validation (default)
+ * - `withMinimalValidation(workflow)` - Skip expensive checks
+ * - `withoutValidation(workflow)` - No validation (use with caution)
+ */
+// Re-export validation utilities
+export { withoutValidation, validatePortReference, portReferencesEqual, formatPortReference, generateUniqueNodeId, assertNodeExists, assertNodeNotExists, } from "./validation.js";
+// Re-export workflow-level operations
+export { cloneWorkflow, setWorkflowDescription, setWorkflowMetadata, setOutputFileType, renameWorkflow, setWorkflowPorts, } from "./workflow.js";
+// Re-export node type operations
+export { addNodeType, removeNodeType, updateNodeType, getNodeType, hasNodeType, listNodeTypes, renameNodeType, replaceNodeTypes, } from "./node-types.js";
+// Re-export node instance operations
+export { addNode, removeNode, renameNode, updateNode, addNodes, removeNodes, setNodeConfig, setNodePosition, setNodeMinimized, setNodeSize, setNodeLabel, } from "./nodes.js";
+// Re-export connection operations
+export { addConnection, removeConnection, removeAllConnections, reconnect, addConnections, replaceConnections, } from "./connections.js";
+// Re-export port operations
+export { swapPortOrder, swapNodeInstancePortOrder, setStartExitPorts, setInstancePortConfigs, } from "./ports.js";
+// Re-export scope operations
+export { createScope, removeScope, addToScope, removeFromScope, moveToScope, } from "./scopes.js";
+//# sourceMappingURL=index.js.map

package/dist/api/manipulation/node-types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Node type operations for workflow manipulation
+ */
+import type { TWorkflowAST, TNodeTypeAST } from "../../ast/types.js";
+/**
+ * Add a node type definition to the workflow (idempotent).
+ * Uses no validation to allow adding even when workflow has other errors.
+ *
+ * If a node type with the same name already exists, returns the AST unchanged
+ * without throwing an error. This handles state desync between server and client,
+ * race conditions, double-clicks, and server restarts gracefully.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeType - Node type to add
+ * @returns Modified workflow (or unchanged if node type already exists)
+ *
+ * @example
+ * ```typescript
+ * const ast = addNodeType(workflow, {
+ *   type: 'NodeType',
+ *   name: 'double',
+ *   functionName: 'double',
+ *   inputs: { x: { dataType: 'NUMBER' } },
+ *   outputs: { result: { dataType: 'NUMBER' } },
+ *   hasSuccessPort: true,
+ *   hasFailurePort: true,
+ *   executeWhen: 'CONJUNCTION'
+ * });
+ * ```
+ */
+export declare function addNodeType(ast: TWorkflowAST, nodeType: TNodeTypeAST): TWorkflowAST;
+/**
+ * Remove a node type from the workflow.
+ * Uses minimal validation (only checks type exists and has no instances)
+ * to allow deletion even when the workflow has other validation errors.
+ *
+ * @param ast - Workflow to modify
+ * @param typeName - Name of node type to remove
+ * @returns Modified workflow
+ * @throws {Error} If node type doesn't exist or instances reference it
+ *
+ * @example
+ * ```typescript
+ * const ast = removeNodeType(workflow, 'obsoleteType');
+ * ```
+ */
+export declare function removeNodeType(ast: TWorkflowAST, typeName: string): TWorkflowAST;
+/**
+ * Update an existing node type.
+ * Uses no validation to allow updates even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param typeName - Name of node type to update
+ * @param updates - Partial node type to merge
+ * @returns Modified workflow
+ * @throws {Error} If node type doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const ast = updateNodeType(workflow, 'processor', {
+ *   label: 'Data Processor',
+ *   description: 'Processes incoming data'
+ * });
+ * ```
+ */
+export declare function updateNodeType(ast: TWorkflowAST, typeName: string, updates: Partial<Omit<TNodeTypeAST, "type" | "name">>): TWorkflowAST;
+/**
+ * Get a node type by name
+ *
+ * @param ast - Workflow to query
+ * @param typeName - Name of node type
+ * @returns Node type or undefined
+ */
+export declare function getNodeType(ast: TWorkflowAST, typeName: string): TNodeTypeAST | undefined;
+/**
+ * Check if node type exists
+ *
+ * @param ast - Workflow to query
+ * @param typeName - Name of node type
+ * @returns True if exists
+ */
+export declare function hasNodeType(ast: TWorkflowAST, typeName: string): boolean;
+/**
+ * List all node types
+ *
+ * @param ast - Workflow to query
+ * @returns Array of node types
+ */
+export declare function listNodeTypes(ast: TWorkflowAST): TNodeTypeAST[];
+/**
+ * Rename a node type and update all instances that reference it.
+ * Uses no validation to allow renames even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param oldTypeName - Current name of the node type
+ * @param newTypeName - New name for the node type
+ * @returns Modified workflow
+ * @throws {Error} If node type doesn't exist or new name already exists
+ *
+ * @example
+ * ```typescript
+ * const ast = renameNodeType(workflow, 'OldTypeName', 'NewTypeName');
+ * ```
+ */
+export declare function renameNodeType(ast: TWorkflowAST, oldTypeName: string, newTypeName: string): TWorkflowAST;
+/**
+ * Replace all node types in workflow.
+ * Uses no validation to allow replacement even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeTypes - New array of node types
+ * @returns Modified workflow
+ *
+ * @example
+ * ```typescript
+ * const ast = replaceNodeTypes(workflow, [
+ *   { type: 'NodeType', name: 'type1', ... },
+ *   { type: 'NodeType', name: 'type2', ... }
+ * ]);
+ * ```
+ */
+export declare function replaceNodeTypes(ast: TWorkflowAST, nodeTypes: TNodeTypeAST[]): TWorkflowAST;
+//# sourceMappingURL=node-types.d.ts.map

package/dist/api/manipulation/node-types.js

@@ -0,0 +1,200 @@
+/**
+ * Node type operations for workflow manipulation
+ */
+import { produce } from "immer";
+import { withoutValidation } from "../helpers.js";
+/**
+ * Add a node type definition to the workflow (idempotent).
+ * Uses no validation to allow adding even when workflow has other errors.
+ *
+ * If a node type with the same name already exists, returns the AST unchanged
+ * without throwing an error. This handles state desync between server and client,
+ * race conditions, double-clicks, and server restarts gracefully.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeType - Node type to add
+ * @returns Modified workflow (or unchanged if node type already exists)
+ *
+ * @example
+ * ```typescript
+ * const ast = addNodeType(workflow, {
+ *   type: 'NodeType',
+ *   name: 'double',
+ *   functionName: 'double',
+ *   inputs: { x: { dataType: 'NUMBER' } },
+ *   outputs: { result: { dataType: 'NUMBER' } },
+ *   hasSuccessPort: true,
+ *   hasFailurePort: true,
+ *   executeWhen: 'CONJUNCTION'
+ * });
+ * ```
+ */
+export function addNodeType(ast, nodeType) {
+    const existingIndex = ast.nodeTypes.findIndex((nt) => nt.name === nodeType.name);
+    // If node type already exists, check if we need to update it with new properties
+    // (e.g., importSource for npm types that were parsed without @import annotation)
+    if (existingIndex >= 0) {
+        const existing = ast.nodeTypes[existingIndex];
+        const newImportSource = nodeType.importSource;
+        const existingImportSource = existing.importSource;
+        // If the new type has importSource but the existing one doesn't, update it
+        if (newImportSource && !existingImportSource) {
+            return produce(ast, (draft) => {
+                draft.nodeTypes[existingIndex].importSource = newImportSource;
+            });
+        }
+        // Otherwise, return unchanged (idempotent)
+        return ast;
+    }
+    // Add new node type
+    return produce(ast, (draft) => {
+        draft.nodeTypes.push(nodeType);
+    });
+}
+/**
+ * Remove a node type from the workflow.
+ * Uses minimal validation (only checks type exists and has no instances)
+ * to allow deletion even when the workflow has other validation errors.
+ *
+ * @param ast - Workflow to modify
+ * @param typeName - Name of node type to remove
+ * @returns Modified workflow
+ * @throws {Error} If node type doesn't exist or instances reference it
+ *
+ * @example
+ * ```typescript
+ * const ast = removeNodeType(workflow, 'obsoleteType');
+ * ```
+ */
+export function removeNodeType(ast, typeName) {
+    // First, verify node type exists
+    const typeIndex = ast.nodeTypes.findIndex((nt) => nt.name === typeName);
+    if (typeIndex === -1) {
+        throw new Error(`Node type "${typeName}" not found`);
+    }
+    // Check if any instances reference this type
+    const functionName = ast.nodeTypes[typeIndex].functionName;
+    const referencingInstances = ast.instances.filter((inst) => inst.nodeType === functionName);
+    if (referencingInstances.length > 0) {
+        throw new Error(`Cannot remove node type "${typeName}": ${referencingInstances.length} instance(s) still reference it (${referencingInstances.map((i) => i.id).join(", ")})`);
+    }
+    return withoutValidation(ast, (draft) => {
+        const idx = draft.nodeTypes.findIndex((nt) => nt.name === typeName);
+        draft.nodeTypes.splice(idx, 1);
+    });
+}
+/**
+ * Update an existing node type.
+ * Uses no validation to allow updates even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param typeName - Name of node type to update
+ * @param updates - Partial node type to merge
+ * @returns Modified workflow
+ * @throws {Error} If node type doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const ast = updateNodeType(workflow, 'processor', {
+ *   label: 'Data Processor',
+ *   description: 'Processes incoming data'
+ * });
+ * ```
+ */
+export function updateNodeType(ast, typeName, updates) {
+    // Verify node type exists
+    if (!ast.nodeTypes.find((nt) => nt.name === typeName)) {
+        throw new Error(`Node type "${typeName}" not found`);
+    }
+    return withoutValidation(ast, (draft) => {
+        const nodeType = draft.nodeTypes.find((nt) => nt.name === typeName);
+        Object.assign(nodeType, updates);
+    });
+}
+/**
+ * Get a node type by name
+ *
+ * @param ast - Workflow to query
+ * @param typeName - Name of node type
+ * @returns Node type or undefined
+ */
+export function getNodeType(ast, typeName) {
+    return ast.nodeTypes.find((nt) => nt.name === typeName);
+}
+/**
+ * Check if node type exists
+ *
+ * @param ast - Workflow to query
+ * @param typeName - Name of node type
+ * @returns True if exists
+ */
+export function hasNodeType(ast, typeName) {
+    return ast.nodeTypes.some((nt) => nt.name === typeName);
+}
+/**
+ * List all node types
+ *
+ * @param ast - Workflow to query
+ * @returns Array of node types
+ */
+export function listNodeTypes(ast) {
+    return [...ast.nodeTypes];
+}
+/**
+ * Rename a node type and update all instances that reference it.
+ * Uses no validation to allow renames even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param oldTypeName - Current name of the node type
+ * @param newTypeName - New name for the node type
+ * @returns Modified workflow
+ * @throws {Error} If node type doesn't exist or new name already exists
+ *
+ * @example
+ * ```typescript
+ * const ast = renameNodeType(workflow, 'OldTypeName', 'NewTypeName');
+ * ```
+ */
+export function renameNodeType(ast, oldTypeName, newTypeName) {
+    // Check if new name already exists
+    if (ast.nodeTypes.some((nt) => nt.name === newTypeName)) {
+        throw new Error(`Node type "${newTypeName}" already exists`);
+    }
+    return withoutValidation(ast, (draft) => {
+        // Find the node type in nodeTypes array
+        const nodeTypeIndex = draft.nodeTypes.findIndex((nt) => nt.name === oldTypeName);
+        // Rename the node type if it exists in nodeTypes array
+        if (nodeTypeIndex >= 0) {
+            draft.nodeTypes[nodeTypeIndex].name = newTypeName;
+        }
+        // Update all instances that reference this node type
+        draft.instances.forEach((instance) => {
+            if (instance.nodeType === oldTypeName) {
+                instance.nodeType = newTypeName;
+            }
+        });
+    });
+}
+/**
+ * Replace all node types in workflow.
+ * Uses no validation to allow replacement even when workflow has other errors.
+ *
+ * @param ast - Workflow to modify
+ * @param nodeTypes - New array of node types
+ * @returns Modified workflow
+ *
+ * @example
+ * ```typescript
+ * const ast = replaceNodeTypes(workflow, [
+ *   { type: 'NodeType', name: 'type1', ... },
+ *   { type: 'NodeType', name: 'type2', ... }
+ * ]);
+ * ```
+ */
+export function replaceNodeTypes(ast, nodeTypes) {
+    // Use produce directly with simplified type to avoid excessive type instantiation
+    return produce(ast, (draft) => {
+        draft.nodeTypes = nodeTypes;
+    });
+}
+//# sourceMappingURL=node-types.js.map

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

@@ -0,0 +1,144 @@
+/**
+ * Node instance operations for workflow manipulation
+ */
+import type { TWorkflowAST, TNodeInstanceAST, TNodeInstanceConfig } from "../../ast/types.js";
+import { type RemoveOptions } 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 declare function addNode(ast: TWorkflowAST, node: TNodeInstanceAST): TWorkflowAST;
+/**
+ * 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 declare function removeNode(ast: TWorkflowAST, nodeId: string, options?: RemoveOptions): TWorkflowAST;
+/**
+ * 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 declare function renameNode(ast: TWorkflowAST, oldId: string, newId: string): TWorkflowAST;
+/**
+ * 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 declare function updateNode(ast: TWorkflowAST, nodeId: string, updates: Partial<Omit<TNodeInstanceAST, "type" | "id">>): TWorkflowAST;
+/**
+ * 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 declare function addNodes(ast: TWorkflowAST, nodes: TNodeInstanceAST[]): TWorkflowAST;
+/**
+ * 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 declare function removeNodes(ast: TWorkflowAST, nodeIds: string[]): TWorkflowAST;
+/**
+ * Set node configuration
+ *
+ * @param ast - Workflow to modify
+ * @param nodeId - ID of node to configure
+ * @param config - Configuration to set
+ * @returns Modified workflow
+ */
+export declare function setNodeConfig(ast: TWorkflowAST, nodeId: string, config: TNodeInstanceConfig): TWorkflowAST;
+/**
+ * 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 declare function setNodePosition(ast: TWorkflowAST, nodeId: string, x: number, y: number): TWorkflowAST;
+/**
+ * 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 declare function setNodeMinimized(ast: TWorkflowAST, nodeId: string, minimized: boolean): TWorkflowAST;
+/**
+ * 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 declare function setNodeLabel(ast: TWorkflowAST, nodeId: string, label: string | undefined): TWorkflowAST;
+/**
+ * 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 declare function setNodeSize(ast: TWorkflowAST, nodeId: string, width: number, height: number): TWorkflowAST;
+//# sourceMappingURL=nodes.d.ts.map