@flowdrop/flowdrop 1.4.0 → 1.6.0

package/dist/utils/connections.js

@@ -5,7 +5,7 @@
  * Loopback port name constant
  * This is the standard input port name used for loop iteration triggers
  */
-const LOOPBACK_PORT_NAME = "loop_back";
+const LOOPBACK_PORT_NAME = 'loop_back';
 /**
  * Determines if an edge is a loopback edge.
  * Loopback edges target the special `loop_back` input port on ForEach nodes.
@@ -21,7 +21,7 @@ const LOOPBACK_PORT_NAME = "loop_back";
  * ```
  */
 export function isLoopbackEdge(edge) {
-    const targetHandle = edge.targetHandle ?? "";
+    const targetHandle = edge.targetHandle ?? '';
     return targetHandle.includes(`-input-${LOOPBACK_PORT_NAME}`);
 }
 /**
@@ -119,7 +119,7 @@ export function initializePortCompatibility(portConfig) {
  */
 export function getPortCompatibilityChecker() {
     if (!globalCompatibilityChecker) {
-        throw new Error("Port compatibility checker not initialized. Call initializePortCompatibility() first.");
+        throw new Error('Port compatibility checker not initialized. Call initializePortCompatibility() first.');
     }
     return globalCompatibilityChecker;
 }
@@ -155,7 +155,7 @@ export function getPossibleConnections(sourceNode, targetNodes, nodeTypes) {
                     targetNodeId: targetNode.id,
                     targetPortId: targetPort.id,
                     targetPort,
-                    compatible,
+                    compatible
                 });
             }
         }
@@ -170,36 +170,36 @@ export function validateConnection(sourceNodeId, sourcePortId, targetNodeId, tar
     const sourceNode = nodes.find((n) => n.id === sourceNodeId);
     const targetNode = nodes.find((n) => n.id === targetNodeId);
     if (!sourceNode) {
-        return { valid: false, error: "Source node not found" };
+        return { valid: false, error: 'Source node not found' };
     }
     if (!targetNode) {
-        return { valid: false, error: "Target node not found" };
+        return { valid: false, error: 'Target node not found' };
     }
     // Check for self-connection
     if (sourceNodeId === targetNodeId) {
-        return { valid: false, error: "Cannot connect node to itself" };
+        return { valid: false, error: 'Cannot connect node to itself' };
     }
     // Get node metadata
     const sourceMetadata = nodeTypes.find((nt) => nt.id === sourceNode.data.metadata.id);
     const targetMetadata = nodeTypes.find((nt) => nt.id === targetNode.data.metadata.id);
     if (!sourceMetadata || !targetMetadata) {
-        return { valid: false, error: "Node metadata not found" };
+        return { valid: false, error: 'Node metadata not found' };
     }
     // Find ports
     const sourcePort = sourceMetadata.outputs.find((p) => p.id === sourcePortId);
     const targetPort = targetMetadata.inputs.find((p) => p.id === targetPortId);
     if (!sourcePort) {
-        return { valid: false, error: "Source port not found" };
+        return { valid: false, error: 'Source port not found' };
     }
     if (!targetPort) {
-        return { valid: false, error: "Target port not found" };
+        return { valid: false, error: 'Target port not found' };
     }
     // Check data type compatibility using the global checker
     const checker = getPortCompatibilityChecker();
     if (!checker.areDataTypesCompatible(sourcePort.dataType, targetPort.dataType)) {
         return {
             valid: false,
-            error: `Incompatible data types: ${sourcePort.dataType} cannot connect to ${targetPort.dataType}`,
+            error: `Incompatible data types: ${sourcePort.dataType} cannot connect to ${targetPort.dataType}`
         };
     }
     return { valid: true };
@@ -232,9 +232,9 @@ export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
                     nodeName: otherNode.data.label,
                     portId: output.id,
                     portName: output.name,
-                    portType: "output",
+                    portType: 'output',
                     dataType: output.dataType,
-                    compatible,
+                    compatible
                 });
             }
         }
@@ -247,9 +247,9 @@ export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
                     nodeName: otherNode.data.label,
                     portId: input.id,
                     portName: input.name,
-                    portType: "input",
+                    portType: 'input',
                     dataType: input.dataType,
-                    compatible,
+                    compatible
                 });
             }
         }

package/dist/utils/edgeStyling.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Edge Styling Utility
+ *
+ * Standalone functions for determining edge categories and applying
+ * visual styling to workflow edges based on source port data types.
+ * Used by both the visual editor and the command DSL system.
+ */
+import type { WorkflowNode as WorkflowNodeType, WorkflowEdge, EdgeCategory } from '../types/index.js';
+/**
+ * Check if a port ID matches a dynamic branch in a Gateway node.
+ * Gateway nodes store branches in config.branches array.
+ */
+export declare function isGatewayBranch(node: WorkflowNodeType, portId: string): boolean;
+/**
+ * Get the data type of a port from a node's metadata.
+ * Also handles dynamic ports like Gateway branches.
+ */
+export declare function getPortDataType(node: WorkflowNodeType, portId: string, portType: 'input' | 'output'): string | null;
+/**
+ * Determine the edge category based on source port data type.
+ * Note: This does not check for loopback edges — use getEdgeCategoryWithLoopback() for that.
+ */
+export declare function getEdgeCategory(sourcePortDataType: string | null): EdgeCategory;
+/**
+ * Determine the full edge category including loopback detection.
+ * Loopback edges take precedence over source port data type.
+ */
+export declare function getEdgeCategoryWithLoopback(edge: WorkflowEdge, sourcePortDataType: string | null): EdgeCategory;
+/**
+ * Apply custom styling to a connection edge based on its source/target nodes.
+ *
+ * Sets:
+ * - edge.data.metadata.edgeType (trigger/tool/loopback/data)
+ * - edge.style, edge.class, edge.markerEnd based on category
+ * - edge.data.targetNodeType and edge.data.targetCategory
+ */
+export declare function applyConnectionStyling(edge: WorkflowEdge, sourceNode: WorkflowNodeType, targetNode: WorkflowNodeType): void;
+/**
+ * Update existing edges with custom styling rules.
+ * Batch operation that applies styling to all edges using a node map for O(1) lookup.
+ */
+export declare function updateEdgeStyles(edges: WorkflowEdge[], nodes: WorkflowNodeType[]): WorkflowEdge[];

package/dist/utils/edgeStyling.js

@@ -0,0 +1,173 @@
+/**
+ * Edge Styling Utility
+ *
+ * Standalone functions for determining edge categories and applying
+ * visual styling to workflow edges based on source port data types.
+ * Used by both the visual editor and the command DSL system.
+ */
+import { MarkerType } from '@xyflow/svelte';
+import { extractPortId } from '../utils/handleIds.js';
+import { isLoopbackEdge } from '../utils/connections.js';
+import { EDGE_MARKER_SIZES } from '../config/constants.js';
+/**
+ * Check if a port ID matches a dynamic branch in a Gateway node.
+ * Gateway nodes store branches in config.branches array.
+ */
+export function isGatewayBranch(node, portId) {
+    const nodeType = node.data?.metadata?.type || node.type;
+    if (nodeType !== 'gateway') {
+        return false;
+    }
+    const branches = node.data?.config?.branches;
+    if (!branches || !Array.isArray(branches)) {
+        return false;
+    }
+    return branches.some((branch) => branch.name === portId);
+}
+/**
+ * Get the data type of a port from a node's metadata.
+ * Also handles dynamic ports like Gateway branches.
+ */
+export function getPortDataType(node, portId, portType) {
+    // First, check static ports in metadata
+    const ports = portType === 'output' ? node.data?.metadata?.outputs : node.data?.metadata?.inputs;
+    if (ports && Array.isArray(ports)) {
+        const port = ports.find((p) => p.id === portId);
+        if (port?.dataType) {
+            return port.dataType;
+        }
+    }
+    // Check dynamic ports from config (dynamicInputs/dynamicOutputs)
+    const dynamicKey = portType === 'output' ? 'dynamicOutputs' : 'dynamicInputs';
+    const dynamicPorts = node.data?.config?.[dynamicKey];
+    if (dynamicPorts && Array.isArray(dynamicPorts)) {
+        const dynamicPort = dynamicPorts.find((p) => p.name === portId);
+        if (dynamicPort?.dataType) {
+            return dynamicPort.dataType;
+        }
+    }
+    // For output ports, also check dynamic Gateway branches
+    // Gateway branches are always trigger type (control flow)
+    if (portType === 'output' && isGatewayBranch(node, portId)) {
+        return 'trigger';
+    }
+    return null;
+}
+/**
+ * Determine the edge category based on source port data type.
+ * Note: This does not check for loopback edges — use getEdgeCategoryWithLoopback() for that.
+ */
+export function getEdgeCategory(sourcePortDataType) {
+    if (sourcePortDataType === 'trigger') {
+        return 'trigger';
+    }
+    if (sourcePortDataType === 'tool') {
+        return 'tool';
+    }
+    return 'data';
+}
+/**
+ * Determine the full edge category including loopback detection.
+ * Loopback edges take precedence over source port data type.
+ */
+export function getEdgeCategoryWithLoopback(edge, sourcePortDataType) {
+    if (isLoopbackEdge(edge)) {
+        return 'loopback';
+    }
+    return getEdgeCategory(sourcePortDataType);
+}
+/**
+ * Apply custom styling to a connection edge based on its source/target nodes.
+ *
+ * Sets:
+ * - edge.data.metadata.edgeType (trigger/tool/loopback/data)
+ * - edge.style, edge.class, edge.markerEnd based on category
+ * - edge.data.targetNodeType and edge.data.targetCategory
+ */
+export function applyConnectionStyling(edge, sourceNode, targetNode) {
+    // Extract port ID from sourceHandle
+    const sourcePortId = extractPortId(edge.sourceHandle);
+    // Get the source port's data type
+    const sourcePortDataType = sourcePortId
+        ? getPortDataType(sourceNode, sourcePortId, 'output')
+        : null;
+    // Determine edge category (loopback takes precedence)
+    const edgeCategory = getEdgeCategoryWithLoopback(edge, sourcePortDataType);
+    // Apply styling based on edge category
+    // Marker colors use CSS custom properties so they respond to theme changes automatically
+    switch (edgeCategory) {
+        case 'loopback':
+            edge.style =
+                'stroke: var(--fd-edge-loopback); stroke-dasharray: var(--fd-edge-loopback-dasharray); stroke-width: var(--fd-edge-loopback-width); opacity: var(--fd-edge-loopback-opacity);';
+            edge.class = 'flowdrop--edge--loopback';
+            edge.markerEnd = {
+                type: MarkerType.ArrowClosed,
+                ...EDGE_MARKER_SIZES.loopback,
+                color: 'var(--fd-edge-loopback)'
+            };
+            break;
+        case 'trigger':
+            edge.style = 'stroke: var(--fd-edge-trigger); stroke-width: var(--fd-edge-trigger-width);';
+            edge.class = 'flowdrop--edge--trigger';
+            edge.markerEnd = {
+                type: MarkerType.ArrowClosed,
+                ...EDGE_MARKER_SIZES.trigger,
+                color: 'var(--fd-edge-trigger)'
+            };
+            break;
+        case 'tool':
+            edge.style = 'stroke: var(--fd-edge-tool); stroke-dasharray: 5 3;';
+            edge.class = 'flowdrop--edge--tool';
+            edge.markerEnd = {
+                type: MarkerType.ArrowClosed,
+                ...EDGE_MARKER_SIZES.tool,
+                color: 'var(--fd-edge-tool)'
+            };
+            break;
+        case 'data':
+        default:
+            edge.style = 'stroke: var(--fd-edge-data);';
+            edge.class = 'flowdrop--edge--data';
+            edge.markerEnd = {
+                type: MarkerType.ArrowClosed,
+                ...EDGE_MARKER_SIZES.data,
+                color: 'var(--fd-edge-data)'
+            };
+            break;
+    }
+    // Store metadata in edge data for API and persistence
+    edge.data = {
+        ...edge.data,
+        metadata: {
+            ...(edge.data?.metadata || {}),
+            edgeType: edgeCategory,
+            sourcePortDataType: sourcePortDataType ?? undefined
+        },
+        targetNodeType: targetNode.type,
+        targetCategory: targetNode.data.metadata.category
+    };
+}
+/**
+ * Update existing edges with custom styling rules.
+ * Batch operation that applies styling to all edges using a node map for O(1) lookup.
+ */
+export function updateEdgeStyles(edges, nodes) {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    return edges.map((edge) => {
+        const sourceNode = nodeMap.get(edge.source);
+        const targetNode = nodeMap.get(edge.target);
+        const updatedEdge = { ...edge };
+        if (!sourceNode || !targetNode) {
+            updatedEdge.data = {
+                ...updatedEdge.data,
+                metadata: {
+                    ...(updatedEdge.data?.metadata || {}),
+                    edgeType: 'data'
+                }
+            };
+            return updatedEdge;
+        }
+        applyConnectionStyling(updatedEdge, sourceNode, targetNode);
+        return updatedEdge;
+    });
+}

package/dist/utils/errors.js

@@ -21,7 +21,7 @@ export function normalizeError(error) {
     if (error instanceof Error) {
         return error;
     }
-    if (typeof error === "string") {
+    if (typeof error === 'string') {
         return new Error(error);
     }
     return new Error(String(error));
@@ -33,11 +33,11 @@ export function normalizeError(error) {
  * @param fallback - Fallback message if error has no useful info
  * @returns A string message
  */
-export function getErrorMessage(error, fallback = "Unknown error") {
+export function getErrorMessage(error, fallback = 'Unknown error') {
     if (error instanceof Error) {
         return error.message;
     }
-    if (typeof error === "string") {
+    if (typeof error === 'string') {
         return error;
     }
     return fallback;

package/dist/utils/fetchWithAuth.d.ts

@@ -6,7 +6,7 @@
  *
  * @module utils/fetchWithAuth
  */
-import type { AuthProvider } from "../types/auth.js";
+import type { AuthProvider } from '../types/auth.js';
 /**
  * Build fetch headers with optional authentication
  *

package/dist/utils/fetchWithAuth.js

@@ -23,8 +23,8 @@
  */
 export async function buildFetchHeaders(authProvider) {
     const headers = {
-        Accept: "application/json",
-        "Content-Type": "application/json",
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
     };
     if (authProvider) {
         const authHeaders = await authProvider.getAuthHeaders();

package/dist/utils/handleIds.d.ts

@@ -14,7 +14,7 @@
  * @param portId - The port identifier
  * @returns A composite handle ID string
  */
-export declare function buildHandleId(nodeId: string, direction: "input" | "output", portId: string): string;
+export declare function buildHandleId(nodeId: string, direction: 'input' | 'output', portId: string): string;
 /**
  * Extract the port ID from a composite handle ID.
  *
@@ -32,4 +32,4 @@ export declare function extractPortId(handleId: string | undefined): string | nu
  * @param handleId - The handle ID string
  * @returns 'input', 'output', or null if not found
  */
-export declare function extractDirection(handleId: string | undefined): "input" | "output" | null;
+export declare function extractDirection(handleId: string | undefined): 'input' | 'output' | null;

package/dist/utils/handleIds.js

@@ -30,13 +30,13 @@ export function buildHandleId(nodeId, direction, portId) {
 export function extractPortId(handleId) {
     if (!handleId)
         return null;
-    const outputMatch = handleId.lastIndexOf("-output-");
+    const outputMatch = handleId.lastIndexOf('-output-');
     if (outputMatch !== -1) {
-        return handleId.substring(outputMatch + "-output-".length);
+        return handleId.substring(outputMatch + '-output-'.length);
     }
-    const inputMatch = handleId.lastIndexOf("-input-");
+    const inputMatch = handleId.lastIndexOf('-input-');
     if (inputMatch !== -1) {
-        return handleId.substring(inputMatch + "-input-".length);
+        return handleId.substring(inputMatch + '-input-'.length);
     }
     // Short format: the handleId IS the port ID
     return handleId;
@@ -50,9 +50,9 @@ export function extractPortId(handleId) {
 export function extractDirection(handleId) {
     if (!handleId)
         return null;
-    if (handleId.includes("-output-"))
-        return "output";
-    if (handleId.includes("-input-"))
-        return "input";
+    if (handleId.includes('-output-'))
+        return 'output';
+    if (handleId.includes('-input-'))
+        return 'input';
     return null;
 }

package/dist/utils/handlePositioning.d.ts

@@ -28,4 +28,4 @@ export interface HandlePosition {
  * getCircleHandlePosition(0, 2, 'left') // { left: ~4.8, top: ~18 }
  * getCircleHandlePosition(1, 2, 'left') // { left: ~4.8, top: ~54 }
  */
-export declare function getCircleHandlePosition(index: number, count: number, side: "left" | "right", radius?: number, arcSpan?: number): HandlePosition;
+export declare function getCircleHandlePosition(index: number, count: number, side: 'left' | 'right', radius?: number, arcSpan?: number): HandlePosition;

package/dist/utils/handlePositioning.js

@@ -25,11 +25,11 @@
  * getCircleHandlePosition(1, 2, 'left') // { left: ~4.8, top: ~54 }
  */
 export function getCircleHandlePosition(index, count, side, radius = 40, arcSpan = (Math.PI * 5) / 6) {
-    const centerAngle = side === "left" ? Math.PI : 0; // 180° for left, 0° for right
+    const centerAngle = side === 'left' ? Math.PI : 0; // 180° for left, 0° for right
     const angle = centerAngle - arcSpan / 2 + (arcSpan * (index + 1)) / (count + 1);
     const centerOffset = radius; // center of the circle (assuming square bounding box)
     return {
         left: centerOffset + radius * Math.cos(angle),
-        top: centerOffset + radius * Math.sin(angle),
+        top: centerOffset + radius * Math.sin(angle)
     };
 }

package/dist/utils/icons.d.ts

@@ -2,7 +2,7 @@
  * Centralized icon management for FlowDrop
  * Ensures consistent icon usage across all components
  */
-import type { NodeCategory } from "../types/index.js";
+import type { NodeCategory } from '../types/index.js';
 /**
  * Default icons for different contexts
  */

package/dist/utils/icons.js

@@ -2,80 +2,80 @@
  * Centralized icon management for FlowDrop
  * Ensures consistent icon usage across all components
  */
-import { getCategoryIcon as getCategoryIconFromStore } from "../stores/categoriesStore.svelte.js";
+import { getCategoryIcon as getCategoryIconFromStore } from '../stores/categoriesStore.svelte.js';
 /**
  * Default icons for different contexts
  */
 export const DEFAULT_ICONS = {
     // Node fallback icons
-    NODE: "mdi:cube",
-    CATEGORY: "mdi:folder",
+    NODE: 'mdi:cube',
+    CATEGORY: 'mdi:folder',
     // UI action icons
-    ADD: "mdi:plus",
-    REMOVE: "mdi:minus",
-    EDIT: "mdi:pencil",
-    SAVE: "mdi:content-save",
-    LOAD: "mdi:folder-open",
-    EXPORT: "mdi:download",
-    IMPORT: "mdi:upload",
-    SEARCH: "mdi:magnify",
-    CLOSE: "mdi:close",
-    SETTINGS: "mdi:cog",
-    HELP: "mdi:help-circle",
+    ADD: 'mdi:plus',
+    REMOVE: 'mdi:minus',
+    EDIT: 'mdi:pencil',
+    SAVE: 'mdi:content-save',
+    LOAD: 'mdi:folder-open',
+    EXPORT: 'mdi:download',
+    IMPORT: 'mdi:upload',
+    SEARCH: 'mdi:magnify',
+    CLOSE: 'mdi:close',
+    SETTINGS: 'mdi:cog',
+    HELP: 'mdi:help-circle',
     // Status icons
-    SUCCESS: "mdi:check-circle",
-    ERROR: "mdi:alert-circle",
-    WARNING: "mdi:alert",
-    INFO: "mdi:information",
-    LOADING: "mdi:loading",
+    SUCCESS: 'mdi:check-circle',
+    ERROR: 'mdi:alert-circle',
+    WARNING: 'mdi:alert',
+    INFO: 'mdi:information',
+    LOADING: 'mdi:loading',
     // Navigation icons
-    HOME: "mdi:home",
-    BACK: "mdi:arrow-left",
-    FORWARD: "mdi:arrow-right",
-    UP: "mdi:arrow-up",
-    DOWN: "mdi:arrow-down",
+    HOME: 'mdi:home',
+    BACK: 'mdi:arrow-left',
+    FORWARD: 'mdi:arrow-right',
+    UP: 'mdi:arrow-up',
+    DOWN: 'mdi:arrow-down',
     // Workflow icons
-    WORKFLOW: "mdi:graph",
-    NODE_ADD: "mdi:plus-circle",
-    NODE_DELETE: "mdi:minus-circle",
-    CONNECTION: "mdi:connection",
+    WORKFLOW: 'mdi:graph',
+    NODE_ADD: 'mdi:plus-circle',
+    NODE_DELETE: 'mdi:minus-circle',
+    CONNECTION: 'mdi:connection',
     // Data icons
-    DATA: "mdi:database",
-    FILE: "mdi:file",
-    TEXT: "mdi:text",
-    JSON: "mdi:code-json",
+    DATA: 'mdi:database',
+    FILE: 'mdi:file',
+    TEXT: 'mdi:text',
+    JSON: 'mdi:code-json',
     // Model and processing icons
-    MODEL: "mdi:chip",
-    BRAIN: "mdi:brain",
-    VECTOR: "mdi:vector-point",
-    ROBOT: "mdi:robot",
+    MODEL: 'mdi:chip',
+    BRAIN: 'mdi:brain',
+    VECTOR: 'mdi:vector-point',
+    ROBOT: 'mdi:robot',
     // Tool icons
-    TOOL: "mdi:wrench",
-    CALCULATOR: "mdi:calculator",
-    CLOCK: "mdi:clock",
+    TOOL: 'mdi:wrench',
+    CALCULATOR: 'mdi:calculator',
+    CLOCK: 'mdi:clock',
     // Communication icons
-    CHAT: "mdi:chat",
-    MESSAGE: "mdi:message",
-    EMAIL: "mdi:email",
-    WEBHOOK: "mdi:webhook",
+    CHAT: 'mdi:chat',
+    MESSAGE: 'mdi:message',
+    EMAIL: 'mdi:email',
+    WEBHOOK: 'mdi:webhook',
     // Storage icons
-    STORAGE: "mdi:database",
-    MEMORY: "mdi:memory",
-    CACHE: "mdi:cached",
+    STORAGE: 'mdi:database',
+    MEMORY: 'mdi:memory',
+    CACHE: 'mdi:cached',
     // Processing icons
-    PROCESS: "mdi:cog",
-    FILTER: "mdi:filter",
-    SORT: "mdi:sort",
-    TRANSFORM: "mdi:transform",
+    PROCESS: 'mdi:cog',
+    FILTER: 'mdi:filter',
+    SORT: 'mdi:sort',
+    TRANSFORM: 'mdi:transform',
     // Logic icons
-    LOGIC: "mdi:git-branch",
-    CONDITION: "mdi:source-fork",
-    LOOP: "mdi:loop",
+    LOGIC: 'mdi:git-branch',
+    CONDITION: 'mdi:source-fork',
+    LOOP: 'mdi:loop',
     // Integration icons
-    API: "mdi:api",
-    LINK: "mdi:link",
-    PLUGIN: "mdi:puzzle",
-    BUNDLE: "mdi:package-variant",
+    API: 'mdi:api',
+    LINK: 'mdi:link',
+    PLUGIN: 'mdi:puzzle',
+    BUNDLE: 'mdi:package-variant'
 };
 /**
  * Category-specific icons for built-in categories.
@@ -83,23 +83,23 @@ export const DEFAULT_ICONS = {
  * These serve as static defaults; the categories store provides dynamic overrides.
  */
 export const CATEGORY_ICONS = {
-    triggers: "mdi:lightning-bolt",
-    inputs: "mdi:arrow-down-circle",
-    outputs: "mdi:arrow-up-circle",
-    prompts: "mdi:message-text",
-    models: "mdi:robot",
-    processing: "mdi:cog",
-    logic: "mdi:source-branch",
-    data: "mdi:database",
-    helpers: "mdi:help-circle",
-    tools: "mdi:wrench",
-    "vector stores": "mdi:vector-square",
-    embeddings: "mdi:vector-polygon",
-    memories: "mdi:brain",
-    agents: "mdi:account-cog",
-    ai: "mdi:shimmer",
-    interrupts: "mdi:hand-back-left",
-    bundles: "mdi:package-variant",
+    triggers: 'mdi:lightning-bolt',
+    inputs: 'mdi:arrow-down-circle',
+    outputs: 'mdi:arrow-up-circle',
+    prompts: 'mdi:message-text',
+    models: 'mdi:robot',
+    processing: 'mdi:cog',
+    logic: 'mdi:source-branch',
+    data: 'mdi:database',
+    helpers: 'mdi:help-circle',
+    tools: 'mdi:wrench',
+    'vector stores': 'mdi:vector-square',
+    embeddings: 'mdi:vector-polygon',
+    memories: 'mdi:brain',
+    agents: 'mdi:account-cog',
+    ai: 'mdi:shimmer',
+    interrupts: 'mdi:hand-back-left',
+    bundles: 'mdi:package-variant'
 };
 /**
  * Get the appropriate icon for a node

package/dist/utils/logger.d.ts

@@ -21,7 +21,7 @@
  * ```
  */
 /** Log severity levels. `'none'` disables all output. */
-export type LogLevel = "debug" | "info" | "warn" | "error" | "none";
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 /**
  * Set the minimum log level for FlowDrop library output.
  * Messages below this level are silently discarded.