@@ -414,10 +414,8 @@ pub(crate) fn compile_requested_model(
     session: &mut Session,
     model_name: &str,
 ) -> Result<CompilationResult, JsValue> {
-    let mut report = session.compile_model_with_mode(
-        model_name,
-        CompilationMode::StrictReachableUncachedWithRecovery,
-    );
+    let mut report =
+        session.compile_model_with_mode(model_name, CompilationMode::StrictReachableWithRecovery);
     if !report.failures.is_empty() {
         return Err(JsValue::from_str(&format!(
             "Compilation error: {}",
 
@@ -524,6 +524,51 @@ mod tests {
         assert!(second.cache_file.is_none());
     }
 
+    #[test]
+    fn warm_source_root_cache_hit_skips_reparse_timing() {
+        let temp = tempfile::tempdir().expect("tempdir");
+        let lib_dir = temp.path().join("lib");
+        let cache_dir = temp.path().join("cache");
+        std::fs::create_dir_all(&lib_dir).expect("mkdir");
+        std::fs::write(lib_dir.join("package.mo"), "package Lib\nend Lib;\n")
+            .expect("write package");
+        for index in 0..24 {
+            std::fs::write(
+                lib_dir.join(format!("M{index}.mo")),
+                format!(
+                    "within Lib;\nmodel M{index}\n  Real x;\nequation\n  der(x) = {index}.0;\nend M{index};\n"
+                ),
+            )
+            .expect("write model");
+        }
+
+        let first =
+            parse_source_root_with_cache_in(&lib_dir, Some(&cache_dir)).expect("first parse");
+        assert_eq!(first.cache_status, SourceRootCacheStatus::Miss);
+        assert_eq!(first.file_count, 25);
+
+        let second =
+            parse_source_root_with_cache_in(&lib_dir, Some(&cache_dir)).expect("second parse");
+        assert_eq!(second.cache_status, SourceRootCacheStatus::Hit);
+        assert_eq!(second.file_count, first.file_count);
+        assert_eq!(
+            second.timing.parse_files_ms, 0,
+            "warm source-root cache hit must not fall back to parsing files"
+        );
+        assert_eq!(
+            second.timing.cache_write_ms, 0,
+            "warm source-root cache hit should not rewrite parsed artifacts"
+        );
+        assert!(
+            second.timing.total_ms
+                >= second.timing.collect_files_ms
+                    + second.timing.hash_inputs_ms
+                    + second.timing.cache_deserialize_ms
+                    + second.timing.validate_layout_ms,
+            "reported warm timing should account for cache hydration work"
+        );
+    }
+
     #[test]
     fn resolve_source_root_cache_dir_is_absolute_and_stable() {
         let path = resolve_source_root_cache_dir().expect("cache dir should resolve by default");
 
@@ -0,0 +1,304 @@
+import { inflateRawSync } from "node:zlib";
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { ensureNodeSelfForWasmBindgenRayon } from "./node_rayon_shim.mjs";
+
+const END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
+const CENTRAL_DIRECTORY_FILE_HEADER_SIGNATURE = 0x02014b50;
+const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
+
+function argValue(name, fallback) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+function argValues(name) {
+  const values = [];
+  for (let index = 0; index < process.argv.length; index++) {
+    if (process.argv[index] === name && process.argv[index + 1]) {
+      values.push(process.argv[index + 1]);
+    }
+  }
+  return values;
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+async function collectMoFiles(root, prefix = "") {
+  const entries = await readdir(root, { withFileTypes: true });
+  entries.sort((lhs, rhs) => lhs.name.localeCompare(rhs.name));
+  const files = [];
+  for (const entry of entries) {
+    const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (relative.includes("Test") || relative.includes("Obsolete")) {
+      continue;
+    }
+    const absolute = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectMoFiles(absolute, relative));
+    } else if (entry.isFile() && entry.name.endsWith(".mo")) {
+      files.push([absolute, relative]);
+    }
+  }
+  return files;
+}
+
+async function readMslSources(mslArchiveRoot) {
+  const roots = [
+    ["Modelica", path.join(mslArchiveRoot, "Modelica 4.1.0")],
+    ["ModelicaServices", path.join(mslArchiveRoot, "ModelicaServices 4.1.0")],
+  ];
+  const sources = {};
+  for (const [logicalRoot, root] of roots) {
+    const rootStat = await stat(root);
+    assert(rootStat.isDirectory(), `missing MSL source-root directory: ${root}`);
+    for (const [absolute, relative] of await collectMoFiles(root)) {
+      sources[`${logicalRoot}/${relative}`] = await readFile(absolute, "utf8");
+    }
+  }
+
+  const complexPath = path.join(mslArchiveRoot, "Complex.mo");
+  sources["Complex.mo"] = await readFile(complexPath, "utf8");
+  return sources;
+}
+
+function findEndOfCentralDirectory(zip) {
+  const minOffset = Math.max(0, zip.length - 0xffff - 22);
+  for (let offset = zip.length - 22; offset >= minOffset; offset--) {
+    if (zip.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY_SIGNATURE) {
+      return offset;
+    }
+  }
+  throw new Error("ZIP end-of-central-directory record not found");
+}
+
+function zipEntries(zip) {
+  const eocdOffset = findEndOfCentralDirectory(zip);
+  const entryCount = zip.readUInt16LE(eocdOffset + 10);
+  let offset = zip.readUInt32LE(eocdOffset + 16);
+  const entries = [];
+
+  for (let index = 0; index < entryCount; index++) {
+    assert(
+      zip.readUInt32LE(offset) === CENTRAL_DIRECTORY_FILE_HEADER_SIGNATURE,
+      `invalid ZIP central directory header at ${offset}`,
+    );
+    const compressionMethod = zip.readUInt16LE(offset + 10);
+    const compressedSize = zip.readUInt32LE(offset + 20);
+    const uncompressedSize = zip.readUInt32LE(offset + 24);
+    const fileNameLength = zip.readUInt16LE(offset + 28);
+    const extraLength = zip.readUInt16LE(offset + 30);
+    const commentLength = zip.readUInt16LE(offset + 32);
+    const localHeaderOffset = zip.readUInt32LE(offset + 42);
+    const nameStart = offset + 46;
+    const name = zip.toString("utf8", nameStart, nameStart + fileNameLength);
+    entries.push({
+      name,
+      compressionMethod,
+      compressedSize,
+      uncompressedSize,
+      localHeaderOffset,
+    });
+    offset = nameStart + fileNameLength + extraLength + commentLength;
+  }
+
+  return entries;
+}
+
+function normalizeArchivePath(relativePath) {
+  const parts = relativePath.split("/");
+  if (parts.length > 1 && /(?:Standard)?Library|^MSL/i.test(parts[0])) {
+    return parts.slice(1).join("/");
+  }
+  if (parts.length > 0) {
+    parts[0] = parts[0].replace(/[\s-][\d.]+$/, "");
+    return parts.join("/");
+  }
+  return relativePath;
+}
+
+function inflateZipEntryToString(zip, entry) {
+  assert(
+    zip.readUInt32LE(entry.localHeaderOffset) === LOCAL_FILE_HEADER_SIGNATURE,
+    `invalid ZIP local file header at ${entry.localHeaderOffset}`,
+  );
+  const fileNameLength = zip.readUInt16LE(entry.localHeaderOffset + 26);
+  const extraLength = zip.readUInt16LE(entry.localHeaderOffset + 28);
+  const dataStart = entry.localHeaderOffset + 30 + fileNameLength + extraLength;
+  const compressed = zip.subarray(dataStart, dataStart + entry.compressedSize);
+  if (entry.compressionMethod === 0) {
+    return compressed.toString("utf8");
+  }
+  if (entry.compressionMethod === 8) {
+    const inflated = inflateRawSync(compressed);
+    assert(
+      inflated.length === entry.uncompressedSize,
+      `inflated size mismatch for ${entry.name}`,
+    );
+    return inflated.toString("utf8");
+  }
+  throw new Error(
+    `unsupported ZIP compression method ${entry.compressionMethod} for ${entry.name}`,
+  );
+}
+
+async function readMslZipSources(mslZipPath) {
+  const readStarted = performance.now();
+  const zip = await readFile(mslZipPath);
+  const zipReadMs = ms(readStarted);
+
+  const parseStarted = performance.now();
+  const moEntries = zipEntries(zip).filter((entry) => {
+    return (
+      entry.name.endsWith(".mo") &&
+      !entry.name.includes("Test") &&
+      !entry.name.includes("Obsolete")
+    );
+  });
+  const zipParseMs = ms(parseStarted);
+
+  const extractStarted = performance.now();
+  const sources = {};
+  for (const entry of moEntries) {
+    sources[normalizeArchivePath(entry.name)] = inflateZipEntryToString(zip, entry);
+  }
+
+  return {
+    sources,
+    zipReadMs,
+    zipParseMs,
+    zipExtractMs: ms(extractStarted),
+  };
+}
+
+function ms(msStarted) {
+  return Math.round((performance.now() - msStarted) * 10) / 10;
+}
+
+function compileTiming(raw) {
+  const parsed = JSON.parse(raw);
+  return {
+    jsonBytes: Buffer.byteLength(raw),
+    balanced: parsed.balance?.is_balanced === true,
+    equations: parsed.balance?.num_equations ?? null,
+    unknowns: parsed.balance?.num_unknowns ?? null,
+    phaseTiming: parsed.__compile_phase_timing ?? null,
+  };
+}
+
+function compileModels(wasmModule, models) {
+  const source = "model WasmBenchmarkInput\nend WasmBenchmarkInput;\n";
+  return models.map((model) => {
+    const started = performance.now();
+    try {
+      const raw = wasmModule.compile(source, model);
+      return {
+        model,
+        ok: true,
+        compileMs: ms(started),
+        ...compileTiming(raw),
+      };
+    } catch (error) {
+      return {
+        model,
+        ok: false,
+        compileMs: ms(started),
+        error: error?.message || String(error),
+      };
+    }
+  });
+}
+
+async function main() {
+  ensureNodeSelfForWasmBindgenRayon();
+  const pkgSubdir = argValue("--pkg-subdir", "release-full-web");
+  const mslRoot = argValue(
+    "--msl-root",
+    "target/msl/ModelicaStandardLibrary-4.1.0",
+  );
+  const mslZip = argValue("--msl-zip", "");
+  const models = argValues("--compile-model");
+  if (models.length === 0) {
+    models.push(
+      "Modelica.Blocks.Examples.BooleanNetwork1",
+      "Modelica.Electrical.Analog.Examples.Resistor",
+      "Modelica.Blocks.Examples.PID_Controller",
+    );
+  }
+  const wasmModule = await import(`../../../pkg/${pkgSubdir}/rumoca_bind_wasm.js`);
+  const wasmBytes = await readFile(
+    new URL(`../../../pkg/${pkgSubdir}/rumoca_bind_wasm_bg.wasm`, import.meta.url),
+  );
+  await wasmModule.default({ module_or_path: wasmBytes });
+
+  wasmModule.clear_source_root_cache();
+
+  let started = performance.now();
+  const zipTimings = mslZip
+    ? await readMslZipSources(path.resolve(mslZip))
+    : null;
+  const sources = zipTimings
+    ? zipTimings.sources
+    : await readMslSources(path.resolve(mslRoot));
+  const readMs = zipTimings ? undefined : ms(started);
+  const uris = Object.keys(sources).sort((lhs, rhs) => lhs.localeCompare(rhs));
+
+  started = performance.now();
+  const sourceRootsJson = JSON.stringify(sources);
+  const stringifyMs = ms(started);
+
+  started = performance.now();
+  const loadResult = JSON.parse(wasmModule.load_source_roots(sourceRootsJson));
+  const loadMs = ms(started);
+  const documentCountAfterLoad = wasmModule.get_source_root_document_count();
+
+  const compileAfterTextLoad = compileModels(wasmModule, models);
+
+  started = performance.now();
+  const binaryCache = wasmModule.export_parsed_source_roots_binary(JSON.stringify(uris));
+  const exportBinaryMs = ms(started);
+
+  wasmModule.clear_source_root_cache();
+  started = performance.now();
+  const restoredCount = wasmModule.merge_parsed_source_roots_binary(binaryCache);
+  const restoreBinaryMs = ms(started);
+  const documentCountAfterRestore = wasmModule.get_source_root_document_count();
+
+  const compileAfterBinaryRestore = compileModels(wasmModule, models);
+
+  const report = {
+    pkgSubdir,
+    mslRoot: path.resolve(mslRoot),
+    fileCount: uris.length,
+    sourceJsonBytes: Buffer.byteLength(sourceRootsJson),
+    binaryCacheBytes: binaryCache.length,
+    readMs,
+    zipReadMs: zipTimings?.zipReadMs,
+    zipParseMs: zipTimings?.zipParseMs,
+    zipExtractMs: zipTimings?.zipExtractMs,
+    stringifyMs,
+    wasmLoadSourceRootsMs: loadMs,
+    exportParsedBinaryMs: exportBinaryMs,
+    restoreParsedBinaryMs: restoreBinaryMs,
+    parsedCount: loadResult.parsed_count,
+    errorCount: loadResult.error_count,
+    documentCountAfterLoad,
+    compileAfterTextLoad,
+    restoredCount,
+    documentCountAfterRestore,
+    compileAfterBinaryRestore,
+  };
+
+  console.log(JSON.stringify(report, null, 2));
+}
+
+main().catch((error) => {
+  console.error("[wasm-benchmark] failed:");
+  console.error(error);
+  process.exit(1);
+});