@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+import type { CosimMqttClient } from "@modelscript/cosim";
 import express from "express";
+import type { Pool } from "pg";
 
 import { LibraryDatabase } from "./database.js";
 import { JobQueue } from "./jobs.js";
@@ -16,11 +18,28 @@ import { simulateRouter } from "./routes/simulate.js";
 import { sparqlRouter } from "./routes/sparql.js";
 import { LibraryStorage } from "./storage.js";
 
-export function createApp(storage?: LibraryStorage): express.Express {
+/** Options for creating the Express application. */
+export interface AppOptions {
+  /** Optional library storage override. */
+  storage?: LibraryStorage | undefined;
+  /** MQTT client for co-simulation (null = no MQTT). */
+  mqttClient?: CosimMqttClient | null | undefined;
+  /** PostgreSQL pool for historian queries (null = stubs). */
+  dbPool?: Pool | null | undefined;
+}
+
+export function createApp(options?: AppOptions | LibraryStorage): express.Express {
   const app = express();
-  const libraryStorage = storage ?? new LibraryStorage();
+
+  // Support legacy signature: createApp(storage?)
+  const opts: AppOptions =
+    options && "storage" in options ? (options as AppOptions) : { storage: options as LibraryStorage | undefined };
+
+  const libraryStorage = opts.storage ?? new LibraryStorage();
   const jobQueue = new JobQueue();
   const database = new LibraryDatabase();
+  const mqttClient = opts.mqttClient ?? null;
+  const dbPool = opts.dbPool ?? null;
 
   app.use(express.json());
 
@@ -35,15 +54,19 @@ export function createApp(storage?: LibraryStorage): express.Express {
   app.use("/api/v1/libraries", sparqlRouter(database));
   app.use("/api/v1", simulateRouter(libraryStorage, jobQueue));
 
-  // Co-simulation routes (MQTT client injected as null until runtime wiring)
-  app.use("/api/v1/cosim", cosimRouter(null));
-  app.use("/api/v1/mqtt/participants", mqttParticipantsRouter(null));
-  app.use("/api/v1/historian", historianRouter());
+  // Co-simulation routes (with MQTT client injection)
+  app.use("/api/v1/cosim", cosimRouter(mqttClient));
+  app.use("/api/v1/mqtt/participants", mqttParticipantsRouter(mqttClient));
+  app.use("/api/v1/historian", historianRouter(dbPool));
   app.use("/api/v1/fmus", fmuRouter());
 
   // Health check
   app.get("/health", (_req, res) => {
-    res.json({ status: "ok" });
+    res.json({
+      status: "ok",
+      mqtt: mqttClient ? "connected" : "unavailable",
+      historian: dbPool ? "connected" : "unavailable",
+    });
   });
 
   return app;
 
@@ -6,23 +6,37 @@
  * Wires together:
  * - Express app with all route modules
  * - MQTT client for co-simulation participant discovery
+ * - TimescaleDB pool for historian queries
+ * - Historian recorder for live telemetry ingestion
  * - WebSocket server for live variable streaming
  * - Graceful shutdown handling
  */
 
-import { CosimMqttClient, attachCosimWebSocket } from "@modelscript/cosim";
+import { CosimMqttClient, HistorianRecorder, attachCosimWebSocket } from "@modelscript/cosim";
 import { createApp } from "./app.js";
 
 const port = parseInt(process.env["PORT"] ?? "3000", 10);
 const mqttUrl = process.env["MQTT_BROKER_URL"];
-
-const app = createApp();
-
-// ── Start HTTP server ──
-
-const server = app.listen(port, () => {
-  console.log(`ModelScript API server listening on port ${port}`);
-});
+const timescaleUrl = process.env["TIMESCALE_URL"];
+
+// ── TimescaleDB pool (optional — only if TIMESCALE_URL is set) ──
+
+let dbPool: import("pg").Pool | null = null;
+
+if (timescaleUrl) {
+  // Lazy-load pg to avoid hard dependency when TimescaleDB is unavailable
+  try {
+    const { Pool } = await import("pg");
+    dbPool = new Pool({ connectionString: timescaleUrl, max: 10 });
+    // Test the connection
+    await dbPool.query("SELECT 1");
+    console.log("TimescaleDB connected.");
+  } catch (err: unknown) {
+    console.error("TimescaleDB connection failed:", err instanceof Error ? err.message : err);
+    console.warn("Historian features will be unavailable.");
+    dbPool = null;
+  }
+}
 
 // ── MQTT client (optional — only if MQTT_BROKER_URL is set) ──
 
@@ -38,23 +52,41 @@ if (mqttUrl) {
     },
   });
 
-  mqttClient
-    .connect()
-    .then(async () => {
-      console.log(`MQTT connected to ${mqttUrl}`);
-      if (mqttClient) {
-        await mqttClient.subscribeParticipants();
-        console.log(`MQTT participant discovery active (${mqttClient.participants.size} online)`);
-      }
-    })
-    .catch((err: unknown) => {
-      console.error("MQTT connection failed:", err instanceof Error ? err.message : err);
-      console.warn("Co-simulation features will be unavailable.");
-      mqttClient = null;
-    });
+  try {
+    await mqttClient.connect();
+    console.log(`MQTT connected to ${mqttUrl}`);
+    await mqttClient.subscribeParticipants();
+    console.log(`MQTT participant discovery active (${mqttClient.participants.size} online)`);
+  } catch (err: unknown) {
+    console.error("MQTT connection failed:", err instanceof Error ? err.message : err);
+    console.warn("Co-simulation features will be unavailable.");
+    mqttClient = null;
+  }
 }
 
-// ── WebSocket streaming (attaches to the HTTP server upgrade event) ──
+// ── Historian recorder (only when both MQTT and TimescaleDB are available) ──
+
+let recorder: HistorianRecorder | null = null;
+
+if (mqttClient && dbPool) {
+  recorder = new HistorianRecorder(dbPool, mqttClient, {
+    batchSize: 500,
+    flushIntervalMs: 200,
+  });
+  console.log("Historian recorder ready (starts per-session).");
+}
+
+// ── Create Express app ──
+
+const app = createApp({ mqttClient, dbPool });
+
+// ── Start HTTP server ──
+
+const server = app.listen(port, () => {
+  console.log(`ModelScript API server listening on port ${port}`);
+});
+
+// ── WebSocket streaming ──
 
 attachCosimWebSocket(server, mqttClient);
 console.log("WebSocket co-simulation stream available at /api/v1/cosim/stream");
@@ -64,10 +96,16 @@ console.log("WebSocket co-simulation stream available at /api/v1/cosim/stream");
 async function shutdown(signal: string): Promise<void> {
   console.log(`\n${signal} received. Shutting down gracefully...`);
 
-  // Stop accepting new connections
   server.close();
 
-  // Disconnect MQTT
+  if (recorder) {
+    try {
+      await recorder.stopRecording();
+    } catch {
+      // Best-effort
+    }
+  }
+
   if (mqttClient) {
     try {
       await mqttClient.disconnect();
@@ -77,6 +115,15 @@ async function shutdown(signal: string): Promise<void> {
     }
   }
 
+  if (dbPool) {
+    try {
+      await dbPool.end();
+      console.log("TimescaleDB pool closed.");
+    } catch {
+      // Best-effort
+    }
+  }
+
   process.exit(0);
 }
 
 
@@ -3,15 +3,19 @@
 /**
  * Co-simulation REST routes.
  *
- * Provides endpoints for session management, MQTT participant discovery,
- * and historian queries.
+ * Provides endpoints for session management, participant enrollment,
+ * MQTT participant discovery, variable couplings, and orchestrator control.
  */
 
 import type { CosimMqttClient } from "@modelscript/cosim";
-import { Orchestrator, SessionManager } from "@modelscript/cosim";
+import { FmuJsParticipant, FmuStorage, Orchestrator, SessionManager } from "@modelscript/cosim";
 import express from "express";
 
 const sessionManager = new SessionManager();
+const fmuStorage = new FmuStorage();
+
+/** Track running orchestrators by session ID for pause/stop. */
+const orchestrators = new Map<string, Orchestrator>();
 
 /**
  * Create the co-simulation router.
@@ -46,6 +50,73 @@ export function cosimRouter(mqttClient: CosimMqttClient | null): express.Router
     res.json(session.toJSON());
   });
 
+  // ── Participant Enrollment ──
+
+  // POST /api/v1/cosim/sessions/:id/participants/fmu — Add an FMU participant
+  router.post("/sessions/:id/participants/fmu", (req, res) => {
+    const session = sessionManager.getSession(req.params["id"] ?? "");
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+
+    const { fmuId, participantId } = req.body as { fmuId?: string; participantId?: string };
+    if (!fmuId) {
+      return res.status(400).json({ error: "Missing required field: fmuId" });
+    }
+
+    const pid = participantId ?? `fmu-${fmuId}-${Math.random().toString(36).slice(2, 6)}`;
+
+    try {
+      const participant = new FmuJsParticipant({
+        id: pid,
+        fmuId,
+        storage: fmuStorage,
+      });
+      session.addParticipant(participant);
+      res.status(201).json({
+        ok: true,
+        participantId: pid,
+        modelName: participant.modelName,
+        variables: participant.metadata.variables.length,
+      });
+    } catch (err: unknown) {
+      res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+
+  // GET /api/v1/cosim/sessions/:id/participants — List session participants
+  router.get("/sessions/:id/participants", (req, res) => {
+    const session = sessionManager.getSession(req.params["id"] ?? "");
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+
+    const participants = Array.from(session.participants.values()).map((p) => ({
+      id: p.id,
+      modelName: p.modelName,
+      type: p.metadata.type,
+      variables: p.metadata.variables.length,
+    }));
+    res.json({ participants });
+  });
+
+  // DELETE /api/v1/cosim/sessions/:id/participants/:pid — Remove a participant
+  router.delete("/sessions/:id/participants/:pid", (req, res) => {
+    const session = sessionManager.getSession(req.params["id"] ?? "");
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+
+    try {
+      session.removeParticipant(req.params["pid"] ?? "");
+      res.json({ ok: true });
+    } catch (err: unknown) {
+      res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+
+  // ── Couplings ──
+
   // POST /api/v1/cosim/sessions/:id/couplings — Define variable couplings
   router.post("/sessions/:id/couplings", (req, res) => {
     const session = sessionManager.getSession(req.params["id"] ?? "");
@@ -73,6 +144,8 @@ export function cosimRouter(mqttClient: CosimMqttClient | null): express.Router
     }
   });
 
+  // ── Orchestrator Control ──
+
   // POST /api/v1/cosim/sessions/:id/start — Start co-simulation
   router.post("/sessions/:id/start", (req, res) => {
     const session = sessionManager.getSession(req.params["id"] ?? "");
@@ -87,12 +160,16 @@ export function cosimRouter(mqttClient: CosimMqttClient | null): express.Router
     const orchestrator = new Orchestrator(session, mqttClient, {
       onComplete: () => {
         console.log(`[cosim] Session ${session.sessionId} completed`);
+        orchestrators.delete(session.sessionId);
       },
       onError: (err: Error) => {
         console.error(`[cosim] Session ${session.sessionId} error:`, err.message);
+        orchestrators.delete(session.sessionId);
       },
     });
 
+    orchestrators.set(session.sessionId, orchestrator);
+
     // Run asynchronously — don't await
     void orchestrator.run();
 
@@ -101,25 +178,43 @@ export function cosimRouter(mqttClient: CosimMqttClient | null): express.Router
 
   // POST /api/v1/cosim/sessions/:id/pause — Pause simulation
   router.post("/sessions/:id/pause", (req, res) => {
-    const session = sessionManager.getSession(req.params["id"] ?? "");
-    if (!session) {
-      return res.status(404).json({ error: "Session not found" });
+    const sessionId = req.params["id"] ?? "";
+    const orchestrator = orchestrators.get(sessionId);
+    if (!orchestrator) {
+      return res.status(404).json({ error: "No running orchestrator for this session" });
     }
-    res.json({ ok: true, state: session.state });
+    orchestrator.pause();
+    res.json({ ok: true, state: "paused" });
+  });
+
+  // POST /api/v1/cosim/sessions/:id/resume — Resume simulation
+  router.post("/sessions/:id/resume", (req, res) => {
+    const sessionId = req.params["id"] ?? "";
+    const orchestrator = orchestrators.get(sessionId);
+    if (!orchestrator) {
+      return res.status(404).json({ error: "No running orchestrator for this session" });
+    }
+    orchestrator.resume();
+    res.json({ ok: true, state: "running" });
   });
 
   // POST /api/v1/cosim/sessions/:id/stop — Stop and terminate
   router.post("/sessions/:id/stop", (req, res) => {
-    const session = sessionManager.getSession(req.params["id"] ?? "");
-    if (!session) {
-      return res.status(404).json({ error: "Session not found" });
+    const sessionId = req.params["id"] ?? "";
+    const orchestrator = orchestrators.get(sessionId);
+    if (!orchestrator) {
+      return res.status(404).json({ error: "No running orchestrator for this session" });
     }
-    res.json({ ok: true, state: session.state });
+    orchestrator.abort();
+    orchestrators.delete(sessionId);
+    res.json({ ok: true, state: "stopping" });
   });
 
   // DELETE /api/v1/cosim/sessions/:id — Remove completed/failed session
   router.delete("/sessions/:id", (req, res) => {
-    sessionManager.removeSession(req.params["id"] ?? "");
+    const sessionId = req.params["id"] ?? "";
+    orchestrators.delete(sessionId);
+    sessionManager.removeSession(sessionId);
     res.json({ ok: true });
   });
 
@@ -185,7 +280,6 @@ export function mqttParticipantsRouter(mqttClient: CosimMqttClient | null): expr
       return res.status(404).json({ error: "Participant not found" });
     }
 
-    // Return in the same format as the library tree nodes
     const treeNode = {
       id: `mqtt://${meta.participantId}`,
       name: meta.modelName,