@@ -547,6 +547,13 @@ function detectAliases3(dae: ModelicaDAE, variables: Fmi3Variable[]): Map<string
 interface DepEntry3 {
   vr: number;
   kind: "dependent" | "constant" | "fixed" | "tunable";
+  /**
+   * Optional per-element dependencies for FMI 3.0 arrays.
+   * Maps each 1-based element index of the *unknown* to the 1-based
+   * element indices of the *dependency* that it depends on.
+   * If absent, the dependency is dense (all elements depend on all elements).
+   */
+  elementDeps?: Map<number, number[]>;
 }
 
 /** Map variable variability to FMI dependency kind. */
@@ -589,21 +596,93 @@ function computeDependencies3(
   for (const ref of allUnknownRefs) {
     const sv = variables.find((v) => v.valueReference === ref);
     if (!sv) continue;
-    const rhsNames = equationDeps.get(sv.name);
-    if (!rhsNames) continue;
-
-    const entries: DepEntry3[] = [];
-    for (const name of rhsNames) {
-      const depSv = svByName.get(name);
-      if (depSv && depSv.valueReference !== ref) {
-        entries.push({ vr: depSv.valueReference, kind: variabilityToDepKind(depSv.variability) });
+
+    // Check if this is an array variable — if so, build element-level deps
+    const isArray = sv.dimensions && sv.dimensions.length > 0;
+    let totalSize = 1;
+    if (isArray && sv.dimensions) {
+      for (const dim of sv.dimensions) {
+        if (dim.start !== undefined) totalSize *= dim.start;
       }
     }
-    if (entries.length > 0) {
-      deps.set(
-        ref,
-        entries.sort((a, b) => a.vr - b.vr),
-      );
+
+    if (isArray && totalSize > 1) {
+      // Build element-level deps from scalar equations matching baseName[i]
+      const elementEntries = new Map<number, Map<number, Set<number>>>();
+      for (let ei = 1; ei <= totalSize; ei++) {
+        const scalarName = `${sv.name}[${ei}]`;
+        const rhsNames = equationDeps.get(scalarName);
+        if (!rhsNames) continue;
+        for (const name of rhsNames) {
+          const depMatch = SUBSCRIPT_RE.exec(name);
+          if (depMatch && depMatch[1] && depMatch[2]) {
+            const depBase = depMatch[1];
+            const depIdx = parseInt(depMatch[2], 10);
+            const depSv = svByName.get(depBase);
+            if (depSv && depSv.valueReference !== ref) {
+              if (!elementEntries.has(depSv.valueReference)) {
+                elementEntries.set(depSv.valueReference, new Map());
+              }
+              const vrMap = elementEntries.get(depSv.valueReference);
+              if (vrMap) {
+                if (!vrMap.has(ei)) vrMap.set(ei, new Set());
+                const eiSet = vrMap.get(ei);
+                if (eiSet) eiSet.add(depIdx);
+              }
+            }
+          } else {
+            // Non-subscripted dep — falls on the root
+            const depSv = svByName.get(name);
+            if (depSv && depSv.valueReference !== ref) {
+              if (!elementEntries.has(depSv.valueReference)) {
+                elementEntries.set(depSv.valueReference, new Map());
+              }
+            }
+          }
+        }
+      }
+
+      const entries: DepEntry3[] = [];
+      for (const [depVr, elemMap] of elementEntries) {
+        const depSv = variables.find((v) => v.valueReference === depVr);
+        if (!depSv) continue;
+        const entry: DepEntry3 = { vr: depVr, kind: variabilityToDepKind(depSv.variability) };
+        if (elemMap.size > 0) {
+          const eDeps = new Map<number, number[]>();
+          for (const [ei, idxSet] of elemMap) {
+            eDeps.set(
+              ei,
+              Array.from(idxSet).sort((a, b) => a - b),
+            );
+          }
+          entry.elementDeps = eDeps;
+        }
+        entries.push(entry);
+      }
+      if (entries.length > 0) {
+        deps.set(
+          ref,
+          entries.sort((a, b) => a.vr - b.vr),
+        );
+      }
+    } else {
+      // Scalar variable — use the existing root-level dep tracking
+      const rhsNames = equationDeps.get(sv.name);
+      if (!rhsNames) continue;
+
+      const entries: DepEntry3[] = [];
+      for (const name of rhsNames) {
+        const depSv = svByName.get(name);
+        if (depSv && depSv.valueReference !== ref) {
+          entries.push({ vr: depSv.valueReference, kind: variabilityToDepKind(depSv.variability) });
+        }
+      }
+      if (entries.length > 0) {
+        deps.set(
+          ref,
+          entries.sort((a, b) => a.vr - b.vr),
+        );
+      }
     }
   }
 
@@ -789,7 +868,8 @@ function isValidFmi3Type(s: string): s is Fmi3Type {
 function mapCausality3(v: ModelicaVariable): Fmi3Causality {
   // FMI 3.0 structural parameter: controls array dimensions at init time
   if (v.variability === ModelicaVariability.PARAMETER) {
-    if (v.attributes.has("__fmi3_structuralParameter")) return "structuralParameter";
+    if (v.attributes.has("__fmi3_structuralParameter") || v.attributes.has("__modelscript_mutableDimension"))
+      return "structuralParameter";
     return "parameter";
   }
   if (v.variability === ModelicaVariability.CONSTANT) return "calculatedParameter";
@@ -799,6 +879,8 @@ function mapCausality3(v: ModelicaVariable): Fmi3Causality {
 }
 
 function mapVariability3(v: ModelicaVariable): Fmi3Variability {
+  // Mutable dimensions get tunable variability (can be resized at runtime)
+  if (v.attributes.has("__modelscript_mutableDimension")) return "tunable";
   switch (v.variability) {
     case ModelicaVariability.CONSTANT:
       return "constant";
@@ -1053,7 +1135,56 @@ function formatUnknown3(elementName: string, ref: number, deps: Map<number, DepE
   }
   const depsAttr = ` dependencies="${entries.map((e) => e.vr).join(" ")}"`;
   const kindsAttr = ` dependenciesKind="${entries.map((e) => e.kind).join(" ")}"`;
-  return `    <${elementName} valueReference="${ref}"${depsAttr}${kindsAttr} />`;
+
+  // Check if any entry has element-level dependencies
+  const hasElementDeps = entries.some((e) => e.elementDeps && e.elementDeps.size > 0);
+  if (!hasElementDeps) {
+    return `    <${elementName} valueReference="${ref}"${depsAttr}${kindsAttr} />`;
+  }
+
+  // Emit element-level dependencies as nested XML
+  const lines: string[] = [];
+  lines.push(`    <${elementName} valueReference="${ref}"${depsAttr}${kindsAttr}>`);
+  for (const e of entries) {
+    if (e.elementDeps && e.elementDeps.size > 0) {
+      for (const [unknownIdx, depIndices] of e.elementDeps) {
+        lines.push(`      <!-- element ${unknownIdx} depends on ${e.vr}[${depIndices.join(",")}] -->`);
+      }
+    }
+  }
+  lines.push(`    </${elementName}>`);
+  return lines.join("\n");
+}
+
+// ── Standalone terminalsAndIcons.xml Generation (FMI 3.0 §2.4.9) ──
+
+/**
+ * Generate a standalone `terminalsAndIcons.xml` file for the FMU archive.
+ * This re-exports the same terminal data that is embedded in modelDescription.xml
+ * as a separate file in `terminalsAndIcons/`, as required by graphical FMI tools.
+ */
+export function generateTerminalsAndIconsXml(terminals: Fmi3Terminal[]): string | null {
+  if (terminals.length === 0) return null;
+
+  const lines: string[] = [];
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push('<fmiTerminalsAndIcons fmiVersion="3.0">');
+  lines.push("  <Terminals>");
+  for (const term of terminals) {
+    const kindAttr = term.terminalKind ? ` terminalKind="${escapeXml(term.terminalKind)}"` : "";
+    const descAttr = term.description ? ` description="${escapeXml(term.description)}"` : "";
+    lines.push(`    <Terminal name="${escapeXml(term.name)}"${kindAttr}${descAttr}>`);
+    for (const mv of term.memberVariables) {
+      lines.push(
+        `      <TerminalMemberVariable variableName="${escapeXml(mv.variableName)}" memberName="${escapeXml(mv.memberName)}" variableKind="signal" />`,
+      );
+    }
+    lines.push("    </Terminal>");
+  }
+  lines.push("  </Terminals>");
+  lines.push("  <!-- GraphicalRepresentation is omitted; no SVG icon data available. -->");
+  lines.push("</fmiTerminalsAndIcons>");
+  return lines.join("\n");
 }
 
 // ── Utility functions ──
 
@@ -467,6 +467,11 @@ function generateFmi2FunctionsC(
   lines.push("#include <stdlib.h>");
   lines.push("#include <string.h>");
   lines.push("#include <stdio.h>");
+  lines.push("#ifdef _WIN32");
+  lines.push("  #include <windows.h>");
+  lines.push("#else");
+  lines.push("  #include <pthread.h>");
+  lines.push("#endif");
   lines.push("");
   lines.push("typedef struct {");
   lines.push(`  ${id}_Instance model;`);
@@ -476,6 +481,19 @@ function generateFmi2FunctionsC(
   lines.push("  double startTime;");
   lines.push("  double stopTime;");
   lines.push("  double stepSize;");
+  lines.push("  /* Async co-simulation fields */");
+  lines.push("  int asyncMode;          /* 0 = synchronous, 1 = asynchronous */");
+  lines.push("  volatile int asyncDone; /* 0 = running, 1 = done */");
+  lines.push("  volatile int cancelRequested;");
+  lines.push("  fmi2Status asyncResult;");
+  lines.push("  double asyncCurrentT;");
+  lines.push("  double asyncTEnd;");
+  lines.push("#ifdef _WIN32");
+  lines.push("  HANDLE stepThread;");
+  lines.push("#else");
+  lines.push("  pthread_t stepThread;");
+  lines.push("  int stepThreadActive;");
+  lines.push("#endif");
   lines.push("} FMUInstance;");
   lines.push("");
 
@@ -635,81 +653,91 @@ function generateFmi2FunctionsC(
   lines.push("}");
   lines.push("");
 
-  // ── Co-Simulation: fmi2DoStep ──
-  lines.push("/* --- Co-Simulation --- */");
-  lines.push("fmi2Status fmi2DoStep(fmi2Component c, fmi2Real currentCommunicationPoint,");
-  lines.push("    fmi2Real communicationStepSize, fmi2Boolean noSetFMUStatePriorToCurrentPoint) {");
-  lines.push("  (void)noSetFMUStatePriorToCurrentPoint;");
-  lines.push("  FMUInstance* inst = (FMUInstance*)c;");
-  lines.push("  double t = currentCommunicationPoint;");
-  lines.push("  double tEnd = t + communicationStepSize;");
+  // ── Static worker function for async co-simulation ──
+  lines.push("/* --- Async Co-Simulation worker --- */");
+  lines.push("static void doStep_sync(FMUInstance* inst) {");
+  lines.push("  double t = inst->asyncCurrentT;");
+  lines.push("  double tEnd = inst->asyncTEnd;");
   lines.push("  double h = inst->stepSize;");
   lines.push("  if (h <= 0) h = 0.001;");
   lines.push("");
-  lines.push("  /* Fixed-step RK4 integration */");
-  lines.push("  while (t < tEnd - 1e-15) {");
+  lines.push("  while (t < tEnd - 1e-15 && !inst->cancelRequested) {");
   lines.push("    if (t + h > tEnd) h = tEnd - t;");
   lines.push("    double states[N_STATES + 1];");
   lines.push("    double k1[N_STATES + 1], k2[N_STATES + 1], k3[N_STATES + 1], k4[N_STATES + 1];");
   lines.push("");
-
   // Save states
   for (let i = 0; i < stateRefs2.length; i++) {
     lines.push(`    states[${i}] = inst->model.vars[${stateRefs2[i]}];`);
   }
-  lines.push("");
-
   // k1
-  lines.push("    inst->model.time = t;");
-  lines.push(`    ${id}_getDerivatives(&inst->model);`);
+  lines.push(`    inst->model.time = t; ${id}_getDerivatives(&inst->model);`);
   lines.push("    for (int i = 0; i < N_STATES; i++) k1[i] = inst->model.derivatives[i];");
-  lines.push("");
-
   // k2
   lines.push("    inst->model.time = t + 0.5 * h;");
   for (let i = 0; i < stateRefs2.length; i++) {
     lines.push(`    inst->model.vars[${stateRefs2[i]}] = states[${i}] + 0.5 * h * k1[${i}];`);
   }
   lines.push(`    ${id}_getDerivatives(&inst->model);`);
   lines.push("    for (int i = 0; i < N_STATES; i++) k2[i] = inst->model.derivatives[i];");
-  lines.push("");
-
   // k3
   for (let i = 0; i < stateRefs2.length; i++) {
     lines.push(`    inst->model.vars[${stateRefs2[i]}] = states[${i}] + 0.5 * h * k2[${i}];`);
   }
   lines.push(`    ${id}_getDerivatives(&inst->model);`);
   lines.push("    for (int i = 0; i < N_STATES; i++) k3[i] = inst->model.derivatives[i];");
-  lines.push("");
-
   // k4
   lines.push("    inst->model.time = t + h;");
   for (let i = 0; i < stateRefs2.length; i++) {
     lines.push(`    inst->model.vars[${stateRefs2[i]}] = states[${i}] + h * k3[${i}];`);
   }
   lines.push(`    ${id}_getDerivatives(&inst->model);`);
   lines.push("    for (int i = 0; i < N_STATES; i++) k4[i] = inst->model.derivatives[i];");
-  lines.push("");
-
   // Update
   for (let i = 0; i < stateRefs2.length; i++) {
     lines.push(
       `    inst->model.vars[${stateRefs2[i]}] = states[${i}] + (h / 6.0) * (k1[${i}] + 2.0*k2[${i}] + 2.0*k3[${i}] + k4[${i}]);`,
     );
   }
   lines.push("    t += h;");
+  lines.push("  }");
+  lines.push("  inst->model.time = tEnd;");
+  lines.push("  inst->asyncResult = inst->cancelRequested ? fmi2Error : fmi2OK;");
+  lines.push("  inst->asyncDone = 1;");
+  lines.push("}");
+  lines.push("");
+  lines.push("#ifndef _WIN32");
+  lines.push("static void* doStep_thread(void* arg) { doStep_sync((FMUInstance*)arg); return NULL; }");
+  lines.push("#else");
+  lines.push("static DWORD WINAPI doStep_thread(LPVOID arg) { doStep_sync((FMUInstance*)arg); return 0; }");
+  lines.push("#endif");
   lines.push("");
 
-  // After each step, check for events and process them
-  lines.push("    /* Event detection after integration step */");
-  lines.push("    if (N_EVENT_INDICATORS > 0) {");
-  lines.push("      fmi2EventInfo info;");
-  lines.push("      fmi2NewDiscreteStates((fmi2Component)inst, &info);");
+  // ── Co-Simulation: fmi2DoStep ──
+  lines.push("/* --- Co-Simulation --- */");
+  lines.push("fmi2Status fmi2DoStep(fmi2Component c, fmi2Real currentCommunicationPoint,");
+  lines.push("    fmi2Real communicationStepSize, fmi2Boolean noSetFMUStatePriorToCurrentPoint) {");
+  lines.push("  (void)noSetFMUStatePriorToCurrentPoint;");
+  lines.push("  FMUInstance* inst = (FMUInstance*)c;");
+  lines.push("  inst->asyncCurrentT = currentCommunicationPoint;");
+  lines.push("  inst->asyncTEnd = currentCommunicationPoint + communicationStepSize;");
+  lines.push("  inst->asyncDone = 0;");
+  lines.push("  inst->cancelRequested = 0;");
+  lines.push("  if (inst->asyncMode) {");
+  lines.push("#ifdef _WIN32");
+  lines.push("    inst->stepThread = CreateThread(NULL, 0, doStep_thread, inst, 0, NULL);");
+  lines.push("    return inst->stepThread ? fmi2Pending : fmi2Error;");
+  lines.push("#else");
+  lines.push("    if (pthread_create(&inst->stepThread, NULL, doStep_thread, inst) == 0) {");
+  lines.push("      inst->stepThreadActive = 1;");
+  lines.push("      return fmi2Pending;");
   lines.push("    }");
-
+  lines.push("    return fmi2Error;");
+  lines.push("#endif");
   lines.push("  }");
-  lines.push("  inst->model.time = tEnd;");
-  lines.push("  return fmi2OK;");
+  lines.push("  /* Synchronous fallback */");
+  lines.push("  doStep_sync(inst);");
+  lines.push("  return inst->asyncResult;");
   lines.push("}");
   lines.push("");
 
@@ -887,10 +915,34 @@ function generateFmi2FunctionsC(
   lines.push("}");
   lines.push("fmi2Status fmi2EnterContinuousTimeMode(fmi2Component c) { (void)c; return fmi2OK; }");
   lines.push("fmi2Status fmi2EnterEventMode(fmi2Component c) { (void)c; return fmi2OK; }");
-  lines.push("fmi2Status fmi2CancelStep(fmi2Component c) { (void)c; return fmi2OK; }");
-  lines.push(
-    "fmi2Status fmi2GetStatus(fmi2Component c, const fmi2StatusKind s, fmi2Status* value) { (void)c; (void)s; *value = fmi2OK; return fmi2OK; }",
-  );
+  lines.push("fmi2Status fmi2CancelStep(fmi2Component c) {");
+  lines.push("  FMUInstance* inst = (FMUInstance*)c;");
+  lines.push("  if (!inst->asyncMode || inst->asyncDone) return fmi2OK;");
+  lines.push("  inst->cancelRequested = 1;");
+  lines.push("#ifdef _WIN32");
+  lines.push("  WaitForSingleObject(inst->stepThread, INFINITE);");
+  lines.push("  CloseHandle(inst->stepThread);");
+  lines.push("#else");
+  lines.push("  if (inst->stepThreadActive) { pthread_join(inst->stepThread, NULL); inst->stepThreadActive = 0; }");
+  lines.push("#endif");
+  lines.push("  return fmi2OK;");
+  lines.push("}");
+  lines.push("fmi2Status fmi2GetStatus(fmi2Component c, const fmi2StatusKind s, fmi2Status* value) {");
+  lines.push("  FMUInstance* inst = (FMUInstance*)c;");
+  lines.push("  if (s == fmi2DoStepStatus) {");
+  lines.push("    if (inst->asyncDone) {");
+  lines.push("#ifndef _WIN32");
+  lines.push("      if (inst->stepThreadActive) { pthread_join(inst->stepThread, NULL); inst->stepThreadActive = 0; }");
+  lines.push("#endif");
+  lines.push("      *value = inst->asyncResult;");
+  lines.push("    } else {");
+  lines.push("      *value = fmi2Pending;");
+  lines.push("    }");
+  lines.push("  } else {");
+  lines.push("    *value = fmi2OK;");
+  lines.push("  }");
+  lines.push("  return fmi2OK;");
+  lines.push("}");
   lines.push(
     "fmi2Status fmi2GetRealStatus(fmi2Component c, const fmi2StatusKind s, fmi2Real* value) { (void)c; (void)s; *value = 0.0; return fmi2OK; }",
   );