@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.1

package/dist/types/playground.d.ts

@@ -376,11 +376,26 @@ export interface PlaygroundConfig {
      */
     showSidebar?: boolean;
     /**
-     * Whether to show the session header bar (default: true)
-     * When false, the header with session name and close button is hidden.
-     * Typically used together with showSidebar: false for minimal UI.
+     * Whether to show the ControlPanel header bar (default: true)
+     * When false, hides the entire header row: session label, session chip
+     * (with its New Session / session list popover) and the toolbar actions
+     * (Pipeline / Refresh / Logs). Use for a minimal, locked-down playground.
      */
     showSessionHeader?: boolean;
+    /**
+     * Whether to show the "New Session" entry in the session chip popover
+     * (default: true). When false, users cannot create additional sessions
+     * from the UI — useful for single-session playground embeds.
+     * No effect when showSessionHeader is false.
+     */
+    showNewSessionButton?: boolean;
+    /**
+     * Whether to show the session chip selector and its session list (default:
+     * true). When false, the chip dropdown is hidden entirely — users cannot
+     * switch sessions or see other sessions. Useful for locking a playground
+     * embed to a single session. No effect when showSessionHeader is false.
+     */
+    showSessionList?: boolean;
     /**
      * Determines if polling should stop for a given session status.
      * Override to customize which statuses pause polling.

package/dist/types/settings.d.ts

@@ -72,6 +72,19 @@ export interface BehaviorSettings {
     autoSave: boolean;
     /** Auto-save interval in milliseconds */
     autoSaveInterval: number;
+    /**
+     * Persist workflow drafts in browser storage.
+     *
+     * When enabled (default), unsaved changes are written to browser storage
+     * so they survive page reloads. On the default `localStorage` backend,
+     * drafts remain stored on the device even after the tab or browser is
+     * closed, until they are saved or cleared. Turning this off stops draft
+     * writes and removes the current draft.
+     *
+     * Caveat: the toggle applies per tab. Other tabs that are already open
+     * read settings at load time and keep writing drafts until reloaded.
+     */
+    storeDraftsInBrowser: boolean;
     /** Maximum number of undo history entries */
     undoHistoryLimit: number;
     /** Show confirmation dialog before deleting nodes */

package/dist/types/settings.js

@@ -70,6 +70,7 @@ export const DEFAULT_UI_SETTINGS = {
 export const DEFAULT_BEHAVIOR_SETTINGS = {
     autoSave: false,
     autoSaveInterval: 30000,
+    storeDraftsInBrowser: true,
     undoHistoryLimit: 50,
     confirmDelete: false,
     chatAutoRetry: true

package/dist/utils/colors.d.ts

@@ -4,6 +4,8 @@
  * Uses BEM syntax for CSS classes
  */
 import type { NodeCategory, PortDataTypeConfig } from '../types/index.js';
+import type { PortCompatibilityChecker } from './connections.js';
+import type { CategoriesStore } from '../stores/categoriesStore.svelte.js';
 /**
  * Category color mapping to design tokens (CSS variables)
  * Uses --fd-node-* tokens from tokens.css
@@ -14,20 +16,27 @@ export declare const CATEGORY_COLOR_TOKENS: Record<string, string>;
  * Get the design token for a category color.
  * Checks the categories store first (which includes API overrides),
  * then falls back to the static CATEGORY_COLOR_TOKENS map, then to slate.
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
+ * @param category - The node category
  */
-export declare function getCategoryColorToken(category: NodeCategory): string;
+export declare function getCategoryColorToken(categories: CategoriesStore, category: NodeCategory): string;
 /**
  * Get the reference color token for a data type (configurable version)
+ * @param checker - The instance's port compatibility checker (provides data-type config)
+ * @param dataType - The data type
  */
-export declare function getDataTypeColorToken(dataType: string): string;
+export declare function getDataTypeColorToken(checker: PortCompatibilityChecker, dataType: string): string;
 /**
  * Get data type configuration from port config
+ * @param checker - The instance's port compatibility checker
+ * @param dataType - The data type
  */
-export declare function getDataTypeConfig(dataType: string): PortDataTypeConfig | undefined;
+export declare function getDataTypeConfig(checker: PortCompatibilityChecker, dataType: string): PortDataTypeConfig | undefined;
 /**
  * Get all available data types from port configuration
+ * @param checker - The instance's port compatibility checker
  */
-export declare function getAvailableDataTypes(): PortDataTypeConfig[];
+export declare function getAvailableDataTypes(checker: PortCompatibilityChecker): PortDataTypeConfig[];
 /**
  * Default colors for fallback cases
  */
@@ -39,43 +48,49 @@ export declare const DEFAULT_COLORS: {
 };
 /**
  * Get category colors
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The color configuration for the category
  */
-export declare function getCategoryColors(category: NodeCategory): string;
+export declare function getCategoryColors(categories: CategoriesStore, category: NodeCategory): string;
 /**
  * Get category background color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The background color class
  */
-export declare function getCategoryBackground(category: NodeCategory): string;
+export declare function getCategoryBackground(categories: CategoriesStore, category: NodeCategory): string;
 /**
  * Get category accent color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The accent color class
  */
-export declare function getCategoryAccent(category: NodeCategory): string;
+export declare function getCategoryAccent(categories: CategoriesStore, category: NodeCategory): string;
 /**
  * Get category text color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The text color class
  */
-export declare function getCategoryText(category: NodeCategory): string;
+export declare function getCategoryText(categories: CategoriesStore, category: NodeCategory): string;
 /**
  * Get category border color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The border color class
  */
-export declare function getCategoryBorder(category: NodeCategory): string;
+export declare function getCategoryBorder(categories: CategoriesStore, category: NodeCategory): string;
 /**
  * Get node colors based on category and state
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The color configuration object
  */
-export declare function getNodeColors(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): {
+export declare function getNodeColors(categories: CategoriesStore, category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): {
     background: string;
     accent: string;
     text: string;
@@ -83,52 +98,58 @@ export declare function getNodeColors(category: NodeCategory, isError?: boolean,
 };
 /**
  * Get node background color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The background color
  */
-export declare function getNodeBackground(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
+export declare function getNodeBackground(categories: CategoriesStore, category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
 /**
  * Get node accent color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The accent color
  */
-export declare function getNodeAccent(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
+export declare function getNodeAccent(categories: CategoriesStore, category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
 /**
  * Get node text color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The text color
  */
-export declare function getNodeText(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
+export declare function getNodeText(categories: CategoriesStore, category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
 /**
  * Get node border color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The border color
  */
-export declare function getNodeBorder(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
+export declare function getNodeBorder(categories: CategoriesStore, category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
 /**
  * Get data type color
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type
  * @returns The color for the data type
  */
-export declare function getDataTypeColor(dataType: string): string;
+export declare function getDataTypeColor(checker: PortCompatibilityChecker, dataType: string): string;
 /**
  * Parse typed array notation and get display information
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type (e.g., "string[]", "number", "object[]")
  * @returns Object with display information
  */
-export declare function parseDataTypeDisplay(dataType: string): {
+export declare function parseDataTypeDisplay(checker: PortCompatibilityChecker, dataType: string): {
     baseType: string;
     isArray: boolean;
     displayName: string;
@@ -136,10 +157,11 @@ export declare function parseDataTypeDisplay(dataType: string): {
 };
 /**
  * Get formatted display text for a data type
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type
  * @returns Formatted display text
  */
-export declare function getDataTypeDisplayText(dataType: string): string;
+export declare function getDataTypeDisplayText(checker: PortCompatibilityChecker, dataType: string): string;
 /**
  * Check if a data type represents an array
  * @param dataType - The data type
@@ -191,30 +213,34 @@ export declare function getContrastTextColor(backgroundColor: string): string;
 export declare function resolveColorToken(token: string): string;
 /**
  * Get the appropriate contrast text color for a data type badge
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type (e.g., "array", "string", "number")
  * @returns CSS color value for text that provides good contrast on the data type's background
  */
-export declare function getContrastTextColorForDataType(dataType: string): string;
+export declare function getContrastTextColorForDataType(checker: PortCompatibilityChecker, dataType: string): string;
 /**
  * Get the appropriate contrast text color for a category badge
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns CSS color value for text that provides good contrast on the category's background
  */
-export declare function getContrastTextColorForCategory(category: NodeCategory): string;
+export declare function getContrastTextColorForCategory(categories: CategoriesStore, category: NodeCategory): string;
 /**
  * Get a semi-transparent tinted background color for ports
  * Creates a cohesive look with the icon wrapper styling
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type
  * @param opacity - Opacity percentage (default 25%)
  * @returns CSS color-mix expression for the tinted background
  */
-export declare function getPortBackgroundColor(dataType: string, opacity?: number): string;
+export declare function getPortBackgroundColor(checker: PortCompatibilityChecker, dataType: string, opacity?: number): string;
 /**
  * Get the border color for ports (solid data type color)
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type
  * @returns CSS color value for the port border
  */
-export declare function getPortBorderColor(dataType: string): string;
+export declare function getPortBorderColor(checker: PortCompatibilityChecker, dataType: string): string;
 /**
  * Convert RGB components to hex color string
  * @param r - Red component (0-255)

package/dist/utils/colors.js

@@ -3,9 +3,6 @@
  * Ensures consistent category colors across sidebar and canvas
  * Uses BEM syntax for CSS classes
  */
-import { getPortCompatibilityChecker } from './connections.js';
-import { getCategoryColor as getCategoryColorFromStore } from '../stores/categoriesStore.svelte.js';
-import { logger } from './logger.js';
 /**
  * Category color mapping to design tokens (CSS variables)
  * Uses --fd-node-* tokens from tokens.css
@@ -67,51 +64,38 @@ const DEFAULT_DATA_TYPE_COLORS = {
  * Get the design token for a category color.
  * Checks the categories store first (which includes API overrides),
  * then falls back to the static CATEGORY_COLOR_TOKENS map, then to slate.
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
+ * @param category - The node category
  */
-export function getCategoryColorToken(category) {
-    return getCategoryColorFromStore(category);
+export function getCategoryColorToken(categories, category) {
+    return categories.getColor(category);
 }
 /**
  * Get the reference color token for a data type (configurable version)
+ * @param checker - The instance's port compatibility checker (provides data-type config)
+ * @param dataType - The data type
  */
-export function getDataTypeColorToken(dataType) {
-    try {
-        const checker = getPortCompatibilityChecker();
-        const config = checker.getDataTypeConfig(dataType);
-        if (config?.color) {
-            return config.color;
-        }
-    }
-    catch {
-        // Fallback to static color mapping if port checker not initialized
+export function getDataTypeColorToken(checker, dataType) {
+    const config = checker.getDataTypeConfig(dataType);
+    if (config?.color) {
+        return config.color;
     }
     return DEFAULT_DATA_TYPE_COLORS[dataType.toLowerCase()] || 'var(--fd-node-slate)';
 }
 /**
  * Get data type configuration from port config
+ * @param checker - The instance's port compatibility checker
+ * @param dataType - The data type
  */
-export function getDataTypeConfig(dataType) {
-    try {
-        const checker = getPortCompatibilityChecker();
-        return checker.getDataTypeConfig(dataType);
-    }
-    catch (error) {
-        logger.warn('Port compatibility checker not initialized:', error);
-        return undefined;
-    }
+export function getDataTypeConfig(checker, dataType) {
+    return checker.getDataTypeConfig(dataType);
 }
 /**
  * Get all available data types from port configuration
+ * @param checker - The instance's port compatibility checker
  */
-export function getAvailableDataTypes() {
-    try {
-        const checker = getPortCompatibilityChecker();
-        return checker.getEnabledDataTypes();
-    }
-    catch (error) {
-        logger.warn('Port compatibility checker not initialized:', error);
-        return [];
-    }
+export function getAvailableDataTypes(checker) {
+    return checker.getEnabledDataTypes();
 }
 /**
  * Default colors for fallback cases
@@ -124,54 +108,60 @@ export const DEFAULT_COLORS = {
 };
 /**
  * Get category colors
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The color configuration for the category
  */
-export function getCategoryColors(category) {
-    return getCategoryColorFromStore(category);
+export function getCategoryColors(categories, category) {
+    return categories.getColor(category);
 }
 /**
  * Get category background color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The background color class
  */
-export function getCategoryBackground(category) {
-    return getCategoryColors(category);
+export function getCategoryBackground(categories, category) {
+    return getCategoryColors(categories, category);
 }
 /**
  * Get category accent color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The accent color class
  */
-export function getCategoryAccent(category) {
-    return getCategoryColors(category);
+export function getCategoryAccent(categories, category) {
+    return getCategoryColors(categories, category);
 }
 /**
  * Get category text color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The text color class
  */
-export function getCategoryText(category) {
-    return getCategoryColors(category);
+export function getCategoryText(categories, category) {
+    return getCategoryColors(categories, category);
 }
 /**
  * Get category border color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns The border color class
  */
-export function getCategoryBorder(category) {
-    return getCategoryColors(category);
+export function getCategoryBorder(categories, category) {
+    return getCategoryColors(categories, category);
 }
 /**
  * Get node colors based on category and state
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The color configuration object
  */
-export function getNodeColors(category, isError = false, isProcessing = false, isSelected = false) {
-    const baseColor = getCategoryColors(category);
+export function getNodeColors(categories, category, isError = false, isProcessing = false, isSelected = false) {
+    const baseColor = getCategoryColors(categories, category);
     if (isError) {
         return {
             background: 'var(--fd-error-muted)',
@@ -205,67 +195,73 @@ export function getNodeColors(category, isError = false, isProcessing = false, i
 }
 /**
  * Get node background color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The background color
  */
-export function getNodeBackground(category, isError = false, isProcessing = false, isSelected = false) {
-    return getNodeColors(category, isError, isProcessing, isSelected).background;
+export function getNodeBackground(categories, category, isError = false, isProcessing = false, isSelected = false) {
+    return getNodeColors(categories, category, isError, isProcessing, isSelected).background;
 }
 /**
  * Get node accent color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The accent color
  */
-export function getNodeAccent(category, isError = false, isProcessing = false, isSelected = false) {
-    return getNodeColors(category, isError, isProcessing, isSelected).accent;
+export function getNodeAccent(categories, category, isError = false, isProcessing = false, isSelected = false) {
+    return getNodeColors(categories, category, isError, isProcessing, isSelected).accent;
 }
 /**
  * Get node text color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The text color
  */
-export function getNodeText(category, isError = false, isProcessing = false, isSelected = false) {
-    return getNodeColors(category, isError, isProcessing, isSelected).text;
+export function getNodeText(categories, category, isError = false, isProcessing = false, isSelected = false) {
+    return getNodeColors(categories, category, isError, isProcessing, isSelected).text;
 }
 /**
  * Get node border color
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
  * @returns The border color
  */
-export function getNodeBorder(category, isError = false, isProcessing = false, isSelected = false) {
-    return getNodeColors(category, isError, isProcessing, isSelected).border;
+export function getNodeBorder(categories, category, isError = false, isProcessing = false, isSelected = false) {
+    return getNodeColors(categories, category, isError, isProcessing, isSelected).border;
 }
 /**
  * Get data type color
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type
  * @returns The color for the data type
  */
-export function getDataTypeColor(dataType) {
-    return getDataTypeColorToken(dataType);
+export function getDataTypeColor(checker, dataType) {
+    return getDataTypeColorToken(checker, dataType);
 }
 /**
  * Parse typed array notation and get display information
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type (e.g., "string[]", "number", "object[]")
  * @returns Object with display information
  */
-export function parseDataTypeDisplay(dataType) {
+export function parseDataTypeDisplay(checker, dataType) {
     // Check if it's a typed array (ends with [])
     const isArray = dataType.endsWith('[]');
     if (isArray) {
         const elementType = dataType.slice(0, -2); // Remove []
-        const config = getDataTypeConfig(dataType);
+        const config = getDataTypeConfig(checker, dataType);
         return {
             baseType: dataType,
             isArray: true,
@@ -274,7 +270,7 @@ export function parseDataTypeDisplay(dataType) {
         };
     }
     else {
-        const config = getDataTypeConfig(dataType);
+        const config = getDataTypeConfig(checker, dataType);
         return {
             baseType: dataType,
             isArray: false,
@@ -284,11 +280,12 @@ export function parseDataTypeDisplay(dataType) {
 }
 /**
  * Get formatted display text for a data type
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type
  * @returns Formatted display text
  */
-export function getDataTypeDisplayText(dataType) {
-    const parsed = parseDataTypeDisplay(dataType);
+export function getDataTypeDisplayText(checker, dataType) {
+    const parsed = parseDataTypeDisplay(checker, dataType);
     return parsed.displayName;
 }
 /**
@@ -391,42 +388,46 @@ export function resolveColorToken(token) {
 }
 /**
  * Get the appropriate contrast text color for a data type badge
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type (e.g., "array", "string", "number")
  * @returns CSS color value for text that provides good contrast on the data type's background
  */
-export function getContrastTextColorForDataType(dataType) {
-    const colorToken = getDataTypeColorToken(dataType);
+export function getContrastTextColorForDataType(checker, dataType) {
+    const colorToken = getDataTypeColorToken(checker, dataType);
     const hexColor = resolveColorToken(colorToken);
     return getContrastTextColor(hexColor);
 }
 /**
  * Get the appropriate contrast text color for a category badge
+ * @param categories - The instance's categories store (e.g. `fd.categories`)
  * @param category - The node category
  * @returns CSS color value for text that provides good contrast on the category's background
  */
-export function getContrastTextColorForCategory(category) {
-    const colorToken = getCategoryColorToken(category);
+export function getContrastTextColorForCategory(categories, category) {
+    const colorToken = getCategoryColorToken(categories, category);
     const hexColor = resolveColorToken(colorToken);
     return getContrastTextColor(hexColor);
 }
 /**
  * Get a semi-transparent tinted background color for ports
  * Creates a cohesive look with the icon wrapper styling
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type
  * @param opacity - Opacity percentage (default 25%)
  * @returns CSS color-mix expression for the tinted background
  */
-export function getPortBackgroundColor(dataType, opacity = 25) {
-    const colorToken = getDataTypeColorToken(dataType);
+export function getPortBackgroundColor(checker, dataType, opacity = 25) {
+    const colorToken = getDataTypeColorToken(checker, dataType);
     return `color-mix(in srgb, ${colorToken} ${opacity}%, transparent)`;
 }
 /**
  * Get the border color for ports (solid data type color)
+ * @param checker - The instance's port compatibility checker
  * @param dataType - The data type
  * @returns CSS color value for the port border
  */
-export function getPortBorderColor(dataType) {
-    return getDataTypeColorToken(dataType);
+export function getPortBorderColor(checker, dataType) {
+    return getDataTypeColorToken(checker, dataType);
 }
 /**
  * Convert RGB components to hex color string

package/dist/utils/connections.d.ts

@@ -32,6 +32,12 @@ export declare class PortCompatibilityChecker {
     private portConfig;
     private compatibilityMap;
     constructor(portConfig: PortConfig);
+    /**
+     * 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: PortConfig): void;
     /**
      * Build the compatibility map from configuration rules
      */
@@ -53,22 +59,10 @@ export declare class PortCompatibilityChecker {
      */
     getEnabledDataTypes(): PortDataTypeConfig[];
 }
-/**
- * Initialize the global port compatibility checker
- */
-export declare function initializePortCompatibility(portConfig: PortConfig): void;
-/**
- * Returns true if the port compatibility checker has been initialized.
- */
-export declare function isPortCompatibilityInitialized(): boolean;
-/**
- * Get the global port compatibility checker
- */
-export declare function getPortCompatibilityChecker(): PortCompatibilityChecker;
 /**
  * Get all possible connections from a source node to target nodes
  */
-export declare function getPossibleConnections(sourceNode: WorkflowNode, targetNodes: WorkflowNode[], nodeTypes: NodeMetadata[]): Array<{
+export declare function getPossibleConnections(checker: PortCompatibilityChecker, sourceNode: WorkflowNode, targetNodes: WorkflowNode[], nodeTypes: NodeMetadata[]): Array<{
     sourceNodeId: string;
     sourcePortId: string;
     sourcePort: NodePort;
@@ -80,14 +74,14 @@ export declare function getPossibleConnections(sourceNode: WorkflowNode, targetN
 /**
  * Validate if a specific connection is valid
  */
-export declare function validateConnection(sourceNodeId: string, sourcePortId: string, targetNodeId: string, targetPortId: string, nodes: WorkflowNode[], nodeTypes: NodeMetadata[]): {
+export declare function validateConnection(checker: PortCompatibilityChecker, sourceNodeId: string, sourcePortId: string, targetNodeId: string, targetPortId: string, nodes: WorkflowNode[], nodeTypes: NodeMetadata[]): {
     valid: boolean;
     error?: string;
 };
 /**
  * Get connection suggestions for a node
  */
-export declare function getConnectionSuggestions(nodeId: string, nodes: WorkflowNode[], nodeTypes: NodeMetadata[]): Array<{
+export declare function getConnectionSuggestions(checker: PortCompatibilityChecker, nodeId: string, nodes: WorkflowNode[], nodeTypes: NodeMetadata[]): Array<{
     nodeId: string;
     nodeName: string;
     portId: string;