@@ -20,6 +20,7 @@ import {
   ModelicaBooleanLiteral,
   ModelicaFunctionCallExpression,
   ModelicaIfElseExpression,
+  ModelicaInitialStateEquation,
   ModelicaIntegerLiteral,
   ModelicaNameExpression,
   ModelicaRealLiteral,
@@ -72,6 +73,9 @@ export function generateFmuCSources(dae: ModelicaDAE, fmuResult: FmuResult, opti
 // ── Expression → C transpiler ──
 
 /** Convert a DAE expression to a C expression string. */
+/** Counter for deterministic delay buffer indexing across exprToC calls. */
+let delayBufferCounter = 0;
+
 function exprToC(expr: ModelicaExpression): string {
   if (expr instanceof ModelicaRealLiteral) {
     return formatCDouble(expr.value);
@@ -100,6 +104,14 @@ function exprToC(expr: ModelicaExpression): string {
     return `(${lhs} ${op} ${rhs})`;
   }
   if (expr instanceof ModelicaFunctionCallExpression) {
+    // Special handling for delay() — generate ring-buffer interpolation lookup
+    if (expr.functionName === "delay" && expr.args.length >= 2) {
+      const delayExpr = exprToC(expr.args[0] as ModelicaExpression);
+      const delayTime = exprToC(expr.args[1] as ModelicaExpression);
+      // Use a deterministic buffer index based on expression hash
+      const bufIdx = delayBufferCounter++;
+      return `delay_lookup(&m->delayBuf[${bufIdx}], m->time - (${delayTime}), ${delayExpr})`;
+    }
     const args = expr.args.map((a: ModelicaExpression) => exprToC(a)).join(", ");
     const fname = mapFunctionName(expr.functionName);
     return `${fname}(${args})`;
@@ -508,12 +520,80 @@ function generateAlgebraicLoopSolvers(id: string, dae: ModelicaDAE, result: FmuR
 }
 
 function generateModelC(id: string, dae: ModelicaDAE, result: FmuResult): string {
+  // Reset delay buffer counter for this codegen invocation
+  delayBufferCounter = 0;
+
   const lines: string[] = [];
   lines.push("/* Auto-generated by ModelScript — do not edit */");
   lines.push(`#include "${id}_model.h"`);
   lines.push("#include <stdio.h>");
   lines.push("");
 
+  // Count delay() calls to determine if delay helpers are needed
+  let hasDelays = false;
+  const checkDelays = (expr: ModelicaExpression): void => {
+    if (expr instanceof ModelicaFunctionCallExpression && expr.functionName === "delay") {
+      hasDelays = true;
+      return;
+    }
+    if (expr instanceof ModelicaFunctionCallExpression) {
+      for (const arg of expr.args) checkDelays(arg);
+    }
+    if ("expression1" in expr && expr.expression1) checkDelays(expr.expression1 as ModelicaExpression);
+    if ("expression2" in expr && expr.expression2) checkDelays(expr.expression2 as ModelicaExpression);
+  };
+  for (const eq of dae.equations) {
+    if (eq instanceof ModelicaSimpleEquation) {
+      checkDelays(eq.expression1);
+      checkDelays(eq.expression2);
+    }
+  }
+
+  if (hasDelays) {
+    lines.push("/* --- Delay ring-buffer helpers --- */");
+    lines.push("#define DELAY_BUF_SIZE 1024");
+    lines.push("");
+    lines.push("typedef struct {");
+    lines.push("  double times[DELAY_BUF_SIZE];");
+    lines.push("  double values[DELAY_BUF_SIZE];");
+    lines.push("  int head;");
+    lines.push("  int count;");
+    lines.push("} DelayBuffer;");
+    lines.push("");
+    lines.push("static void delay_record(DelayBuffer* buf, double t, double value) {");
+    lines.push("  buf->times[buf->head] = t;");
+    lines.push("  buf->values[buf->head] = value;");
+    lines.push("  buf->head = (buf->head + 1) % DELAY_BUF_SIZE;");
+    lines.push("  if (buf->count < DELAY_BUF_SIZE) buf->count++;");
+    lines.push("}");
+    lines.push("");
+    lines.push("static double delay_lookup(DelayBuffer* buf, double tLookup, double currentValue) {");
+    lines.push("  if (buf->count == 0) return currentValue;");
+    lines.push("  /* Find the two nearest entries bracketing tLookup and linearly interpolate */");
+    lines.push("  int start = (buf->head - buf->count + DELAY_BUF_SIZE) % DELAY_BUF_SIZE;");
+    lines.push("  int n = buf->count;");
+    lines.push("  /* If tLookup is before the earliest recorded time, return earliest value */");
+    lines.push("  double t0 = buf->times[start];");
+    lines.push("  if (tLookup <= t0) return buf->values[start];");
+    lines.push("  /* Linear search for bracketing interval */");
+    lines.push("  for (int k = 0; k < n - 1; k++) {");
+    lines.push("    int i0 = (start + k) % DELAY_BUF_SIZE;");
+    lines.push("    int i1 = (start + k + 1) % DELAY_BUF_SIZE;");
+    lines.push("    double ta = buf->times[i0];");
+    lines.push("    double tb = buf->times[i1];");
+    lines.push("    if (tLookup >= ta && tLookup <= tb) {");
+    lines.push("      if (tb == ta) return buf->values[i0];");
+    lines.push("      double alpha = (tLookup - ta) / (tb - ta);");
+    lines.push("      return buf->values[i0] * (1.0 - alpha) + buf->values[i1] * alpha;");
+    lines.push("    }");
+    lines.push("  }");
+    lines.push("  /* tLookup is after all recorded times — return latest */");
+    lines.push("  int last = (buf->head - 1 + DELAY_BUF_SIZE) % DELAY_BUF_SIZE;");
+    lines.push("  return buf->values[last];");
+    lines.push("}");
+    lines.push("");
+  }
+
   // Build value-reference → C accessor mappings
   const vrMap = new Map<string, number>();
   for (const sv of result.scalarVariables) {
@@ -595,6 +675,36 @@ function generateModelC(id: string, dae: ModelicaDAE, result: FmuResult): string
       derIdx++;
     }
   }
+  if (hasDelays) {
+    // Record current values of delay() expressions into ring buffers
+    lines.push("");
+    lines.push("  /* Record delay buffer entries */");
+    let delayIdx = 0;
+    const collectDelayExprs = (expr: ModelicaExpression, records: string[]): void => {
+      if (expr instanceof ModelicaFunctionCallExpression && expr.functionName === "delay" && expr.args.length >= 2) {
+        const delayExprC = exprToC(expr.args[0] as ModelicaExpression);
+        records.push(`  delay_record(&inst->delayBuf[${delayIdx}], inst->time, ${delayExprC});`);
+        delayIdx++;
+        return;
+      }
+      if (expr instanceof ModelicaFunctionCallExpression) {
+        for (const arg of expr.args) collectDelayExprs(arg, records);
+      }
+      if ("expression1" in expr && expr.expression1) collectDelayExprs(expr.expression1 as ModelicaExpression, records);
+      if ("expression2" in expr && expr.expression2) collectDelayExprs(expr.expression2 as ModelicaExpression, records);
+    };
+    const recordLines: string[] = [];
+    for (const eq of dae.equations) {
+      if (eq instanceof ModelicaSimpleEquation) {
+        collectDelayExprs(eq.expression1, recordLines);
+        collectDelayExprs(eq.expression2, recordLines);
+      }
+    }
+    for (const rl of recordLines) {
+      lines.push(rl);
+    }
+  }
+
   lines.push("}");
   lines.push("");
 
@@ -924,21 +1034,57 @@ function generateFmi2FunctionsC(
       );
       transitions.sort((a, b) => a.priority - b.priority);
 
+      // Find initial state
+      const initialStateEq = sm.equations.find(
+        (eq): eq is ModelicaInitialStateEquation => eq instanceof ModelicaInitialStateEquation,
+      );
+      const initialIdx = initialStateEq ? stateNames.indexOf(initialStateEq.stateName) : 0;
+
       if (transitions.length > 0) {
-        lines.push(`  /* SM ${si}: ${sm.name} */`);
-        let first = true;
+        lines.push(`  /* SM ${si}: ${sm.name} (initial state: ${stateNames[initialIdx] ?? "?"}) */`);
+        lines.push(`  {`);
+        lines.push(`    int prevState_${si} = inst->activeState_${si};`);
+
         for (const tr of transitions) {
           const fromIdx = stateNames.indexOf(tr.fromState);
           const toIdx = stateNames.indexOf(tr.toState);
           if (fromIdx < 0 || toIdx < 0) continue;
-          const prefix = first ? "if" : "else if";
-          first = false;
-          lines.push(
-            `  ${prefix} (inst->activeState_${si} == ${fromIdx}) { /* ${tr.fromState} -> ${tr.toState}, priority ${tr.priority} */`,
-          );
-          lines.push(`    /* TODO: evaluate condition and set inst->activeState_${si} = ${toIdx}; */`);
-          lines.push("  }");
+          const condC = exprToC(tr.condition);
+          if (tr.immediate) {
+            // Immediate transition: fires in the same step the condition becomes true
+            lines.push(
+              `    if (inst->activeState_${si} == ${fromIdx} && (${condC})) { /* ${tr.fromState} -> ${tr.toState} */`,
+            );
+          } else {
+            // Delayed transition: fires at the next step after the condition becomes true
+            lines.push(
+              `    if (prevState_${si} == ${fromIdx} && (${condC})) { /* ${tr.fromState} -> ${tr.toState} (delayed) */`,
+            );
+          }
+          lines.push(`      inst->activeState_${si} = ${toIdx};`);
+
+          // Reset semantics: re-initialize target state's variables to start values
+          if (tr.reset) {
+            const targetState = sm.states[toIdx];
+            if (targetState) {
+              for (const v of targetState.variables) {
+                const sv = result.scalarVariables.find((s) => s.name === v.name);
+                if (sv) {
+                  const startAttr = v.attributes.get("start");
+                  const startExpr = startAttr ?? v.expression;
+                  if (startExpr) {
+                    lines.push(
+                      `      inst->model.vars[${sv.valueReference}] = ${exprToC(startExpr)};  /* reset ${v.name} */`,
+                    );
+                  }
+                }
+              }
+            }
+          }
+
+          lines.push("    }");
         }
+        lines.push("  }");
       }
     }
     lines.push("");