@orcalang/orca-lang 0.1.19 → 0.1.24

package/src/compiler/dt-compiler.ts

@@ -1,5 +1,5 @@
 // Decision Table Compiler
-// Compiles verified decision tables to TypeScript evaluator functions or JSON
+// Compiles verified decision tables to TypeScript, Python, Go evaluator functions or JSON
 
 import { DecisionTableDef, CellValue } from '../parser/dt-ast.js';
 
@@ -11,6 +11,14 @@ function toPascalCase(name: string): string {
     .join('');
 }
 
+// Convert PascalCase or camelCase to snake_case
+export function toSnakeCase(name: string): string {
+  return name
+    .replace(/([A-Z])/g, '_$1')
+    .toLowerCase()
+    .replace(/^_/, '');
+}
+
 // Generate TypeScript type for input interface
 function generateInputType(dt: DecisionTableDef): string {
   const lines: string[] = [];
@@ -47,7 +55,7 @@ function generateTypeScriptType(type: string, values: string[]): string {
   if (type === 'enum') {
     return values.length > 0 ? values.map(v => `'${v}'`).join(' | ') : 'string';
   }
-  if (type === 'int_range') {
+  if (type === 'int_range' || type === 'decimal_range') {
     return 'number';
   }
   return 'string';
@@ -60,10 +68,12 @@ function generateConditionCheck(condName: string, condType: string, cell: CellVa
       return ''; // No condition needed
 
     case 'exact':
-      // For bool type, compare to boolean; for others, compare to string
       if (condType === 'bool') {
         return `input.${condName} === ${cell.value}`;
       }
+      if (condType === 'int_range' || condType === 'decimal_range') {
+        return `input.${condName} === ${cell.value}`;
+      }
       return `input.${condName} === '${cell.value}'`;
 
     case 'negated':
@@ -72,7 +82,7 @@ function generateConditionCheck(condName: string, condType: string, cell: CellVa
       }
       return `input.${condName} !== '${cell.value}'`;
 
-    case 'set':
+    case 'set': {
       const checks = cell.values.map(v => {
         if (condType === 'bool') {
           return `input.${condName} === ${v}`;
@@ -80,6 +90,16 @@ function generateConditionCheck(condName: string, condType: string, cell: CellVa
         return `input.${condName} === '${v}'`;
       }).join(' || ');
       return `(${checks})`;
+    }
+
+    case 'compare':
+      return `input.${condName} ${cell.op} ${cell.value}`;
+
+    case 'range': {
+      const lowCheck = cell.lowInc ? `input.${condName} >= ${cell.low}` : `input.${condName} > ${cell.low}`;
+      const highCheck = cell.highInc ? `input.${condName} <= ${cell.high}` : `input.${condName} < ${cell.high}`;
+      return `(${lowCheck} && ${highCheck})`;
+    }
 
     default:
       return '';
@@ -230,3 +250,353 @@ export function compileDecisionTableToJSON(dt: DecisionTableDef): string {
 
   return JSON.stringify(json, null, 2);
 }
+
+// ============================================================
+// Python Compiler
+// ============================================================
+
+function generatePythonType(type: string): string {
+  if (type === 'bool') return 'bool';
+  if (type === 'int_range') return 'int';
+  if (type === 'decimal_range') return 'float';
+  return 'str';
+}
+
+function generatePythonConditionCheck(condName: string, condType: string, cell: CellValue): string {
+  switch (cell.kind) {
+    case 'any':
+      return '';
+    case 'exact':
+      if (condType === 'bool') return `input.${condName} == ${cell.value}`;
+      if (condType === 'int_range' || condType === 'decimal_range') return `input.${condName} == ${cell.value}`;
+      return `input.${condName} == '${cell.value}'`;
+    case 'negated':
+      if (condType === 'bool') return `input.${condName} != ${cell.value}`;
+      return `input.${condName} != '${cell.value}'`;
+    case 'set': {
+      const checks = cell.values.map(v =>
+        condType === 'bool' ? `input.${condName} == ${v}` : `input.${condName} == '${v}'`
+      ).join(' or ');
+      return `(${checks})`;
+    }
+    case 'compare':
+      return `input.${condName} ${cell.op} ${cell.value}`;
+    case 'range': {
+      const lowCheck = cell.lowInc ? `input.${condName} >= ${cell.low}` : `input.${condName} > ${cell.low}`;
+      const highCheck = cell.highInc ? `input.${condName} <= ${cell.high}` : `input.${condName} < ${cell.high}`;
+      return `(${lowCheck} and ${highCheck})`;
+    }
+    default:
+      return '';
+  }
+}
+
+export function compileDecisionTableToPython(dt: DecisionTableDef): string {
+  const inputClassName = `${toPascalCase(dt.name)}Input`;
+  const outputClassName = `${toPascalCase(dt.name)}Output`;
+  const fnName = `evaluate_${toSnakeCase(dt.name)}`;
+
+  const lines: string[] = [
+    'from typing import Optional',
+    'from dataclasses import dataclass',
+    '',
+    '',
+    '@dataclass',
+    `class ${inputClassName}:`,
+  ];
+
+  for (const cond of dt.conditions) {
+    const typeStr = generatePythonType(cond.type);
+    const comment = cond.type === 'enum' && cond.values.length > 0
+      ? `  # ${cond.values.join(', ')}`
+      : '';
+    lines.push(`    ${cond.name}: ${typeStr}${comment}`);
+  }
+
+  lines.push('');
+  lines.push('');
+  lines.push('@dataclass');
+  lines.push(`class ${outputClassName}:`);
+
+  for (const action of dt.actions) {
+    const typeStr = generatePythonType(action.type);
+    const comment = action.type === 'enum' && action.values && action.values.length > 0
+      ? `  # ${action.values.join(', ')}`
+      : '';
+    lines.push(`    ${action.name}: ${typeStr}${comment}`);
+  }
+
+  lines.push('');
+  lines.push('');
+  lines.push(`def ${fnName}(input: ${inputClassName}) -> Optional[${outputClassName}]:`);
+
+  for (let ruleIdx = 0; ruleIdx < dt.rules.length; ruleIdx++) {
+    const rule = dt.rules[ruleIdx];
+    const ruleNum = rule.number ?? ruleIdx + 1;
+
+    const checks: string[] = [];
+    for (const [condName, cell] of rule.conditions) {
+      const condDef = dt.conditions.find(c => c.name === condName);
+      const condType = condDef?.type ?? 'string';
+      const check = generatePythonConditionCheck(condName, condType, cell);
+      if (check) checks.push(check);
+    }
+
+    const actionArgs = dt.actions
+      .map(a => {
+        const value = rule.actions.get(a.name);
+        if (value === undefined) return null;
+        if (a.type === 'bool') return `${a.name}=${value}`;
+        return `${a.name}='${value}'`;
+      })
+      .filter((v): v is string => v !== null)
+      .join(', ');
+
+    lines.push(`    # Rule ${ruleNum}`);
+    if (checks.length === 0) {
+      lines.push(`    return ${outputClassName}(${actionArgs})`);
+    } else {
+      lines.push(`    if ${checks.join(' and ')}:`);
+      lines.push(`        return ${outputClassName}(${actionArgs})`);
+    }
+  }
+
+  lines.push('    return None  # no rule matched');
+
+  return lines.join('\n');
+}
+
+// ============================================================
+// Go Compiler
+// ============================================================
+
+function generateGoType(type: string): string {
+  if (type === 'bool') return 'bool';
+  if (type === 'int_range') return 'int';
+  if (type === 'decimal_range') return 'float64';
+  return 'string';
+}
+
+function generateGoConditionCheck(condName: string, condType: string, cell: CellValue): string {
+  const goField = toPascalCase(condName);
+  switch (cell.kind) {
+    case 'any':
+      return '';
+    case 'exact':
+      if (condType === 'bool') return `input.${goField} == ${cell.value}`;
+      if (condType === 'int_range' || condType === 'decimal_range') return `input.${goField} == ${cell.value}`;
+      return `input.${goField} == "${cell.value}"`;
+    case 'negated':
+      if (condType === 'bool') return `input.${goField} != ${cell.value}`;
+      return `input.${goField} != "${cell.value}"`;
+    case 'set': {
+      const checks = cell.values.map(v =>
+        condType === 'bool' ? `input.${goField} == ${v}` : `input.${goField} == "${v}"`
+      ).join(' || ');
+      return `(${checks})`;
+    }
+    case 'compare':
+      return `input.${goField} ${cell.op} ${cell.value}`;
+    case 'range': {
+      const lowCheck = cell.lowInc ? `input.${goField} >= ${cell.low}` : `input.${goField} > ${cell.low}`;
+      const highCheck = cell.highInc ? `input.${goField} <= ${cell.high}` : `input.${goField} < ${cell.high}`;
+      return `(${lowCheck} && ${highCheck})`;
+    }
+    default:
+      return '';
+  }
+}
+
+export function compileDecisionTableToGo(dt: DecisionTableDef): string {
+  const inputTypeName = `${toPascalCase(dt.name)}Input`;
+  const outputTypeName = `${toPascalCase(dt.name)}Output`;
+  const fnName = `Evaluate${toPascalCase(dt.name)}`;
+
+  const lines: string[] = [];
+
+  lines.push(`// ${inputTypeName} defines the input conditions for the ${dt.name} decision table`);
+  lines.push(`type ${inputTypeName} struct {`);
+  for (const cond of dt.conditions) {
+    const goType = generateGoType(cond.type);
+    const fieldName = toPascalCase(cond.name);
+    const comment = cond.type === 'enum' && cond.values.length > 0
+      ? ` // ${cond.values.join(', ')}`
+      : '';
+    lines.push(`\t${fieldName} ${goType}${comment}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  lines.push(`// ${outputTypeName} defines the decision outputs for the ${dt.name} decision table`);
+  lines.push(`type ${outputTypeName} struct {`);
+  for (const action of dt.actions) {
+    const goType = generateGoType(action.type);
+    const fieldName = toPascalCase(action.name);
+    const comment = action.type === 'enum' && action.values && action.values.length > 0
+      ? ` // ${action.values.join(', ')}`
+      : '';
+    lines.push(`\t${fieldName} ${goType}${comment}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  const policy = dt.policy ?? 'first-match';
+  lines.push(`// ${fnName} evaluates the ${dt.name} decision table (${policy} policy)`);
+  lines.push(`func ${fnName}(input ${inputTypeName}) *${outputTypeName} {`);
+
+  for (let ruleIdx = 0; ruleIdx < dt.rules.length; ruleIdx++) {
+    const rule = dt.rules[ruleIdx];
+    const ruleNum = rule.number ?? ruleIdx + 1;
+
+    const checks: string[] = [];
+    for (const [condName, cell] of rule.conditions) {
+      const condDef = dt.conditions.find(c => c.name === condName);
+      const condType = condDef?.type ?? 'string';
+      const check = generateGoConditionCheck(condName, condType, cell);
+      if (check) checks.push(check);
+    }
+
+    const actionFields = dt.actions
+      .map(a => {
+        const value = rule.actions.get(a.name);
+        if (value === undefined) return null;
+        const fieldName = toPascalCase(a.name);
+        if (a.type === 'bool') return `${fieldName}: ${value}`;
+        return `${fieldName}: "${value}"`;
+      })
+      .filter((v): v is string => v !== null)
+      .join(', ');
+
+    lines.push(`\t// Rule ${ruleNum}`);
+    if (checks.length === 0) {
+      lines.push(`\treturn &${outputTypeName}{${actionFields}}`);
+    } else {
+      lines.push(`\tif ${checks.join(' && ')} {`);
+      lines.push(`\t\treturn &${outputTypeName}{${actionFields}}`);
+      lines.push(`\t}`);
+    }
+  }
+
+  lines.push('\treturn nil // no rule matched');
+  lines.push('}');
+
+  return lines.join('\n');
+}
+
+// ============================================================
+// Rust Compiler
+// ============================================================
+
+function generateRustType(type: string): string {
+  if (type === 'bool') return 'bool';
+  if (type === 'int_range') return 'i64';
+  if (type === 'decimal_range') return 'f64';
+  return 'String';
+}
+
+function generateRustConditionCheck(condName: string, condType: string, cell: CellValue): string {
+  switch (cell.kind) {
+    case 'any':
+      return '';
+    case 'exact':
+      if (condType === 'bool') return `input.${condName} == ${cell.value}`;
+      if (condType === 'int_range' || condType === 'decimal_range') return `input.${condName} == ${cell.value}`;
+      return `input.${condName} == "${cell.value}"`;
+    case 'negated':
+      if (condType === 'bool') return `input.${condName} != ${cell.value}`;
+      return `input.${condName} != "${cell.value}"`;
+    case 'set': {
+      const checks = cell.values.map(v =>
+        condType === 'bool' ? `input.${condName} == ${v}` : `input.${condName} == "${v}"`
+      ).join(' || ');
+      return `(${checks})`;
+    }
+    case 'compare':
+      return `input.${condName} ${cell.op} ${cell.value}`;
+    case 'range': {
+      const lowCheck = cell.lowInc ? `input.${condName} >= ${cell.low}` : `input.${condName} > ${cell.low}`;
+      const highCheck = cell.highInc ? `input.${condName} <= ${cell.high}` : `input.${condName} < ${cell.high}`;
+      return `(${lowCheck} && ${highCheck})`;
+    }
+    default:
+      return '';
+  }
+}
+
+export function compileDecisionTableToRust(dt: DecisionTableDef): string {
+  const inputTypeName = `${toPascalCase(dt.name)}Input`;
+  const outputTypeName = `${toPascalCase(dt.name)}Output`;
+  const fnName = `evaluate_${toSnakeCase(dt.name)}`;
+
+  const lines: string[] = [];
+
+  lines.push(`/// Input conditions for the ${dt.name} decision table`);
+  lines.push('#[derive(Debug, Clone)]');
+  lines.push(`pub struct ${inputTypeName} {`);
+  for (const cond of dt.conditions) {
+    const rustType = generateRustType(cond.type);
+    const comment = cond.type === 'enum' && cond.values.length > 0
+      ? ` // ${cond.values.join(', ')}`
+      : '';
+    lines.push(`    pub ${cond.name}: ${rustType},${comment}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  lines.push(`/// Decision outputs for the ${dt.name} decision table`);
+  lines.push('#[derive(Debug, Clone)]');
+  lines.push(`pub struct ${outputTypeName} {`);
+  for (const action of dt.actions) {
+    const rustType = generateRustType(action.type);
+    const comment = action.type === 'enum' && action.values && action.values.length > 0
+      ? ` // ${action.values.join(', ')}`
+      : '';
+    lines.push(`    pub ${action.name}: ${rustType},${comment}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  const policy = dt.policy ?? 'first-match';
+  lines.push(`/// Evaluate the ${dt.name} decision table (${policy} policy)`);
+  lines.push(`pub fn ${fnName}(input: &${inputTypeName}) -> Option<${outputTypeName}> {`);
+
+  for (let ruleIdx = 0; ruleIdx < dt.rules.length; ruleIdx++) {
+    const rule = dt.rules[ruleIdx];
+    const ruleNum = rule.number ?? ruleIdx + 1;
+
+    const checks: string[] = [];
+    for (const [condName, cell] of rule.conditions) {
+      const condDef = dt.conditions.find(c => c.name === condName);
+      const condType = condDef?.type ?? 'string';
+      const check = generateRustConditionCheck(condName, condType, cell);
+      if (check) checks.push(check);
+    }
+
+    const actionFields = dt.actions
+      .map(a => {
+        const value = rule.actions.get(a.name);
+        if (value === undefined) return null;
+        const aType = a.type as string;
+        if (aType === 'bool') return `${a.name}: ${value}`;
+        if (aType === 'int_range') return `${a.name}: ${value}`;
+        if (aType === 'decimal_range') return `${a.name}: ${value}`;
+        return `${a.name}: "${value}".to_string()`;
+      })
+      .filter((v): v is string => v !== null)
+      .join(', ');
+
+    lines.push(`    // Rule ${ruleNum}`);
+    if (checks.length === 0) {
+      lines.push(`    return Some(${outputTypeName} { ${actionFields} });`);
+    } else {
+      lines.push(`    if ${checks.join(' && ')} {`);
+      lines.push(`        return Some(${outputTypeName} { ${actionFields} });`);
+      lines.push(`    }`);
+    }
+  }
+
+  lines.push('    None // no rule matched');
+  lines.push('}');
+
+  return lines.join('\n');
+}

package/src/health-check.ts

@@ -186,6 +186,85 @@ async function runHealthCheck(): Promise<HealthReport> {
     }
   }
 
+  // ── Step 7: runtime-rust tests ──────────────────────────────────
+  {
+    const step: StepResult = { name: 'runtime-rust:test', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running runtime-rust tests ━━━');
+    const result = runCommand('cd packages/runtime-rust && cargo test 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Tests passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} runtime-rust tests ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 7b: demo-fortran ─────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-fortran', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+
+    // Check if gfortran is available
+    const gfortranCheck = runCommand('which gfortran 2>/dev/null', REPO_ROOT);
+    if (gfortranCheck.status !== 0) {
+      step.duration = Date.now() - start;
+      step.status = 'success';
+      step.output = 'Skipped (gfortran not installed)';
+      report.steps.push(step);
+      console.log(`  ○ demo-fortran skipped (gfortran not installed) (${step.duration}ms)\n`);
+    } else {
+      console.log('━━━ Building and running demo-fortran ━━━');
+      const result = runCommand('cd packages/demo-fortran && make run 2>&1', REPO_ROOT);
+      step.duration = Date.now() - start;
+      step.status = result.status === 0 ? 'success' : 'failed';
+      step.output = result.status === 0 ? 'Demo passed' : result.stdout;
+      report.steps.push(step);
+      console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-fortran ${step.status} (${step.duration}ms)\n`);
+      if (step.status === 'failed') {
+        report.endTime = Date.now();
+        return report;
+      }
+    }
+  }
+
+  // ── Step 7c: demo-rust ─────────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-rust', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-rust tests ━━━');
+    const result = runCommand('cd packages/demo-rust && cargo test 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Tests passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-rust tests ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 7d: demo-rust-event ───────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-rust-event', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-rust-event ━━━');
+    const result = runCommand('cd packages/demo-rust-event && cargo run 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Demo passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-rust-event ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
   // ── Step 8: demo-nanolab tests ─────────────────────────────────
   {
     const step: StepResult = { name: 'demo-nanolab:test', status: 'pending', output: '', duration: 0 };

package/src/index.ts

@@ -22,6 +22,7 @@ import { checkStructural, analyzeFile } from './verifier/structural.js';
 import { checkCompleteness } from './verifier/completeness.js';
 import { checkDeterminism } from './verifier/determinism.js';
 import { checkProperties } from './verifier/properties.js';
+import { computeAlignedDTOutputDomain } from './verifier/dt-verifier.js';
 import { compileToXState, compileToXStateMachine } from './compiler/xstate.js';
 import { compileToMermaid } from './compiler/mermaid.js';
 import { verifySkill, compileSkill, generateActionsSkill, refineSkill, generateOrcaSkill, generateOrcaMultiSkill, parseSkill, type SkillInput } from './skills.js';
@@ -232,7 +233,10 @@ async function verify(input: SkillInput, json: boolean = false): Promise<void> {
   const structural = checkStructural(machine);
   const completeness = checkCompleteness(machine);
   const determinism = checkDeterminism(machine);
-  const properties = checkProperties(machine);
+  const dtOutputDomain = file.decisionTables.length > 0
+    ? computeAlignedDTOutputDomain({ machines: [machine], decisionTables: file.decisionTables })
+    : undefined;
+  const properties = checkProperties(machine, { dtOutputDomain });
 
   const allErrors = [
     ...structural.errors,

package/src/parser/ast-to-markdown.ts

@@ -101,7 +101,8 @@ function emitStates(states: StateDef[], level: number): string[] {
     if (state.onEntry) lines.push(`- on_entry: ${state.onEntry}`);
     if (state.onExit) lines.push(`- on_exit: ${state.onExit}`);
     if (state.timeout) lines.push(`- timeout: ${state.timeout.duration} -> ${state.timeout.target}`);
-    if (state.ignoredEvents?.length) lines.push(`- ignore: ${state.ignoredEvents.join(', ')}`);
+    if (state.ignoredAll) lines.push(`- ignore: *`);
+    else if (state.ignoredEvents?.length) lines.push(`- ignore: ${state.ignoredEvents.join(', ')}`);
     if (state.onDone) lines.push(`- on_done: -> ${state.onDone}`);
 
     if (state.parallel) {

package/src/parser/ast.ts

@@ -120,6 +120,7 @@ export interface StateDef {
   parent?: string;  // Parent state name for hierarchical states
   transitions?: Transition[];
   ignoredEvents?: string[];
+  ignoredAll?: boolean;     // true when "- ignore: *" — all unhandled events discarded
 }
 
 export interface Transition {

package/src/parser/dt-ast.ts

@@ -1,6 +1,6 @@
 // Decision Table AST Types
 
-export type ConditionType = 'bool' | 'enum' | 'int_range' | 'string';
+export type ConditionType = 'bool' | 'enum' | 'int_range' | 'decimal_range' | 'string';
 
 export interface ConditionDef {
   name: string;
@@ -22,7 +22,9 @@ export type CellValue =
   | { kind: 'any' }                           // "-" wildcard
   | { kind: 'exact'; value: string }          // exact match
   | { kind: 'negated'; value: string }        // "!value"
-  | { kind: 'set'; values: string[] };        // "a,b" (match any in set)
+  | { kind: 'set'; values: string[] }         // "a,b" (match any in set)
+  | { kind: 'compare'; op: '>' | '>=' | '<' | '<='; value: number }  // >=750, <0.3
+  | { kind: 'range'; low: number; high: number; lowInc: boolean; highInc: boolean }; // 700..749, 0.3-0.4
 
 export interface Rule {
   number?: number;           // optional rule # from the # column

package/src/parser/dt-parser.ts

@@ -21,7 +21,37 @@ function findColumnIndex(headers: string[], name: string): number {
 
 // --- Cell Value Parsing ---
 
-function parseCellValue(text: string | undefined): CellValue {
+function parseNumericCell(text: string): CellValue | null {
+  // Suffix form: 750+ means >=750
+  const suffixPlus = text.match(/^(-?\d+(?:\.\d+)?)\+$/);
+  if (suffixPlus) {
+    return { kind: 'compare', op: '>=', value: parseFloat(suffixPlus[1]) };
+  }
+
+  // Comparison operators: >=750, <=0.3, >100, <600
+  const cmpMatch = text.match(/^(>=|<=|>|<)\s*(-?\d+(?:\.\d+)?)$/);
+  if (cmpMatch) {
+    return { kind: 'compare', op: cmpMatch[1] as '>' | '>=' | '<' | '<=', value: parseFloat(cmpMatch[2]) };
+  }
+
+  // Range with .. separator: 1..50 (inclusive both ends)
+  const dotRange = text.match(/^(-?\d+(?:\.\d+)?)\s*\.\.\s*(-?\d+(?:\.\d+)?)$/);
+  if (dotRange) {
+    return { kind: 'range', low: parseFloat(dotRange[1]), high: parseFloat(dotRange[2]), lowInc: true, highInc: true };
+  }
+
+  // Range with - separator for numbers: 700-749, 0.3-0.4
+  // Must have at least one side that looks numeric (digit-starting).
+  // Negative numbers on the left are ambiguous with subtraction — require left >= 0.
+  const dashRange = text.match(/^(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?)$/);
+  if (dashRange) {
+    return { kind: 'range', low: parseFloat(dashRange[1]), high: parseFloat(dashRange[2]), lowInc: true, highInc: true };
+  }
+
+  return null;
+}
+
+function parseCellValue(text: string | undefined, condType?: ConditionType): CellValue {
   if (!text || text.trim() === '' || text.trim() === '-') {
     return { kind: 'any' };
   }
@@ -36,6 +66,12 @@ function parseCellValue(text: string | undefined): CellValue {
     }
   }
 
+  // Numeric range/compare patterns — only attempt for numeric condition types
+  if (condType === 'int_range' || condType === 'decimal_range') {
+    const numeric = parseNumericCell(trimmed);
+    if (numeric) return numeric;
+  }
+
   // Set: a,b,c
   if (trimmed.includes(',')) {
     return { kind: 'set', values: trimmed.split(',').map(v => v.trim()).filter(Boolean) };
@@ -65,11 +101,11 @@ function parseConditionsTable(table: MdTable): ConditionDef[] {
 
     if (type === 'bool') {
       values = valuesStr.trim() ? valuesStr.split(',').map(v => v.trim()) : ['true', 'false'];
-    } else if (type === 'int_range') {
-      // Parse min..max format
-      const rangeMatch = valuesStr.match(/(\d+)\s*\.\.\s*(\d+)/);
+    } else if (type === 'int_range' || type === 'decimal_range') {
+      // Parse min..max format (integers or decimals)
+      const rangeMatch = valuesStr.match(/(-?\d+(?:\.\d+)?)\s*\.\.\s*(-?\d+(?:\.\d+)?)/);
       if (rangeMatch) {
-        range = { min: parseInt(rangeMatch[1], 10), max: parseInt(rangeMatch[2], 10) };
+        range = { min: parseFloat(rangeMatch[1]), max: parseFloat(rangeMatch[2]) };
         values = [];
       } else {
         values = [];
@@ -116,7 +152,8 @@ function parseActionsTable(table: MdTable): ActionOutputDef[] {
 function parseRulesTable(
   table: MdTable,
   conditionNames: Set<string>,
-  actionNames: Set<string>
+  actionNames: Set<string>,
+  conditionDefs?: ConditionDef[]
 ): { rules: Rule[]; warnings: string[] } {
   const warnings: string[] = [];
   const rules: Rule[] = [];
@@ -167,7 +204,8 @@ function parseRulesTable(
           rule.number = num;
         }
       } else if (col.type === 'condition') {
-        const cellValue = parseCellValue(cell);
+        const condDef = conditionDefs?.find(c => c.name === col.name);
+        const cellValue = parseCellValue(cell, condDef?.type);
         rule.conditions.set(col.name, cellValue);
       } else if (col.type === 'action') {
         const value = cell?.trim() || '';
@@ -254,7 +292,7 @@ export function parseDecisionTable(elements: MdElement[]): { decisionTable: Deci
       } else if (currentSection === 'actions') {
         actions = parseActionsTable(el);
       } else if (currentSection === 'rules') {
-        const result = parseRulesTable(el, new Set(conditions.map(c => c.name)), new Set(actions.map(a => a.name)));
+        const result = parseRulesTable(el, new Set(conditions.map(c => c.name)), new Set(actions.map(a => a.name)), conditions);
         rules = result.rules;
         warnings.push(...result.warnings);
       }