@flowdrop/flowdrop 1.5.0 → 1.6.0

package/dist/utils/nodeIds.d.ts

@@ -3,7 +3,7 @@
  * Used by both the visual editor and the workflow adapter to ensure
  * consistent behavior across all code paths.
  */
-import type { ConfigSchema } from "../types/index.js";
+import type { ConfigSchema } from '../types/index.js';
 /**
  * Minimal node shape required for ID generation.
  * Both WorkflowNode and StandardNode satisfy this interface.

package/dist/utils/nodeIds.js

@@ -34,7 +34,7 @@ export function extractConfigDefaults(configSchema) {
     if (!configSchema?.properties)
         return config;
     for (const [key, prop] of Object.entries(configSchema.properties)) {
-        if (prop && typeof prop === "object" && "default" in prop) {
+        if (prop && typeof prop === 'object' && 'default' in prop) {
             config[key] = prop.default;
         }
     }

package/dist/utils/nodeStatus.d.ts

@@ -2,7 +2,7 @@
  * Node Status Utility Functions
  * Provides utilities for managing and displaying node execution status
  */
-import type { NodeExecutionStatus, NodeExecutionInfo } from "../types/index.js";
+import type { NodeExecutionStatus, NodeExecutionInfo } from '../types/index.js';
 /**
  * Get the display color for a node execution status
  */

package/dist/utils/nodeStatus.js

@@ -7,13 +7,13 @@
  */
 export function getStatusColor(status) {
     const statusColors = {
-        idle: "#6b7280", // gray
-        pending: "#f59e0b", // amber
-        running: "#3b82f6", // blue
-        completed: "#10b981", // emerald
-        failed: "#ef4444", // red
-        cancelled: "#6b7280", // gray
-        skipped: "#8b5cf6", // violet
+        idle: '#6b7280', // gray
+        pending: '#f59e0b', // amber
+        running: '#3b82f6', // blue
+        completed: '#10b981', // emerald
+        failed: '#ef4444', // red
+        cancelled: '#6b7280', // gray
+        skipped: '#8b5cf6' // violet
     };
     return statusColors[status] || statusColors.idle;
 }
@@ -22,13 +22,13 @@ export function getStatusColor(status) {
  */
 export function getStatusIcon(status) {
     const statusIcons = {
-        idle: "mdi:circle-outline",
-        pending: "mdi:clock-outline",
-        running: "mdi:loading",
-        completed: "mdi:check-circle",
-        failed: "mdi:alert-circle",
-        cancelled: "mdi:cancel",
-        skipped: "mdi:skip-next",
+        idle: 'mdi:circle-outline',
+        pending: 'mdi:clock-outline',
+        running: 'mdi:loading',
+        completed: 'mdi:check-circle',
+        failed: 'mdi:alert-circle',
+        cancelled: 'mdi:cancel',
+        skipped: 'mdi:skip-next'
     };
     return statusIcons[status] || statusIcons.idle;
 }
@@ -37,13 +37,13 @@ export function getStatusIcon(status) {
  */
 export function getStatusLabel(status) {
     const statusLabels = {
-        idle: "Idle",
-        pending: "Pending",
-        running: "Running",
-        completed: "Completed",
-        failed: "Failed",
-        cancelled: "Cancelled",
-        skipped: "Skipped",
+        idle: 'Idle',
+        pending: 'Pending',
+        running: 'Running',
+        completed: 'Completed',
+        failed: 'Failed',
+        cancelled: 'Cancelled',
+        skipped: 'Skipped'
     };
     return statusLabels[status] || statusLabels.idle;
 }
@@ -52,13 +52,13 @@ export function getStatusLabel(status) {
  */
 export function getStatusBackgroundColor(status) {
     const statusBackgroundColors = {
-        idle: "#f9fafb", // light gray
-        pending: "#fef3c7", // light amber
-        running: "#dbeafe", // light blue
-        completed: "#d1fae5", // light emerald
-        failed: "#fee2e2", // light red
-        cancelled: "#f3f4f6", // light gray
-        skipped: "#ede9fe", // light violet
+        idle: '#f9fafb', // light gray
+        pending: '#fef3c7', // light amber
+        running: '#dbeafe', // light blue
+        completed: '#d1fae5', // light emerald
+        failed: '#fee2e2', // light red
+        cancelled: '#f3f4f6', // light gray
+        skipped: '#ede9fe' // light violet
     };
     return statusBackgroundColors[status] || statusBackgroundColors.idle;
 }
@@ -67,13 +67,13 @@ export function getStatusBackgroundColor(status) {
  */
 export function getStatusTextColor(status) {
     const statusTextColors = {
-        idle: "#6b7280", // gray
-        pending: "#d97706", // amber
-        running: "#1d4ed8", // blue
-        completed: "#059669", // emerald
-        failed: "#dc2626", // red
-        cancelled: "#6b7280", // gray
-        skipped: "#7c3aed", // violet
+        idle: '#6b7280', // gray
+        pending: '#d97706', // amber
+        running: '#1d4ed8', // blue
+        completed: '#059669', // emerald
+        failed: '#dc2626', // red
+        cancelled: '#6b7280', // gray
+        skipped: '#7c3aed' // violet
     };
     return statusTextColors[status] || statusTextColors.idle;
 }
@@ -82,9 +82,9 @@ export function getStatusTextColor(status) {
  */
 export function createDefaultExecutionInfo() {
     return {
-        status: "idle",
+        status: 'idle',
         executionCount: 0,
-        isExecuting: false,
+        isExecuting: false
     };
 }
 /**
@@ -93,8 +93,8 @@ export function createDefaultExecutionInfo() {
 export function updateExecutionStart(executionInfo) {
     return {
         ...executionInfo,
-        status: "running",
-        isExecuting: true,
+        status: 'running',
+        isExecuting: true
     };
 }
 /**
@@ -103,12 +103,12 @@ export function updateExecutionStart(executionInfo) {
 export function updateExecutionComplete(executionInfo, duration) {
     return {
         ...executionInfo,
-        status: "completed",
+        status: 'completed',
         executionCount: executionInfo.executionCount + 1,
         lastExecuted: new Date().toISOString(),
         lastExecutionDuration: duration,
         isExecuting: false,
-        lastError: undefined, // Clear any previous error
+        lastError: undefined // Clear any previous error
     };
 }
 /**
@@ -117,12 +117,12 @@ export function updateExecutionComplete(executionInfo, duration) {
 export function updateExecutionFailed(executionInfo, error, duration) {
     return {
         ...executionInfo,
-        status: "failed",
+        status: 'failed',
         executionCount: executionInfo.executionCount + 1,
         lastExecuted: new Date().toISOString(),
         lastExecutionDuration: duration,
         isExecuting: false,
-        lastError: error,
+        lastError: error
     };
 }
 /**
@@ -131,9 +131,9 @@ export function updateExecutionFailed(executionInfo, error, duration) {
 export function resetExecutionInfo(executionInfo) {
     return {
         ...executionInfo,
-        status: "idle",
+        status: 'idle',
         isExecuting: false,
-        lastError: undefined,
+        lastError: undefined
     };
 }
 /**
@@ -141,7 +141,7 @@ export function resetExecutionInfo(executionInfo) {
  */
 export function formatExecutionDuration(duration) {
     if (!duration)
-        return "N/A";
+        return 'N/A';
     if (duration < 1000) {
         return `${Math.round(duration)}ms`;
     }
@@ -159,13 +159,13 @@ export function formatExecutionDuration(duration) {
  */
 export function formatLastExecuted(timestamp) {
     if (!timestamp)
-        return "Never";
+        return 'Never';
     const date = new Date(timestamp);
     const now = new Date();
     const diffMs = now.getTime() - date.getTime();
     if (diffMs < 60000) {
         // Less than 1 minute
-        return "Just now";
+        return 'Just now';
     }
     else if (diffMs < 3600000) {
         // Less than 1 hour

package/dist/utils/nodeSwap.d.ts

@@ -6,9 +6,9 @@
  *
  * @module utils/nodeSwap
  */
-import type { WorkflowNode, WorkflowEdge, NodeMetadata, NodePort, ConfigSchema, ConfigValues } from "../types/index.js";
-import type { WorkflowValidationResult } from "./validation.js";
-import type { PortCompatibilityChecker } from "./connections.js";
+import type { WorkflowNode, WorkflowEdge, NodeMetadata, NodePort, ConfigSchema, ConfigValues } from '../types/index.js';
+import type { WorkflowValidationResult } from './validation.js';
+import type { PortCompatibilityChecker } from './connections.js';
 /**
  * Describes how a single port was remapped during a swap.
  */
@@ -17,7 +17,7 @@ export interface PortMapping {
     newHandleId: string;
     oldPortId: string;
     newPortId: string;
-    direction: "input" | "output";
+    direction: 'input' | 'output';
 }
 /**
  * An edge that could not be remapped and will be dropped.
@@ -54,17 +54,17 @@ export interface SwapResult {
     updatedEdges: WorkflowEdge[];
 }
 /** Quality annotation for how a port was matched. */
-export type MatchQuality = "id" | "name" | "type" | "manual" | "unmapped";
+export type MatchQuality = 'id' | 'name' | 'type' | 'manual' | 'unmapped';
 /** Manual override for a single port mapping. */
 export interface PortMappingOverride {
     oldPortId: string;
     newPortId: string | null;
-    direction: "input" | "output";
+    direction: 'input' | 'output';
 }
 /** Manual override for a single config mapping. */
 export interface ConfigMappingOverride {
     key: string;
-    action: "carry" | "reset" | "set";
+    action: 'carry' | 'reset' | 'set';
     value?: unknown;
 }
 /** Options bag for advanced swap functions. */
@@ -81,7 +81,7 @@ export interface SwapStrategy {
     canHandle(ctx: SwapStrategyContext): boolean;
     mapPorts?(ctx: SwapStrategyContext): Record<string, string | null> | undefined;
     mapConfig?(ctx: SwapStrategyContext): Record<string, {
-        action: "carry" | "reset" | "set";
+        action: 'carry' | 'reset' | 'set';
         value?: unknown;
     }> | undefined;
 }
@@ -109,7 +109,7 @@ export declare class SwapValidationError extends Error {
 export interface EditablePortMapping {
     oldPort: NodePort;
     edge: WorkflowEdge;
-    direction: "input" | "output";
+    direction: 'input' | 'output';
     selectedNewPortId: string | null;
     matchQuality: MatchQuality;
     autoSuggestedPortId: string | null;

package/dist/utils/nodeSwap.js

@@ -6,23 +6,19 @@
  *
  * @module utils/nodeSwap
  */
-import { buildHandleId, extractPortId, extractDirection } from "./handleIds.js";
-import { generateNodeId } from "./nodeIds.js";
+import { buildHandleId, extractPortId, extractDirection } from './handleIds.js';
+import { generateNodeId } from './nodeIds.js';
 /** Error class for swap validation failures. */
 export class SwapValidationError extends Error {
     constructor(message) {
         super(message);
-        this.name = "SwapValidationError";
+        this.name = 'SwapValidationError';
     }
 }
 // =========================================================================
 // Dynamic port keys that should never be carried over
 // =========================================================================
-const DYNAMIC_PORT_KEYS = new Set([
-    "dynamicInputs",
-    "dynamicOutputs",
-    "branches",
-]);
+const DYNAMIC_PORT_KEYS = new Set(['dynamicInputs', 'dynamicOutputs', 'branches']);
 // =========================================================================
 // Semver comparison
 // =========================================================================
@@ -34,10 +30,10 @@ const DYNAMIC_PORT_KEYS = new Set([
  */
 export function compareSemver(a, b) {
     // Split off pre-release tag
-    const [aCore, aPre] = a.split("-", 2);
-    const [bCore, bPre] = b.split("-", 2);
-    const aParts = aCore.split(".").map(Number);
-    const bParts = bCore.split(".").map(Number);
+    const [aCore, aPre] = a.split('-', 2);
+    const [bCore, bPre] = b.split('-', 2);
+    const aParts = aCore.split('.').map(Number);
+    const bParts = bCore.split('.').map(Number);
     const maxLen = Math.max(aParts.length, bParts.length);
     for (let i = 0; i < maxLen; i++) {
         const av = aParts[i] ?? 0;
@@ -107,7 +103,7 @@ function findMatchingPort(oldPort, newPorts, usedPortIds, checker) {
         if (!checker)
             return a.dataType === b.dataType;
         // Check both directions since the port role (input vs output) matters
-        if (oldPort.type === "input") {
+        if (oldPort.type === 'input') {
             // Old port is input → old dataType was the target; check any source can feed into new port
             return checker.areDataTypesCompatible(a.dataType, b.dataType);
         }
@@ -135,9 +131,7 @@ function resolvePort(node, handleId, direction) {
     const portId = extractPortId(handleId);
     if (!portId)
         return null;
-    const ports = direction === "input"
-        ? node.data.metadata.inputs
-        : node.data.metadata.outputs;
+    const ports = direction === 'input' ? node.data.metadata.inputs : node.data.metadata.outputs;
     return ports.find((p) => p.id === portId) ?? null;
 }
 // =========================================================================
@@ -161,7 +155,7 @@ export function computeSwapPreview(oldNode, newMetadata, edges, allNodes, checke
     const droppedEdges = [];
     for (const edge of connectedEdges) {
         const isSource = edge.source === oldNodeId;
-        const direction = isSource ? "output" : "input";
+        const direction = isSource ? 'output' : 'input';
         const handleId = isSource ? edge.sourceHandle : edge.targetHandle;
         const usedPorts = isSource ? usedOutputPortIds : usedInputPortIds;
         // Resolve the old port
@@ -169,17 +163,17 @@ export function computeSwapPreview(oldNode, newMetadata, edges, allNodes, checke
         if (!oldPort) {
             droppedEdges.push({
                 edge,
-                reason: `Port not found on original node`,
+                reason: `Port not found on original node`
             });
             continue;
         }
         // Find matching port on new node
-        const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+        const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
         const match = findMatchingPort(oldPort, newPorts, usedPorts, checker);
         if (!match) {
             droppedEdges.push({
                 edge,
-                reason: `No compatible ${direction} port found on "${newMetadata.name}"`,
+                reason: `No compatible ${direction} port found on "${newMetadata.name}"`
             });
             continue;
         }
@@ -205,7 +199,7 @@ export function computeSwapPreview(oldNode, newMetadata, edges, allNodes, checke
         hasDataLoss: droppedEdges.length > 0,
         newNodeId,
         configCarriedOver: carriedOver,
-        configReset: reset,
+        configReset: reset
     };
 }
 // =========================================================================
@@ -225,20 +219,20 @@ export function executeSwap(oldNode, newMetadata, preview, allNodes, allEdges) {
     const extensions = {
         ...oldNode.data.extensions,
         swap: {
-            previousNodeId: oldNodeId,
-        },
+            previousNodeId: oldNodeId
+        }
     };
     const newNode = {
         id: newNodeId,
-        type: "universalNode",
+        type: 'universalNode',
         position: { ...oldNode.position },
         deletable: oldNode.deletable,
         data: {
             label: newMetadata.name,
             config: mappedConfig,
             metadata: newMetadata,
-            extensions,
-        },
+            extensions
+        }
     };
     // Build dropped edge IDs set for fast lookup
     const droppedEdgeIds = new Set(preview.droppedEdges.map((d) => d.edge.id));
@@ -261,7 +255,7 @@ export function executeSwap(oldNode, newMetadata, preview, allNodes, allEdges) {
         }
     }
     // Build updated nodes: replace old node with new node (preserving array order)
-    const updatedNodes = allNodes.map((node) => node.id === oldNodeId ? newNode : node);
+    const updatedNodes = allNodes.map((node) => (node.id === oldNodeId ? newNode : node));
     return { updatedNodes, updatedEdges };
 }
 // =========================================================================
@@ -292,12 +286,12 @@ export function getVersionUpgrade(currentMetadata, allNodeTypes) {
  */
 function classifyMatch(oldPort, matchedPort) {
     if (!matchedPort)
-        return "unmapped";
+        return 'unmapped';
     if (matchedPort.id === oldPort.id)
-        return "id";
+        return 'id';
     if (matchedPort.name.toLowerCase() === oldPort.name.toLowerCase())
-        return "name";
-    return "type";
+        return 'name';
+    return 'type';
 }
 /**
  * Compute a swap preview with full options support (strategies, overrides).
@@ -323,7 +317,7 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
             newMetadata,
             edges,
             allNodes,
-            checker,
+            checker
         };
         for (const strategy of options.strategies) {
             if (strategy.canHandle(ctx)) {
@@ -345,12 +339,12 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
     const droppedEdges = [];
     for (const edge of connectedEdges) {
         const isSource = edge.source === oldNodeId;
-        const direction = isSource ? "output" : "input";
+        const direction = isSource ? 'output' : 'input';
         const handleId = isSource ? edge.sourceHandle : edge.targetHandle;
         const usedPorts = isSource ? usedOutputPortIds : usedInputPortIds;
         const oldPort = resolvePort(oldNode, handleId, direction);
         if (!oldPort) {
-            droppedEdges.push({ edge, reason: "Port not found on original node" });
+            droppedEdges.push({ edge, reason: 'Port not found on original node' });
             continue;
         }
         // Priority 1: Manual port override
@@ -358,10 +352,10 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
         if (portOverrideLookup.has(overrideKey)) {
             const overrideNewPortId = portOverrideLookup.get(overrideKey);
             if (overrideNewPortId === null) {
-                droppedEdges.push({ edge, reason: "Manually dropped" });
+                droppedEdges.push({ edge, reason: 'Manually dropped' });
                 continue;
             }
-            const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+            const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
             const overridePort = newPorts.find((p) => p.id === overrideNewPortId);
             if (overridePort) {
                 usedPorts.add(overridePort.id);
@@ -383,10 +377,10 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
         if (strategyPortMap && oldPort.id in strategyPortMap) {
             const strategyNewPortId = strategyPortMap[oldPort.id];
             if (strategyNewPortId === null) {
-                droppedEdges.push({ edge, reason: "Dropped by strategy" });
+                droppedEdges.push({ edge, reason: 'Dropped by strategy' });
                 continue;
             }
-            const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+            const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
             const strategyPort = newPorts.find((p) => p.id === strategyNewPortId);
             if (strategyPort && !usedPorts.has(strategyPort.id)) {
                 usedPorts.add(strategyPort.id);
@@ -405,12 +399,12 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
             }
         }
         // Priority 3: Built-in 3-pass matching
-        const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+        const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
         const match = findMatchingPort(oldPort, newPorts, usedPorts, checker);
         if (!match) {
             droppedEdges.push({
                 edge,
-                reason: `No compatible ${direction} port found on "${newMetadata.name}"`,
+                reason: `No compatible ${direction} port found on "${newMetadata.name}"`
             });
             continue;
         }
@@ -432,14 +426,14 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
     // Apply strategy config overrides
     if (strategyConfigMap) {
         for (const [key, mapping] of Object.entries(strategyConfigMap)) {
-            if (mapping.action === "carry" && key in oldNode.data.config) {
+            if (mapping.action === 'carry' && key in oldNode.data.config) {
                 if (!carriedOver.includes(key))
                     carriedOver.push(key);
                 const resetIdx = reset.indexOf(key);
                 if (resetIdx >= 0)
                     reset.splice(resetIdx, 1);
             }
-            else if (mapping.action === "reset") {
+            else if (mapping.action === 'reset') {
                 if (!reset.includes(key))
                     reset.push(key);
                 const carryIdx = carriedOver.indexOf(key);
@@ -450,21 +444,21 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
     }
     // Apply manual config overrides (highest priority)
     for (const override of options.configOverrides ?? []) {
-        if (override.action === "carry" && override.key in oldNode.data.config) {
+        if (override.action === 'carry' && override.key in oldNode.data.config) {
             if (!carriedOver.includes(override.key))
                 carriedOver.push(override.key);
             const resetIdx = reset.indexOf(override.key);
             if (resetIdx >= 0)
                 reset.splice(resetIdx, 1);
         }
-        else if (override.action === "reset") {
+        else if (override.action === 'reset') {
             if (!reset.includes(override.key))
                 reset.push(override.key);
             const carryIdx = carriedOver.indexOf(override.key);
             if (carryIdx >= 0)
                 carriedOver.splice(carryIdx, 1);
         }
-        else if (override.action === "set") {
+        else if (override.action === 'set') {
             if (!carriedOver.includes(override.key))
                 carriedOver.push(override.key);
             const resetIdx = reset.indexOf(override.key);
@@ -478,7 +472,7 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
         hasDataLoss: droppedEdges.length > 0,
         newNodeId,
         configCarriedOver: carriedOver,
-        configReset: reset,
+        configReset: reset
     };
 }
 /**
@@ -507,15 +501,15 @@ export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, o
     const portMappings = [];
     for (const edge of connectedEdges) {
         const isSource = edge.source === oldNodeId;
-        const direction = isSource ? "output" : "input";
+        const direction = isSource ? 'output' : 'input';
         const handleId = isSource ? edge.sourceHandle : edge.targetHandle;
         const oldPort = resolvePort(oldNode, handleId, direction);
         if (!oldPort)
             continue;
         const matchedPortId = keptEdgePortMap.get(edge.id) ?? null;
-        const newPorts = direction === "input" ? newMetadata.inputs : newMetadata.outputs;
+        const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
         const matchedPort = matchedPortId
-            ? newPorts.find((p) => p.id === matchedPortId) ?? null
+            ? (newPorts.find((p) => p.id === matchedPortId) ?? null)
             : null;
         const matchQuality = classifyMatch(oldPort, matchedPort);
         portMappings.push({
@@ -525,7 +519,7 @@ export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, o
             selectedNewPortId: matchedPortId,
             matchQuality,
             autoSuggestedPortId: matchedPortId,
-            isOverridden: false,
+            isOverridden: false
         });
     }
     // Build config mappings
@@ -548,7 +542,7 @@ export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, o
                 newDefault,
                 carryOver: hasOldValue && isFlat,
                 autoCarryOver: hasOldValue && isFlat,
-                isFlat,
+                isFlat
             });
         }
     }
@@ -559,7 +553,7 @@ export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, o
         portMappings,
         configMappings,
         availableNewInputs: [...newMetadata.inputs],
-        availableNewOutputs: [...newMetadata.outputs],
+        availableNewOutputs: [...newMetadata.outputs]
     };
 }
 /** Check if a value is a primitive (string, number, boolean, null, undefined). */
@@ -567,7 +561,7 @@ function isPrimitive(value) {
     if (value === null || value === undefined)
         return true;
     const t = typeof value;
-    return t === "string" || t === "number" || t === "boolean";
+    return t === 'string' || t === 'number' || t === 'boolean';
 }
 /**
  * Convert user-edited InteractiveSwapState back into a SwapPreview
@@ -580,9 +574,9 @@ export function buildSwapPreviewFromState(state, allEdges) {
         if (!mapping.selectedNewPortId) {
             droppedEdges.push({
                 edge: mapping.edge,
-                reason: mapping.matchQuality === "unmapped"
+                reason: mapping.matchQuality === 'unmapped'
                     ? `No compatible ${mapping.direction} port found on "${state.newMetadata.name}"`
-                    : "Manually dropped",
+                    : 'Manually dropped'
             });
             continue;
         }
@@ -616,7 +610,7 @@ export function buildSwapPreviewFromState(state, allEdges) {
         hasDataLoss: droppedEdges.length > 0,
         newNodeId: state.newNodeId,
         configCarriedOver,
-        configReset,
+        configReset
     };
 }
 /**
@@ -672,13 +666,13 @@ export function validateSwapResult(result) {
         if (!nodeIds.has(edge.source)) {
             return {
                 valid: false,
-                error: `Dangling edge "${edge.id}": source node "${edge.source}" not found`,
+                error: `Dangling edge "${edge.id}": source node "${edge.source}" not found`
             };
         }
         if (!nodeIds.has(edge.target)) {
             return {
                 valid: false,
-                error: `Dangling edge "${edge.id}": target node "${edge.target}" not found`,
+                error: `Dangling edge "${edge.id}": target node "${edge.target}" not found`
             };
         }
     }

package/dist/utils/nodeTypes.d.ts

@@ -9,7 +9,7 @@
  *
  * Works with both built-in types and custom registered types.
  */
-import type { NodeType, NodeMetadata } from "../types/index.js";
+import type { NodeType, NodeMetadata } from '../types/index.js';
 /**
  * Gets the SvelteFlow component name for a given NodeType.
  * Uses the node component registry to resolve types.