@runtypelabs/react-flow 1.0.40 → 1.0.41

package/src/hooks/useFlowValidation.ts

@@ -12,9 +12,6 @@ import type {
   SendEmailStepConfig,
 } from '../types'
 
-// ============================================================================
-// Validation Rules
-// ============================================================================
 
 interface ValidationRule {
   validate: (step: FlowStep, allSteps: FlowStep[]) => ValidationError[]
@@ -24,9 +21,6 @@ interface WarningRule {
   check: (step: FlowStep, allSteps: FlowStep[]) => ValidationWarning[]
 }
 
-// ============================================================================
-// Prompt Step Validation
-// ============================================================================
 
 const promptValidation: ValidationRule = {
   validate: (step) => {
@@ -61,9 +55,6 @@ const promptValidation: ValidationRule = {
   },
 }
 
-// ============================================================================
-// Fetch URL Step Validation
-// ============================================================================
 
 const fetchUrlValidation: ValidationRule = {
   validate: (step) => {
@@ -77,7 +68,6 @@ const fetchUrlValidation: ValidationRule = {
         message: 'URL is required',
       })
     } else {
-      // Validate URL format (allow template variables)
       const url = config.http.url
       if (!url.startsWith('http://') && !url.startsWith('https://') && !url.includes('{{')) {
         errors.push({
@@ -100,9 +90,6 @@ const fetchUrlValidation: ValidationRule = {
   },
 }
 
-// ============================================================================
-// Transform Data Step Validation
-// ============================================================================
 
 const transformDataValidation: ValidationRule = {
   validate: (step) => {
@@ -129,9 +116,6 @@ const transformDataValidation: ValidationRule = {
   },
 }
 
-// ============================================================================
-// Conditional Step Validation
-// ============================================================================
 
 const conditionalValidation: ValidationRule = {
   validate: (step, allSteps) => {
@@ -146,7 +130,6 @@ const conditionalValidation: ValidationRule = {
       })
     }
 
-    // Validate nested steps
     if (config.trueSteps && config.trueSteps.length > 0) {
       for (const nestedStep of config.trueSteps) {
         const nestedErrors = validateStep(nestedStep, allSteps)
@@ -175,9 +158,6 @@ const conditionalValidation: ValidationRule = {
   },
 }
 
-// ============================================================================
-// Send Email Step Validation
-// ============================================================================
 
 const sendEmailValidation: ValidationRule = {
   validate: (step) => {
@@ -191,7 +171,6 @@ const sendEmailValidation: ValidationRule = {
         message: 'Recipient (To) is required',
       })
     } else {
-      // Validate email format (allow template variables)
       const to = config.to
       if (!to.includes('@') && !to.includes('{{')) {
         errors.push({
@@ -230,9 +209,6 @@ const sendEmailValidation: ValidationRule = {
   },
 }
 
-// ============================================================================
-// Warning Rules
-// ============================================================================
 
 const outputVariableWarning: WarningRule = {
   check: (step, allSteps) => {
@@ -240,7 +216,6 @@ const outputVariableWarning: WarningRule = {
     const config = step.config as { outputVariable?: string }
 
     if (config.outputVariable) {
-      // Check for duplicate output variables
       const duplicates = allSteps.filter(
         (s) =>
           s.id !== step.id &&
@@ -288,9 +263,6 @@ const emptyBranchWarning: WarningRule = {
   },
 }
 
-// ============================================================================
-// Validation Logic
-// ============================================================================
 
 const validationRules: Record<string, ValidationRule> = {
   prompt: promptValidation,
@@ -305,7 +277,6 @@ const warningRules: WarningRule[] = [outputVariableWarning, emptyBranchWarning]
 function validateStep(step: FlowStep, allSteps: FlowStep[]): ValidationError[] {
   const errors: ValidationError[] = []
 
-  // Common validation
   if (!step.name?.trim()) {
     errors.push({
       stepId: step.id,
@@ -314,7 +285,6 @@ function validateStep(step: FlowStep, allSteps: FlowStep[]): ValidationError[] {
     })
   }
 
-  // Type-specific validation
   const rule = validationRules[step.type]
   if (rule) {
     errors.push(...rule.validate(step, allSteps))
@@ -333,9 +303,6 @@ function checkWarnings(step: FlowStep, allSteps: FlowStep[]): ValidationWarning[
   return warnings
 }
 
-// ============================================================================
-// Hook
-// ============================================================================
 
 export interface UseFlowValidationOptions {
   /** Steps to validate */
@@ -360,14 +327,12 @@ export interface UseFlowValidationReturn {
 export function useFlowValidation(options: UseFlowValidationOptions): UseFlowValidationReturn {
   const { steps: providedSteps, nodes } = options
 
-  // Extract steps from nodes if not provided directly
   const steps = useMemo(() => {
     if (providedSteps) return providedSteps
     if (nodes) return nodes.map((n) => n.data.step)
     return []
   }, [providedSteps, nodes])
 
-  // Perform validation
   const result = useMemo((): FlowValidationResult => {
     const errors: ValidationError[] = []
     const warnings: ValidationWarning[] = []
@@ -384,7 +349,6 @@ export function useFlowValidation(options: UseFlowValidationOptions): UseFlowVal
     }
   }, [steps])
 
-  // Helper functions
   const validateStepFn = useCallback((step: FlowStep) => validateStep(step, steps), [steps])
 
   const isStepValid = useCallback(

package/src/hooks/useRuntypeFlow.ts

@@ -17,9 +17,6 @@ import {
 import { autoLayout } from '../utils/layout'
 import type { FlowStepType } from '../flow-step-types'
 
-// ============================================================================
-// Hook Options
-// ============================================================================
 
 export interface UseRuntypeFlowOptions {
   /** Runtype API client instance */
@@ -38,9 +35,6 @@ export interface UseRuntypeFlowOptions {
   autoLayoutOnLoad?: boolean
 }
 
-// ============================================================================
-// Main Hook
-// ============================================================================
 
 export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowReturn {
   const {
@@ -53,7 +47,6 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
     autoLayoutOnLoad = true,
   } = options
 
-  // State
   const [flowId, setFlowId] = useState<string | null>(initialFlowId || null)
   const [flowName, setFlowName] = useState(initialName)
   const [flowDescription, setFlowDescription] = useState(initialDescription)
@@ -62,16 +55,11 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
   const [error, setError] = useState<Error | null>(null)
   const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false)
 
-  // React Flow state
   const [nodes, setNodes, onNodesChange] = useNodesState<RuntypeNode>([])
   const [edges, setEdges, onEdgesChange] = useEdgesState<RuntypeEdge>([])
 
-  // Track last saved state for change detection
   const lastSavedState = useRef<string>('')
 
-  // ============================================================================
-  // Handlers
-  // ============================================================================
 
   const handleStepChange = useCallback(
     (stepId: string, updates: Partial<FlowStep>) => {
@@ -117,9 +105,6 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
     [setEdges]
   )
 
-  // ============================================================================
-  // API Operations
-  // ============================================================================
 
   /**
    * Load a flow by ID
@@ -130,10 +115,8 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
       setError(null)
 
       try {
-        // Get flow with embedded steps
         const flow = await client.flows.get(id)
 
-        // Use flow steps from the flow response (consolidated endpoint)
         const steps: FlowStep[] = Array.isArray(flow.flowSteps)
           ? flow.flowSteps.map((s) => ({
               id: s.id,
@@ -145,13 +128,11 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
             }))
           : []
 
-        // Convert to React Flow nodes
         let newNodes = flowStepsToNodes(steps, {
           onChange: handleStepChange,
           onDelete: handleStepDelete,
         })
 
-        // Auto-layout if enabled
         if (autoLayoutOnLoad) {
           const newEdges = createEdgesFromNodes(newNodes)
           newNodes = autoLayout(newNodes, newEdges)
@@ -161,14 +142,11 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
 
         setFlowId(id)
         setFlowName(flow.name || '')
-        // The flow GET response carries no `description` (the handler never
-        // selects it), so there is nothing to load into the editor here.
         setFlowDescription('')
         setNodes(newNodes)
         setEdges(newEdges)
         setHasUnsavedChanges(false)
 
-        // Store last saved state
         lastSavedState.current = JSON.stringify(nodesToFlowSteps(newNodes))
       } catch (err) {
         setError(err instanceof Error ? err : new Error('Failed to load flow'))
@@ -194,11 +172,6 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
     try {
       const steps = nodesToFlowSteps(nodes)
 
-      // Update flow with metadata and steps in one atomic operation.
-      // `description` is intentionally omitted: the flow update endpoint does
-      // not persist it (the GET response carries no description either), so
-      // sending the local value here would be a no-op at best and could
-      // overwrite a description with an empty string if the schema ever changes.
       await client.flows.update(flowId, {
         name: flowName,
         flowSteps: steps.map((step) => ({
@@ -308,7 +281,6 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
 
       setNodes((nds) => [...nds, newNode])
 
-      // Add edge from previous node if exists
       if (nodes.length > 0) {
         const lastNode = nodes[nodes.length - 1]
         setEdges((eds) => [
@@ -327,16 +299,11 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
     [nodes, setNodes, setEdges, handleStepChange, handleStepDelete]
   )
 
-  // ============================================================================
-  // Effects
-  // ============================================================================
 
-  // Load initial flow if flowId is provided
   useEffect(() => {
     if (initialFlowId) {
       loadFlow(initialFlowId)
     } else if (initialSteps.length > 0) {
-      // Initialize with provided steps
       let newNodes = flowStepsToNodes(initialSteps, {
         onChange: handleStepChange,
         onDelete: handleStepDelete,
@@ -354,12 +321,10 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
     }
   }, []) // Only run on mount
 
-  // Notify onChange when nodes/edges change
   useEffect(() => {
     onChange?.(nodes, edges)
   }, [nodes, edges, onChange])
 
-  // Detect unsaved changes
   useEffect(() => {
     const currentState = JSON.stringify(nodesToFlowSteps(nodes))
     if (lastSavedState.current && currentState !== lastSavedState.current) {
@@ -367,26 +332,20 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
     }
   }, [nodes])
 
-  // ============================================================================
-  // Return
-  // ============================================================================
 
   return {
-    // React Flow state
     nodes,
     edges,
     onNodesChange: onNodesChange as unknown as (changes: unknown) => void,
     onEdgesChange: onEdgesChange as unknown as (changes: unknown) => void,
     onConnect: handleConnect as unknown as (connection: unknown) => void,
 
-    // Flow metadata
     flowName,
     flowDescription,
     flowId,
     setFlowName,
     setFlowDescription,
 
-    // API operations
     loadFlow,
     saveFlow,
     createFlow,
@@ -394,7 +353,6 @@ export function useRuntypeFlow(options: UseRuntypeFlowOptions): UseRuntypeFlowRe
     updateStep,
     addStep,
 
-    // Status
     isLoading,
     isSaving,
     error,

package/src/index.ts

@@ -1,7 +1,5 @@
-// Types
 export * from './types'
 
-// Components
 export { RuntypeFlowEditor } from './components/RuntypeFlowEditor'
 export { BaseNode } from './components/nodes/BaseNode'
 export { PromptNode } from './components/nodes/PromptNode'
@@ -10,11 +8,9 @@ export { CodeNode } from './components/nodes/CodeNode'
 export { ConditionalNode } from './components/nodes/ConditionalNode'
 export { SendEmailNode } from './components/nodes/SendEmailNode'
 
-// Hooks
 export { useRuntypeFlow } from './hooks/useRuntypeFlow'
 export { useFlowValidation } from './hooks/useFlowValidation'
 
-// Utilities
 export {
   flowStepsToNodes,
   nodesToFlowSteps,

package/src/types/index.ts

@@ -2,9 +2,6 @@ import type { Node, Edge, NodeProps } from '@xyflow/react'
 import type { FlowStepType, PromptStepMode } from '../flow-step-types'
 import type { RuntypeClient } from '@runtypelabs/sdk'
 
-// ============================================================================
-// Flow Step Types (matching Runtype API)
-// ============================================================================
 
 /**
  * Core FlowStep interface matching the Runtype API structure
@@ -124,9 +121,6 @@ export interface GenericStepConfig {
   outputVariable?: string
 }
 
-// ============================================================================
-// React Flow Node Types
-// ============================================================================
 
 /**
  * Base data structure for all Runtype nodes
@@ -154,9 +148,6 @@ export type RuntypeEdge = Edge<{ stepOrder?: number }>
  */
 export type RuntypeNodeProps = NodeProps
 
-// ============================================================================
-// Node Type Registry
-// ============================================================================
 
 /**
  * Supported node types that have custom components
@@ -178,9 +169,6 @@ export function isSupportedNodeType(type: FlowStepType): type is SupportedNodeTy
   return SUPPORTED_NODE_TYPES.includes(type as SupportedNodeType)
 }
 
-// ============================================================================
-// Editor Configuration
-// ============================================================================
 
 /**
  * Configuration for the RuntypeFlowEditor component
@@ -233,9 +221,6 @@ export interface SavedFlow {
   updatedAt?: string
 }
 
-// ============================================================================
-// Hook Types
-// ============================================================================
 
 /**
  * Return type for useRuntypeFlow hook
@@ -302,9 +287,6 @@ export interface ValidationWarning {
   message: string
 }
 
-// ============================================================================
-// Event Types
-// ============================================================================
 
 /**
  * Event emitted when a step is updated

package/src/utils/adapter.ts

@@ -1,21 +1,15 @@
 import type { FlowStep, RuntypeNode, RuntypeEdge, RuntypeNodeData } from '../types'
 import type { FlowStepType } from '../flow-step-types'
 
-// ============================================================================
-// Constants
-// ============================================================================
 
 const NODE_WIDTH = 280
 const NODE_HEIGHT = 200 // Increased for better card visibility
 const NODE_SPACING_X = 350 // Horizontal space between main steps
 const NODE_SPACING_Y = 80 // Vertical space between branch steps
-const BRANCH_OFFSET_X = 350 // Horizontal offset for branches to the right of conditional
+const BRANCH_OFFSET_X = 350
 const BRANCH_OFFSET_Y = -80 // Vertical offset for true branch (above center)
 const FALSE_BRANCH_GAP = 100 // Gap between true and false branches
 
-// ============================================================================
-// Flow Steps to React Flow Nodes
-// ============================================================================
 
 interface FlowStepsToNodesOptions {
   onChange?: (stepId: string, updates: Partial<FlowStep>) => void
@@ -43,7 +37,6 @@ export function flowStepsToNodes(
     parentId,
   } = options ?? {}
 
-  // Sort steps by order
   const sortedSteps = [...steps].sort((a, b) => a.order - b.order)
 
   const nodes: RuntypeNode[] = []
@@ -75,23 +68,18 @@ export function flowStepsToNodes(
 
     nodes.push(node)
 
-    // DEBUG: Log node positions
     console.log(`[flowStepsToNodes] Placed "${step.name}" (${step.type}) at x=${currentX}`)
 
-    // Handle conditional branches - position to the right with true above, false below
     if (step.type === 'conditional' && step.config) {
       const config = step.config as { trueSteps?: FlowStep[]; falseSteps?: FlowStep[] }
       const branchX = currentX + BRANCH_OFFSET_X
 
-      // Calculate branch lengths (horizontal extent)
       const trueBranchLength = config.trueSteps?.length || 0
       const falseBranchLength = config.falseSteps?.length || 0
       const maxBranchLength = Math.max(trueBranchLength, falseBranchLength)
 
-      // Calculate true branch height (vertical extent for stacking)
       const trueBranchHeight = trueBranchLength * (NODE_HEIGHT + NODE_SPACING_Y)
 
-      // True branch nodes (positioned to the right, above center)
       if (config.trueSteps && config.trueSteps.length > 0) {
         const trueBranchY = startPosition.y + BRANCH_OFFSET_Y
         const trueBranchNodes = flowStepsToNodes(config.trueSteps, {
@@ -109,9 +97,7 @@ export function flowStepsToNodes(
         maxBranchY = Math.max(maxBranchY, trueBranchY + trueBranchHeight)
       }
 
-      // False branch nodes (positioned to the right, below center)
       if (config.falseSteps && config.falseSteps.length > 0) {
-        // Position false branch below true branch (or at center + gap if no true branch)
         const falseBranchY =
           trueBranchLength > 0
             ? startPosition.y + BRANCH_OFFSET_Y + trueBranchHeight + FALSE_BRANCH_GAP
@@ -133,10 +119,6 @@ export function flowStepsToNodes(
         maxBranchY = Math.max(maxBranchY, falseBranchY + falseBranchHeight)
       }
 
-      // Skip past the conditional AND all its branch steps
-      // Branches start at branchX, so we need to account for:
-      // - The offset from conditional to first branch step (BRANCH_OFFSET_X)
-      // - All the branch steps (maxBranchLength * (NODE_WIDTH + NODE_SPACING_X))
       if (maxBranchLength > 0) {
         const advance = BRANCH_OFFSET_X + maxBranchLength * (NODE_WIDTH + NODE_SPACING_X)
         console.log(
@@ -148,7 +130,6 @@ export function flowStepsToNodes(
         currentX += NODE_WIDTH + NODE_SPACING_X
       }
     } else {
-      // Move to the next X position for horizontal layout (non-conditional steps)
       currentX += NODE_WIDTH + NODE_SPACING_X
     }
   }
@@ -156,26 +137,20 @@ export function flowStepsToNodes(
   return nodes
 }
 
-// ============================================================================
-// React Flow Nodes to Flow Steps
-// ============================================================================
 
 /**
  * Convert React Flow Node array back to Runtype FlowStep array
  */
 export function nodesToFlowSteps(nodes: RuntypeNode[]): FlowStep[] {
-  // Filter out branch nodes (handled within conditional steps)
   const topLevelNodes = nodes.filter(
     (n) => !n.parentId && !n.id.includes('-true-') && !n.id.includes('-false-')
   )
 
-  // Sort by X position to determine order (horizontal layout)
   const sortedNodes = [...topLevelNodes].sort((a, b) => a.position.x - b.position.x)
 
   return sortedNodes.map((node, index) => {
     const step = node.data.step
 
-    // Handle conditional steps - extract nested steps
     if (step.type === 'conditional') {
       const trueSteps = extractBranchSteps(nodes, node.id, 'true')
       const falseSteps = extractBranchSteps(nodes, node.id, 'false')
@@ -206,11 +181,9 @@ function extractBranchSteps(
   parentId: string,
   branch: 'true' | 'false'
 ): FlowStep[] {
-  // Match nodes with the branch prefix pattern
   const branchPrefix = `${parentId}-${branch}-`
   const branchNodes = nodes.filter((n) => n.id.startsWith(branchPrefix))
 
-  // Sort by X position (horizontal layout within branches)
   const sortedBranchNodes = [...branchNodes].sort((a, b) => a.position.x - b.position.x)
 
   return sortedBranchNodes.map((node, index) => ({
@@ -219,9 +192,6 @@ function extractBranchSteps(
   }))
 }
 
-// ============================================================================
-// Create Edges from Nodes
-// ============================================================================
 
 /**
  * Create edges connecting nodes in sequence
@@ -229,22 +199,17 @@ function extractBranchSteps(
 export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
   const edges: RuntypeEdge[] = []
 
-  // Helper to check if a node is a branch node
   const isBranchNode = (n: RuntypeNode) =>
     n.parentId || n.id.includes('-true-') || n.id.includes('-false-')
 
-  // Get top-level nodes sorted by X position (horizontal layout)
   const topLevelNodes = nodes
     .filter((n) => !isBranchNode(n))
     .sort((a, b) => a.position.x - b.position.x)
 
-  // Create sequential edges for top-level nodes
-  // Skip conditionals - their branches connect to the next step instead
   for (let i = 0; i < topLevelNodes.length - 1; i++) {
     const sourceNode = topLevelNodes[i]
     const targetNode = topLevelNodes[i + 1]
 
-    // Skip edge from conditional - branches will connect to next step
     if (sourceNode.data.step.type === 'conditional') {
       continue
     }
@@ -260,7 +225,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
     })
   }
 
-  // Create edges for conditional branches
   const conditionalNodes = nodes.filter(
     (n) => n.data.step.type === 'conditional' && !isBranchNode(n)
   )
@@ -271,19 +235,14 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
     const nextMainStep =
       conditionalIndex < topLevelNodes.length - 1 ? topLevelNodes[conditionalIndex + 1] : null
 
-    // Find true branch nodes (contain -true- after the conditional ID)
-    // Sort by X position since branches flow horizontally
     const trueBranchNodes = nodes
       .filter((n) => n.id.startsWith(`${conditionalId}-true-`))
       .sort((a, b) => a.position.x - b.position.x)
 
-    // Find false branch nodes (contain -false- after the conditional ID)
-    // Sort by X position since branches flow horizontally
     const falseBranchNodes = nodes
       .filter((n) => n.id.startsWith(`${conditionalId}-false-`))
       .sort((a, b) => a.position.x - b.position.x)
 
-    // Connect conditional to first true branch node (branch goes right)
     if (trueBranchNodes.length > 0) {
       edges.push({
         id: `edge-${conditionalId}-to-true-branch`,
@@ -300,7 +259,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
         style: { stroke: '#22c55e', strokeWidth: 2 },
       })
 
-      // Connect true branch nodes sequentially (horizontal connections)
       for (let i = 0; i < trueBranchNodes.length - 1; i++) {
         edges.push({
           id: `edge-true-${trueBranchNodes[i].id}-${trueBranchNodes[i + 1].id}`,
@@ -313,7 +271,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
         })
       }
 
-      // Connect last true branch node to next main step (convergence)
       if (nextMainStep) {
         const lastTrueNode = trueBranchNodes[trueBranchNodes.length - 1]
         edges.push({
@@ -327,7 +284,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
         })
       }
     } else if (nextMainStep) {
-      // No true branch steps - connect conditional directly to next step via true handle
       edges.push({
         id: `edge-${conditionalId}-true-to-${nextMainStep.id}`,
         source: conditionalId,
@@ -344,7 +300,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
       })
     }
 
-    // Connect conditional to first false branch node (branch goes right, below true)
     if (falseBranchNodes.length > 0) {
       edges.push({
         id: `edge-${conditionalId}-to-false-branch`,
@@ -361,7 +316,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
         style: { stroke: '#ef4444', strokeWidth: 2 },
       })
 
-      // Connect false branch nodes sequentially (horizontal connections)
       for (let i = 0; i < falseBranchNodes.length - 1; i++) {
         edges.push({
           id: `edge-false-${falseBranchNodes[i].id}-${falseBranchNodes[i + 1].id}`,
@@ -374,7 +328,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
         })
       }
 
-      // Connect last false branch node to next main step (convergence)
       if (nextMainStep) {
         const lastFalseNode = falseBranchNodes[falseBranchNodes.length - 1]
         edges.push({
@@ -388,7 +341,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
         })
       }
     } else if (nextMainStep) {
-      // No false branch steps - connect conditional directly to next step via false handle
       edges.push({
         id: `edge-${conditionalId}-false-to-${nextMainStep.id}`,
         source: conditionalId,
@@ -405,7 +357,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
       })
     }
 
-    // Handle case where conditional has no branches - connect directly to next step
     if (trueBranchNodes.length === 0 && falseBranchNodes.length === 0 && nextMainStep) {
       edges.push({
         id: `edge-${conditionalId}-to-${nextMainStep.id}`,
@@ -421,9 +372,6 @@ export function createEdgesFromNodes(nodes: RuntypeNode[]): RuntypeEdge[] {
   return edges
 }
 
-// ============================================================================
-// Utility Functions
-// ============================================================================
 
 /**
  * Get default name for a step type