@@ -149,6 +149,8 @@ interface FlattenerContext {
   streamConnections?: { side1: string; side2: string }[];
   /** Deferred flow variable connection pairs for connection-set-based flow balance generation. */
   flowConnectPairs?: { name1: string; name2: string }[];
+  /** Monomorphization bindings for higher order functions */
+  functionBindings?: Map<string, ModelicaPartialFunctionExpression | string>;
 }
 
 /** Extract an integer shape array from a list of expressions (all must be ModelicaIntegerLiteral). */
@@ -2926,6 +2928,22 @@ class ModelicaSyntaxFlattener extends ModelicaSyntaxVisitor<ModelicaExpression,
     let functionName =
       node.functionReference?.parts?.map((p) => p.identifier?.text ?? "").join(".") ||
       (node.functionReferenceName ?? "");
+
+    // Monomorphization: Resolve bound function parameters dynamically
+    let boundArgsMap: Map<string, ModelicaExpression> | null = null;
+    if (ctx.functionBindings?.has(functionName)) {
+      const boundItem = ctx.functionBindings.get(functionName);
+      if (typeof boundItem === "string") {
+        functionName = boundItem;
+      } else if (boundItem instanceof ModelicaPartialFunctionExpression) {
+        functionName = boundItem.functionName;
+        boundArgsMap = new Map();
+        for (const namedArg of boundItem.namedArgs) {
+          boundArgsMap.set(namedArg.name, namedArg.value);
+        }
+      }
+    }
+
     let flatArgs: ModelicaExpression[] = [];
     for (const arg of node.functionCallArguments?.arguments ?? []) {
       let flatArg: ModelicaExpression | null;
@@ -2937,6 +2955,39 @@ class ModelicaSyntaxFlattener extends ModelicaSyntaxVisitor<ModelicaExpression,
       if (flatArg) flatArgs.push(flatArg);
     }
 
+    // Merge bound arguments into the flattened arguments array
+    if (boundArgsMap && boundArgsMap.size > 0) {
+      // Resolve the target function to correctly align named bound arguments with positions
+      const resolved = ctx.classInstance.resolveName(functionName.split("."));
+      if (
+        resolved instanceof ModelicaClassInstance &&
+        (resolved.classKind === ModelicaClassKind.FUNCTION ||
+          resolved.classKind === ModelicaClassKind.OPERATOR_FUNCTION)
+      ) {
+        if (!resolved.instantiated) resolved.instantiate();
+        const inputs = Array.from(resolved.components).filter((c) => c.causality?.toString() === "input");
+
+        const mergedArgs: ModelicaExpression[] = [];
+        let positionalIndex = 0;
+        for (const input of inputs) {
+          const inputName = input.name ?? "";
+          const boundValue = boundArgsMap.get(inputName);
+          if (boundValue) {
+            mergedArgs.push(boundValue);
+          } else if (positionalIndex < flatArgs.length) {
+            mergedArgs.push(flatArgs[positionalIndex] as ModelicaExpression);
+            positionalIndex++;
+          }
+        }
+        // Append any remaining arguments
+        while (positionalIndex < flatArgs.length) {
+          mergedArgs.push(flatArgs[positionalIndex] as ModelicaExpression);
+          positionalIndex++;
+        }
+        flatArgs = mergedArgs;
+      }
+    }
+
     // Handle record constructor calls: Complex(re=2.0, im=3.0) or Rec(r = 1.0)
     // Record constructors use the record type name as the function name and may have named arguments.
     {
@@ -3862,8 +3913,73 @@ class ModelicaSyntaxFlattener extends ModelicaSyntaxVisitor<ModelicaExpression,
         }
       }
     }
+    // Specialized Higher-Order Function Execution (Monomorphization)
+    let finalFunctionName = isExternalBuiltinAlias ? functionName : originalName;
+    let finalArgs = flatArgs;
 
-    const result = new ModelicaFunctionCallExpression(isExternalBuiltinAlias ? functionName : originalName, flatArgs);
+    if (!builtinDef) {
+      const fDef =
+        ctx.dae.functions.find((f) => f.name === functionName) ||
+        ctx.rootDae?.functions.find((f) => f.name === functionName);
+      if (fDef) {
+        const inputVars = fDef.variables.filter((v) => v.causality === "input");
+        let hasHigherOrderArg = false;
+        const newBindings = new Map<string, ModelicaPartialFunctionExpression | string>();
+        const filteredArgs: ModelicaExpression[] = [];
+
+        for (let i = 0; i < flatArgs.length && i < inputVars.length; i++) {
+          const inVar = inputVars[i];
+          const argVal = flatArgs[i];
+          if (inVar?.functionType) {
+            hasHigherOrderArg = true;
+            if (argVal instanceof ModelicaPartialFunctionExpression) {
+              newBindings.set(inVar.name, argVal);
+            } else if (argVal instanceof ModelicaNameExpression) {
+              newBindings.set(inVar.name, argVal.name);
+            }
+          } else if (argVal) {
+            filteredArgs.push(argVal);
+          }
+        }
+
+        // Push any remaining defaults that were expanded
+        for (let i = inputVars.length; i < flatArgs.length; i++) {
+          const argVal = flatArgs[i];
+          if (argVal) filteredArgs.push(argVal);
+        }
+
+        if (hasHigherOrderArg) {
+          // Generate deterministic specialized name based on bound function names
+          const hashPairs = Array.from(newBindings.entries()).map(([k, v]) => {
+            const vName = v instanceof ModelicaPartialFunctionExpression ? v.functionName : v;
+            return `${k}_${vName.replace(/\\./g, "_")}`;
+          });
+          const specializedName = `${functionName}$${hashPairs.join("$")}`;
+
+          // Resolve the base function class instance to use as an override
+          let baseResolved: ModelicaClassInstance | undefined = resolvedOverride;
+          if (!baseResolved && ctx.classInstance) {
+            const parts = originalName.split(".");
+            const r = ctx.classInstance.resolveName(parts);
+            if (r instanceof ModelicaClassInstance) baseResolved = r;
+          }
+
+          if (baseResolved) {
+            const baseBindings = ctx.functionBindings ? Array.from(ctx.functionBindings.entries()) : [];
+            const specializedCtx: FlattenerContext = {
+              ...ctx,
+              functionBindings: new Map([...baseBindings, ...Array.from(newBindings.entries())]),
+            };
+            this.#collectFunctionDefinition(specializedName, specializedCtx, baseResolved, componentPrefix);
+
+            finalFunctionName = specializedName;
+            finalArgs = filteredArgs;
+          }
+        }
+      }
+    }
+
+    const result = new ModelicaFunctionCallExpression(finalFunctionName, finalArgs);
 
     // Only inline user-defined function calls when ALL arguments are compile-time constants.
     // Parameters are NOT constants — they can change between simulations.
@@ -4468,6 +4584,11 @@ class ModelicaSyntaxFlattener extends ModelicaSyntaxVisitor<ModelicaExpression,
           variable.customTypeName = typeInstance.name ?? null;
         }
       }
+
+      if (ctx.functionBindings?.has(compName)) {
+        // Skip emitting this variable as an argument! It is statically bound.
+        continue;
+      }
       fnDae.variables.push(variable);
     }
 
@@ -4526,6 +4647,7 @@ class ModelicaSyntaxFlattener extends ModelicaSyntaxVisitor<ModelicaExpression,
           stmtCollector: [],
           rootDae: targetDae,
           ...(componentPrefix ? { componentFunctionPrefix: componentPrefix } : {}),
+          ...(ctx.functionBindings ? { functionBindings: ctx.functionBindings } : {}),
         });
       }
     }
@@ -4539,6 +4661,7 @@ class ModelicaSyntaxFlattener extends ModelicaSyntaxVisitor<ModelicaExpression,
           stmtCollector: collector,
           rootDae: targetDae,
           ...(componentPrefix ? { componentFunctionPrefix: componentPrefix } : {}),
+          ...(ctx.functionBindings ? { functionBindings: ctx.functionBindings } : {}),
         });
       }
       if (collector.length > 0) {
 
@@ -152,21 +152,21 @@ export interface Fmi3Options {
   /** Model identifier. */
   modelIdentifier: string;
   /** Description of the model. */
-  description?: string;
+  description?: string | undefined;
   /** Author name. */
-  author?: string;
+  author?: string | undefined;
   /** Generation tool name. */
-  generationTool?: string;
+  generationTool?: string | undefined;
   /** GUID (auto-generated if not provided). */
-  guid?: string;
+  guid?: string | undefined;
   /** Default experiment start time. */
-  startTime?: number;
+  startTime?: number | undefined;
   /** Default experiment stop time. */
-  stopTime?: number;
+  stopTime?: number | undefined;
   /** Default experiment step size. */
-  stepSize?: number;
+  stepSize?: number | undefined;
   /** FMU type flags. */
-  fmuType?: Fmi3TypeFlags;
+  fmuType?: Fmi3TypeFlags | undefined;
 }
 
 /** Result of FMI 3.0 FMU generation. */
@@ -189,6 +189,8 @@ export interface Fmi3Result {
   numberOfEventIndicators: number;
   /** Terminals (from Modelica connectors). */
   terminals: Fmi3Terminal[];
+  /** Terminals and Icons XML payload. */
+  terminalsAndIconsXml?: string | null;
 }
 
 // ── Main generator ──
@@ -281,6 +283,7 @@ export function generateFmi3(dae: ModelicaDAE, options: Fmi3Options, stateVars?:
   // ── Generate modelDescription.xml ──
   const fmuType = options.fmuType ?? { modelExchange: true, coSimulation: true };
   const nEventIndicators = countEventIndicators3(dae);
+  const terminals = detectTerminals3(groupedVariables);
   const xml = generateModelDescriptionXml3(groupedVariables, {
     ...options,
     guid,
@@ -293,7 +296,7 @@ export function generateFmi3(dae: ModelicaDAE, options: Fmi3Options, stateVars?:
     aliasMap,
     deps,
     enumTypes,
-    terminals: detectTerminals3(groupedVariables),
+    terminals,
   });
 
   return {
@@ -308,7 +311,8 @@ export function generateFmi3(dae: ModelicaDAE, options: Fmi3Options, stateVars?:
     },
     guid,
     numberOfEventIndicators: nEventIndicators,
-    terminals: detectTerminals3(groupedVariables),
+    terminals,
+    terminalsAndIconsXml: generateTerminalsAndIconsXml(terminals),
   };
 }
 
 
@@ -20,6 +20,7 @@ import { deflateRaw } from "pako";
 import type { ModelicaDAE } from "./dae.js";
 import type { FmuOptions, FmuResult } from "./fmi.js";
 import { generateFmu } from "./fmi.js";
+import { generateFmi3 } from "./fmi3.js";
 import { generateFmuCSources } from "./fmu-codegen.js";
 import type { ModelicaSimulator } from "./simulator.js";
 
@@ -58,6 +59,7 @@ export function buildFmuArchive(
 ): FmuArchiveResult {
   const stateVars = simulator?.stateVars ?? new Set<string>();
   const fmuResult = generateFmu(dae, options, stateVars);
+  const fmi3Result = generateFmi3(dae, options, stateVars);
   const id = options.modelIdentifier;
 
   const files = new Map<string, Uint8Array>();
@@ -66,6 +68,11 @@ export function buildFmuArchive(
   // ── modelDescription.xml ──
   files.set("modelDescription.xml", encoder.encode(fmuResult.modelDescriptionXml));
 
+  // ── terminalsAndIcons.xml (FMI 3.0) ──
+  if (fmi3Result.terminalsAndIconsXml) {
+    files.set("terminalsAndIcons/terminalsAndIcons.xml", encoder.encode(fmi3Result.terminalsAndIconsXml));
+  }
+
   // ── C source files ──
   if (options.includeSources !== false) {
     const sources = generateFmuCSources(dae, fmuResult, options);
 
@@ -1571,6 +1571,7 @@ export function generateFmi3FunctionsC(id: string): string {
   lines.push("/* Typedefs for FMI 3.0 */");
   lines.push("typedef void* fmi3Instance;");
   lines.push("typedef void* fmi3InstanceEnvironment;");
+  lines.push("typedef void* fmi3FMUState;");
   lines.push("typedef const char* fmi3String;");
   lines.push("typedef double fmi3Float64;");
   lines.push("typedef float fmi3Float32;");
@@ -1617,7 +1618,69 @@ export function generateFmi3FunctionsC(id: string): string {
   lines.push("}");
   lines.push("");
   lines.push("void fmi3FreeInstance(fmi3Instance instance) {");
-  lines.push("  if (instance) free(instance);");
+  lines.push("  if (!instance) return;");
+  lines.push("  FMI3InstanceData* inst = (FMI3InstanceData*)instance;");
+  lines.push("  for (int i = 0; i < N_STRING_VARS; i++) {");
+  lines.push("    if (inst->model.stringVars[i]) free(inst->model.stringVars[i]);");
+  lines.push("  }");
+  lines.push("  free(instance);");
+  lines.push("}");
+  lines.push("");
+  lines.push("fmi3Status fmi3GetFMUState(fmi3Instance instance, fmi3FMUState* state) {");
+  lines.push("  if (!instance || !state) return fmi3Error;");
+  lines.push("  FMI3InstanceData* inst = (FMI3InstanceData*)instance;");
+  lines.push("  FMI3InstanceData* copy = (FMI3InstanceData*)malloc(sizeof(FMI3InstanceData));");
+  lines.push("  if (!copy) return fmi3Error;");
+  lines.push("  memcpy(copy, inst, sizeof(FMI3InstanceData));");
+  lines.push("  /* Deep copy strings */");
+  lines.push("  for (int i = 0; i < N_STRING_VARS; i++) {");
+  lines.push("    if (inst->model.stringVars[i]) {");
+  lines.push("      copy->model.stringVars[i] = strdup(inst->model.stringVars[i]);");
+  lines.push("    } else {");
+  lines.push("      copy->model.stringVars[i] = NULL;");
+  lines.push("    }");
+  lines.push("  }");
+  lines.push("  *state = (fmi3FMUState)copy;");
+  lines.push("  return fmi3OK;");
+  lines.push("}");
+  lines.push("");
+  lines.push("fmi3Status fmi3SetFMUState(fmi3Instance instance, fmi3FMUState state) {");
+  lines.push("  if (!instance || !state) return fmi3Error;");
+  lines.push("  FMI3InstanceData* inst = (FMI3InstanceData*)instance;");
+  lines.push("  fmi3String savedName = inst->instanceName;");
+  lines.push("  fmi3InstanceEnvironment savedEnv = inst->env;");
+  lines.push("  fmi3LogMessageCallback savedLogMessage = inst->logMessage;");
+  lines.push("  fmi3Boolean savedLoggingOn = inst->loggingOn;");
+  lines.push("  /* Free current strings */");
+  lines.push("  for (int i = 0; i < N_STRING_VARS; i++) {");
+  lines.push("    if (inst->model.stringVars[i]) free(inst->model.stringVars[i]);");
+  lines.push("  }");
+  lines.push("  memcpy(inst, (FMI3InstanceData*)state, sizeof(FMI3InstanceData));");
+  lines.push("  inst->instanceName = savedName;");
+  lines.push("  inst->env = savedEnv;");
+  lines.push("  inst->logMessage = savedLogMessage;");
+  lines.push("  inst->loggingOn = savedLoggingOn;");
+  lines.push("  /* Deep copy strings */");
+  lines.push("  for (int i = 0; i < N_STRING_VARS; i++) {");
+  lines.push("    if (((FMI3InstanceData*)state)->model.stringVars[i]) {");
+  lines.push("      inst->model.stringVars[i] = strdup(((FMI3InstanceData*)state)->model.stringVars[i]);");
+  lines.push("    } else {");
+  lines.push("      inst->model.stringVars[i] = NULL;");
+  lines.push("    }");
+  lines.push("  }");
+  lines.push("  return fmi3OK;");
+  lines.push("}");
+  lines.push("");
+  lines.push("fmi3Status fmi3FreeFMUState(fmi3Instance instance, fmi3FMUState* state) {");
+  lines.push("  (void)instance;");
+  lines.push("  if (!state || !*state) return fmi3Error;");
+  lines.push("  FMI3InstanceData* copy = (FMI3InstanceData*)(*state);");
+  lines.push("  for (int i = 0; i < N_STRING_VARS; i++) {");
+  lines.push("    if (copy->model.stringVars[i]) free(copy->model.stringVars[i]);");
+  lines.push("  }");
+  lines.push("  free(copy);");
+  lines.push("  *state = NULL;");
+  lines.push("  return fmi3OK;");
   lines.push("}");
   lines.push("");
   lines.push(