@o-lang/olang 1.2.38 → 1.4.0-alpha.1

package/src/parser/index.js

@@ -8,8 +8,6 @@ function normalizeSymbol(raw) {
   return raw.split(/\s+/)[0].replace(/[^\w$]/g, '');
 }
 
-// ❌ REMOVED: normalizeAction() function (was stripping "Action" prefix → broke resolver matching)
-
 function parse(content, filename = '<unknown>') {
   if (typeof content === 'string') {
     // ✅ Strip UTF-8 BOM if present (0xFEFF = Unicode BOM)
@@ -39,6 +37,10 @@ function parseLines(lines, filename) {
   return parseWorkflowLines(lines, filename);
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// CORE WORKFLOW PARSER
+// ─────────────────────────────────────────────────────────────────────────────
+
 function parseWorkflowLines(lines, filename) {
   const workflow = {
     type: 'workflow',
@@ -55,17 +57,26 @@ function parseWorkflowLines(lines, filename) {
   let i = 0;
   let currentStep = null;
   let inAllowResolvers = false;
+  
+  // If/Else State Machine Variables (FIXED: Separate accumulators)
   let inIfBlock = false;
   let ifCondition = null;
-  let ifBody = [];
+  let mainIfBody = [];       // Accumulates main if branch lines
+  let currentBranchBody = []; // Accumulates else-if or else branches
+  let elseIfChain = [];
+  let currentElseIf = null;
+  let inElseBlock = false;
+
+  // Parallel State
   let inParallelBlock = false;
   let parallelSteps = [];
   let parallelTimeout = null;
+
+  // Escalation State
   let inEscalationBlock = false;
   let escalationLevels = [];
   let currentLevel = null;
 
-  // ✅ Helper to flush currentStep
   const flushCurrentStep = () => {
     if (currentStep) {
       workflow.steps.push(currentStep);
@@ -75,12 +86,9 @@ function parseWorkflowLines(lines, filename) {
 
   while (i < lines.length) {
     let line = lines[i++].trim();
+    if (line === '' || line.startsWith('#')) continue;
 
-    if (line === '' || line.startsWith('#')) {
-      continue;
-    }
-
-    // Workflow declaration
+    // --- 1. Workflow Declaration ---
     if (line.startsWith('Workflow ')) {
       const match = line.match(/^Workflow\s+"([^"]+)"(?:\s+with\s+(.+))?$/i);
       if (match) {
@@ -94,18 +102,16 @@ function parseWorkflowLines(lines, filename) {
       continue;
     }
 
-    // Global Constraint: max_generations
+    // --- 2. Global Constraints ---
     if (line.startsWith('Constraint: max_generations = ')) {
       const match = line.match(/^Constraint:\s+max_generations\s*=\s*(\d+)$/i);
       if (match) {
         workflow.maxGenerations = parseInt(match[1], 10);
-      } else {
-        workflow.__warnings.push(`Invalid Constraint syntax: ${line}`);
       }
       continue;
     }
 
-    // Allow resolvers section
+    // --- 3. Allow Resolvers Section ---
     if (line === 'Allow resolvers:') {
       inAllowResolvers = true;
       continue;
@@ -121,13 +127,13 @@ function parseWorkflowLines(lines, filename) {
         continue;
       } else {
         inAllowResolvers = false;
-        i--;
+        i--; // Re-process this line as normal step
         continue;
       }
       continue;
     }
 
-    // ✅ Parse Escalation block
+    // --- 4. Block: Escalation ---
     if (line.match(/^Run in parallel with escalation:$/i)) {
       flushCurrentStep();
       inEscalationBlock = true;
@@ -138,9 +144,7 @@ function parseWorkflowLines(lines, filename) {
 
     if (inEscalationBlock) {
       if (line.match(/^End$/i)) {
-        if (currentLevel) {
-          escalationLevels.push(currentLevel);
-        }
+        if (currentLevel) escalationLevels.push(currentLevel);
         workflow.steps.push({
           type: 'escalation',
           levels: escalationLevels,
@@ -149,14 +153,10 @@ function parseWorkflowLines(lines, filename) {
         inEscalationBlock = false;
         continue;
       } else if (line.match(/^Level \d+:/i)) {
-        // Parse level declaration
         const levelMatch = line.match(/^Level (\d+):\s+(.+)$/i);
         if (levelMatch) {
-          if (currentLevel) {
-            escalationLevels.push(currentLevel);
-          }
+          if (currentLevel) escalationLevels.push(currentLevel);
           
-          // Parse timeout from level description
           let timeoutMs = null;
           const desc = levelMatch[2].trim().toLowerCase();
           if (desc.includes('immediately')) {
@@ -174,34 +174,30 @@ function parseWorkflowLines(lines, filename) {
           currentLevel = {
             levelNumber: parseInt(levelMatch[1]),
             timeout: timeoutMs,
-            steps: []
+            steps: [] 
           };
           continue;
         }
       } else if (currentLevel) {
-        // Parse steps within level
         currentLevel.steps.push(line);
         continue;
       }
     }
 
-    // ✅ Parse Timed Parallel block (EXACT FORMAT - NO DUPLICATION)
+    // --- 5. Block: Parallel ---
     const timedParMatch = line.match(/^Run in parallel for (\d+)\s*([smhd])$/i);
     if (timedParMatch) {
       flushCurrentStep();
-      
       const value = parseInt(timedParMatch[1]);
       const unit = timedParMatch[2].toLowerCase();
       const multipliers = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
-      const timeoutMs = value * (multipliers[unit] || 1000);
+      parallelTimeout = value * (multipliers[unit] || 1000);
       
       inParallelBlock = true;
       parallelSteps = [];
-      parallelTimeout = timeoutMs;
       continue;
     }
 
-    // ✅ Parse Normal Parallel block (backward compatible)
     if (line.match(/^Run in parallel$/i)) {
       flushCurrentStep();
       inParallelBlock = true;
@@ -212,7 +208,7 @@ function parseWorkflowLines(lines, filename) {
 
     if (inParallelBlock) {
       if (line.match(/^End$/i)) {
-        flushCurrentStep(); // ✅ Flush last parallel step
+        flushCurrentStep();
         const parsedParallel = parseBlock(parallelSteps);
         workflow.steps.push({
           type: 'parallel',
@@ -229,96 +225,144 @@ function parseWorkflowLines(lines, filename) {
       }
     }
 
-    // ✅ FLUSH before If/When block
+    // --- 6. Block: If / Else If / Else (FIXED STATE MACHINE) ---
+    
+    // Start If
     if (line.match(/^(?:If|When)\s+(.+)$/i)) {
       flushCurrentStep();
       const ifMatch = line.match(/^(?:If|When)\s+(.+)$/i);
       ifCondition = ifMatch[1].trim();
       inIfBlock = true;
-      ifBody = [];
+      
+      // Reset accumulators
+      mainIfBody = [];
+      currentBranchBody = [];
+      elseIfChain = [];
+      currentElseIf = null;
+      inElseBlock = false;
       continue;
     }
 
     if (inIfBlock) {
+      // Handle Else If
+      if (line.match(/^Else If\s+(.+)$/i) || line.match(/^Elseif\s+(.+)$/i)) {
+        const eiMatch = line.match(/^(?:Else If|Elseif)\s+(.+)$/i);
+        
+        // Save previous branch (either main if or previous else-if)
+        if (currentElseIf) {
+          currentElseIf.body = parseBlock(currentBranchBody);
+          elseIfChain.push(currentElseIf);
+        }
+        
+        // Reset for new else-if branch
+        currentBranchBody = [];
+        currentElseIf = { condition: eiMatch[1].trim(), body: [] };
+        continue;
+      }
+
+      // Handle Else
+      if (line.match(/^Else$/i)) {
+        // Save previous else-if if it exists
+        if (currentElseIf) {
+          currentElseIf.body = parseBlock(currentBranchBody);
+          elseIfChain.push(currentElseIf);
+          currentElseIf = null;
+        }
+        
+        inElseBlock = true;
+        currentBranchBody = [];
+        continue;
+      }
+
+      // Handle End
       if (line.match(/^End(?:If)?$/i)) {
-        flushCurrentStep(); // ✅ Flush last if step
-        const parsedIfBody = parseBlock(ifBody);
+        flushCurrentStep();
+
+        // Close any open else-if
+        if (currentElseIf) {
+          currentElseIf.body = parseBlock(currentBranchBody);
+          elseIfChain.push(currentElseIf);
+          currentElseIf = null;
+        }
+
         workflow.steps.push({
           type: 'if',
           condition: ifCondition,
-          body: parsedIfBody,
+          body: parseBlock(mainIfBody),           // Main body correctly isolated
+          elseIf: elseIfChain,                    // Else-if chain
+          elseBranch: inElseBlock ? parseBlock(currentBranchBody) : [], // Else body
           stepNumber: workflow.steps.length + 1
         });
+
+        // Reset State
         inIfBlock = false;
         ifCondition = null;
-        ifBody = [];
+        mainIfBody = [];
+        currentBranchBody = [];
+        elseIfChain = [];
+        inElseBlock = false;
         continue;
+      }
+
+      // Accumulate lines into correct bucket
+      if (inElseBlock || currentElseIf) {
+        currentBranchBody.push(line);
       } else {
-        ifBody.push(line);
-        continue;
+        mainIfBody.push(line); // Main if body accumulates here
       }
+      continue;
+    }
+
+    // --- 7. Standard Steps & Keywords ---
+
+    // Connect: Connect "name" to url "..." OR Connect "name" to resolver "..."
+    const connectMatch = line.match(/^Connect\s+"([^"]+)"\s+to\s+(url|resolver)\s+"([^"]+)"$/i);
+    if (connectMatch) {
+      flushCurrentStep();
+      workflow.steps.push({
+        type: 'connect',
+        resource: connectMatch[1],
+        endpoint: connectMatch[3],
+        targetType: connectMatch[2].toLowerCase(),
+        stepNumber: workflow.steps.length + 1
+      });
+      continue;
+    }
+
+    // Use: Use "logicalName" as "resource"
+    const useMatch = line.match(/^Use\s+"([^"]+)"\s+as\s+"([^"]+)"$/i);
+    if (useMatch) {
+      flushCurrentStep();
+      workflow.steps.push({
+        type: 'agent_use',
+        logicalName: useMatch[1],
+        resource: useMatch[2],
+        stepNumber: workflow.steps.length + 1
+      });
+      continue;
     }
 
-    // Step declaration - ✅ PRESERVE ACTION EXACTLY (NO NORMALIZATION)
+    // Step Declaration
     const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
     if (stepMatch) {
-      flushCurrentStep(); // ✅ Flush previous step
-      const stepNumber = parseInt(stepMatch[1], 10);
-      const stepContent = stepMatch[2].trim();  // ← PRESERVED EXACTLY (no normalizeAction)
-      
+      flushCurrentStep();
       currentStep = {
         type: 'action',
-        stepNumber: stepNumber,
-        actionRaw: stepContent,  // ← CRITICAL: No normalization here
+        stepNumber: parseInt(stepMatch[1], 10),
+        actionRaw: stepMatch[2].trim(),
         saveAs: null,
         constraints: {}
       };
       continue;
     }
 
-    // Save as - ✅ Apply normalization (safe for symbol names)
+    // Save As
     const saveMatch = line.match(/^Save as\s+(.+)$/i);
     if (saveMatch && currentStep) {
       currentStep.saveAs = normalizeSymbol(saveMatch[1].trim());
       continue;
     }
 
-    // Constraint (per-step)
-    const constraintMatch = line.match(/^Constraint:\s*(.+)$/i);
-    if (constraintMatch && currentStep) {
-      const constraintLine = constraintMatch[1].trim();
-      const eq = constraintLine.match(/^([^=]+)=\s*(.+)$/);
-      if (eq) {
-        let key = eq[1].trim();
-        let value = eq[2].trim();
-
-        if (value.startsWith('[') && value.endsWith(']')) {
-          value = value.slice(1, -1).split(',').map(v => v.trim().replace(/^"/, '').replace(/"$/, ''));
-        } else if (!isNaN(value)) {
-          value = Number(value);
-        } else if (value.startsWith('"') && value.endsWith('"')) {
-          value = value.slice(1, -1);
-        }
-
-        currentStep.constraints[key] = value;
-      }
-      continue;
-    }
-
-    // ✅ ADD: Set keyword (e.g., Set analysis_result = "")
-    const setMatch = line.match(/^Set\s+(\w+)\s*=\s*(.+)$/i);
-    if (setMatch) {
-      flushCurrentStep();
-      workflow.steps.push({
-        type: 'calculate',
-        stepNumber: workflow.steps.length + 1,
-        actionRaw: setMatch[2].trim(),  // e.g., '""' or '"N/A"'
-        saveAs: setMatch[1].trim(),     // e.g., 'analysis_result'
-        constraints: {}
-      });
-      continue;
-    }
-
     // Debrief
     const debriefMatch = line.match(/^Debrief\s+([^\s]+)\s+with\s+"([^"]*)"$/i);
     if (debriefMatch) {
@@ -332,19 +376,6 @@ function parseWorkflowLines(lines, filename) {
       continue;
     }
 
-    // Evolve
-    const evolveMatch = line.match(/^Evolve\s+([^\s]+)\s+using\s+feedback:\s*"([^"]*)"$/i);
-    if (evolveMatch) {
-      flushCurrentStep();
-      workflow.steps.push({
-        type: 'evolve',
-        targetResolver: evolveMatch[1].trim(),
-        feedback: evolveMatch[2],
-        stepNumber: workflow.steps.length + 1
-      });
-      continue;
-    }
-
     // Prompt
     const promptMatch = line.match(/^Prompt user to\s+"([^"]*)"$/i);
     if (promptMatch) {
@@ -384,29 +415,12 @@ function parseWorkflowLines(lines, filename) {
       continue;
     }
 
-    // Use (for Notify-like actions) - ✅ PRESERVE TOOL EXACTLY (NO NORMALIZATION)
-    const useMatch = line.match(/^Use\s+(.+)$/i);
-    if (useMatch) {
-      flushCurrentStep();
-      workflow.steps.push({
-        type: 'use',
-        tool: useMatch[1].trim(),  // ← PRESERVED EXACTLY (no normalizeAction)
-        stepNumber: workflow.steps.length + 1,
-        saveAs: null,
-        constraints: {}
-      });
-      continue;
-    }
-
-    // Ask (for Notify/resolver calls) - ✅ PRESERVE TARGET EXACTLY (NO NORMALIZATION)
+    // Ask (Multiline support)
     const askMatch = line.match(/^Ask\s+(.+)$/i);
     if (askMatch) {
       flushCurrentStep();
       let actionContent = askMatch[1].trim();
-
-      // ✅ Multiline heredoc support: Ask llm-groq """
       if (actionContent.endsWith('"""')) {
-        // Consume lines until closing """
         let multiline = actionContent.slice(0, -3).trim() + ' ';
         while (i < lines.length) {
           const nextLine = lines[i++].trim();
@@ -415,7 +429,6 @@ function parseWorkflowLines(lines, filename) {
         }
         actionContent = multiline.trim();
       }
-
       workflow.steps.push({
         type: 'action',
         actionRaw: `Action ${actionContent}`,
@@ -426,59 +439,36 @@ function parseWorkflowLines(lines, filename) {
       continue;
     }
 
-    // ✅ ADD: Return keyword support (ensures wf.returnValues is populated)
-// ✅ ADD: Return keyword support (with debug logging)
-const returnMatch = line.match(/^Return\s+(.+)$/i);
-if (returnMatch) {
-  flushCurrentStep();
-  const rawReturns = returnMatch[1];
-  console.log(`[PARSER DEBUG] Return line: "${line}"`);
-  console.log(`[PARSER DEBUG] Return match[1]: "${rawReturns}"`);
-  console.log(`[PARSER DEBUG] Return match[1] char codes: ${Array.from(rawReturns).map(c => c.charCodeAt(0))}`);
-  
-  workflow.returnValues = rawReturns
-    .split(',')
-    .map(r => r.trim())
-    .filter(r => r !== '');
-    
-  console.log(`[PARSER DEBUG] Parsed returnValues: ${JSON.stringify(workflow.returnValues)}`);
-  continue;
-}
-    // Fallback: treat as action
+    // Return
+    const returnMatch = line.match(/^Return\s+(.+)$/i);
+    if (returnMatch) {
+      flushCurrentStep();
+      workflow.returnValues = returnMatch[1]
+        .split(',')
+        .map(r => r.trim())
+        .filter(r => r !== '');
+      continue;
+    }
+
+    // Fallback: Treat as action
     if (line.trim() !== '') {
       if (!currentStep) {
         currentStep = {
           type: 'action',
           stepNumber: workflow.steps.length + 1,
-          actionRaw: line,  // ← PRESERVED EXACTLY (no normalizeAction)
+          actionRaw: line,
           saveAs: null,
           constraints: {}
         };
       } else {
-        currentStep.actionRaw += ' ' + line;  // ← PRESERVED EXACTLY (no normalizeAction)
+        currentStep.actionRaw += ' ' + line;
       }
     }
   }
 
-  flushCurrentStep(); // ✅ Final flush
-
-    // ✅ FALLBACK: Scan raw lines for Return if regex missed it (Windows line endings, hidden chars, etc.)
-  if (workflow.returnValues.length === 0) {
-    for (let j = 0; j < lines.length; j++) {
-      const clean = lines[j].replace(/\r/g, '').trim();
-      const match = clean.match(/^Return\s+(.+)$/i);
-      if (match) {
-        console.log(`[PARSER] Recovered Return at line ${j+1}: "${clean}"`);
-        workflow.returnValues = match[1]
-          .split(',')
-          .map(r => r.trim())
-          .filter(r => r !== '');
-        break;
-      }
-    }
-  }
+  flushCurrentStep();
 
-  // Post-process Save as in actionRaw - ✅ Apply normalization
+  // Post-process Save as in actionRaw
   workflow.steps.forEach(step => {
     if (step.actionRaw && step.saveAs === null) {
       const saveInAction = step.actionRaw.match(/(.+?)\s+Save as\s+(.+)$/i);
@@ -487,27 +477,18 @@ if (returnMatch) {
         step.saveAs = normalizeSymbol(saveInAction[2].trim());
       }
     }
-    // ✅ Also normalize any existing saveAs values
     if (step.saveAs) {
       step.saveAs = normalizeSymbol(step.saveAs);
     }
   });
 
-  // Validation warnings
-  if (!workflow.name) {
-    workflow.__warnings.push('Workflow name not found');
-  }
-  if (workflow.steps.length === 0) {
-    workflow.__warnings.push('No steps found in workflow');
-  }
-  if (workflow.returnValues.length === 0 && workflow.steps.length > 0) {
-    workflow.__warnings.push('No Return statement found');
-  }
-
   return workflow;
 }
 
-// Parses blocks (for parallel, if, escalation levels) - ✅ PRESERVE ALL FUNCTIONALITY
+// ─────────────────────────────────────────────────────────────────────────────
+// BLOCK PARSER (Exported for RuntimeAPI Escalation)
+// ─────────────────────────────────────────────────────────────────────────────
+
 function parseBlock(lines) {
   const steps = [];
   let current = null;
@@ -523,31 +504,53 @@ function parseBlock(lines) {
     line = line.trim();
     if (!line || line.startsWith('#')) continue;
 
-    // Step declaration in block - ✅ PRESERVE ACTION EXACTLY (NO NORMALIZATION)
+    // Connect in Block
+    const connectMatch = line.match(/^Connect\s+"([^"]+)"\s+to\s+(url|resolver)\s+"([^"]+)"$/i);
+    if (connectMatch) {
+      flush();
+      steps.push({
+        type: 'connect',
+        resource: connectMatch[1],
+        endpoint: connectMatch[3],
+        targetType: connectMatch[2].toLowerCase()
+      });
+      continue;
+    }
+
+    // Use in Block
+    const useMatch = line.match(/^Use\s+"([^"]+)"\s+as\s+"([^"]+)"$/i);
+    if (useMatch) {
+      flush();
+      steps.push({
+        type: 'agent_use',
+        logicalName: useMatch[1],
+        resource: useMatch[2]
+      });
+      continue;
+    }
+
+    // Step in Block
     const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
     if (stepMatch) {
       flush();
-      const stepNumber = parseInt(stepMatch[1], 10);
-      const stepContent = stepMatch[2].trim();  // ← PRESERVED EXACTLY
-      
       current = {
         type: 'action',
-        stepNumber: stepNumber,
-        actionRaw: stepContent,  // ← CRITICAL: No normalization
+        stepNumber: parseInt(stepMatch[1], 10),
+        actionRaw: stepMatch[2].trim(),
         saveAs: null,
         constraints: {}
       };
       continue;
     }
 
-    // Save as - ✅ Apply normalization
+    // Save As in Block
     const saveMatch = line.match(/^Save as\s+(.+)$/i);
     if (saveMatch && current) {
       current.saveAs = normalizeSymbol(saveMatch[1].trim());
       continue;
     }
 
-    // Handle all special steps inside blocks
+    // Debrief in Block
     const debriefMatch = line.match(/^Debrief\s+([^\s]+)\s+with\s+"([^"]*)"$/i);
     if (debriefMatch) {
       flush();
@@ -555,20 +558,7 @@ function parseBlock(lines) {
       continue;
     }
 
-    const evolveMatch = line.match(/^Evolve\s+([^\s]+)\s+using\s+feedback:\s*"([^"]*)"$/i);
-    if (evolveMatch) {
-      flush();
-      steps.push({ type: 'evolve', targetResolver: evolveMatch[1].trim(), feedback: evolveMatch[2] });
-      continue;
-    }
-
-    const promptMatch = line.match(/^Prompt user to\s+"([^"]*)"$/i);
-    if (promptMatch) {
-      flush();
-      steps.push({ type: 'prompt', question: promptMatch[1], saveAs: null });
-      continue;
-    }
-
+    // Persist in Block
     const persistMatch = line.match(/^Persist\s+([^\s]+)\s+to\s+"([^"]*)"$/i);
     if (persistMatch) {
       flush();
@@ -576,6 +566,7 @@ function parseBlock(lines) {
       continue;
     }
 
+    // Emit in Block
     const emitMatch = line.match(/^Emit\s+"([^"]+)"\s+with\s+(.+)$/i);
     if (emitMatch) {
       flush();
@@ -583,20 +574,7 @@ function parseBlock(lines) {
       continue;
     }
 
-    // ✅ FIXED: Use in block — consistent with top-level Use handler (Bug 1 + Bug 2)
-    const useMatch = line.match(/^Use\s+(.+)$/i);
-    if (useMatch) {
-      flush();
-      steps.push({
-        type: 'use',
-        tool: useMatch[1].trim(),
-        saveAs: null,
-        constraints: {}
-      });
-      continue;
-    }
-
-    // Ask in block — CANONICALIZE AT PARSE TIME
+    // Ask in Block
     const askMatch = line.match(/^Ask\s+(.+)$/i);
     if (askMatch) {
       flush();
@@ -609,56 +587,15 @@ function parseBlock(lines) {
       continue;
     }
 
-    // Constraint inside block
-    const constraintMatch = line.match(/^Constraint:\s*(.+)$/i);
-    if (constraintMatch && current) {
-      const constraintLine = constraintMatch[1].trim();
-      const eq = constraintLine.match(/^([^=]+)=\s*(.+)$/);
-      if (eq) {
-        let key = eq[1].trim();
-        let value = eq[2].trim();
-        if (value.startsWith('[') && value.endsWith(']')) {
-          value = value.slice(1, -1).split(',').map(v => v.trim().replace(/^"/, '').replace(/"$/, ''));
-        } else if (!isNaN(value)) {
-          value = Number(value);
-        } else if (value.startsWith('"') && value.endsWith('"')) {
-          value = value.slice(1, -1);
-        }
-        current.constraints[key] = value;
-      }
-      continue;
-    }
-
-    // ✅ ADD: Set keyword inside blocks (e.g., Set analysis_result = "")
-    const setMatch = line.match(/^Set\s+(\w+)\s*=\s*(.+)$/i);
-    if (setMatch) {
-      flush(); // Flush any pending step
-      steps.push({
-        type: 'calculate',
-        actionRaw: setMatch[2].trim(),  // e.g., '""' or '"N/A"'
-        saveAs: setMatch[1].trim(),     // e.g., 'analysis_result'
-        constraints: {}
-      });
-      continue;
-    }
-
-    // ✅ ADD: Return keyword inside blocks (rare but supported)
-    const returnMatch = line.match(/^Return\s+(.+)$/i);
-    if (returnMatch) {
-      flush();
-      // Note: Return inside blocks is unusual; this just parses it
-      continue;
-    }
-
-    // Fallback
+    // Fallback for block actions
     if (current) {
-      current.actionRaw += ' ' + line;  // ← PRESERVED EXACTLY (no normalizeAction)
+      current.actionRaw += ' ' + line;
     }
   }
 
-  flush(); // ✅ Final flush in block
+  flush();
 
-  // ✅ Post-process Save as for steps inside blocks - Apply normalization
+  // Post-process Save as in block steps
   steps.forEach(step => {
     if (step.actionRaw && step.saveAs === null) {
       const saveInAction = step.actionRaw.match(/(.+?)\s+Save as\s+(.+)$/i);
@@ -667,7 +604,6 @@ function parseBlock(lines) {
         step.saveAs = normalizeSymbol(saveInAction[2].trim());
       }
     }
-    // ✅ Also normalize any existing saveAs values
     if (step.saveAs) {
       step.saveAs = normalizeSymbol(step.saveAs);
     }
@@ -676,12 +612,5 @@ function parseBlock(lines) {
   return steps;
 }
 
-function validate(workflow) {
-  const errors = [];
-  if (workflow.maxGenerations !== null && workflow.maxGenerations <= 0) {
-    errors.push('max_generations must be positive');
-  }
-  return errors;
-}
-
-module.exports = { parse, parseFromFile, parseLines, validate };
+// ✅ EXPORTS: Added parseBlock so RuntimeAPI can use it for Escalation
+module.exports = { parse, parseFromFile, parseLines, parseBlock };