@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.1

package/dist/utils/connections.js

@@ -45,6 +45,15 @@ export class PortCompatibilityChecker {
         this.compatibilityMap = new Map();
         this.buildCompatibilityMap();
     }
+    /**
+     * Replace the port configuration and rebuild the compatibility map in place.
+     * Used by mount to apply the backend-fetched port config to an instance's
+     * checker without swapping the instance field.
+     */
+    reinitialize(portConfig) {
+        this.portConfig = portConfig;
+        this.buildCompatibilityMap();
+    }
     /**
      * Build the compatibility map from configuration rules
      */
@@ -106,41 +115,16 @@ export class PortCompatibilityChecker {
         return this.portConfig.dataTypes.filter((dt) => dt.enabled !== false);
     }
 }
-// Global instance - will be initialized with configuration
-let globalCompatibilityChecker = null;
-/**
- * Initialize the global port compatibility checker
- */
-export function initializePortCompatibility(portConfig) {
-    globalCompatibilityChecker = new PortCompatibilityChecker(portConfig);
-}
-/**
- * Returns true if the port compatibility checker has been initialized.
- */
-export function isPortCompatibilityInitialized() {
-    return globalCompatibilityChecker !== null;
-}
-/**
- * Get the global port compatibility checker
- */
-export function getPortCompatibilityChecker() {
-    if (!globalCompatibilityChecker) {
-        throw new Error('Port compatibility checker not initialized. Call initializePortCompatibility() first.');
-    }
-    return globalCompatibilityChecker;
-}
 /**
  * Get all possible connections from a source node to target nodes
  */
-export function getPossibleConnections(sourceNode, targetNodes, nodeTypes) {
+export function getPossibleConnections(checker, sourceNode, targetNodes, nodeTypes) {
     const sourceMetadata = nodeTypes.find((nt) => nt.id === sourceNode.data.metadata.id);
     if (!sourceMetadata)
         return [];
     const possibleConnections = [];
     // Get all output ports from source node
     const sourceOutputs = sourceMetadata.outputs;
-    // Get the compatibility checker instance
-    const checker = getPortCompatibilityChecker();
     // Check each target node
     for (const targetNode of targetNodes) {
         if (targetNode.id === sourceNode.id)
@@ -171,7 +155,7 @@ export function getPossibleConnections(sourceNode, targetNodes, nodeTypes) {
 /**
  * Validate if a specific connection is valid
  */
-export function validateConnection(sourceNodeId, sourcePortId, targetNodeId, targetPortId, nodes, nodeTypes) {
+export function validateConnection(checker, sourceNodeId, sourcePortId, targetNodeId, targetPortId, nodes, nodeTypes) {
     // Check if nodes exist
     const sourceNode = nodes.find((n) => n.id === sourceNodeId);
     const targetNode = nodes.find((n) => n.id === targetNodeId);
@@ -200,8 +184,7 @@ export function validateConnection(sourceNodeId, sourcePortId, targetNodeId, tar
     if (!targetPort) {
         return { valid: false, error: 'Target port not found' };
     }
-    // Check data type compatibility using the global checker
-    const checker = getPortCompatibilityChecker();
+    // Check data type compatibility using the instance's checker
     if (!checker.areDataTypesCompatible(sourcePort.dataType, targetPort.dataType)) {
         return {
             valid: false,
@@ -213,7 +196,7 @@ export function validateConnection(sourceNodeId, sourcePortId, targetNodeId, tar
 /**
  * Get connection suggestions for a node
  */
-export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
+export function getConnectionSuggestions(checker, nodeId, nodes, nodeTypes) {
     const node = nodes.find((n) => n.id === nodeId);
     if (!node)
         return [];
@@ -223,8 +206,6 @@ export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
     const suggestions = [];
     // Get all other nodes
     const otherNodes = nodes.filter((n) => n.id !== nodeId);
-    // Get the compatibility checker instance
-    const checker = getPortCompatibilityChecker();
     for (const otherNode of otherNodes) {
         const otherMetadata = nodeTypes.find((nt) => nt.id === otherNode.data.metadata.id);
         if (!otherMetadata)

package/dist/utils/duration.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Duration formatting helpers.
+ *
+ * Mirrors the backend `Drupal\flowdrop\Utility\Duration::formatMicroseconds()`
+ * tiers so the playground and the Drupal admin pages render identical values.
+ */
+/**
+ * Formats a duration in human-readable form from microseconds.
+ *
+ * Examples: `150µs`, `2.5ms`, `25.1ms`, `250ms`, `1.23s`, `45s`,
+ * `2m 30s`, `1h 30m`.
+ */
+export declare function formatMicroseconds(microseconds: number | null | undefined): string | null;

package/dist/utils/duration.js

@@ -0,0 +1,45 @@
+/**
+ * Duration formatting helpers.
+ *
+ * Mirrors the backend `Drupal\flowdrop\Utility\Duration::formatMicroseconds()`
+ * tiers so the playground and the Drupal admin pages render identical values.
+ */
+/**
+ * Formats a duration in human-readable form from microseconds.
+ *
+ * Examples: `150µs`, `2.5ms`, `25.1ms`, `250ms`, `1.23s`, `45s`,
+ * `2m 30s`, `1h 30m`.
+ */
+export function formatMicroseconds(microseconds) {
+    if (microseconds == null || !Number.isFinite(microseconds) || microseconds < 0)
+        return null;
+    const us = Math.round(microseconds);
+    if (us < 1000) {
+        return `${us}µs`;
+    }
+    if (us < 1_000_000) {
+        const ms = us / 1000;
+        if (us < 100_000) {
+            // 2 decimals below 10ms, 1 decimal below 100ms — matches PHP round().
+            const decimals = us < 10_000 ? 2 : 1;
+            // Drop trailing zeros the way PHP round() renders (2.50 → 2.5, 3.00 → 3).
+            return `${parseFloat(ms.toFixed(decimals))}ms`;
+        }
+        return `${Math.round(ms)}ms`;
+    }
+    if (us < 10_000_000) {
+        return `${parseFloat((us / 1_000_000).toFixed(2))}s`;
+    }
+    if (us < 60_000_000) {
+        return `${Math.floor(us / 1_000_000)}s`;
+    }
+    const totalSeconds = Math.floor(us / 1_000_000);
+    if (us < 3_600_000_000) {
+        const minutes = Math.floor(totalSeconds / 60);
+        const secs = totalSeconds % 60;
+        return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+}

package/dist/utils/icons.d.ts

@@ -3,6 +3,7 @@
  * Ensures consistent icon usage across all components
  */
 import type { NodeCategory } from '../types/index.js';
+import type { CategoriesStore } from '../stores/categoriesStore.svelte.js';
 /**
  * Default icons for different contexts
  */
@@ -72,19 +73,21 @@ export declare const DEFAULT_ICONS: {
 export declare const CATEGORY_ICONS: Record<string, string>;
 /**
  * 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 declare function getNodeIcon(nodeIcon?: string, category?: NodeCategory): string;
+export declare function getNodeIcon(categories: CategoriesStore, nodeIcon?: string, category?: NodeCategory): string;
 /**
  * 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 declare function getCategoryIcon(category: NodeCategory): string;
+export declare function getCategoryIcon(categories: CategoriesStore, category: NodeCategory): string;
 /**
  * Get a default icon by key
  * @param key - The icon key from DEFAULT_ICONS

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[];