@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/utils/fetchWithAuth.js

@@ -1,34 +1,64 @@
 /**
- * Fetch authentication utilities
+ * Authenticated fetch
  *
- * Shared logic for building HTTP headers with authentication.
- * Used by components that make authenticated API requests (e.g., FormAutocomplete).
+ * The single fetch path for FlowDrop's per-instance services. It builds request
+ * headers (static endpoint headers + the {@link AuthProvider}'s headers + any
+ * caller headers) and uniformly applies the auth lifecycle: on `401` it invokes
+ * `onUnauthorized()` and — if that reports a successful refresh — retries the
+ * request once with freshly fetched headers; on `403` it invokes
+ * `onForbidden()`. Callers receive the raw {@link Response} and keep their own
+ * status/parse handling.
+ *
+ * Routing every service through this helper means a configured `AuthProvider`
+ * authenticates *and* refreshes consistently — matching the behaviour the typed
+ * workflow/node API gets from {@link EnhancedFlowDropApiClient}.
  *
  * @module utils/fetchWithAuth
  */
+import { getEndpointHeaders } from '../config/endpoints.js';
+const DEFAULT_HEADERS = {
+    Accept: 'application/json',
+    'Content-Type': 'application/json'
+};
 /**
- * Build fetch headers with optional authentication
- *
- * Constructs standard JSON request headers and merges in authentication
- * headers from the provided AuthProvider, if available.
- *
- * @param authProvider - Optional auth provider to get headers from
- * @returns Promise resolving to a complete headers object
+ * Build the merged header set: base headers < auth headers < per-request headers.
  *
- * @example
- * ```typescript
- * const headers = await buildFetchHeaders(authProvider);
- * const response = await fetch(url, { headers });
- * ```
+ * Re-invoked for the retry so a refreshed token is picked up.
  */
-export async function buildFetchHeaders(authProvider) {
-    const headers = {
-        Accept: 'application/json',
-        'Content-Type': 'application/json'
-    };
-    if (authProvider) {
-        const authHeaders = await authProvider.getAuthHeaders();
-        Object.assign(headers, authHeaders);
+async function buildHeaders(init, opts) {
+    const headers = opts.config && opts.endpointKey
+        ? getEndpointHeaders(opts.config, opts.endpointKey)
+        : { ...DEFAULT_HEADERS, ...opts.baseHeaders };
+    if (opts.authProvider) {
+        Object.assign(headers, await opts.authProvider.getAuthHeaders());
+    }
+    if (init.headers) {
+        Object.assign(headers, init.headers);
     }
     return headers;
 }
+/**
+ * Perform an authenticated fetch with consistent 401/403 handling.
+ *
+ * @param url - The fully-resolved request URL
+ * @param init - Standard fetch options (method, body, signal, headers, …)
+ * @param opts - Auth provider and header source
+ * @returns The raw {@link Response}; callers handle `.ok`/parsing themselves
+ */
+export async function authenticatedFetch(url, init = {}, opts = {}) {
+    const headers = await buildHeaders(init, opts);
+    let response = await fetch(url, { ...init, headers });
+    // 401 → let the provider refresh, then retry once with fresh headers.
+    if (response.status === 401 && opts.authProvider?.onUnauthorized) {
+        const refreshed = await opts.authProvider.onUnauthorized();
+        if (refreshed) {
+            const retryHeaders = await buildHeaders(init, opts);
+            response = await fetch(url, { ...init, headers: retryHeaders });
+        }
+    }
+    // 403 → notify the provider (e.g. surface a permission error).
+    if (response.status === 403 && opts.authProvider?.onForbidden) {
+        await opts.authProvider.onForbidden();
+    }
+    return response;
+}

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