@@ -295,14 +295,34 @@ function detectAliases(dae: ModelicaDAE, scalarVariables: FmiScalarVariable[]):
  * Compute variable dependency graph for ModelStructure.
  * For each output/derivative/initial-unknown, find which inputs/states it depends on.
  */
+/** A single entry in the enriched FMI 2.0 dependency graph. */
+interface DepEntry2 {
+  vr: number;
+  kind: "dependent" | "constant" | "fixed" | "tunable";
+}
+
+/** Map FMI 2.0 variability to dependency kind. */
+function variabilityToDepKind2(v: FmiVariability): DepEntry2["kind"] {
+  switch (v) {
+    case "constant":
+      return "constant";
+    case "fixed":
+      return "fixed";
+    case "tunable":
+      return "tunable";
+    default:
+      return "dependent";
+  }
+}
+
 function computeDependencies(
   dae: ModelicaDAE,
   scalarVariables: FmiScalarVariable[],
   outputRefs: number[],
   derivativeRefs: number[],
   initialUnknownRefs: number[],
-): Map<number, number[]> {
-  const deps = new Map<number, number[]>();
+): Map<number, DepEntry2[]> {
+  const deps = new Map<number, DepEntry2[]>();
   const svByName = new Map<string, FmiScalarVariable>();
   for (const sv of scalarVariables) svByName.set(sv.name, sv);
 
@@ -326,18 +346,18 @@ function computeDependencies(
     const rhsNames = equationDeps.get(sv.name);
     if (!rhsNames) continue;
 
-    // Map referenced names to their value references
-    const depRefs: number[] = [];
+    // Map referenced names to their value references with enriched kinds
+    const entries: DepEntry2[] = [];
     for (const name of rhsNames) {
       const depSv = svByName.get(name);
       if (depSv && depSv.valueReference !== ref) {
-        depRefs.push(depSv.valueReference);
+        entries.push({ vr: depSv.valueReference, kind: variabilityToDepKind2(depSv.variability) });
       }
     }
-    if (depRefs.length > 0) {
+    if (entries.length > 0) {
       deps.set(
         ref,
-        depRefs.sort((a, b) => a - b),
+        entries.sort((a, b) => a.vr - b.vr),
       );
     }
   }
@@ -506,7 +526,7 @@ function generateModelDescriptionXml(
     initialUnknownRefs: number[];
     fmuType: FmuTypeFlags;
     nEventIndicators: number;
-    deps: Map<number, number[]>;
+    deps: Map<number, DepEntry2[]>;
     aliasMap: Map<string, string>;
     enumTypes: Map<string, { name: string; description: string | null }[]>;
   },
@@ -654,16 +674,18 @@ function generateModelDescriptionXml(
 function formatUnknown(
   index: number,
   ref: number,
-  deps: Map<number, number[]>,
+  deps: Map<number, DepEntry2[]>,
   variables: FmiScalarVariable[],
 ): string {
-  const depRefs = deps.get(ref);
-  if (!depRefs || depRefs.length === 0) {
+  const entries = deps.get(ref);
+  if (!entries || entries.length === 0) {
     return `      <Unknown index="${index}" />`;
   }
   // Convert VRs to 1-based indices
-  const depIndices = depRefs.map((vr) => variables.findIndex((v) => v.valueReference === vr) + 1).filter((i) => i > 0);
-  const depsAttr = ` dependencies="${depIndices.join(" ")}"`;
-  const kindsAttr = ` dependenciesKind="${depIndices.map(() => "dependent").join(" ")}"`;
+  const depItems = entries
+    .map((e) => ({ idx: variables.findIndex((v) => v.valueReference === e.vr) + 1, kind: e.kind }))
+    .filter((d) => d.idx > 0);
+  const depsAttr = ` dependencies="${depItems.map((d) => d.idx).join(" ")}"`;
+  const kindsAttr = ` dependenciesKind="${depItems.map((d) => d.kind).join(" ")}"`;
   return `      <Unknown index="${index}"${depsAttr}${kindsAttr} />`;
 }
@@ -543,14 +543,34 @@ function detectAliases3(dae: ModelicaDAE, variables: Fmi3Variable[]): Map<string
   return aliasMap;
 }
 
+/** A single entry in the enriched dependency graph. */
+interface DepEntry3 {
+  vr: number;
+  kind: "dependent" | "constant" | "fixed" | "tunable";
+}
+
+/** Map variable variability to FMI dependency kind. */
+function variabilityToDepKind(v: Fmi3Variability): DepEntry3["kind"] {
+  switch (v) {
+    case "constant":
+      return "constant";
+    case "fixed":
+      return "fixed";
+    case "tunable":
+      return "tunable";
+    default:
+      return "dependent";
+  }
+}
+
 function computeDependencies3(
   dae: ModelicaDAE,
   variables: Fmi3Variable[],
   outputRefs: number[],
   derivativeRefs: number[],
   initialUnknownRefs: number[],
-): Map<number, number[]> {
-  const deps = new Map<number, number[]>();
+): Map<number, DepEntry3[]> {
+  const deps = new Map<number, DepEntry3[]>();
   const svByName = new Map<string, Fmi3Variable>();
   for (const sv of variables) svByName.set(sv.name, sv);
 
@@ -572,17 +592,17 @@ function computeDependencies3(
     const rhsNames = equationDeps.get(sv.name);
     if (!rhsNames) continue;
 
-    const depRefs: number[] = [];
+    const entries: DepEntry3[] = [];
     for (const name of rhsNames) {
       const depSv = svByName.get(name);
       if (depSv && depSv.valueReference !== ref) {
-        depRefs.push(depSv.valueReference);
+        entries.push({ vr: depSv.valueReference, kind: variabilityToDepKind(depSv.variability) });
       }
     }
-    if (depRefs.length > 0) {
+    if (entries.length > 0) {
       deps.set(
         ref,
-        depRefs.sort((a, b) => a - b),
+        entries.sort((a, b) => a.vr - b.vr),
       );
     }
   }
@@ -816,7 +836,7 @@ function generateModelDescriptionXml3(
     clockRefs: number[];
     fmuType: Fmi3TypeFlags;
     nEventIndicators: number;
-    deps: Map<number, number[]>;
+    deps: Map<number, DepEntry3[]>;
     aliasMap: Map<string, string>;
     enumTypes: Map<string, { name: string; description: string | null }[]>;
     terminals: Fmi3Terminal[];
@@ -1026,13 +1046,13 @@ function generateModelDescriptionXml3(
 }
 
 /** Format an Unknown/Output/ContinuousStateDerivative element. */
-function formatUnknown3(elementName: string, ref: number, deps: Map<number, number[]>): string {
-  const depRefs = deps.get(ref);
-  if (!depRefs || depRefs.length === 0) {
+function formatUnknown3(elementName: string, ref: number, deps: Map<number, DepEntry3[]>): string {
+  const entries = deps.get(ref);
+  if (!entries || entries.length === 0) {
     return `    <${elementName} valueReference="${ref}" />`;
   }
-  const depsAttr = ` dependencies="${depRefs.join(" ")}"`;
-  const kindsAttr = ` dependenciesKind="${depRefs.map(() => "dependent").join(" ")}"`;
+  const depsAttr = ` dependencies="${entries.map((e) => e.vr).join(" ")}"`;
+  const kindsAttr = ` dependenciesKind="${entries.map((e) => e.kind).join(" ")}"`;
   return `    <${elementName} valueReference="${ref}"${depsAttr}${kindsAttr} />`;
 }
 
 
@@ -95,6 +95,19 @@ export function buildFmuArchive(
     }
   }
 
+  // ── buildDescription.xml (FMI 3.0 §2.5) ──
+  const buildDescLines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<fmiBuildDescription fmiVersion="3.0">',
+    `  <BuildConfiguration modelIdentifier="${id}">`,
+    '    <SourceFileSet language="C">',
+    `      <SourceFile name="${id}_model.c" />`,
+    "    </SourceFileSet>",
+    "  </BuildConfiguration>",
+    "</fmiBuildDescription>",
+  ];
+  files.set("extra/buildDescription.xml", encoder.encode(buildDescLines.join("\n")));
+
   // ── Build ZIP archive ──
   const archive = createZip(files);
 
 
@@ -371,7 +371,14 @@ function generateFmi3FunctionsC(
   L.push("  fmi3Float64 startTime;");
   L.push("  fmi3Float64 stopTime;");
   L.push("  fmi3Float64 stepSize;");
+  L.push("  fmi3Boolean eventModeUsed;");
+  L.push("  fmi3Boolean earlyReturnAllowed;");
+  L.push("  int state; /* 0=INIT, 1=STEP, 2=EVENT, 3=TERMINATED */");
   L.push("} FMU3Instance;");
+  L.push("#define FMU3_STATE_INIT  0");
+  L.push("#define FMU3_STATE_STEP  1");
+  L.push("#define FMU3_STATE_EVENT 2");
+  L.push("#define FMU3_STATE_TERM  3");
   L.push("");
   L.push("/* Variable size lookup table for array batching (FMI 3.0 §2.2.7) */");
   L.push("static const size_t varSizes[N_VARS + 1] = {");
@@ -402,7 +409,6 @@ function generateFmi3FunctionsC(
   L.push("    fmi3InstanceEnvironment instanceEnvironment, fmi3LogMessageCallback logMessage,");
   L.push("    fmi3IntermediateUpdateCallback intermediateUpdate) {");
   L.push("  (void)instantiationToken; (void)resourcePath; (void)visible;");
-  L.push("  (void)eventModeUsed; (void)earlyReturnAllowed;");
   L.push("  (void)requiredIntermediateVariables; (void)nRequiredIntermediateVariables;");
   L.push("  FMU3Instance* inst = (FMU3Instance*)calloc(1, sizeof(FMU3Instance));");
   L.push("  if (!inst) return NULL;");
@@ -412,6 +418,9 @@ function generateFmi3FunctionsC(
   L.push("  inst->instanceEnvironment = instanceEnvironment;");
   L.push("  inst->loggingOn = loggingOn;");
   L.push("  inst->stepSize = 0.001;");
+  L.push("  inst->eventModeUsed = eventModeUsed;");
+  L.push("  inst->earlyReturnAllowed = earlyReturnAllowed;");
+  L.push("  inst->state = FMU3_STATE_INIT;");
   L.push(`  ${id}_initialize(&inst->model);`);
   L.push("  return (fmi3Instance)inst;");
   L.push("}");
@@ -444,10 +453,16 @@ function generateFmi3FunctionsC(
   L.push("  if (stopTimeDefined) inst->stopTime = stopTime;");
   L.push("  return fmi3OK;");
   L.push("}");
-  L.push("fmi3Status fmi3ExitInitializationMode(fmi3Instance instance) { (void)instance; return fmi3OK; }");
-  L.push("fmi3Status fmi3Terminate(fmi3Instance instance) { (void)instance; return fmi3OK; }");
+  L.push(
+    "fmi3Status fmi3ExitInitializationMode(fmi3Instance instance) { ((FMU3Instance*)instance)->state = FMU3_STATE_STEP; return fmi3OK; }",
+  );
+  L.push(
+    "fmi3Status fmi3Terminate(fmi3Instance instance) { ((FMU3Instance*)instance)->state = FMU3_STATE_TERM; return fmi3OK; }",
+  );
   L.push("void fmi3FreeInstance(fmi3Instance instance) { if (instance) free(instance); }");
-  L.push("fmi3Status fmi3Reset(fmi3Instance instance) { (void)instance; return fmi3OK; }");
+  L.push(
+    "fmi3Status fmi3Reset(fmi3Instance instance) { ((FMU3Instance*)instance)->state = FMU3_STATE_INIT; return fmi3OK; }",
+  );
   L.push("");
 
   const numericTypes = ["Float32", "Float64", "Int8", "UInt8", "Int16", "UInt16", "Int32", "UInt32", "Int64", "UInt64"];
@@ -710,6 +725,20 @@ function generateFmi3FunctionsC(
   );
   L.push("      if (canReturnEarly) { *earlyReturn = fmi3True; *lastSuccessfulTime = t; return fmi3OK; }");
   L.push("    }");
+  L.push("    /* FMI 3.0: CS Event Mode — check event indicators for zero crossings */");
+  L.push("    if (inst->eventModeUsed) {");
+  L.push("      double ei[N_EVENT_INDICATORS + 1];");
+  L.push(`      ${id}_getEventIndicators(&inst->model, ei);`);
+  L.push("      for (int k = 0; k < N_EVENT_INDICATORS; k++) {");
+  L.push("        if ((inst->model.eventPrev[k] <= 0 && ei[k] > 0) || (inst->model.eventPrev[k] >= 0 && ei[k] < 0)) {");
+  L.push("          *eventHandlingNeeded = fmi3True;");
+  L.push("          if (inst->earlyReturnAllowed) { *earlyReturn = fmi3True; *lastSuccessfulTime = t; }");
+  L.push("          break;");
+  L.push("        }");
+  L.push("      }");
+  L.push("      for (int k = 0; k < N_EVENT_INDICATORS; k++) inst->model.eventPrev[k] = ei[k];");
+  L.push("      if (*earlyReturn) return fmi3OK;");
+  L.push("    }");
   L.push("  }");
   L.push("  inst->model.time = tEnd; *lastSuccessfulTime = tEnd;");
   L.push("  return fmi3OK;");
@@ -718,9 +747,13 @@ function generateFmi3FunctionsC(
 
   // Remaining stubs
   L.push("/* --- Stubs --- */");
-  L.push("fmi3Status fmi3EnterEventMode(fmi3Instance instance) { (void)instance; return fmi3OK; }");
+  L.push(
+    "fmi3Status fmi3EnterEventMode(fmi3Instance instance) { ((FMU3Instance*)instance)->state = FMU3_STATE_EVENT; return fmi3OK; }",
+  );
   L.push("fmi3Status fmi3EnterContinuousTimeMode(fmi3Instance instance) { (void)instance; return fmi3OK; }");
-  L.push("fmi3Status fmi3EnterStepMode(fmi3Instance instance) { (void)instance; return fmi3OK; }");
+  L.push(
+    "fmi3Status fmi3EnterStepMode(fmi3Instance instance) { ((FMU3Instance*)instance)->state = FMU3_STATE_STEP; return fmi3OK; }",
+  );
   L.push(
     "fmi3Status fmi3CompletedIntegratorStep(fmi3Instance instance, fmi3Boolean noSetFMUStatePriorToCurrentPoint, fmi3Boolean* enterEventMode, fmi3Boolean* terminateSimulation) { (void)instance; (void)noSetFMUStatePriorToCurrentPoint; *enterEventMode = fmi3False; *terminateSimulation = fmi3False; return fmi3OK; }",
   );