@flowdrop/flowdrop 1.5.0 → 1.7.0

package/dist/commands/executor.js

@@ -6,13 +6,13 @@
  *
  * @module commands/executor
  */
-import { generateNodeId } from "../utils/nodeIds.js";
-import { extractConfigDefaults } from "../utils/nodeIds.js";
-import { computeAutoPosition } from "./positioner.js";
-import { buildHandleId, extractPortId } from "../utils/handleIds.js";
-import { applyConnectionStyling } from "../utils/edgeStyling.js";
-import { computeSwapPreview, executeSwap } from "../utils/nodeSwap.js";
-import { computeAutoLayout, computeBeautifyLayout } from "../adapters/agentspec/autoLayout.js";
+import { generateNodeId } from '../utils/nodeIds.js';
+import { extractConfigDefaults } from '../utils/nodeIds.js';
+import { computeAutoPosition } from './positioner.js';
+import { buildHandleId, extractPortId } from '../utils/handleIds.js';
+import { applyConnectionStyling } from '../utils/edgeStyling.js';
+import { computeSwapPreview, executeSwap } from '../utils/nodeSwap.js';
+import { computeAutoLayout, computeBeautifyLayout } from '../adapters/agentspec/autoLayout.js';
 // ============================================================================
 // Internal Helpers
 // ============================================================================
@@ -25,12 +25,12 @@ export function toShortId(internalId) {
     // Node IDs are <namespace>.<typeId>.<number> or <typeId>.<number>
     // The namespace is the first segment if there are 3+ dot-separated parts
     // and the last segment is a number
-    const parts = internalId.split(".");
+    const parts = internalId.split('.');
     if (parts.length >= 3) {
         const lastPart = parts[parts.length - 1];
         if (/^\d+$/.test(lastPart)) {
             // Strip the first segment (namespace)
-            return parts.slice(1).join(".");
+            return parts.slice(1).join('.');
         }
     }
     return internalId;
@@ -41,7 +41,7 @@ export function toShortId(internalId) {
  * "llm_node" → "llm_node" (no namespace, unchanged)
  */
 export function toShortTypeId(typeId) {
-    const dotIndex = typeId.indexOf(".");
+    const dotIndex = typeId.indexOf('.');
     if (dotIndex !== -1) {
         return typeId.substring(dotIndex + 1);
     }
@@ -65,14 +65,14 @@ export function resolveNode(shortId, nodes) {
 function executeAddNode(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const metadata = context.typeMap.get(command.nodeTypeId);
     if (!metadata) {
         return {
             ok: false,
             error: `Unknown node type: ${command.nodeTypeId}`,
-            code: "NODE_TYPE_NOT_FOUND",
+            code: 'NODE_TYPE_NOT_FOUND'
         };
     }
     const position = command.position ?? computeAutoPosition(workflow.nodes);
@@ -80,15 +80,15 @@ function executeAddNode(command, context) {
     const config = extractConfigDefaults(metadata.configSchema);
     const node = {
         id: nodeId,
-        type: "universalNode",
+        type: 'universalNode',
         position,
         deletable: true,
         data: {
             label: metadata.name,
             config,
             metadata,
-            nodeId,
-        },
+            nodeId
+        }
     };
     context.dispatch.addNode(node);
     const shortId = toShortId(nodeId);
@@ -96,52 +96,52 @@ function executeAddNode(command, context) {
         nodeId: shortId,
         type: command.nodeTypeId,
         label: metadata.name,
-        position,
+        position
     };
     return {
         ok: true,
         message: `Added ${metadata.name} as ${shortId}`,
-        data: resultData,
+        data: resultData
     };
 }
 function executeDeleteNode(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     context.dispatch.removeNode(node.id);
     return {
         ok: true,
-        message: `Deleted node ${toShortId(node.id)}`,
+        message: `Deleted node ${toShortId(node.id)}`
     };
 }
 function executeRenameNode(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     context.dispatch.updateNode(node.id, {
-        data: { ...node.data, label: command.label },
+        data: { ...node.data, label: command.label }
     });
     return {
         ok: true,
-        message: `Renamed ${toShortId(node.id)} to "${command.label}"`,
+        message: `Renamed ${toShortId(node.id)} to "${command.label}"`
     };
 }
 /**
@@ -163,7 +163,7 @@ function parseConfigValue(raw) {
         return raw.slice(1, -1);
     }
     // Try JSON (arrays, objects, null)
-    if (raw.startsWith("[") || raw.startsWith("{") || raw === "null") {
+    if (raw.startsWith('[') || raw.startsWith('{') || raw === 'null') {
         try {
             return JSON.parse(raw);
         }
@@ -172,13 +172,13 @@ function parseConfigValue(raw) {
         }
     }
     // Number
-    if (raw !== "" && !isNaN(Number(raw))) {
+    if (raw !== '' && !isNaN(Number(raw))) {
         return Number(raw);
     }
     // Boolean
-    if (raw === "true")
+    if (raw === 'true')
         return true;
-    if (raw === "false")
+    if (raw === 'false')
         return false;
     // Raw string
     return raw;
@@ -195,25 +195,25 @@ function validateConfigValue(key, value, property) {
     if (property.enum && property.enum.length > 0) {
         if (!property.enum.includes(value)) {
             warnings.push({
-                type: "enum",
-                message: `Value ${JSON.stringify(value)} is not in allowed values: ${property.enum.map((v) => JSON.stringify(v)).join(", ")}`,
-                allowedValues: property.enum,
+                type: 'enum',
+                message: `Value ${JSON.stringify(value)} is not in allowed values: ${property.enum.map((v) => JSON.stringify(v)).join(', ')}`,
+                allowedValues: property.enum
             });
         }
     }
     // Type validation
     if (property.type) {
-        const actualType = Array.isArray(value) ? "array" : typeof value;
-        const expectedType = property.type === "integer" ? "number" : property.type;
+        const actualType = Array.isArray(value) ? 'array' : typeof value;
+        const expectedType = property.type === 'integer' ? 'number' : property.type;
         // Only warn if there's a genuine mismatch (null/object handled specially)
         if (value !== null &&
             actualType !== expectedType &&
-            !(expectedType === "object" && actualType === "object")) {
+            !(expectedType === 'object' && actualType === 'object')) {
             warnings.push({
-                type: "type_mismatch",
+                type: 'type_mismatch',
                 message: `Expected type '${property.type}' but got '${actualType}'`,
                 expectedType: property.type,
-                actualType,
+                actualType
             });
         }
     }
@@ -222,14 +222,14 @@ function validateConfigValue(key, value, property) {
 function executeSetConfig(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     const parsedValue = parseConfigValue(command.value);
@@ -240,43 +240,43 @@ function executeSetConfig(command, context) {
     const warnings = validateConfigValue(command.key, parsedValue, property);
     // In strict mode, validation warnings become errors
     if (command.strict && warnings && warnings.length > 0) {
-        const messages = warnings.map((w) => w.message).join("; ");
+        const messages = warnings.map((w) => w.message).join('; ');
         return {
             ok: false,
             error: `Config validation failed for ${toShortId(node.id)}:${command.key}: ${messages}`,
-            code: "CONFIG_VALIDATION_ERROR",
+            code: 'CONFIG_VALIDATION_ERROR'
         };
     }
     const updatedConfig = { ...node.data.config, [command.key]: parsedValue };
     context.dispatch.updateNode(node.id, {
-        data: { ...node.data, config: updatedConfig },
+        data: { ...node.data, config: updatedConfig }
     });
     const resultData = {
         nodeId: toShortId(node.id),
         key: command.key,
         value: parsedValue,
-        ...(warnings && warnings.length > 0 ? { warnings } : {}),
+        ...(warnings && warnings.length > 0 ? { warnings } : {})
     };
     const warningMsg = warnings && warnings.length > 0
-        ? ` (warning: ${warnings.map((w) => w.message).join("; ")})`
-        : "";
+        ? ` (warning: ${warnings.map((w) => w.message).join('; ')})`
+        : '';
     return {
         ok: true,
         message: `Set ${toShortId(node.id)}:${command.key} = ${JSON.stringify(parsedValue)}${warningMsg}`,
-        data: resultData,
+        data: resultData
     };
 }
 function executeGetConfig(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     const config = node.data.config;
@@ -284,31 +284,31 @@ function executeGetConfig(command, context) {
         return {
             ok: false,
             error: `Config key not found: ${command.key} on ${toShortId(node.id)}`,
-            code: "CONFIG_KEY_NOT_FOUND",
+            code: 'CONFIG_KEY_NOT_FOUND'
         };
     }
     const resultData = {
         nodeId: toShortId(node.id),
         key: command.key,
-        value: config[command.key],
+        value: config[command.key]
     };
     return {
         ok: true,
         message: `${toShortId(node.id)}:${command.key} = ${JSON.stringify(config[command.key])}`,
-        data: resultData,
+        data: resultData
     };
 }
 function executeInfo(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     const metadata = node.data.metadata;
@@ -316,19 +316,19 @@ function executeInfo(command, context) {
     const inputs = (metadata?.inputs ?? []).map((p) => ({
         portId: p.id,
         name: p.name,
-        dataType: p.dataType,
+        dataType: p.dataType
     }));
     const staticOutputs = (metadata?.outputs ?? []).map((p) => ({
         portId: p.id,
         name: p.name,
-        dataType: p.dataType,
+        dataType: p.dataType
     }));
     // Gateway nodes expose dynamic branch ports from config.branches
-    const branchOutputs = metadata?.type === "gateway"
+    const branchOutputs = metadata?.type === 'gateway'
         ? (node.data.config?.branches ?? []).map((b) => ({
             portId: b.name,
             name: b.name,
-            dataType: "trigger",
+            dataType: 'trigger'
         }))
         : [];
     const outputs = [...staticOutputs, ...branchOutputs];
@@ -338,36 +338,36 @@ function executeInfo(command, context) {
         if (edge.source === node.id) {
             connectedEdges.push({
                 edgeId: edge.id,
-                direction: "outgoing",
+                direction: 'outgoing',
                 remoteNodeId: toShortId(edge.target),
-                remotePort: extractPortId(edge.targetHandle) ?? "",
-                localPort: extractPortId(edge.sourceHandle) ?? "",
+                remotePort: extractPortId(edge.targetHandle) ?? '',
+                localPort: extractPortId(edge.sourceHandle) ?? ''
             });
         }
         else if (edge.target === node.id) {
             connectedEdges.push({
                 edgeId: edge.id,
-                direction: "incoming",
+                direction: 'incoming',
                 remoteNodeId: toShortId(edge.source),
-                remotePort: extractPortId(edge.sourceHandle) ?? "",
-                localPort: extractPortId(edge.targetHandle) ?? "",
+                remotePort: extractPortId(edge.sourceHandle) ?? '',
+                localPort: extractPortId(edge.targetHandle) ?? ''
             });
         }
     }
     const resultData = {
         nodeId: shortId,
-        label: node.data.label ?? metadata?.name ?? "",
-        type: metadata?.id ? toShortTypeId(metadata.id) : "",
+        label: node.data.label ?? metadata?.name ?? '',
+        type: metadata?.id ? toShortTypeId(metadata.id) : '',
         position: node.position,
         config: node.data.config ?? {},
         inputs,
         outputs,
-        connectedEdges,
+        connectedEdges
     };
     return {
         ok: true,
         message: `Info for ${shortId}`,
-        data: resultData,
+        data: resultData
     };
 }
 // ============================================================================
@@ -383,29 +383,32 @@ function findPort(node, portId, preferDirection) {
         return null;
     const outputPort = metadata.outputs?.find((p) => p.id === portId);
     const inputPort = metadata.inputs?.find((p) => p.id === portId);
-    if (preferDirection === "output") {
+    if (preferDirection === 'output') {
         if (outputPort)
-            return { port: outputPort, direction: "output" };
+            return { port: outputPort, direction: 'output' };
         if (inputPort)
-            return { port: inputPort, direction: "input" };
+            return { port: inputPort, direction: 'input' };
     }
-    else if (preferDirection === "input") {
+    else if (preferDirection === 'input') {
         if (inputPort)
-            return { port: inputPort, direction: "input" };
+            return { port: inputPort, direction: 'input' };
         if (outputPort)
-            return { port: outputPort, direction: "output" };
+            return { port: outputPort, direction: 'output' };
     }
     else {
         if (outputPort)
-            return { port: outputPort, direction: "output" };
+            return { port: outputPort, direction: 'output' };
         if (inputPort)
-            return { port: inputPort, direction: "input" };
+            return { port: inputPort, direction: 'input' };
     }
     // Gateway nodes have dynamic branch ports stored in config.branches, not metadata.outputs
-    if (metadata.type === "gateway") {
+    if (metadata.type === 'gateway') {
         const branches = node.data.config?.branches;
         if (branches?.some((b) => b.name === portId)) {
-            return { port: { id: portId, name: portId, dataType: "trigger" }, direction: "output" };
+            return {
+                port: { id: portId, name: portId, dataType: 'trigger' },
+                direction: 'output'
+            };
         }
     }
     return null;
@@ -413,7 +416,7 @@ function findPort(node, portId, preferDirection) {
 function executeConnect(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     // Resolve both nodes
     const sourceNode = resolveNode(command.sourceNodeId, workflow.nodes);
@@ -421,7 +424,7 @@ function executeConnect(command, context) {
         return {
             ok: false,
             error: `Node not found: ${command.sourceNodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     const targetNode = resolveNode(command.targetNodeId, workflow.nodes);
@@ -429,56 +432,56 @@ function executeConnect(command, context) {
         return {
             ok: false,
             error: `Node not found: ${command.targetNodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     // Look up ports in metadata to determine direction.
     // Since connections always flow output → input, prefer the output port on the
     // source node and the input port on the target node when the same port name
     // exists in both directions on a node.
-    const sourcePortInfo = findPort(sourceNode, command.sourcePort, "output");
+    const sourcePortInfo = findPort(sourceNode, command.sourcePort, 'output');
     if (!sourcePortInfo) {
         return {
             ok: false,
             error: `Port '${command.sourcePort}' not found on node ${toShortId(sourceNode.id)}`,
-            code: "PORT_NOT_FOUND",
+            code: 'PORT_NOT_FOUND'
         };
     }
-    const targetPortInfo = findPort(targetNode, command.targetPort, "input");
+    const targetPortInfo = findPort(targetNode, command.targetPort, 'input');
     if (!targetPortInfo) {
         return {
             ok: false,
             error: `Port '${command.targetPort}' not found on node ${toShortId(targetNode.id)}`,
-            code: "PORT_NOT_FOUND",
+            code: 'PORT_NOT_FOUND'
         };
     }
     // Validate directions: source port must be output, target port must be input
-    if (sourcePortInfo.direction !== "output" || targetPortInfo.direction !== "input") {
+    if (sourcePortInfo.direction !== 'output' || targetPortInfo.direction !== 'input') {
         // Check if they're reversed
-        if (sourcePortInfo.direction === "input" && targetPortInfo.direction === "output") {
+        if (sourcePortInfo.direction === 'input' && targetPortInfo.direction === 'output') {
             return {
                 ok: false,
                 error: `Connection direction reversed: '${command.sourcePort}' is an input on ${toShortId(sourceNode.id)} and '${command.targetPort}' is an output on ${toShortId(targetNode.id)}. Swap source and target.`,
-                code: "INVALID_CONNECTION",
+                code: 'INVALID_CONNECTION'
             };
         }
         // One of them is the wrong direction
-        if (sourcePortInfo.direction !== "output") {
+        if (sourcePortInfo.direction !== 'output') {
             return {
                 ok: false,
                 error: `Port '${command.sourcePort}' on ${toShortId(sourceNode.id)} is an input, not an output (per node metadata)`,
-                code: "INVALID_CONNECTION",
+                code: 'INVALID_CONNECTION'
             };
         }
         return {
             ok: false,
             error: `Port '${command.targetPort}' on ${toShortId(targetNode.id)} is an output, not an input (per node metadata)`,
-            code: "INVALID_CONNECTION",
+            code: 'INVALID_CONNECTION'
         };
     }
     // Build handle IDs
-    const sourceHandle = buildHandleId(sourceNode.id, "output", command.sourcePort);
-    const targetHandle = buildHandleId(targetNode.id, "input", command.targetPort);
+    const sourceHandle = buildHandleId(sourceNode.id, 'output', command.sourcePort);
+    const targetHandle = buildHandleId(targetNode.id, 'input', command.targetPort);
     // Generate edge ID
     const edgeId = `${sourceNode.id}-${sourceHandle}-${targetNode.id}-${targetHandle}`;
     // Build edge
@@ -487,7 +490,7 @@ function executeConnect(command, context) {
         source: sourceNode.id,
         target: targetNode.id,
         sourceHandle,
-        targetHandle,
+        targetHandle
     };
     // Apply styling
     applyConnectionStyling(edge, sourceNode, targetNode);
@@ -495,13 +498,13 @@ function executeConnect(command, context) {
     context.dispatch.addEdge(edge);
     return {
         ok: true,
-        message: `Connected ${toShortId(sourceNode.id)}:${command.sourcePort} → ${toShortId(targetNode.id)}:${command.targetPort}`,
+        message: `Connected ${toShortId(sourceNode.id)}:${command.sourcePort} → ${toShortId(targetNode.id)}:${command.targetPort}`
     };
 }
 function executeDisconnectPorts(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     // Resolve both nodes
     const sourceNode = resolveNode(command.sourceNodeId, workflow.nodes);
@@ -509,7 +512,7 @@ function executeDisconnectPorts(command, context) {
         return {
             ok: false,
             error: `Node not found: ${command.sourceNodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     const targetNode = resolveNode(command.targetNodeId, workflow.nodes);
@@ -517,7 +520,7 @@ function executeDisconnectPorts(command, context) {
         return {
             ok: false,
             error: `Node not found: ${command.targetNodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     // Find the matching edge by checking source/target node IDs and port IDs
@@ -532,26 +535,26 @@ function executeDisconnectPorts(command, context) {
         return {
             ok: false,
             error: `No edge found from ${toShortId(sourceNode.id)}:${command.sourcePort} to ${toShortId(targetNode.id)}:${command.targetPort}`,
-            code: "EDGE_NOT_FOUND",
+            code: 'EDGE_NOT_FOUND'
         };
     }
     context.dispatch.removeEdge(edge.id);
     return {
         ok: true,
-        message: `Disconnected ${toShortId(sourceNode.id)}:${command.sourcePort} from ${toShortId(targetNode.id)}:${command.targetPort}`,
+        message: `Disconnected ${toShortId(sourceNode.id)}:${command.sourcePort} from ${toShortId(targetNode.id)}:${command.targetPort}`
     };
 }
 function executeDisconnectNode(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     // Find all edges connected to this node
@@ -561,7 +564,7 @@ function executeDisconnectNode(command, context) {
     }
     return {
         ok: true,
-        message: `Disconnected ${connectedEdges.length} edge(s) from ${toShortId(node.id)}`,
+        message: `Disconnected ${connectedEdges.length} edge(s) from ${toShortId(node.id)}`
     };
 }
 // ============================================================================
@@ -570,84 +573,174 @@ function executeDisconnectNode(command, context) {
 function executeListNodes(context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const nodes = workflow.nodes.map((n) => ({
         nodeId: toShortId(n.id),
-        label: n.data.label ?? n.data.metadata?.name ?? "",
-        type: n.data.metadata?.id ? toShortTypeId(n.data.metadata.id) : "",
+        label: n.data.label ?? n.data.metadata?.name ?? '',
+        type: n.data.metadata?.id ? toShortTypeId(n.data.metadata.id) : ''
     }));
     const resultData = { nodes };
     return {
         ok: true,
         message: nodes.length === 0
-            ? "No nodes in workflow"
-            : `${nodes.length} node(s): ${nodes.map((n) => n.nodeId).join(", ")}`,
-        data: resultData,
+            ? 'No nodes in workflow'
+            : `${nodes.length} node(s): ${nodes.map((n) => n.nodeId).join(', ')}`,
+        data: resultData
     };
 }
 function executeListEdges(context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const edges = workflow.edges.map((e) => ({
         edgeId: e.id,
         sourceNodeId: toShortId(e.source),
-        sourcePort: extractPortId(e.sourceHandle) ?? "",
+        sourcePort: extractPortId(e.sourceHandle) ?? '',
         targetNodeId: toShortId(e.target),
-        targetPort: extractPortId(e.targetHandle) ?? "",
+        targetPort: extractPortId(e.targetHandle) ?? ''
     }));
     const resultData = { edges };
     return {
         ok: true,
-        message: edges.length === 0
-            ? "No edges in workflow"
-            : `${edges.length} edge(s)`,
-        data: resultData,
+        message: edges.length === 0 ? 'No edges in workflow' : `${edges.length} edge(s)`,
+        data: resultData
     };
 }
 function executeListTypes(context) {
     const types = context.nodeTypes.map((m) => ({
         typeId: toShortTypeId(m.id),
         name: m.name,
-        category: m.category,
+        category: m.category
     }));
     const resultData = { types };
     return {
         ok: true,
         message: `${types.length} type(s) available`,
-        data: resultData,
+        data: resultData
     };
 }
 /** All command help entries */
 export const COMMAND_HELP = [
-    { name: "add", syntax: "add <type> [at <x>,<y>]", description: "Add a new node of the specified type" },
-    { name: "delete", syntax: "delete <nodeId>", description: "Delete a node and its connections" },
-    { name: "rename", syntax: "rename <nodeId> <label>", description: "Rename a node's display label" },
-    { name: "set", syntax: "set <nodeId>:<key> <value>", description: "Set a config value on a node" },
-    { name: "get", syntax: "get <nodeId>:<key>", description: "Get a config value from a node" },
-    { name: "connect", syntax: "connect <nid>:<port> to <nid>:<port>", description: "Connect two node ports" },
-    { name: "disconnect", syntax: "disconnect <nid>:<port> from <nid>:<port>", description: "Disconnect two node ports" },
-    { name: "disconnect", syntax: "disconnect <nodeId>", description: "Disconnect all edges from a node" },
-    { name: "list", syntax: "list nodes|edges|types", description: "List workflow nodes, edges, or available types" },
-    { name: "info", syntax: "info <nodeId>", description: "Show detailed info about a node" },
-    { name: "config", syntax: "config <nodeId>", description: "Open the config panel for a node" },
-    { name: "select", syntax: "select <nodeId>", description: "Select a node on the canvas" },
-    { name: "swap", syntax: "swap <nodeId> with <type>", description: "Replace a node's type, preserving connections" },
-    { name: "move", syntax: "move <nodeId> to <x>,<y>", description: "Move a node to a position" },
-    { name: "layout", syntax: "layout auto [--direction horizontal|vertical]", description: "Auto-arrange all nodes" },
-    { name: "layout", syntax: "layout beautify", description: "Normalize spacing while preserving node arrangement" },
-    { name: "undo", syntax: "undo", description: "Undo the last action" },
-    { name: "redo", syntax: "redo", description: "Redo the last undone action" },
-    { name: "help", syntax: "help [<command>]", description: "Show help for all or a specific command" },
-    { name: "clear", syntax: "clear", description: "Remove all nodes and edges" },
-    { name: "canvas", syntax: "canvas fitview", description: "Fit all nodes into the viewport" },
-    { name: "canvas", syntax: "canvas zoom in", description: "Zoom in on the canvas" },
-    { name: "canvas", syntax: "canvas zoom out", description: "Zoom out on the canvas" },
-    { name: "canvas", syntax: "canvas zoom <level>", description: "Set zoom to a specific level (e.g. 1.5)" },
-    { name: "canvas", syntax: "canvas pan <x>,<y>", description: "Pan the canvas to center on a position" },
-    { name: "canvas", syntax: "canvas reset", description: "Reset viewport to default position and zoom" },
+    {
+        name: 'add',
+        syntax: 'add <type> [at <x>,<y>]',
+        description: 'Add a new node of the specified type'
+    },
+    {
+        name: 'delete',
+        syntax: 'delete <nodeId>',
+        description: 'Delete a node and its connections'
+    },
+    {
+        name: 'rename',
+        syntax: 'rename <nodeId> <label>',
+        description: "Rename a node's display label"
+    },
+    {
+        name: 'set',
+        syntax: 'set <nodeId>:<key> <value>',
+        description: 'Set a config value on a node'
+    },
+    {
+        name: 'get',
+        syntax: 'get <nodeId>:<key>',
+        description: 'Get a config value from a node'
+    },
+    {
+        name: 'connect',
+        syntax: 'connect <nid>:<port> to <nid>:<port>',
+        description: 'Connect two node ports'
+    },
+    {
+        name: 'disconnect',
+        syntax: 'disconnect <nid>:<port> from <nid>:<port>',
+        description: 'Disconnect two node ports'
+    },
+    {
+        name: 'disconnect',
+        syntax: 'disconnect <nodeId>',
+        description: 'Disconnect all edges from a node'
+    },
+    {
+        name: 'list',
+        syntax: 'list nodes|edges|types',
+        description: 'List workflow nodes, edges, or available types'
+    },
+    {
+        name: 'info',
+        syntax: 'info <nodeId>',
+        description: 'Show detailed info about a node'
+    },
+    {
+        name: 'config',
+        syntax: 'config <nodeId>',
+        description: 'Open the config panel for a node'
+    },
+    {
+        name: 'select',
+        syntax: 'select <nodeId>',
+        description: 'Select a node on the canvas'
+    },
+    {
+        name: 'swap',
+        syntax: 'swap <nodeId> with <type>',
+        description: "Replace a node's type, preserving connections"
+    },
+    {
+        name: 'move',
+        syntax: 'move <nodeId> to <x>,<y>',
+        description: 'Move a node to a position'
+    },
+    {
+        name: 'layout',
+        syntax: 'layout auto [--direction horizontal|vertical]',
+        description: 'Auto-arrange all nodes'
+    },
+    {
+        name: 'layout',
+        syntax: 'layout beautify',
+        description: 'Normalize spacing while preserving node arrangement'
+    },
+    { name: 'undo', syntax: 'undo', description: 'Undo the last action' },
+    { name: 'redo', syntax: 'redo', description: 'Redo the last undone action' },
+    {
+        name: 'help',
+        syntax: 'help [<command>]',
+        description: 'Show help for all or a specific command'
+    },
+    { name: 'clear', syntax: 'clear', description: 'Remove all nodes and edges' },
+    {
+        name: 'canvas',
+        syntax: 'canvas fitview',
+        description: 'Fit all nodes into the viewport'
+    },
+    {
+        name: 'canvas',
+        syntax: 'canvas zoom in',
+        description: 'Zoom in on the canvas'
+    },
+    {
+        name: 'canvas',
+        syntax: 'canvas zoom out',
+        description: 'Zoom out on the canvas'
+    },
+    {
+        name: 'canvas',
+        syntax: 'canvas zoom <level>',
+        description: 'Set zoom to a specific level (e.g. 1.5)'
+    },
+    {
+        name: 'canvas',
+        syntax: 'canvas pan <x>,<y>',
+        description: 'Pan the canvas to center on a position'
+    },
+    {
+        name: 'canvas',
+        syntax: 'canvas reset',
+        description: 'Reset viewport to default position and zoom'
+    }
 ];
 function executeHelp(command) {
     let commands;
@@ -661,15 +754,13 @@ function executeHelp(command) {
         commands = COMMAND_HELP;
     }
     const resultData = { commands };
-    const message = commands
-        .map((c) => `  ${c.syntax} — ${c.description}`)
-        .join("\n");
+    const message = commands.map((c) => `  ${c.syntax} — ${c.description}`).join('\n');
     return {
         ok: true,
         message: command.command
             ? `Help for '${command.command}':\n${message}`
             : `Available commands:\n${message}`,
-        data: resultData,
+        data: resultData
     };
 }
 // ============================================================================
@@ -680,99 +771,99 @@ function executeUndo(context) {
     if (!success) {
         return {
             ok: false,
-            error: "Nothing to undo",
-            code: "UNDO_UNAVAILABLE",
+            error: 'Nothing to undo',
+            code: 'UNDO_UNAVAILABLE'
         };
     }
-    return { ok: true, message: "Undone" };
+    return { ok: true, message: 'Undone' };
 }
 function executeRedo(context) {
     const success = context.dispatch.redo();
     if (!success) {
         return {
             ok: false,
-            error: "Nothing to redo",
-            code: "REDO_UNAVAILABLE",
+            error: 'Nothing to redo',
+            code: 'REDO_UNAVAILABLE'
         };
     }
-    return { ok: true, message: "Redone" };
+    return { ok: true, message: 'Redone' };
 }
 function executeClear(context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const nodeCount = workflow.nodes.length;
     const edgeCount = workflow.edges.length;
     context.dispatch.batchUpdate({ nodes: [], edges: [] });
     return {
         ok: true,
-        message: `Cleared ${nodeCount} node(s) and ${edgeCount} edge(s)`,
+        message: `Cleared ${nodeCount} node(s) and ${edgeCount} edge(s)`
     };
 }
 function executeConfigOpen(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     if (context.dispatch.emitUIAction) {
-        context.dispatch.emitUIAction({ type: "open_config", nodeId: node.id });
+        context.dispatch.emitUIAction({ type: 'open_config', nodeId: node.id });
         return {
             ok: true,
-            message: `Opened config for ${toShortId(node.id)}`,
+            message: `Opened config for ${toShortId(node.id)}`
         };
     }
     return {
         ok: true,
         message: `Config open requested for ${toShortId(node.id)} (no UI handler)`,
-        uiActionPending: true,
+        uiActionPending: true
     };
 }
 function executeSelectNode(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     if (context.dispatch.emitUIAction) {
-        context.dispatch.emitUIAction({ type: "select_node", nodeId: node.id });
+        context.dispatch.emitUIAction({ type: 'select_node', nodeId: node.id });
         return {
             ok: true,
-            message: `Selected ${toShortId(node.id)}`,
+            message: `Selected ${toShortId(node.id)}`
         };
     }
     return {
         ok: true,
         message: `Select requested for ${toShortId(node.id)} (no UI handler)`,
-        uiActionPending: true,
+        uiActionPending: true
     };
 }
 function executeSwapNode(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     const newMetadata = context.typeMap.get(command.newTypeId);
@@ -780,7 +871,7 @@ function executeSwapNode(command, context) {
         return {
             ok: false,
             error: `Unknown node type: ${command.newTypeId}`,
-            code: "NODE_TYPE_NOT_FOUND",
+            code: 'NODE_TYPE_NOT_FOUND'
         };
     }
     const preview = computeSwapPreview(node, newMetadata, workflow.edges, workflow.nodes);
@@ -788,13 +879,13 @@ function executeSwapNode(command, context) {
     if (context.dispatch.swapNode) {
         context.dispatch.swapNode({
             nodes: swapResult.updatedNodes,
-            edges: swapResult.updatedEdges,
+            edges: swapResult.updatedEdges
         });
     }
     else {
         context.dispatch.batchUpdate({
             nodes: swapResult.updatedNodes,
-            edges: swapResult.updatedEdges,
+            edges: swapResult.updatedEdges
         });
     }
     const resultData = {
@@ -805,50 +896,48 @@ function executeSwapNode(command, context) {
         droppedEdges: preview.droppedEdges.length,
         hasDataLoss: preview.hasDataLoss,
         configCarriedOver: preview.configCarriedOver,
-        configReset: preview.configReset,
+        configReset: preview.configReset
     };
-    const droppedMsg = preview.droppedEdges.length > 0
-        ? ` (${preview.droppedEdges.length} edge(s) dropped)`
-        : "";
+    const droppedMsg = preview.droppedEdges.length > 0 ? ` (${preview.droppedEdges.length} edge(s) dropped)` : '';
     return {
         ok: true,
         message: `Swapped ${toShortId(node.id)} → ${toShortId(preview.newNodeId)} (${command.newTypeId})${droppedMsg}`,
-        data: resultData,
+        data: resultData
     };
 }
 function executeMoveNode(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     const node = resolveNode(command.nodeId, workflow.nodes);
     if (!node) {
         return {
             ok: false,
             error: `Node not found: ${command.nodeId}`,
-            code: "NODE_NOT_FOUND",
+            code: 'NODE_NOT_FOUND'
         };
     }
     context.dispatch.updateNode(node.id, {
-        position: command.position,
+        position: command.position
     });
     return {
         ok: true,
-        message: `Moved ${toShortId(node.id)} to (${command.position.x}, ${command.position.y})`,
+        message: `Moved ${toShortId(node.id)} to (${command.position.x}, ${command.position.y})`
     };
 }
 function executeAutoLayout(command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     if (workflow.nodes.length === 0) {
-        return { ok: true, message: "No nodes to layout" };
+        return { ok: true, message: 'No nodes to layout' };
     }
-    const isVertical = command.direction === "vertical";
+    const isVertical = command.direction === 'vertical';
     // Filter out loopback edges (loop_back port) — they go backwards and
     // would reverse the layout direction if included.
-    const layoutEdges = workflow.edges.filter((e) => !(e.targetHandle ?? "").includes("-input-loop_back"));
+    const layoutEdges = workflow.edges.filter((e) => !(e.targetHandle ?? '').includes('-input-loop_back'));
     // Determine start node via in-degree: a node with no incoming edges
     // (from non-loopback edges) is a root. Fall back to leftmost position.
     const inDegree = new Map();
@@ -858,20 +947,20 @@ function executeAutoLayout(command, context) {
         inDegree.set(e.target, (inDegree.get(e.target) ?? 0) + 1);
     }
     const startNode = workflow.nodes.find((n) => (inDegree.get(n.id) ?? 0) === 0)?.id ??
-        workflow.nodes.reduce((leftmost, n) => n.position.x < leftmost.position.x ? n : leftmost).id;
+        workflow.nodes.reduce((leftmost, n) => (n.position.x < leftmost.position.x ? n : leftmost)).id;
     const flow = {
-        component_type: "flow",
-        name: "layout",
+        component_type: 'flow',
+        name: 'layout',
         start_node: startNode,
         nodes: workflow.nodes.map((n) => ({
-            component_type: "start_node",
-            name: n.id,
+            component_type: 'start_node',
+            name: n.id
         })),
         control_flow_connections: layoutEdges.map((e) => ({
             name: e.id,
             from_node: e.source,
-            to_node: e.target,
-        })),
+            to_node: e.target
+        }))
     };
     // Collect measured node dimensions when available
     const nodeDimensions = new Map();
@@ -890,23 +979,23 @@ function executeAutoLayout(command, context) {
             return n;
         return {
             ...n,
-            position: isVertical ? { x: pos.y, y: pos.x } : pos,
+            position: isVertical ? { x: pos.y, y: pos.x } : pos
         };
     });
     context.dispatch.batchUpdate({ nodes: updatedNodes });
-    const direction = command.direction ?? "horizontal";
+    const direction = command.direction ?? 'horizontal';
     return {
         ok: true,
-        message: `Auto-layout applied to ${workflow.nodes.length} nodes (${direction})`,
+        message: `Auto-layout applied to ${workflow.nodes.length} nodes (${direction})`
     };
 }
 function executeBeautifyLayout(_command, context) {
     const workflow = context.getWorkflow();
     if (!workflow) {
-        return { ok: false, error: "No workflow loaded", code: "NO_WORKFLOW" };
+        return { ok: false, error: 'No workflow loaded', code: 'NO_WORKFLOW' };
     }
     if (workflow.nodes.length === 0) {
-        return { ok: true, message: "No nodes to beautify" };
+        return { ok: true, message: 'No nodes to beautify' };
     }
     // Collect current positions
     const currentPositions = new Map();
@@ -933,7 +1022,7 @@ function executeBeautifyLayout(_command, context) {
     context.dispatch.batchUpdate({ nodes: updatedNodes });
     return {
         ok: true,
-        message: `Beautified layout for ${workflow.nodes.length} nodes`,
+        message: `Beautified layout for ${workflow.nodes.length} nodes`
     };
 }
 // ============================================================================
@@ -947,26 +1036,26 @@ function emitCanvasAction(context, action, successMessage) {
     return {
         ok: true,
         message: `${successMessage} (no UI handler)`,
-        uiActionPending: true,
+        uiActionPending: true
     };
 }
 function executeCanvasFitView(context) {
-    return emitCanvasAction(context, { type: "canvas_fit_view" }, "Fit view applied");
+    return emitCanvasAction(context, { type: 'canvas_fit_view' }, 'Fit view applied');
 }
 function executeCanvasZoomIn(context) {
-    return emitCanvasAction(context, { type: "canvas_zoom_in" }, "Zoomed in");
+    return emitCanvasAction(context, { type: 'canvas_zoom_in' }, 'Zoomed in');
 }
 function executeCanvasZoomOut(context) {
-    return emitCanvasAction(context, { type: "canvas_zoom_out" }, "Zoomed out");
+    return emitCanvasAction(context, { type: 'canvas_zoom_out' }, 'Zoomed out');
 }
 function executeCanvasZoomTo(command, context) {
-    return emitCanvasAction(context, { type: "canvas_zoom_to", level: command.level }, `Zoom set to ${command.level}`);
+    return emitCanvasAction(context, { type: 'canvas_zoom_to', level: command.level }, `Zoom set to ${command.level}`);
 }
 function executeCanvasPanTo(command, context) {
-    return emitCanvasAction(context, { type: "canvas_pan_to", position: command.position }, `Panned to (${command.position.x}, ${command.position.y})`);
+    return emitCanvasAction(context, { type: 'canvas_pan_to', position: command.position }, `Panned to (${command.position.x}, ${command.position.y})`);
 }
 function executeCanvasResetView(context) {
-    return emitCanvasAction(context, { type: "canvas_reset_view" }, "Viewport reset");
+    return emitCanvasAction(context, { type: 'canvas_reset_view' }, 'Viewport reset');
 }
 // ============================================================================
 // Public API
@@ -976,68 +1065,68 @@ function executeCanvasResetView(context) {
  */
 export function executeCommand(command, context) {
     switch (command.type) {
-        case "add_node":
+        case 'add_node':
             return executeAddNode(command, context);
-        case "delete_node":
+        case 'delete_node':
             return executeDeleteNode(command, context);
-        case "rename_node":
+        case 'rename_node':
             return executeRenameNode(command, context);
-        case "set_config":
+        case 'set_config':
             return executeSetConfig(command, context);
-        case "get_config":
+        case 'get_config':
             return executeGetConfig(command, context);
-        case "info":
+        case 'info':
             return executeInfo(command, context);
-        case "connect":
+        case 'connect':
             return executeConnect(command, context);
-        case "disconnect_ports":
+        case 'disconnect_ports':
             return executeDisconnectPorts(command, context);
-        case "disconnect_node":
+        case 'disconnect_node':
             return executeDisconnectNode(command, context);
-        case "list_nodes":
+        case 'list_nodes':
             return executeListNodes(context);
-        case "list_edges":
+        case 'list_edges':
             return executeListEdges(context);
-        case "list_types":
+        case 'list_types':
             return executeListTypes(context);
-        case "help":
+        case 'help':
             return executeHelp(command);
-        case "undo":
+        case 'undo':
             return executeUndo(context);
-        case "redo":
+        case 'redo':
             return executeRedo(context);
-        case "clear":
+        case 'clear':
             return executeClear(context);
-        case "config_open":
+        case 'config_open':
             return executeConfigOpen(command, context);
-        case "select_node":
+        case 'select_node':
             return executeSelectNode(command, context);
-        case "swap_node":
+        case 'swap_node':
             return executeSwapNode(command, context);
-        case "move_node":
+        case 'move_node':
             return executeMoveNode(command, context);
-        case "auto_layout":
+        case 'auto_layout':
             return executeAutoLayout(command, context);
-        case "beautify_layout":
+        case 'beautify_layout':
             return executeBeautifyLayout(command, context);
-        case "canvas_fit_view":
+        case 'canvas_fit_view':
             return executeCanvasFitView(context);
-        case "canvas_zoom_in":
+        case 'canvas_zoom_in':
             return executeCanvasZoomIn(context);
-        case "canvas_zoom_out":
+        case 'canvas_zoom_out':
             return executeCanvasZoomOut(context);
-        case "canvas_zoom_to":
+        case 'canvas_zoom_to':
             return executeCanvasZoomTo(command, context);
-        case "canvas_pan_to":
+        case 'canvas_pan_to':
             return executeCanvasPanTo(command, context);
-        case "canvas_reset_view":
+        case 'canvas_reset_view':
             return executeCanvasResetView(context);
         default: {
             const _exhaustive = command;
             return {
                 ok: false,
                 error: `Command not yet implemented: ${_exhaustive.type}`,
-                code: "UNKNOWN_COMMAND",
+                code: 'UNKNOWN_COMMAND'
             };
         }
     }