@flowdrop/flowdrop 1.14.0 → 2.0.0-beta.1

package/dist/utils/icons.js

@@ -2,7 +2,6 @@
  * Centralized icon management for FlowDrop
  * Ensures consistent icon usage across all components
  */
-import { getCategoryIcon as getCategoryIconFromStore } from '../stores/categoriesStore.svelte.js';
 /**
  * Default icons for different contexts
  */
@@ -103,18 +102,19 @@ export const CATEGORY_ICONS = {
 };
 /**
  * Get the appropriate icon for a node
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param nodeIcon - The node's specific icon
  * @param category - The node's category
  * @returns The icon to use
  */
-export function getNodeIcon(nodeIcon, category) {
+export function getNodeIcon(categories, nodeIcon, category) {
     // If node has a specific icon, use it
     if (nodeIcon) {
         return nodeIcon;
     }
     // If category is provided, use category icon from store (which includes API overrides)
     if (category) {
-        return getCategoryIconFromStore(category);
+        return categories.getIcon(category);
     }
     // Fallback to default node icon
     return DEFAULT_ICONS.NODE;
@@ -123,11 +123,12 @@ export function getNodeIcon(nodeIcon, category) {
  * Get the appropriate icon for a category.
  * Checks the categories store first (which includes API overrides),
  * then falls back to the static CATEGORY_ICONS map, then to the default.
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The category
  * @returns The icon to use
  */
-export function getCategoryIcon(category) {
-    return getCategoryIconFromStore(category);
+export function getCategoryIcon(categories, category) {
+    return categories.getIcon(category);
 }
 /**
  * Get a default icon by key

package/dist/utils/nodeSwap.d.ts

@@ -161,6 +161,10 @@ export declare function mapConfig(oldConfig: ConfigValues, newConfigSchema: Conf
  *
  * This does NOT mutate anything — it returns a preview that can be displayed
  * to the user for confirmation before executing the swap.
+ *
+ * Thin wrapper over {@link computeSwapPreviewWithOptions} — with no strategies
+ * or overrides the cascade reduces to the built-in exact matching, so both
+ * entry points share one implementation.
  */
 export declare function computeSwapPreview(oldNode: WorkflowNode, newMetadata: NodeMetadata, edges: WorkflowEdge[], allNodes: WorkflowNode[], checker?: PortCompatibilityChecker | null): SwapPreview;
 /**
@@ -183,7 +187,7 @@ export declare function getVersionUpgrade(currentMetadata: NodeMetadata, allNode
  *
  * Resolution order:
  * 1. Check strategies — first canHandle() match wins for mapPorts()/mapConfig()
- * 2. Fall through to built-in 3-pass for ports not covered by strategy
+ * 2. Fall through to built-in exact matching (ID, then name) for ports not covered by strategy
  * 3. Apply portOverrides on top (highest priority — user's manual overrides)
  * 4. Same cascade for config
  */
@@ -199,7 +203,7 @@ export declare function computeInteractiveState(oldNode: WorkflowNode, newMetada
  * Convert user-edited InteractiveSwapState back into a SwapPreview
  * for executeSwap(). Pure function, no side effects.
  */
-export declare function buildSwapPreviewFromState(state: InteractiveSwapState, allEdges: WorkflowEdge[]): SwapPreview;
+export declare function buildSwapPreviewFromState(state: InteractiveSwapState, _allEdges: WorkflowEdge[]): SwapPreview;
 /**
  * Headless one-shot swap with full validation.
  *

package/dist/utils/nodeSwap.js

@@ -6,7 +6,7 @@
  *
  * @module utils/nodeSwap
  */
-import { buildHandleId, extractPortId, extractDirection } from './handleIds.js';
+import { buildHandleId, extractPortId } from './handleIds.js';
 import { generateNodeId } from './nodeIds.js';
 /** Error class for swap validation failures. */
 export class SwapValidationError extends Error {
@@ -86,16 +86,17 @@ export function mapConfig(oldConfig, newConfigSchema, newDefaults = {}) {
     }
     return { config, carriedOver, reset };
 }
-// =========================================================================
-// Port matching
-// =========================================================================
 /**
  * Find the best matching port on the new node for a given old port.
  *
- * Three-pass strategy:
+ * Two-pass strategy — exact matches only:
  * 1. Exact port ID match with compatible dataType
- * 2. Port name match (case-insensitive) with compatible dataType
- * 3. First available port with compatible dataType
+ * 2. Exact port name match (case-insensitive) with compatible dataType
+ *
+ * There is deliberately no fuzzy "first compatible dataType" fallback:
+ * it silently rewired edges to the wrong port (e.g. a `text` edge landing
+ * on `assistant_message`). If neither ID nor name matches, the edge is
+ * dropped and reported instead.
  */
 function findMatchingPort(oldPort, newPorts, usedPortIds, checker) {
     const available = newPorts.filter((p) => p.type === oldPort.type && !usedPortIds.has(p.id));
@@ -116,11 +117,7 @@ function findMatchingPort(oldPort, newPorts, usedPortIds, checker) {
     // Pass 2: name match (case-insensitive)
     const oldNameLower = oldPort.name.toLowerCase();
     const nameMatch = available.find((p) => p.name.toLowerCase() === oldNameLower && isCompatible(oldPort, p));
-    if (nameMatch)
-        return nameMatch;
-    // Pass 3: first compatible dataType
-    const typeMatch = available.find((p) => isCompatible(oldPort, p));
-    return typeMatch ?? null;
+    return nameMatch ?? null;
 }
 /**
  * Resolve the port metadata for an edge endpoint on a given node.
@@ -142,65 +139,13 @@ function resolvePort(node, handleId, direction) {
  *
  * This does NOT mutate anything — it returns a preview that can be displayed
  * to the user for confirmation before executing the swap.
+ *
+ * Thin wrapper over {@link computeSwapPreviewWithOptions} — with no strategies
+ * or overrides the cascade reduces to the built-in exact matching, so both
+ * entry points share one implementation.
  */
 export function computeSwapPreview(oldNode, newMetadata, edges, allNodes, checker = null) {
-    const oldNodeId = oldNode.id;
-    const newNodeId = generateNodeId(newMetadata.id, allNodes);
-    // Collect all edges connected to the old node
-    const connectedEdges = edges.filter((e) => e.source === oldNodeId || e.target === oldNodeId);
-    // Track which ports on the new node have been claimed
-    const usedInputPortIds = new Set();
-    const usedOutputPortIds = new Set();
-    const keptEdges = [];
-    const droppedEdges = [];
-    for (const edge of connectedEdges) {
-        const isSource = edge.source === oldNodeId;
-        const direction = isSource ? 'output' : 'input';
-        const handleId = isSource ? edge.sourceHandle : edge.targetHandle;
-        const usedPorts = isSource ? usedOutputPortIds : usedInputPortIds;
-        // Resolve the old port
-        const oldPort = resolvePort(oldNode, handleId, direction);
-        if (!oldPort) {
-            droppedEdges.push({
-                edge,
-                reason: `Port not found on original node`
-            });
-            continue;
-        }
-        // Find matching port on new node
-        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}"`
-            });
-            continue;
-        }
-        usedPorts.add(match.id);
-        // Build the rewritten edge
-        const newHandleId = buildHandleId(newNodeId, direction, match.id);
-        const newEdge = { ...edge };
-        if (isSource) {
-            newEdge.source = newNodeId;
-            newEdge.sourceHandle = newHandleId;
-        }
-        else {
-            newEdge.target = newNodeId;
-            newEdge.targetHandle = newHandleId;
-        }
-        keptEdges.push({ edge, newEdge });
-    }
-    // Config mapping preview
-    const { carriedOver, reset } = mapConfig(oldNode.data.config, newMetadata.configSchema, newMetadata.config);
-    return {
-        keptEdges,
-        droppedEdges,
-        hasDataLoss: droppedEdges.length > 0,
-        newNodeId,
-        configCarriedOver: carriedOver,
-        configReset: reset
-    };
+    return computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNodes, { checker });
 }
 // =========================================================================
 // Swap execution
@@ -231,6 +176,9 @@ export function executeSwap(oldNode, newMetadata, preview, allNodes, allEdges) {
             label: newMetadata.name,
             config: mappedConfig,
             metadata: newMetadata,
+            // Node components derive their handle IDs from data.nodeId — without it
+            // every edge anchored to this node silently disappears from the canvas.
+            nodeId: newNodeId,
             extensions
         }
     };
@@ -298,7 +246,7 @@ function classifyMatch(oldPort, matchedPort) {
  *
  * Resolution order:
  * 1. Check strategies — first canHandle() match wins for mapPorts()/mapConfig()
- * 2. Fall through to built-in 3-pass for ports not covered by strategy
+ * 2. Fall through to built-in exact matching (ID, then name) for ports not covered by strategy
  * 3. Apply portOverrides on top (highest priority — user's manual overrides)
  * 4. Same cascade for config
  */
@@ -332,84 +280,73 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
     for (const override of options.portOverrides ?? []) {
         portOverrideLookup.set(`${override.direction}:${override.oldPortId}`, override.newPortId);
     }
-    // Track used ports
+    // Track ports on the new node claimed by a DIFFERENT old port
     const usedInputPortIds = new Set();
     const usedOutputPortIds = new Set();
-    const keptEdges = [];
-    const droppedEdges = [];
-    for (const edge of connectedEdges) {
-        const isSource = edge.source === oldNodeId;
-        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' });
-            continue;
-        }
+    // Memoized old-port → new-port resolutions so every edge anchored on the
+    // same old port maps to the same new port (multi-connection ports, fan-outs).
+    const portResolutions = new Map();
+    /** Resolve a new port for an old port through the priority cascade. */
+    const resolveNewPort = (oldPort, direction, usedPorts) => {
+        const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
         // Priority 1: Manual port override
         const overrideKey = `${direction}:${oldPort.id}`;
         if (portOverrideLookup.has(overrideKey)) {
             const overrideNewPortId = portOverrideLookup.get(overrideKey);
             if (overrideNewPortId === null) {
-                droppedEdges.push({ edge, reason: 'Manually dropped' });
-                continue;
+                return { port: null, reason: 'Manually dropped' };
             }
-            const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
             const overridePort = newPorts.find((p) => p.id === overrideNewPortId);
             if (overridePort) {
-                usedPorts.add(overridePort.id);
-                const newHandleId = buildHandleId(newNodeId, direction, overridePort.id);
-                const newEdge = { ...edge };
-                if (isSource) {
-                    newEdge.source = newNodeId;
-                    newEdge.sourceHandle = newHandleId;
-                }
-                else {
-                    newEdge.target = newNodeId;
-                    newEdge.targetHandle = newHandleId;
-                }
-                keptEdges.push({ edge, newEdge });
-                continue;
+                return { port: overridePort };
             }
         }
         // Priority 2: Strategy port mapping
         if (strategyPortMap && oldPort.id in strategyPortMap) {
             const strategyNewPortId = strategyPortMap[oldPort.id];
             if (strategyNewPortId === null) {
-                droppedEdges.push({ edge, reason: 'Dropped by strategy' });
-                continue;
+                return { port: null, reason: 'Dropped by strategy' };
             }
-            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);
-                const newHandleId = buildHandleId(newNodeId, direction, strategyPort.id);
-                const newEdge = { ...edge };
-                if (isSource) {
-                    newEdge.source = newNodeId;
-                    newEdge.sourceHandle = newHandleId;
-                }
-                else {
-                    newEdge.target = newNodeId;
-                    newEdge.targetHandle = newHandleId;
-                }
-                keptEdges.push({ edge, newEdge });
-                continue;
+                return { port: strategyPort };
             }
         }
-        // Priority 3: Built-in 3-pass matching
-        const newPorts = direction === 'input' ? newMetadata.inputs : newMetadata.outputs;
+        // Priority 3: Built-in exact matching (ID, then name)
         const match = findMatchingPort(oldPort, newPorts, usedPorts, checker);
         if (!match) {
-            droppedEdges.push({
-                edge,
-                reason: `No compatible ${direction} port found on "${newMetadata.name}"`
-            });
+            return {
+                port: null,
+                reason: `No matching ${direction} port for "${oldPort.id}" on "${newMetadata.name}"`
+            };
+        }
+        return { port: match };
+    };
+    const keptEdges = [];
+    const droppedEdges = [];
+    for (const edge of connectedEdges) {
+        const isSource = edge.source === oldNodeId;
+        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' });
             continue;
         }
-        usedPorts.add(match.id);
-        const newHandleId = buildHandleId(newNodeId, direction, match.id);
+        const matchKey = `${direction}:${oldPort.id}`;
+        let resolved = portResolutions.get(matchKey);
+        if (!resolved) {
+            resolved = resolveNewPort(oldPort, direction, usedPorts);
+            portResolutions.set(matchKey, resolved);
+            if (resolved.port)
+                usedPorts.add(resolved.port.id);
+        }
+        if (!resolved.port) {
+            droppedEdges.push({ edge, reason: resolved.reason });
+            continue;
+        }
+        const newHandleId = buildHandleId(newNodeId, direction, resolved.port.id);
         const newEdge = { ...edge };
         if (isSource) {
             newEdge.source = newNodeId;
@@ -422,7 +359,7 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
         keptEdges.push({ edge, newEdge });
     }
     // Config mapping — apply strategy then overrides
-    const { config: baseConfig, carriedOver, reset } = mapConfig(oldNode.data.config, newMetadata.configSchema, newMetadata.config);
+    const { carriedOver, reset } = mapConfig(oldNode.data.config, newMetadata.configSchema, newMetadata.config);
     // Apply strategy config overrides
     if (strategyConfigMap) {
         for (const [key, mapping] of Object.entries(strategyConfigMap)) {
@@ -482,7 +419,6 @@ export function computeSwapPreviewWithOptions(oldNode, newMetadata, edges, allNo
  * with match quality annotations and isFlat flags.
  */
 export function computeInteractiveState(oldNode, newMetadata, edges, allNodes, options = {}) {
-    const checker = options.checker ?? null;
     const oldNodeId = oldNode.id;
     const newNodeId = generateNodeId(newMetadata.id, allNodes);
     const connectedEdges = edges.filter((e) => e.source === oldNodeId || e.target === oldNodeId);
@@ -567,7 +503,7 @@ function isPrimitive(value) {
  * Convert user-edited InteractiveSwapState back into a SwapPreview
  * for executeSwap(). Pure function, no side effects.
  */
-export function buildSwapPreviewFromState(state, allEdges) {
+export function buildSwapPreviewFromState(state, _allEdges) {
     const keptEdges = [];
     const droppedEdges = [];
     for (const mapping of state.portMappings) {

package/dist/utils/nodeTypes.d.ts

@@ -10,14 +10,16 @@
  * Works with both built-in types and custom registered types.
  */
 import type { NodeType, NodeMetadata } from '../types/index.js';
+import type { NodeComponentRegistry } from '../registry/nodeComponentRegistry.js';
 /**
  * Gets the SvelteFlow component name for a given NodeType.
  * Uses the node component registry to resolve types.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param nodeType - The node type identifier
  * @returns The component name to use
  */
-export declare function getComponentNameForNodeType(nodeType: NodeType | string): string;
+export declare function getComponentNameForNodeType(registry: NodeComponentRegistry, nodeType: NodeType | string): string;
 /**
  * Gets the available node types for a given NodeMetadata.
  * Priority: supportedTypes > type > "default"
@@ -43,28 +45,31 @@ export declare function getPrimaryNodeType(metadata: NodeMetadata): NodeType | s
  * 3. First supportedType
  * 4. "default"
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param configNodeType - Optional type from user config
  * @returns The resolved node type
  */
-export declare function resolveNodeType(metadata: NodeMetadata, configNodeType?: string): NodeType | string;
+export declare function resolveNodeType(registry: NodeComponentRegistry, metadata: NodeMetadata, configNodeType?: string): NodeType | string;
 /**
  * Gets the SvelteFlow component name for resolved node type.
  * This is the main function used by UniversalNode to determine which component to render.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param configNodeType - Optional type from user config
  * @returns The component name to use
  */
-export declare function resolveComponentName(metadata: NodeMetadata, configNodeType?: string): string;
+export declare function resolveComponentName(registry: NodeComponentRegistry, metadata: NodeMetadata, configNodeType?: string): string;
 /**
  * Validates if a node type is supported by the given metadata.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param nodeType - The type to check
  * @returns true if the type is supported
  */
-export declare function isNodeTypeSupported(metadata: NodeMetadata, nodeType: NodeType | string): boolean;
+export declare function isNodeTypeSupported(registry: NodeComponentRegistry, metadata: NodeMetadata, nodeType: NodeType | string): boolean;
 /**
  * Gets oneOf options for node type configuration.
  * Used in config schemas to show available options with labels.
@@ -73,11 +78,12 @@ export declare function isNodeTypeSupported(metadata: NodeMetadata, nodeType: No
  * - Types specified in metadata.supportedTypes
  * - Registered custom types (optionally filtered)
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param includeCustomTypes - Whether to include registered custom types
  * @returns Array of oneOf items with const (type value) and title (display name)
  */
-export declare function getNodeTypeOneOfOptions(metadata: NodeMetadata, includeCustomTypes?: boolean): Array<{
+export declare function getNodeTypeOneOfOptions(registry: NodeComponentRegistry, metadata: NodeMetadata, includeCustomTypes?: boolean): Array<{
     const: string;
     title: string;
 }>;
@@ -88,11 +94,12 @@ export declare function getNodeTypeOneOfOptions(metadata: NodeMetadata, includeC
  * Uses JSON Schema `oneOf` pattern with `const`/`title` for labeled options,
  * which is the standard approach supported by form components.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param defaultType - Optional default type override
  * @returns Config schema property object with oneOf for labeled options
  */
-export declare function createNodeTypeConfigProperty(metadata: NodeMetadata, defaultType?: NodeType | string): {
+export declare function createNodeTypeConfigProperty(registry: NodeComponentRegistry, metadata: NodeMetadata, defaultType?: NodeType | string): {
     type: "string";
     title: string;
     description: string;
@@ -105,13 +112,15 @@ export declare function createNodeTypeConfigProperty(metadata: NodeMetadata, def
 /**
  * Check if a type string represents a valid registered or built-in type.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param type - The type to check
  * @returns true if the type is valid
  */
-export declare function isValidNodeType(type: string): boolean;
+export declare function isValidNodeType(registry: NodeComponentRegistry, type: string): boolean;
 /**
  * Get all available node types (built-in + registered).
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @returns Array of all valid node type identifiers
  */
-export declare function getAllNodeTypes(): string[];
+export declare function getAllNodeTypes(registry: NodeComponentRegistry): string[];

package/dist/utils/nodeTypes.js

@@ -9,7 +9,6 @@
  *
  * Works with both built-in types and custom registered types.
  */
-import { nodeComponentRegistry } from '../registry/nodeComponentRegistry.js';
 import { resolveBuiltinAlias, isBuiltinType } from '../registry/builtinNodes.js';
 /**
  * Display names for built-in node types.
@@ -18,6 +17,7 @@ const TYPE_DISPLAY_NAMES = {
     note: 'Note (sticky note style)',
     simple: 'Simple (compact layout)',
     square: 'Square (geometric layout)',
+    atom: 'Atom (minimal value/transform)',
     tool: 'Tool (specialized for agent tools)',
     gateway: 'Gateway (branching control flow)',
     terminal: 'Terminal (start/end/exit)',
@@ -27,14 +27,15 @@ const TYPE_DISPLAY_NAMES = {
  * Gets the SvelteFlow component name for a given NodeType.
  * Uses the node component registry to resolve types.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param nodeType - The node type identifier
  * @returns The component name to use
  */
-export function getComponentNameForNodeType(nodeType) {
+export function getComponentNameForNodeType(registry, nodeType) {
     // Resolve aliases first (e.g., "default" -> "workflowNode")
     const resolvedType = resolveBuiltinAlias(nodeType);
     // Check if it's registered in the registry
-    if (nodeComponentRegistry.has(resolvedType)) {
+    if (registry.has(resolvedType)) {
         return resolvedType;
     }
     // Unknown type - return workflowNode as default
@@ -76,11 +77,12 @@ export function getPrimaryNodeType(metadata) {
  * 3. First supportedType
  * 4. "default"
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param configNodeType - Optional type from user config
  * @returns The resolved node type
  */
-export function resolveNodeType(metadata, configNodeType) {
+export function resolveNodeType(registry, metadata, configNodeType) {
     const availableTypes = getAvailableNodeTypes(metadata);
     // Check if configNodeType is valid for this metadata
     if (configNodeType) {
@@ -92,7 +94,7 @@ export function resolveNodeType(metadata, configNodeType) {
             return configNodeType;
         }
         // Check if it's a registered custom type
-        if (nodeComponentRegistry.has(configNodeType) || nodeComponentRegistry.has(resolvedConfig)) {
+        if (registry.has(configNodeType) || registry.has(resolvedConfig)) {
             return configNodeType;
         }
     }
@@ -103,22 +105,24 @@ export function resolveNodeType(metadata, configNodeType) {
  * Gets the SvelteFlow component name for resolved node type.
  * This is the main function used by UniversalNode to determine which component to render.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param configNodeType - Optional type from user config
  * @returns The component name to use
  */
-export function resolveComponentName(metadata, configNodeType) {
-    const nodeType = resolveNodeType(metadata, configNodeType);
-    return getComponentNameForNodeType(nodeType);
+export function resolveComponentName(registry, metadata, configNodeType) {
+    const nodeType = resolveNodeType(registry, metadata, configNodeType);
+    return getComponentNameForNodeType(registry, nodeType);
 }
 /**
  * Validates if a node type is supported by the given metadata.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param nodeType - The type to check
  * @returns true if the type is supported
  */
-export function isNodeTypeSupported(metadata, nodeType) {
+export function isNodeTypeSupported(registry, metadata, nodeType) {
     const availableTypes = getAvailableNodeTypes(metadata);
     // Check direct match
     if (availableTypes.includes(nodeType)) {
@@ -130,7 +134,7 @@ export function isNodeTypeSupported(metadata, nodeType) {
         return true;
     }
     // Check if it's a registered custom type that's in the available list
-    if (nodeComponentRegistry.has(nodeType)) {
+    if (registry.has(nodeType)) {
         return availableTypes.some((t) => t === nodeType || resolveBuiltinAlias(t) === nodeType);
     }
     return false;
@@ -143,18 +147,19 @@ export function isNodeTypeSupported(metadata, nodeType) {
  * - Types specified in metadata.supportedTypes
  * - Registered custom types (optionally filtered)
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param includeCustomTypes - Whether to include registered custom types
  * @returns Array of oneOf items with const (type value) and title (display name)
  */
-export function getNodeTypeOneOfOptions(metadata, includeCustomTypes = false) {
+export function getNodeTypeOneOfOptions(registry, metadata, includeCustomTypes = false) {
     const availableTypes = getAvailableNodeTypes(metadata);
     const options = [];
     const includedTypes = new Set();
     for (const type of availableTypes) {
         includedTypes.add(type);
         // Get display name from registry or fallback to built-in names
-        const registration = nodeComponentRegistry.get(type);
+        const registration = registry.get(type);
         let title;
         if (registration) {
             title = registration.displayName;
@@ -170,7 +175,7 @@ export function getNodeTypeOneOfOptions(metadata, includeCustomTypes = false) {
     }
     // Optionally include all registered custom types
     if (includeCustomTypes) {
-        const registrations = nodeComponentRegistry.filter({
+        const registrations = registry.filter({
             predicate: (reg) => !isBuiltinType(reg.type) && !includedTypes.has(reg.type)
         });
         for (const reg of registrations) {
@@ -186,12 +191,13 @@ export function getNodeTypeOneOfOptions(metadata, includeCustomTypes = false) {
  * Uses JSON Schema `oneOf` pattern with `const`/`title` for labeled options,
  * which is the standard approach supported by form components.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param defaultType - Optional default type override
  * @returns Config schema property object with oneOf for labeled options
  */
-export function createNodeTypeConfigProperty(metadata, defaultType) {
-    const oneOf = getNodeTypeOneOfOptions(metadata);
+export function createNodeTypeConfigProperty(registry, metadata, defaultType) {
+    const oneOf = getNodeTypeOneOfOptions(registry, metadata);
     const primaryType = defaultType ?? getPrimaryNodeType(metadata);
     return {
         type: 'string',
@@ -204,19 +210,21 @@ export function createNodeTypeConfigProperty(metadata, defaultType) {
 /**
  * Check if a type string represents a valid registered or built-in type.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param type - The type to check
  * @returns true if the type is valid
  */
-export function isValidNodeType(type) {
-    return isBuiltinType(type) || nodeComponentRegistry.has(type);
+export function isValidNodeType(registry, type) {
+    return isBuiltinType(type) || registry.has(type);
 }
 /**
  * Get all available node types (built-in + registered).
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @returns Array of all valid node type identifiers
  */
-export function getAllNodeTypes() {
-    return nodeComponentRegistry.getTypes();
+export function getAllNodeTypes(registry) {
+    return registry.getTypes();
 }
 /**
  * Format a type name for display when no display name is registered.

package/dist/utils/performanceUtils.js

@@ -51,6 +51,9 @@ export function areEdgeArraysEqual(edges1, edges2) {
  * Throttle function execution to reduce frequency
  * Uses requestAnimationFrame for smooth UI updates
  */
+// `any[]` in a generic constraint is the variance-correct idiom (it's how the TS
+// stdlib types Parameters<T>); `unknown[]` would reject every concrete callback.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function throttle(func, wait) {
     let timeout = null;
     let lastRan = 0;
@@ -75,6 +78,8 @@ export function throttle(func, wait) {
  * Debounce function execution to reduce frequency
  * Waits for a pause in calls before executing
  */
+// `any[]` constraint: see throttle() above.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function debounce(func, wait) {
     let timeout = null;
     return function (...args) {
@@ -90,6 +95,8 @@ export function debounce(func, wait) {
  * RequestAnimationFrame-based throttle for smooth animations
  * Better for visual updates like node dragging
  */
+// `any[]` constraint: see throttle() above.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function rafThrottle(func) {
     let rafId = null;
     let lastArgs = null;