@@ -31,6 +31,11 @@ export class ModelicaDAE {
   functions: ModelicaDAE[] = [];
   /** External function declaration text (e.g. `external "C" ...`). */
   externalDecl: string | null = null;
+  /**
+   * Descriptors for variables whose type extends `ExternalObject`.
+   * Track constructor/destructor names for lifecycle management.
+   */
+  externalObjects: ModelicaExternalObjectDescriptor[] = [];
   /** Diagnostics emitted during flattening (e.g. type errors, invalid iterators). */
   diagnostics: ModelicaDiagnostic[] = [];
   /** Experiment annotation data (StartTime, StopTime, Tolerance, etc.). */
@@ -3362,6 +3367,45 @@ export class ModelicaClockPartition {
   }
 }
 
+/**
+ * Describes a variable whose type extends `ExternalObject`.
+ * Tracks the constructor and destructor function names for lifecycle management
+ * during FMU initialization and termination.
+ */
+export class ModelicaExternalObjectDescriptor {
+  /** The variable name in the flattened DAE. */
+  variableName: string;
+  /** The fully-qualified type name (e.g., `MyLib.MyExternalObj`). */
+  typeName: string;
+  /** Constructor function name (e.g., `MyExternalObj.constructor`). */
+  constructorName: string;
+  /** Destructor function name (e.g., `MyExternalObj.destructor`). */
+  destructorName: string;
+
+  constructor(variableName: string, typeName: string, constructorName?: string, destructorName?: string) {
+    this.variableName = variableName;
+    this.typeName = typeName;
+    this.constructorName = constructorName ?? `${typeName}.constructor`;
+    this.destructorName = destructorName ?? `${typeName}.destructor`;
+  }
+
+  get hash(): string {
+    const hash = createHash("sha256");
+    hash.update("externalObject_" + this.variableName + "_" + this.typeName);
+    return hash.digest("hex");
+  }
+
+  get toJSON(): JSONValue {
+    return {
+      "@type": "ExternalObjectDescriptor",
+      variableName: this.variableName,
+      typeName: this.typeName,
+      constructorName: this.constructorName,
+      destructorName: this.destructorName,
+    };
+  }
+}
+
 export class ModelicaState {
   name: string;
   variables: ModelicaVariable[] = [];
 
@@ -2841,6 +2841,33 @@ class ModelicaSyntaxFlattener extends ModelicaSyntaxVisitor<ModelicaExpression,
       }
     }
 
+    // Operator record dispatch for String(x): when the argument is an operator record,
+    // rewrite String(x) as RecordType.'String'(x) using the operator function.
+    if (functionName === "String" && flatArgs.length >= 1) {
+      const arg0 = flatArgs[0];
+      if (arg0) {
+        const stringOp = this.#resolveOperatorRecordFunction(arg0, "'String'", ctx);
+        if (stringOp) {
+          const { qualifiedName, resolvedClass } = stringOp;
+          this.#collectFunctionDefinition(qualifiedName, ctx, resolvedClass);
+          return new ModelicaFunctionCallExpression(qualifiedName, flatArgs);
+        }
+      }
+    }
+
+    // Operator record dispatch for '0' (zero literal): when zeros() is called with
+    // an operator record type argument, rewrite to RecordType.'0'() zero constructor.
+    if (functionName === "zeros" && flatArgs.length >= 1) {
+      const arg0 = flatArgs[0];
+      if (arg0) {
+        const zeroOp = this.#resolveOperatorRecordFunction(arg0, "'0'", ctx);
+        if (zeroOp) {
+          const { qualifiedName, resolvedClass } = zeroOp;
+          this.#collectFunctionDefinition(qualifiedName, ctx, resolvedClass);
+          return new ModelicaFunctionCallExpression(qualifiedName, []);
+        }
+      }
+    }
     // Pre-expansion size() resolution: resolve size(var, dim) directly from
     // class instance BEFORE arg expansion may lose inner dimension info.
     // E.g., size(b, 2) where b is Real[2, 0] — expansion loses the 0 dimension.
@@ -6289,6 +6316,13 @@ class ModelicaSyntaxFlattener extends ModelicaSyntaxVisitor<ModelicaExpression,
         const negatedFirst = new ModelicaUnaryExpression(ModelicaUnaryOperator.UNARY_MINUS, operand.operand1);
         return new ModelicaBinaryExpression(operand.operator, negatedFirst, operand.operand2);
       }
+      // Operator record dispatch: unary minus → RecordType.'-'.negate(x)
+      const operatorInfo = this.#resolveOperatorRecordFunction(operand, "'-'", ctx);
+      if (operatorInfo) {
+        const { qualifiedName, resolvedClass } = operatorInfo;
+        this.#collectFunctionDefinition(qualifiedName, ctx, resolvedClass);
+        return new ModelicaFunctionCallExpression(qualifiedName, [operand]);
+      }
     }
     if (operator === ModelicaUnaryOperator.UNARY_PLUS) {
       if (operand instanceof ModelicaRealLiteral || operand instanceof ModelicaIntegerLiteral) return operand;
 
@@ -536,6 +536,12 @@ function generateFmi2FunctionsC(
       `  int activeState_${si}; /* 0-indexed into states of SM ${si}: ${dae.stateMachines[si]?.name ?? ""} */`,
     );
   }
+  // ExternalObject handle fields
+  for (let ei = 0; ei < dae.externalObjects.length; ei++) {
+    const eo = dae.externalObjects[ei];
+    if (!eo) continue;
+    lines.push(`  void* extObj_${ei}; /* ${eo.typeName}: ${eo.variableName} */`);
+  }
   lines.push("} FMUInstance;");
   lines.push("");
 
@@ -555,6 +561,17 @@ function generateFmi2FunctionsC(
   lines.push("}");
   lines.push("");
 
+  // Emit ExternalObject constructor calls right after fmi2Instantiate
+  if (dae.externalObjects.length > 0) {
+    lines.push("/* --- ExternalObject constructor stubs --- */");
+    for (let ei = 0; ei < dae.externalObjects.length; ei++) {
+      const eo = dae.externalObjects[ei];
+      if (!eo) continue;
+      lines.push(`/* TODO: inst->extObj_${ei} = ${sanitizeIdentifier(eo.constructorName)}(...); */`);
+    }
+    lines.push("");
+  }
+
   // ── fmi2SetupExperiment ──
   lines.push("fmi2Status fmi2SetupExperiment(fmi2Component c, fmi2Boolean toleranceDefined,");
   lines.push("    fmi2Real tolerance, fmi2Real startTime, fmi2Boolean stopTimeDefined, fmi2Real stopTime) {");
@@ -831,6 +848,15 @@ function generateFmi2FunctionsC(
   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("  }");
+  // ExternalObject destructor stubs
+  if (dae.externalObjects.length > 0) {
+    lines.push("  /* ExternalObject destructors */");
+    for (let ei = 0; ei < dae.externalObjects.length; ei++) {
+      const eo = dae.externalObjects[ei];
+      if (!eo) continue;
+      lines.push(`  /* TODO: ${sanitizeIdentifier(eo.destructorName)}(inst->extObj_${ei}); */`);
+    }
+  }
   lines.push("  free(inst);");
   lines.push("}");
   lines.push("");