@@ -0,0 +1,236 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/**
+ * FMU (Functional Mock-up Interface) entity support.
+ *
+ * When an FMI 2.0 `modelDescription.xml` file is found in the workspace,
+ * it is represented as a `ModelicaFmuEntity` — a specialization of
+ * `ModelicaClassInstance` that exposes FMU scalar variables as synthetic
+ * Modelica component instances.  This lets other Modelica models reference
+ * FMU participants seamlessly via normal name resolution and `connect`
+ * equations.
+ */
+
+import type { Scope } from "../scope.js";
+import type { IModelicaModelVisitor } from "./model.js";
+import {
+  ModelicaClassInstance,
+  ModelicaComponentInstance,
+  type ModelicaElement,
+  type ModelicaNamedElement,
+} from "./model.js";
+import { ModelicaCausality, ModelicaClassKind, type ModelicaIdentifierSyntaxNode } from "./syntax.js";
+
+// ── FMU model description types ──
+
+interface FmuScalarVariable {
+  name: string;
+  causality: "input" | "output" | "local" | "parameter" | "calculatedParameter" | "independent";
+  variability: "continuous" | "discrete" | "fixed" | "tunable" | "constant";
+  description: string;
+  start?: number;
+}
+
+// ── XML parsing ──
+
+/**
+ * Parse scalar variables from an FMI 2.0 `modelDescription.xml` string.
+ * Uses lightweight regex matching — no DOM parser required.
+ */
+function parseFmuModelDescription(xml: string): {
+  modelName: string;
+  description: string;
+  variables: FmuScalarVariable[];
+} {
+  // Extract modelName
+  const nameMatch = xml.match(/modelName\s*=\s*"([^"]*)"/);
+  const modelName = nameMatch?.[1] ?? "FMU";
+
+  // Extract top-level description
+  const descMatch = xml.match(/<fmiModelDescription[^>]*\bdescription\s*=\s*"([^"]*)"/);
+  const description = descMatch?.[1] ?? "";
+
+  // Extract scalar variables
+  const variables: FmuScalarVariable[] = [];
+  const scalarRegex =
+    /<ScalarVariable\b([^>]*)\/?>[\s\S]*?(?:<\/ScalarVariable>|(?=<ScalarVariable|<\/ModelVariables))/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = scalarRegex.exec(xml)) !== null) {
+    const attrs = match[0] ?? "";
+    const headerAttrs = match[1] ?? "";
+
+    const varName = headerAttrs.match(/\bname\s*=\s*"([^"]*)"/)?.[1];
+    if (!varName) continue;
+
+    const causality = (headerAttrs.match(/\bcausality\s*=\s*"([^"]*)"/)?.[1] ??
+      "local") as FmuScalarVariable["causality"];
+    const variability = (headerAttrs.match(/\bvariability\s*=\s*"([^"]*)"/)?.[1] ??
+      "continuous") as FmuScalarVariable["variability"];
+    const varDesc = headerAttrs.match(/\bdescription\s*=\s*"([^"]*)"/)?.[1] ?? "";
+
+    // Extract start value from nested <Real>, <Integer>, etc.
+    const startMatch = attrs.match(/\bstart\s*=\s*"([^"]*)"/);
+    const start = startMatch ? parseFloat(startMatch[1] ?? "") : undefined;
+
+    variables.push({
+      name: varName,
+      causality,
+      variability,
+      description: varDesc,
+      ...(Number.isFinite(start) ? { start: start as number } : {}),
+    });
+  }
+
+  return { modelName, description, variables };
+}
+
+// ── ModelicaFmuEntity ──
+
+/**
+ * A Modelica class instance backed by an FMI 2.0 model description XML file.
+ *
+ * Acts as a `block` with input/output connectors derived from the FMU's
+ * scalar variables.  The instantiation algorithm creates synthetic
+ * `ModelicaComponentInstance` objects for each variable, so that other
+ * Modelica models can reference them via normal name resolution.
+ */
+export class ModelicaFmuEntity extends ModelicaClassInstance {
+  /** Absolute path to the model description XML file. */
+  path: string;
+  /** Parsed FMU scalar variables. */
+  fmuVariables: FmuScalarVariable[] = [];
+  /** Synthetic component instances created during instantiation. */
+  #syntheticComponents: ModelicaComponentInstance[] = [];
+  #loaded = false;
+  /** Raw XML content (for browser/memfs environments where path may not be readable). */
+  #xmlContent: string | null = null;
+
+  constructor(parent: Scope, path: string, xmlContent?: string) {
+    super(parent);
+    this.path = path;
+    this.classKind = ModelicaClassKind.BLOCK;
+    this.#xmlContent = xmlContent ?? null;
+  }
+
+  /** Load from pre-supplied XML content (for browser memfs environments). */
+  static fromXml(parent: Scope, name: string, xmlContent: string): ModelicaFmuEntity {
+    const entity = new ModelicaFmuEntity(parent, `__fmu__:${name}`, xmlContent);
+    entity.name = name;
+    return entity;
+  }
+
+  override accept<R, A>(visitor: IModelicaModelVisitor<R, A>, argument?: A): R {
+    return visitor.visitClassInstance(this, argument);
+  }
+
+  override clone(modification?: import("./model.js").ModelicaModification | null): ModelicaClassInstance {
+    if (!this.#loaded) this.load();
+    const cloned = new ModelicaFmuEntity(this.parent ?? this, this.path, this.#xmlContent ?? undefined);
+    cloned.name = this.name;
+    cloned.fmuVariables = this.fmuVariables;
+    cloned.#loaded = true;
+    if (modification) {
+      // FMU entities don't use Modelica modifications, but pass through for compatibility
+    }
+    cloned.instantiate();
+    return cloned;
+  }
+
+  override get elements(): IterableIterator<ModelicaElement> {
+    if (!this.instantiated && !this.instantiating) this.instantiate();
+    const components = this.#syntheticComponents;
+    return (function* () {
+      yield* components;
+    })();
+  }
+
+  override resolveSimpleName(
+    identifier: ModelicaIdentifierSyntaxNode | string | null | undefined,
+    global = false,
+    encapsulated = false,
+  ): ModelicaNamedElement | null {
+    const simpleName = typeof identifier === "string" ? identifier : identifier?.text;
+    if (!simpleName) return null;
+    if (!this.instantiated && !this.instantiating) this.instantiate();
+
+    // Check synthetic components
+    for (const comp of this.#syntheticComponents) {
+      if (comp.name === simpleName) return comp;
+    }
+
+    return super.resolveSimpleName(identifier, global, encapsulated);
+  }
+
+  override instantiate(): void {
+    if (this.instantiated) return;
+    if (this.instantiating) return;
+    this.instantiating = true;
+    try {
+      if (!this.#loaded) this.load();
+      this.declaredElements = [];
+      this.#syntheticComponents = [];
+
+      // Resolve the predefined Real type for component class instances
+      const realType = this.root?.resolveSimpleName("Real") as ModelicaClassInstance | null;
+
+      for (const v of this.fmuVariables) {
+        // Create a synthetic component instance with null AST node
+        const comp = new ModelicaComponentInstance(this, null);
+        comp.name = v.name;
+        comp.description = v.description || null;
+
+        // Set causality from FMU variable
+        if (v.causality === "input") {
+          comp.causality = ModelicaCausality.INPUT;
+        } else if (v.causality === "output") {
+          comp.causality = ModelicaCausality.OUTPUT;
+        }
+
+        // Set the class instance to Real (all FMU 2.0 continuous variables are Real)
+        if (realType) {
+          comp.classInstance = realType.clone();
+        }
+
+        comp.instantiated = true;
+        this.#syntheticComponents.push(comp);
+        this.declaredElements.push(comp);
+      }
+
+      this.instantiated = true;
+    } finally {
+      this.instantiating = false;
+    }
+  }
+
+  /** Read and parse the model description XML. */
+  load(): void {
+    if (this.#loaded) return;
+    this.#loaded = true;
+
+    let xmlContent = this.#xmlContent;
+
+    // Try reading from filesystem if no pre-supplied content
+    if (!xmlContent) {
+      const context = this.context;
+      if (context) {
+        try {
+          xmlContent = context.fs.read(this.path);
+          this.#xmlContent = xmlContent;
+        } catch {
+          console.warn(`[ModelicaFmuEntity] Failed to read FMU XML: ${this.path}`);
+          return;
+        }
+      }
+    }
+
+    if (!xmlContent) return;
+
+    const parsed = parseFmuModelDescription(xmlContent);
+    if (!this.name) {
+      this.name = parsed.modelName;
+    }
+    this.description = parsed.description || this.description;
+    this.fmuVariables = parsed.variables;
+  }
+}
@@ -1763,7 +1763,27 @@ export class ModelicaEntity extends ModelicaClassInstance {
           const pkgPath = context.fs.join(this.path, dirent.name, "package.mo");
           if (!context.fs.stat(pkgPath)?.isFile()) continue;
         } else if (dirent.isFile()) {
-          if (dirent.name === "package.mo" || context.fs.extname(dirent.name) !== ".mo") continue;
+          const ext = context.fs.extname(dirent.name);
+          if (dirent.name === "package.mo") continue;
+          // Check for FMI model description XML files
+          if (ext === ".xml") {
+            const xmlPath = context.fs.join(this.path, dirent.name);
+            try {
+              const xmlContent = context.fs.read(xmlPath);
+              if (xmlContent.includes("fmiModelDescription")) {
+                // Lazy import to avoid circular dependency (fmu.ts imports from model.ts)
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const { ModelicaFmuEntity } = require("./fmu.js") as typeof import("./fmu.js");
+                const fmuEntity = new ModelicaFmuEntity(this, xmlPath);
+                fmuEntity.name = dirent.name.replace(/\.xml$/, "");
+                this.subEntities.push(fmuEntity as unknown as ModelicaEntity);
+              }
+            } catch {
+              // Skip unreadable XML files
+            }
+            continue;
+          }
+          if (ext !== ".mo") continue;
         }
         const subEntity = new ModelicaEntity(this, context.fs.join(this.path, dirent.name));
         // Set name from filesystem path without parsing — enables lazy loading
 
@@ -13,6 +13,7 @@ export * from "./compiler/modelica/flattener.js";
 export * from "./compiler/modelica/fmi.js";
 export * from "./compiler/modelica/fmu-archive.js";
 export * from "./compiler/modelica/fmu-codegen.js";
+export * from "./compiler/modelica/fmu.js";
 export * from "./compiler/modelica/i18n.js";
 export * from "./compiler/modelica/interpreter.js";
 export * from "./compiler/modelica/linter.js";
 
@@ -620,15 +620,15 @@ async function initWorkspaceAndTree(
             "",
           ].join("\n");
 
-          // Write all three files
+          // Write all files
           const controllerUri = Uri.joinPath(workspaceUri, "Controller.mo");
           const plantUri = Uri.joinPath(workspaceUri, "Plant.xml");
           const readmeUri = Uri.joinPath(workspaceUri, "README.md");
 
           const cosimSetupMo = [
             'model CosimSetup "Co-simulation wiring diagram"',
             "  Controller controller;",
-            '  FMUBlock plant(fileName = "Plant.xml");',
+            "  Plant plant;",
             "equation",
             "  connect(controller.y, plant.u);",
             "  connect(plant.y, controller.u);",
 
@@ -581,42 +581,36 @@ export class CosimViewProvider implements vscode.WebviewViewProvider {
       for (const p of result.participants) {
         const participantId = `cosim-${p.id}-${Date.now().toString(36)}`;
 
-        if (p.type === "modelica") {
-          // Find the document URI for this Modelica class
-          // Convention: class name matches filename (e.g., Controller → Controller.mo)
-          const moFileName = `${p.className}.mo`;
-          let moUri = uri; // Default to the wrapper model's URI
-
-          if (workspaceFolder) {
-            const candidateUri = vscode.Uri.joinPath(workspaceFolder, moFileName);
-            try {
-              await vscode.workspace.fs.stat(candidateUri);
-              moUri = candidateUri.toString();
-            } catch {
-              // File not found — fall back to wrapper URI
+        // Auto-detect participant type: check if there's a matching .xml file in the workspace
+        let isFmu = p.type === "fmu";
+        let fmuFileName = p.fileName;
+
+        if (!isFmu && workspaceFolder) {
+          // Check if {className}.xml exists and is an FMI model description
+          const xmlCandidateUri = vscode.Uri.joinPath(workspaceFolder, `${p.className}.xml`);
+          try {
+            const data = await vscode.workspace.fs.readFile(xmlCandidateUri);
+            const xmlContent = new TextDecoder().decode(data);
+            if (xmlContent.includes("fmiModelDescription")) {
+              isFmu = true;
+              fmuFileName = `${p.className}.xml`;
             }
+          } catch {
+            // No matching XML file — treat as Modelica
           }
+        }
 
-          const lspParticipant = new LspSimulatorParticipant(this.client, participantId, p.className, moUri);
-          session.participants.push({
-            id: participantId,
-            modelName: p.className,
-            uri: moUri,
-            type: "modelica",
-            variables: 0,
-            participant: lspParticipant,
-          });
-        } else if (p.type === "fmu" && p.fileName) {
+        if (isFmu && fmuFileName) {
           // Resolve the XML file relative to the workspace
           let xmlContent: string | undefined;
 
           if (workspaceFolder) {
-            const xmlUri = vscode.Uri.joinPath(workspaceFolder, p.fileName);
+            const xmlUri = vscode.Uri.joinPath(workspaceFolder, fmuFileName);
             try {
               const data = await vscode.workspace.fs.readFile(xmlUri);
               xmlContent = new TextDecoder().decode(data);
             } catch {
-              this.postMessage({ type: "error", message: `FMU file not found: ${p.fileName}` });
+              this.postMessage({ type: "error", message: `FMU file not found: ${fmuFileName}` });
               continue;
             }
           }
@@ -627,11 +621,36 @@ export class CosimViewProvider implements vscode.WebviewViewProvider {
           session.participants.push({
             id: participantId,
             modelName: fmuParticipant.modelName || p.className,
-            uri: p.fileName,
+            uri: fmuFileName,
             type: "fmu",
             variables: 0,
             participant: fmuParticipant,
           });
+        } else {
+          // Find the document URI for this Modelica class
+          // Convention: class name matches filename (e.g., Controller → Controller.mo)
+          const moFileName = `${p.className}.mo`;
+          let moUri = uri; // Default to the wrapper model's URI
+
+          if (workspaceFolder) {
+            const candidateUri = vscode.Uri.joinPath(workspaceFolder, moFileName);
+            try {
+              await vscode.workspace.fs.stat(candidateUri);
+              moUri = candidateUri.toString();
+            } catch {
+              // File not found — fall back to wrapper URI
+            }
+          }
+
+          const lspParticipant = new LspSimulatorParticipant(this.client, participantId, p.className, moUri);
+          session.participants.push({
+            id: participantId,
+            modelName: p.className,
+            uri: moUri,
+            type: "modelica",
+            variables: 0,
+            participant: lspParticipant,
+          });
         }
       }