@tracecode/harness 0.6.6 → 0.7.0-beta8

package/dist/browser.js

@@ -1,8 +1,365 @@
+// packages/harness-core/src/generated/runtime-language-info-data.ts
+var LANGUAGE_RUNTIME_INFOS = Object.freeze({
+  "python": {
+    "language": "python",
+    "displayName": "Python",
+    "versionLabel": "Python 3.13.2 (Pyodide 0.29.0)",
+    "description": "Python 3.13.2 (Pyodide 0.29.0).\n\nCommon algorithm helpers are imported automatically, including array, bisect, collections, functools, heapq, itertools. Other standard-library modules can be imported normally.\n\nsortedcontainers 2.4.0 is available for TreeMap, ordered-set, and sorted-list style workflows.",
+    "runtime": {
+      "name": "Pyodide",
+      "version": "0.29.0",
+      "detail": "CPython 3.13.2 compiled to WebAssembly."
+    },
+    "defaultImports": [
+      "array",
+      "bisect",
+      "collections",
+      "functools",
+      "heapq",
+      "itertools",
+      "operator",
+      "re",
+      "string",
+      "typing"
+    ],
+    "libraries": [
+      {
+        "name": "sortedcontainers",
+        "version": "2.4.0",
+        "importName": "sortedcontainers",
+        "detail": "SortedDict, SortedList, and SortedSet are loaded for tree-map/tree-set style use cases."
+      }
+    ]
+  },
+  "javascript": {
+    "language": "javascript",
+    "displayName": "JavaScript",
+    "versionLabel": "JavaScript (ECMAScript 2023)",
+    "runtime": {
+      "name": "Browser Worker JavaScript runtime",
+      "detail": "Runs in the host browser worker; Node.js is not required for browser execution."
+    },
+    "libraries": [
+      {
+        "name": "lodash",
+        "version": "4.17.21",
+        "importName": "lodash",
+        "globalName": "_"
+      },
+      {
+        "name": "@datastructures-js/binary-search-tree",
+        "version": "5.4.0",
+        "importName": "@datastructures-js/binary-search-tree"
+      },
+      {
+        "name": "@datastructures-js/deque",
+        "version": "1.0.8",
+        "importName": "@datastructures-js/deque"
+      },
+      {
+        "name": "@datastructures-js/graph",
+        "version": "5.3.1",
+        "importName": "@datastructures-js/graph"
+      },
+      {
+        "name": "@datastructures-js/heap",
+        "version": "4.3.7",
+        "importName": "@datastructures-js/heap"
+      },
+      {
+        "name": "@datastructures-js/linked-list",
+        "version": "6.1.4",
+        "importName": "@datastructures-js/linked-list"
+      },
+      {
+        "name": "@datastructures-js/priority-queue",
+        "version": "6.3.5",
+        "importName": "@datastructures-js/priority-queue"
+      },
+      {
+        "name": "@datastructures-js/queue",
+        "version": "4.3.0",
+        "importName": "@datastructures-js/queue"
+      },
+      {
+        "name": "@datastructures-js/set",
+        "version": "4.2.2",
+        "importName": "@datastructures-js/set"
+      },
+      {
+        "name": "@datastructures-js/stack",
+        "version": "3.1.6",
+        "importName": "@datastructures-js/stack"
+      },
+      {
+        "name": "@datastructures-js/trie",
+        "version": "4.2.3",
+        "importName": "@datastructures-js/trie"
+      }
+    ],
+    "standard": "ECMAScript 2023-compatible syntax in the browser worker lane.",
+    "description": 'JavaScript runs in an isolated browser Web Worker with ECMAScript 2023-compatible syntax.\n\nLodash 4.17.21 is available as both lodash and _.\n\nThe @datastructures-js packages are bundled for common algorithm data structures. Queue, Stack, Deque, Heap, PriorityQueue, MinPriorityQueue, and MaxPriorityQueue are available globally.\n\nBundled @datastructures-js versions:\n\n"@datastructures-js/binary-search-tree": "5.4.0"\n"@datastructures-js/deque": "1.0.8"\n"@datastructures-js/graph": "5.3.1"\n"@datastructures-js/heap": "4.3.7"\n"@datastructures-js/linked-list": "6.1.4"\n"@datastructures-js/priority-queue": "6.3.5"\n"@datastructures-js/queue": "4.3.0"\n"@datastructures-js/set": "4.2.2"\n"@datastructures-js/stack": "3.1.6"\n"@datastructures-js/trie": "4.2.3"\n\nBinary Search Tree, Trie, and Graph are bundled too, but are not exposed globally because those names can collide with problem definitions. Import or require the matching package when you need one.'
+  },
+  "typescript": {
+    "language": "typescript",
+    "displayName": "TypeScript",
+    "versionLabel": "TypeScript 5.9.3",
+    "description": 'TypeScript 5.9.3 is compiled in the browser and then executed on the JavaScript worker runtime.\n\nCompiler options: --target ES2020 --module None --strict false --esModuleInterop\n\nLodash 4.17.21 is available as both lodash and _.\n\nThe @datastructures-js packages are bundled for common algorithm data structures. Queue, Stack, Deque, Heap, PriorityQueue, MinPriorityQueue, and MaxPriorityQueue are available globally.\n\nBundled @datastructures-js versions:\n\n"@datastructures-js/binary-search-tree": "5.4.0"\n"@datastructures-js/deque": "1.0.8"\n"@datastructures-js/graph": "5.3.1"\n"@datastructures-js/heap": "4.3.7"\n"@datastructures-js/linked-list": "6.1.4"\n"@datastructures-js/priority-queue": "6.3.5"\n"@datastructures-js/queue": "4.3.0"\n"@datastructures-js/set": "4.2.2"\n"@datastructures-js/stack": "3.1.6"\n"@datastructures-js/trie": "4.2.3"\n\nBinary Search Tree, Trie, and Graph are bundled too, but are not exposed globally because those names can collide with problem definitions. Import or require the matching package when you need one.\n\nThe compiled output runs on the same browser worker execution lane as JavaScript submissions.',
+    "runtime": {
+      "name": "Browser Worker JavaScript runtime",
+      "detail": "TypeScript is compiled before execution and runs on the JavaScript worker lane."
+    },
+    "compiler": {
+      "name": "TypeScript",
+      "version": "5.9.3"
+    },
+    "standard": "Transpiles to JavaScript for the browser worker lane.",
+    "libraries": [
+      {
+        "name": "lodash",
+        "version": "4.17.21",
+        "importName": "lodash",
+        "globalName": "_"
+      },
+      {
+        "name": "@datastructures-js/binary-search-tree",
+        "version": "5.4.0",
+        "importName": "@datastructures-js/binary-search-tree"
+      },
+      {
+        "name": "@datastructures-js/deque",
+        "version": "1.0.8",
+        "importName": "@datastructures-js/deque"
+      },
+      {
+        "name": "@datastructures-js/graph",
+        "version": "5.3.1",
+        "importName": "@datastructures-js/graph"
+      },
+      {
+        "name": "@datastructures-js/heap",
+        "version": "4.3.7",
+        "importName": "@datastructures-js/heap"
+      },
+      {
+        "name": "@datastructures-js/linked-list",
+        "version": "6.1.4",
+        "importName": "@datastructures-js/linked-list"
+      },
+      {
+        "name": "@datastructures-js/priority-queue",
+        "version": "6.3.5",
+        "importName": "@datastructures-js/priority-queue"
+      },
+      {
+        "name": "@datastructures-js/queue",
+        "version": "4.3.0",
+        "importName": "@datastructures-js/queue"
+      },
+      {
+        "name": "@datastructures-js/set",
+        "version": "4.2.2",
+        "importName": "@datastructures-js/set"
+      },
+      {
+        "name": "@datastructures-js/stack",
+        "version": "3.1.6",
+        "importName": "@datastructures-js/stack"
+      },
+      {
+        "name": "@datastructures-js/trie",
+        "version": "4.2.3",
+        "importName": "@datastructures-js/trie"
+      }
+    ]
+  },
+  "java": {
+    "language": "java",
+    "displayName": "Java",
+    "versionLabel": "Java 17",
+    "description": "Java 17 is compiled with javac 17 and executed in the browser through CheerpJ 4.2.\n\nCommon imports are added automatically: java.util.*, java.io.*, java.math.*, java.util.stream.*, javafx.util.Pair.",
+    "runtime": {
+      "name": "CheerpJ browser-local OpenJDK runtime",
+      "version": "17",
+      "detail": "Loaded through CheerpJ 4.2."
+    },
+    "compiler": {
+      "name": "javac",
+      "version": "17"
+    },
+    "defaultImports": [
+      "java.util.*",
+      "java.io.*",
+      "java.math.*",
+      "java.util.stream.*",
+      "javafx.util.Pair"
+    ],
+    "libraries": [
+      {
+        "name": "JavaParser",
+        "version": "3.25.10",
+        "detail": "Used internally for Java source rewriting."
+      },
+      {
+        "name": "javafx.util.Pair",
+        "detail": "Small compatibility Pair class bundled with the Java helper jar."
+      }
+    ]
+  },
+  "csharp": {
+    "language": "csharp",
+    "displayName": "C#",
+    "versionLabel": "C# 14 (.NET 10.0.8)",
+    "description": "C# 14 with .NET 10.0.8 runtime.\n\nCode is compiled with Microsoft.CodeAnalysis.CSharp 5.3.0 and executed by a browser-local .NET WebAssembly runtime.\n\nCommon namespaces are imported automatically: System, System.Collections, System.Collections.Generic, System.Linq, System.Numerics, System.Text, System.Text.RegularExpressions.",
+    "runtime": {
+      "name": ".NET WebAssembly runtime",
+      "version": "10.0.8",
+      "detail": "Browser-local .NET runtime targeting net10.0."
+    },
+    "compiler": {
+      "name": "Microsoft.CodeAnalysis.CSharp",
+      "version": "5.3.0"
+    },
+    "standard": "C# 14",
+    "defaultImports": [
+      "System",
+      "System.Collections",
+      "System.Collections.Generic",
+      "System.Linq",
+      "System.Numerics",
+      "System.Text",
+      "System.Text.RegularExpressions"
+    ]
+  },
+  "cpp": {
+    "language": "cpp",
+    "displayName": "C++",
+    "versionLabel": "C++23 (YoWASP Clang 22)",
+    "description": "C++ is compiled with YoWASP Clang/LLD 22.0.0-git20542-10 using the C++23 standard.\n\nSubmissions compile to WebAssembly and run in a browser-local WASI-style execution lane. The harness currently compiles with -O0 and -fno-exceptions, with a fixed program stack size.\n\nCommon standard library headers are included automatically, including <algorithm>, <array>, <bitset>, <climits>, <cmath>, <cstdint>, <functional>, <limits>, <numeric>, <sstream>, <tuple>, <vector>, <unordered_map>, <unordered_set> and more.",
+    "runtime": {
+      "name": "WASI/WebAssembly execution lane",
+      "detail": "Compiled and executed in a browser-local WASI-style worker lane."
+    },
+    "compiler": {
+      "name": "YoWASP Clang/LLD",
+      "version": "22.0.0-git20542-10"
+    },
+    "standard": "C++23",
+    "defaultImports": [
+      "<algorithm>",
+      "<array>",
+      "<bitset>",
+      "<climits>",
+      "<cmath>",
+      "<cstdint>",
+      "<functional>",
+      "<limits>",
+      "<numeric>",
+      "<sstream>",
+      "<tuple>",
+      "<vector>",
+      "<unordered_map>",
+      "<unordered_set>",
+      "<map>",
+      "<set>",
+      "<deque>",
+      "<queue>",
+      "<stack>",
+      "<utility>",
+      "<string>",
+      "<span>",
+      "<ranges>",
+      "<concepts>",
+      "<any>",
+      "<bit>",
+      "<cctype>",
+      "<cerrno>",
+      "<cfloat>",
+      "<charconv>",
+      "<chrono>",
+      "<cinttypes>",
+      "<compare>",
+      "<complex>",
+      "<cstddef>",
+      "<cstdio>",
+      "<cstdlib>",
+      "<cstring>",
+      "<exception>",
+      "<expected>",
+      "<forward_list>",
+      "<initializer_list>",
+      "<iomanip>",
+      "<ios>",
+      "<iostream>",
+      "<iterator>",
+      "<list>",
+      "<memory>",
+      "<numbers>",
+      "<optional>",
+      "<random>",
+      "<ratio>",
+      "<regex>",
+      "<stdexcept>",
+      "<string_view>",
+      "<type_traits>",
+      "<typeindex>",
+      "<typeinfo>",
+      "<valarray>",
+      "<variant>",
+      "<version>"
+    ],
+    "libraries": [
+      {
+        "name": "C++ standard library and WASI libc",
+        "detail": "Provided by the YoWASP Clang toolchain bundle."
+      }
+    ]
+  }
+});
+
+// packages/harness-core/src/runtime-language-info.ts
+var SUPPORTED_LANGUAGE_RUNTIME_INFOS = Object.freeze(
+  Object.values(LANGUAGE_RUNTIME_INFOS)
+);
+function getLanguageRuntimeInfo(language) {
+  const info = LANGUAGE_RUNTIME_INFOS[language];
+  if (!info) {
+    throw new Error(`Runtime info for language "${language}" is not implemented yet.`);
+  }
+  return info;
+}
+function getSupportedLanguageRuntimeInfos() {
+  return SUPPORTED_LANGUAGE_RUNTIME_INFOS;
+}
+
+// packages/harness-browser/src/runtime-diagnostics.ts
+var CONSOLE_METHOD_BY_LEVEL = {
+  debug: "debug",
+  info: "info",
+  warn: "warn",
+  error: "error"
+};
+function runtimeDiagnosticEvent(params) {
+  return {
+    schema: "tracecode.runtime-diagnostic.v1",
+    source: "harness",
+    ...params
+  };
+}
+function logRuntimeDiagnostic(level, params, options = {}) {
+  if (options.enabled === false && level !== "error") {
+    return;
+  }
+  const method = CONSOLE_METHOD_BY_LEVEL[level] ?? "info";
+  console[method]("[TraceRuntime]", runtimeDiagnosticEvent(params));
+}
+
 // packages/harness-browser/src/javascript-worker-client.ts
-var EXECUTION_TIMEOUT_MS = 7e3;
+var EXECUTION_TIMEOUT_MS = 2e4;
 var INTERVIEW_MODE_TIMEOUT_MS = 5e3;
-var TRACING_TIMEOUT_MS = 7e3;
+var TRACING_TIMEOUT_MS = 2e4;
 var INIT_TIMEOUT_MS = 1e4;
+var TYPESCRIPT_WARMUP_TIMEOUT_MS = 3e4;
 var MESSAGE_TIMEOUT_MS = 12e3;
 var WORKER_READY_TIMEOUT_MS = 1e4;
 var JavaScriptWorkerClient = class {
@@ -15,6 +372,7 @@ var JavaScriptWorkerClient = class {
   messageId = 0;
   isInitializing = false;
   initPromise = null;
+  warmupPromises = /* @__PURE__ */ new Map();
   workerReadyPromise = null;
   workerReadyResolve = null;
   workerReadyReject = null;
@@ -39,7 +397,12 @@ var JavaScriptWorkerClient = class {
         this.workerReadyResolve?.();
         this.workerReadyResolve = null;
         this.workerReadyReject = null;
-        if (this.debug) console.log("[JavaScriptWorkerClient] worker-ready");
+        logRuntimeDiagnostic("info", {
+          component: "JavaScriptWorkerClient",
+          runtime: "javascript",
+          phase: "worker-ready",
+          message: "JavaScript worker is ready."
+        }, { enabled: this.debug });
         return;
       }
       if (id) {
@@ -55,7 +418,18 @@ var JavaScriptWorkerClient = class {
       }
     };
     this.worker.onerror = (error) => {
-      console.error("[JavaScriptWorkerClient] Worker error:", error);
+      logRuntimeDiagnostic("error", {
+        component: "JavaScriptWorkerClient",
+        runtime: "javascript",
+        phase: "worker-error",
+        message: "JavaScript worker emitted an error event.",
+        detail: {
+          message: error.message,
+          filename: error.filename,
+          lineno: error.lineno,
+          colno: error.colno
+        }
+      });
       const workerError = new Error("Worker error");
       this.workerReadyReject?.(workerError);
       this.workerReadyResolve = null;
@@ -148,6 +522,7 @@ var JavaScriptWorkerClient = class {
       this.worker = null;
     }
     this.initPromise = null;
+    this.warmupPromises.clear();
     this.isInitializing = false;
     this.workerReadyPromise = null;
     this.workerReadyResolve = null;
@@ -175,6 +550,25 @@ var JavaScriptWorkerClient = class {
       this.isInitializing = false;
     }
   }
+  async warmup(language = "javascript") {
+    const existing = this.warmupPromises.get(language);
+    if (existing) return existing;
+    const warmupPromise = (async () => {
+      await this.init();
+      return this.sendMessage(
+        "warmup",
+        { language },
+        language === "typescript" ? TYPESCRIPT_WARMUP_TIMEOUT_MS : INIT_TIMEOUT_MS
+      );
+    })();
+    this.warmupPromises.set(language, warmupPromise);
+    try {
+      return await warmupPromise;
+    } catch (error) {
+      this.warmupPromises.delete(language);
+      throw error;
+    }
+  }
   async executeWithTracing(code, functionName, inputs, options, executionStyle = "function", language = "javascript") {
     await this.init();
     return this.executeWithTimeout(
@@ -254,344 +648,6 @@ var JavaScriptWorkerClient = class {
   }
 };
 
-// packages/harness-core/src/trace-contract.ts
-var RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION = "2026-04-21";
-var TRACE_EVENTS = /* @__PURE__ */ new Set([
-  "line",
-  "call",
-  "return",
-  "exception",
-  "timeout",
-  "stdout"
-]);
-var TRACE_ACCESS_KINDS = /* @__PURE__ */ new Set([
-  "indexed-read",
-  "indexed-write",
-  "cell-read",
-  "cell-write",
-  "mutating-call"
-]);
-function normalizeLineNumber(value, fallback = 1) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-  const normalized = Math.floor(value);
-  return normalized > 0 ? normalized : fallback;
-}
-function normalizeOutputLineCount(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
-  const normalized = Math.floor(value);
-  return normalized >= 0 ? normalized : void 0;
-}
-function normalizeEvent(value) {
-  if (typeof value === "string" && TRACE_EVENTS.has(value)) {
-    return value;
-  }
-  return "line";
-}
-function normalizeAccessKind(value) {
-  if (typeof value === "string" && TRACE_ACCESS_KINDS.has(value)) {
-    return value;
-  }
-  return null;
-}
-function normalizeFunctionName(value) {
-  if (typeof value === "string" && value.length > 0) return value;
-  return "<module>";
-}
-function normalizeKind(value) {
-  if (value === "map" || value === "set" || value === "hashmap" || value === "object") {
-    return value;
-  }
-  return "hashmap";
-}
-function normalizeObjectKind(value) {
-  if (value === "hashmap" || value === "object" || value === "map" || value === "set" || value === "tree" || value === "linked-list" || value === "graph-adjacency") {
-    return value;
-  }
-  return null;
-}
-function normalizeScalar(value) {
-  if (value === null || value === void 0) return value;
-  if (typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
-  if (typeof value === "bigint") {
-    const asNumber = Number(value);
-    return Number.isSafeInteger(asNumber) ? asNumber : String(value);
-  }
-  if (typeof value === "function") return "<function>";
-  return null;
-}
-function normalizeUnknown(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
-  if (depth > 48) return "<max depth>";
-  const scalar = normalizeScalar(value);
-  if (scalar !== null || value === null || value === void 0) {
-    return scalar;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => {
-      if (item === void 0) return null;
-      return normalizeUnknown(item, depth + 1, seen);
-    });
-  }
-  if (typeof value === "object" && value) {
-    if (seen.has(value)) return "<cycle>";
-    seen.add(value);
-    const normalized = {};
-    for (const key of Object.keys(value).sort()) {
-      const child = value[key];
-      if (child === void 0) continue;
-      normalized[key] = normalizeUnknown(child, depth + 1, seen);
-    }
-    seen.delete(value);
-    return normalized;
-  }
-  return String(value);
-}
-function normalizeAccesses(accesses) {
-  if (!Array.isArray(accesses) || accesses.length === 0) {
-    return void 0;
-  }
-  const normalized = accesses.map((access) => {
-    const variable = typeof access?.variable === "string" && access.variable.length > 0 ? access.variable : "";
-    const kind = normalizeAccessKind(access?.kind);
-    if (!variable || !kind) {
-      return null;
-    }
-    const indices = Array.isArray(access?.indices) ? access.indices.map(
-      (index) => typeof index === "number" && Number.isFinite(index) ? Math.floor(index) : null
-    ).filter((index) => index !== null) : void 0;
-    const pathDepth = access?.pathDepth === 1 || access?.pathDepth === 2 ? access.pathDepth : void 0;
-    const method = typeof access?.method === "string" && access.method.length > 0 ? access.method : void 0;
-    const payload = {
-      variable,
-      kind
-    };
-    if (indices && indices.length > 0) {
-      payload.indices = indices;
-    }
-    if (pathDepth !== void 0) {
-      payload.pathDepth = pathDepth;
-    }
-    if (method) {
-      payload.method = method;
-    }
-    return payload;
-  }).filter((access) => access !== null);
-  if (normalized.length === 0) {
-    return void 0;
-  }
-  const statsByVariable = /* @__PURE__ */ new Map();
-  for (const access of normalized) {
-    const stats = statsByVariable.get(access.variable) ?? { hasCellRead: false, hasCellWrite: false };
-    if (access.kind === "cell-read") stats.hasCellRead = true;
-    if (access.kind === "cell-write") stats.hasCellWrite = true;
-    statsByVariable.set(access.variable, stats);
-  }
-  const deduped = /* @__PURE__ */ new Set();
-  const collapsed = normalized.filter((access) => {
-    const stats = statsByVariable.get(access.variable);
-    if (access.kind === "indexed-read" && (stats?.hasCellRead || stats?.hasCellWrite)) {
-      return false;
-    }
-    if (access.kind === "indexed-write" && stats?.hasCellWrite) {
-      return false;
-    }
-    const key = JSON.stringify([
-      access.variable,
-      access.kind,
-      access.indices ?? null,
-      access.pathDepth ?? null,
-      access.method ?? null
-    ]);
-    if (deduped.has(key)) {
-      return false;
-    }
-    deduped.add(key);
-    return true;
-  });
-  return collapsed.length > 0 ? collapsed : void 0;
-}
-function normalizeRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  return normalizeUnknown(value);
-}
-function normalizeVariableSources(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const entries = Object.entries(value).filter(
-    ([name, source]) => typeof name === "string" && name.length > 0 && (source === "user" || source === "user-input" || source === "harness-prelude")
-  ).sort((a, b) => a[0].localeCompare(b[0]));
-  if (entries.length === 0) return void 0;
-  return Object.fromEntries(entries);
-}
-function normalizeCallStackFrame(frame) {
-  return {
-    function: normalizeFunctionName(frame?.function),
-    line: normalizeLineNumber(frame?.line, 1),
-    args: normalizeRecord(frame?.args)
-  };
-}
-function normalizeVisualizationPayload(payload) {
-  const hashMaps = Array.isArray(payload?.hashMaps) ? payload.hashMaps.map((entry) => ({
-    name: typeof entry?.name === "string" ? entry.name : "",
-    kind: normalizeKind(entry?.kind),
-    entries: Array.isArray(entry?.entries) ? entry.entries.map((item) => ({
-      key: normalizeUnknown(item?.key),
-      value: normalizeUnknown(item?.value),
-      ...item?.highlight ? { highlight: true } : {}
-    })) : [],
-    ...entry?.highlightedKey !== void 0 ? { highlightedKey: normalizeUnknown(entry.highlightedKey) } : {},
-    ...entry?.deletedKey !== void 0 ? { deletedKey: normalizeUnknown(entry.deletedKey) } : {},
-    ...typeof entry?.objectClassName === "string" && entry.objectClassName.length > 0 ? { objectClassName: entry.objectClassName } : {},
-    ...typeof entry?.objectId === "string" && entry.objectId.length > 0 ? { objectId: entry.objectId } : {}
-  })).sort((a, b) => `${a.name}:${a.kind}`.localeCompare(`${b.name}:${b.kind}`)) : [];
-  const objectKinds = payload?.objectKinds && typeof payload.objectKinds === "object" ? Object.fromEntries(
-    Object.entries(payload.objectKinds).filter(([name]) => typeof name === "string" && name.length > 0).map(([name, kind]) => [name, normalizeObjectKind(kind)]).filter((entry) => entry[1] !== null).sort((a, b) => a[0].localeCompare(b[0]))
-  ) : void 0;
-  if (hashMaps.length === 0 && (!objectKinds || Object.keys(objectKinds).length === 0)) {
-    return void 0;
-  }
-  return {
-    ...hashMaps.length > 0 ? { hashMaps } : {},
-    ...objectKinds && Object.keys(objectKinds).length > 0 ? { objectKinds } : {}
-  };
-}
-function normalizeTraceStep(step) {
-  const normalizedStdoutCount = normalizeOutputLineCount(step?.stdoutLineCount);
-  const normalizedVisualization = normalizeVisualizationPayload(step?.visualization);
-  const normalizedAccesses = normalizeAccesses(step?.accesses);
-  const normalizedVariableSources = normalizeVariableSources(step?.variableSources);
-  return {
-    event: normalizeEvent(step?.event),
-    line: normalizeLineNumber(step?.line, 1),
-    function: normalizeFunctionName(step?.function),
-    variables: normalizeRecord(step?.variables),
-    ...normalizedVariableSources ? { variableSources: normalizedVariableSources } : {},
-    ...Array.isArray(step?.callStack) && step.callStack.length > 0 ? { callStack: step.callStack.map(normalizeCallStackFrame) } : {},
-    ...normalizedAccesses ? { accesses: normalizedAccesses } : {},
-    ...step?.returnValue !== void 0 ? { returnValue: normalizeUnknown(step.returnValue) } : {},
-    ...normalizedStdoutCount !== void 0 ? { stdoutLineCount: normalizedStdoutCount } : {},
-    ...normalizedVisualization ? { visualization: normalizedVisualization } : {}
-  };
-}
-function collapseTraceAccessNoise(trace) {
-  const variablesWithCellAccess = /* @__PURE__ */ new Set();
-  const accessStatsByVariable = /* @__PURE__ */ new Map();
-  for (const step of trace) {
-    for (const access of step.accesses ?? []) {
-      const stats = accessStatsByVariable.get(access.variable) ?? {
-        hasCellRead: false,
-        hasCellWrite: false,
-        hasMutatingCall: false,
-        hasIndexedWrite: false
-      };
-      if (access.kind === "cell-read" || access.kind === "cell-write") {
-        variablesWithCellAccess.add(access.variable);
-      }
-      if (access.kind === "cell-read") stats.hasCellRead = true;
-      if (access.kind === "cell-write") stats.hasCellWrite = true;
-      if (access.kind === "mutating-call") stats.hasMutatingCall = true;
-      if (access.kind === "indexed-write") stats.hasIndexedWrite = true;
-      accessStatsByVariable.set(access.variable, stats);
-    }
-  }
-  if (variablesWithCellAccess.size === 0) {
-    return trace;
-  }
-  return trace.map((step) => {
-    if (!step.accesses?.length) {
-      return step;
-    }
-    const filtered = step.accesses.filter((access) => {
-      const stats = accessStatsByVariable.get(access.variable);
-      if (variablesWithCellAccess.has(access.variable)) {
-        return access.kind !== "indexed-read" && access.kind !== "indexed-write";
-      }
-      if (access.kind === "mutating-call" && stats?.hasIndexedWrite && !stats.hasCellRead && !stats.hasCellWrite) {
-        return false;
-      }
-      if (access.kind === "indexed-read" && stats?.hasMutatingCall && !stats.hasIndexedWrite && !stats.hasCellRead && !stats.hasCellWrite) {
-        return false;
-      }
-      return true;
-    });
-    if (filtered.length === step.accesses.length) {
-      return step;
-    }
-    return {
-      ...step,
-      ...filtered.length > 0 ? { accesses: filtered } : {},
-      ...filtered.length === 0 ? { accesses: void 0 } : {}
-    };
-  });
-}
-function normalizeRuntimeTraceContract(language, result) {
-  const rawNormalizedTrace = collapseTraceAccessNoise(
-    Array.isArray(result.trace) ? result.trace.map(normalizeTraceStep) : []
-  );
-  const maxTraceSteps = typeof result.maxTraceSteps === "number" && Number.isFinite(result.maxTraceSteps) ? Math.max(1, Math.floor(result.maxTraceSteps)) : void 0;
-  const traceWasClipped = maxTraceSteps !== void 0 && rawNormalizedTrace.length > maxTraceSteps;
-  const normalizedTrace = traceWasClipped && maxTraceSteps !== void 0 ? rawNormalizedTrace.slice(0, maxTraceSteps) : rawNormalizedTrace;
-  const lineEventCount = typeof result.lineEventCount === "number" && Number.isFinite(result.lineEventCount) ? Math.floor(result.lineEventCount) : normalizedTrace.filter((step) => step.event === "line").length;
-  const normalizedConsole = Array.isArray(result.consoleOutput) ? result.consoleOutput.map((line) => String(line)) : [];
-  return {
-    schemaVersion: RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION,
-    language,
-    success: Boolean(result.success),
-    ...Object.prototype.hasOwnProperty.call(result, "output") ? { output: normalizeUnknown(result.output) } : {},
-    ...typeof result.error === "string" && result.error.length > 0 ? { error: result.error } : {},
-    ...typeof result.errorLine === "number" && Number.isFinite(result.errorLine) ? { errorLine: Math.floor(result.errorLine) } : {},
-    consoleOutput: normalizedConsole,
-    trace: normalizedTrace,
-    ...result.traceLimitExceeded !== void 0 || traceWasClipped ? { traceLimitExceeded: Boolean(result.traceLimitExceeded) || traceWasClipped } : {},
-    ...typeof result.timeoutReason === "string" && result.timeoutReason.length > 0 ? { timeoutReason: result.timeoutReason } : {},
-    lineEventCount: Math.max(0, lineEventCount),
-    traceStepCount: normalizedTrace.length
-  };
-}
-
-// packages/harness-core/src/trace-adapters/shared.ts
-function denormalizeCallStackFrame(frame) {
-  return {
-    function: frame.function,
-    line: frame.line,
-    args: frame.args
-  };
-}
-function denormalizeTraceStep(step) {
-  return {
-    line: step.line,
-    event: step.event,
-    variables: step.variables,
-    function: step.function,
-    ...step.callStack ? { callStack: step.callStack.map(denormalizeCallStackFrame) } : {},
-    ...step.accesses ? { accesses: step.accesses } : {},
-    ...step.returnValue !== void 0 ? { returnValue: step.returnValue } : {},
-    ...step.stdoutLineCount !== void 0 ? { stdoutLineCount: step.stdoutLineCount } : {},
-    ...step.visualization ? { visualization: step.visualization } : {}
-  };
-}
-function adaptTraceExecutionResult(language, result) {
-  const normalized = normalizeRuntimeTraceContract(language, result);
-  const adaptedTrace = normalized.trace.map(denormalizeTraceStep);
-  return {
-    success: normalized.success,
-    ...Object.prototype.hasOwnProperty.call(normalized, "output") ? { output: normalized.output } : {},
-    ...normalized.error ? { error: normalized.error } : {},
-    ...normalized.errorLine !== void 0 ? { errorLine: normalized.errorLine } : {},
-    trace: adaptedTrace,
-    executionTimeMs: typeof result.executionTimeMs === "number" && Number.isFinite(result.executionTimeMs) ? result.executionTimeMs : 0,
-    consoleOutput: normalized.consoleOutput,
-    ...normalized.traceLimitExceeded !== void 0 ? { traceLimitExceeded: normalized.traceLimitExceeded } : {},
-    ...normalized.timeoutReason ? { timeoutReason: normalized.timeoutReason } : {},
-    lineEventCount: normalized.lineEventCount,
-    traceStepCount: adaptedTrace.length
-  };
-}
-
-// packages/harness-core/src/trace-adapters/javascript.ts
-function adaptJavaScriptTraceExecutionResult(language, result) {
-  return adaptTraceExecutionResult(language, result);
-}
-
 // packages/harness-browser/src/runtime-capability-guards.ts
 function isScriptRequest(functionName) {
   if (functionName == null) return true;
@@ -684,12 +740,6 @@ var PYTHON_RUNTIME_PROFILE = {
       setSerialization: true,
       graphSerialization: true,
       cycleReferences: true
-    },
-    visualization: {
-      runtimePayloads: true,
-      objectKinds: true,
-      hashMaps: true,
-      stepVisualization: true
     }
   }
 };
@@ -746,12 +796,6 @@ var JAVASCRIPT_RUNTIME_PROFILE = {
       setSerialization: true,
       graphSerialization: true,
       cycleReferences: true
-    },
-    visualization: {
-      runtimePayloads: true,
-      objectKinds: true,
-      hashMaps: true,
-      stepVisualization: true
     }
   }
 };
@@ -808,12 +852,6 @@ var TYPESCRIPT_RUNTIME_PROFILE = {
       setSerialization: true,
       graphSerialization: true,
       cycleReferences: true
-    },
-    visualization: {
-      runtimePayloads: true,
-      objectKinds: true,
-      hashMaps: true,
-      stepVisualization: true
     }
   }
 };
@@ -870,12 +908,6 @@ var JAVA_RUNTIME_PROFILE = {
       setSerialization: true,
       graphSerialization: false,
       cycleReferences: true
-    },
-    visualization: {
-      runtimePayloads: true,
-      objectKinds: true,
-      hashMaps: true,
-      stepVisualization: true
     }
   },
   notes: [
@@ -884,37 +916,168 @@ var JAVA_RUNTIME_PROFILE = {
     'Script-style Java uses an empty function name with executionStyle="function" and reads the top-level result variable.'
   ]
 };
-var LANGUAGE_RUNTIME_PROFILES = {
-  python: PYTHON_RUNTIME_PROFILE,
-  javascript: JAVASCRIPT_RUNTIME_PROFILE,
-  typescript: TYPESCRIPT_RUNTIME_PROFILE,
-  java: JAVA_RUNTIME_PROFILE
+var CSHARP_RUNTIME_PROFILE = {
+  language: "csharp",
+  maturity: "experimental",
+  capabilities: {
+    execution: {
+      styles: {
+        function: true,
+        solutionMethod: true,
+        opsClass: true,
+        script: true,
+        interviewMode: true
+      },
+      timeouts: {
+        clientTimeouts: true,
+        runtimeTimeouts: true
+      }
+    },
+    tracing: {
+      supported: true,
+      events: {
+        line: true,
+        call: true,
+        return: true,
+        exception: true,
+        stdout: true,
+        timeout: true
+      },
+      controls: {
+        maxTraceSteps: true,
+        maxLineEvents: true,
+        maxSingleLineHits: true,
+        maxStoredEvents: true,
+        minimalTrace: true
+      },
+      fidelity: {
+        preciseLineMapping: true,
+        stableFunctionNames: true,
+        callStack: true
+      }
+    },
+    diagnostics: {
+      compileErrors: true,
+      runtimeErrors: true,
+      mappedErrorLines: true,
+      stackTraces: false
+    },
+    structures: {
+      treeNodeRefs: true,
+      listNodeRefs: true,
+      mapSerialization: true,
+      setSerialization: true,
+      graphSerialization: true,
+      cycleReferences: true
+    }
+  },
+  notes: [
+    "C# support is browser-local and experimental.",
+    "C# supports named function-style requests where the browser-local host can bind the named method.",
+    'Script-style C# uses an empty function name with executionStyle="function" and reads the top-level result variable.',
+    "Interview-mode C# uses the same browser-local worker execution path with interview timeout normalization.",
+    "The first C# slice supports public class Solution methods.",
+    "ListNode and TreeNode inputs are hydrated from level-order arrays or object-shaped JSON.",
+    "Dictionary, HashSet, List, and array return values serialize through the browser-local worker.",
+    "Tracing currently supports line, call, return, stdout, and simple local variable write events.",
+    "Structural visualization is added after execution and diagnostics are proven."
+  ]
 };
-var SUPPORTED_LANGUAGES = Object.freeze(
-  Object.keys(LANGUAGE_RUNTIME_PROFILES)
-);
-function getLanguageRuntimeProfile(language) {
-  const profile = LANGUAGE_RUNTIME_PROFILES[language];
-  if (!profile) {
-    throw new Error(`Runtime profile for language "${language}" is not implemented yet.`);
-  }
-  return profile;
-}
-function getSupportedLanguageProfiles() {
-  return SUPPORTED_LANGUAGES.map((language) => LANGUAGE_RUNTIME_PROFILES[language]);
-}
-function isLanguageSupported(language) {
-  return SUPPORTED_LANGUAGES.includes(language);
-}
-
-// packages/harness-browser/src/javascript-runtime-client.ts
-var JavaScriptRuntimeClient = class {
-  constructor(runtimeLanguage, workerClient) {
-    this.runtimeLanguage = runtimeLanguage;
-    this.workerClient = workerClient;
-  }
-  async init() {
-    return this.workerClient.init();
+var CPP_RUNTIME_PROFILE = {
+  language: "cpp",
+  maturity: "experimental",
+  capabilities: {
+    execution: {
+      styles: {
+        function: true,
+        solutionMethod: true,
+        opsClass: true,
+        script: true,
+        interviewMode: true
+      },
+      timeouts: {
+        clientTimeouts: true,
+        runtimeTimeouts: true
+      }
+    },
+    tracing: {
+      supported: true,
+      events: {
+        line: true,
+        call: true,
+        return: true,
+        exception: true,
+        stdout: true,
+        timeout: true
+      },
+      controls: {
+        maxTraceSteps: true,
+        maxLineEvents: true,
+        maxSingleLineHits: true,
+        maxStoredEvents: true,
+        minimalTrace: true
+      },
+      fidelity: {
+        preciseLineMapping: true,
+        stableFunctionNames: true,
+        callStack: true
+      }
+    },
+    diagnostics: {
+      compileErrors: true,
+      runtimeErrors: true,
+      mappedErrorLines: true,
+      stackTraces: false
+    },
+    structures: {
+      treeNodeRefs: true,
+      listNodeRefs: true,
+      mapSerialization: true,
+      setSerialization: true,
+      graphSerialization: true,
+      cycleReferences: true
+    }
+  },
+  notes: [
+    "C++ uses a focused browser-local Clang/LLD/WASI compiler lane with TraceCode-owned execution glue.",
+    "The runtime intentionally does not depend on a generic multi-language container/runtime SDK.",
+    'Script-style C++ uses an empty function name with executionStyle="function"; the snippet must assign a serializable result variable.',
+    "Interview-mode C++ reuses the tracing compiler path with a trace budget and returns a non-trace execution result."
+  ]
+};
+var LANGUAGE_RUNTIME_PROFILES = {
+  python: PYTHON_RUNTIME_PROFILE,
+  javascript: JAVASCRIPT_RUNTIME_PROFILE,
+  typescript: TYPESCRIPT_RUNTIME_PROFILE,
+  java: JAVA_RUNTIME_PROFILE,
+  csharp: CSHARP_RUNTIME_PROFILE,
+  cpp: CPP_RUNTIME_PROFILE
+};
+var SUPPORTED_LANGUAGES = Object.freeze(
+  Object.keys(LANGUAGE_RUNTIME_PROFILES)
+);
+function getLanguageRuntimeProfile(language) {
+  const profile = LANGUAGE_RUNTIME_PROFILES[language];
+  if (!profile) {
+    throw new Error(`Runtime profile for language "${language}" is not implemented yet.`);
+  }
+  return profile;
+}
+function getSupportedLanguageProfiles() {
+  return SUPPORTED_LANGUAGES.map((language) => LANGUAGE_RUNTIME_PROFILES[language]);
+}
+function isLanguageSupported(language) {
+  return SUPPORTED_LANGUAGES.includes(language);
+}
+
+// packages/harness-browser/src/javascript-runtime-client.ts
+var JavaScriptRuntimeClient = class {
+  constructor(runtimeLanguage, workerClient) {
+    this.runtimeLanguage = runtimeLanguage;
+    this.workerClient = workerClient;
+  }
+  async init() {
+    return this.workerClient.init();
   }
   async executeWithTracing(code, functionName, inputs, options, executionStyle = "function") {
     assertRuntimeRequestSupported(getLanguageRuntimeProfile(this.runtimeLanguage), {
@@ -922,7 +1085,7 @@ var JavaScriptRuntimeClient = class {
       executionStyle,
       functionName
     });
-    const rawResult = await this.workerClient.executeWithTracing(
+    return this.workerClient.executeWithTracing(
       code,
       functionName,
       inputs,
@@ -930,7 +1093,6 @@ var JavaScriptRuntimeClient = class {
       executionStyle,
       this.runtimeLanguage
     );
-    return adaptJavaScriptTraceExecutionResult(this.runtimeLanguage, rawResult);
   }
   async executeCode(code, functionName, inputs, executionStyle = "function") {
     assertRuntimeRequestSupported(getLanguageRuntimeProfile(this.runtimeLanguage), {
@@ -965,11 +1127,364 @@ function createJavaScriptRuntimeClient(runtimeLanguage, workerClient) {
   return new JavaScriptRuntimeClient(runtimeLanguage, workerClient);
 }
 
+// packages/harness-core/src/runtime-trace.ts
+var RUNTIME_TRACE_SCHEMA_VERSION = "runtime-trace-2026-04-28";
+function createEmptyRuntimeTrace(language, options = {}) {
+  return {
+    schemaVersion: RUNTIME_TRACE_SCHEMA_VERSION,
+    language,
+    runId: options.runId ?? `${language}:run`,
+    events: [],
+    lineEventCount: 0,
+    traceStepCount: 0
+  };
+}
+
+// packages/harness-core/src/runtime-raw-emission-contract.ts
+function sortedUnique(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+var FORBIDDEN_RUNTIME_TRACE_TOKENS = [
+  "visualization",
+  "objectKinds",
+  "hashMaps",
+  "graph-adjacency",
+  "linked-list",
+  "tree"
+];
+var FORBIDDEN_RUNTIME_TRACE_KEYS = /* @__PURE__ */ new Set([
+  "visualization",
+  "objectKinds",
+  "hashMaps",
+  "graph-adjacency",
+  "linked-list"
+]);
+function normalizeJavaNativeTraceJsonPayload(payload) {
+  return payload.replace(/(?<![A-Za-z0-9_"])-Infinity(?![A-Za-z0-9_"])/g, '"-Infinity"').replace(/(?<![A-Za-z0-9_"])Infinity(?![A-Za-z0-9_"])/g, '"Infinity"').replace(/(?<![A-Za-z0-9_"])NaN(?![A-Za-z0-9_"])/g, '"NaN"');
+}
+function forbiddenRuntimeTraceTokens(value) {
+  const tokens = /* @__PURE__ */ new Set();
+  collectForbiddenRuntimeTraceTokens(value, tokens, null, false);
+  return FORBIDDEN_RUNTIME_TRACE_TOKENS.filter((token) => tokens.has(token));
+}
+function collectForbiddenRuntimeTraceTokens(value, tokens, parentKey, semanticPayload) {
+  if (typeof value === "string") {
+    if ((semanticPayload || parentKey === "kind" || parentKey === "type" || parentKey === "category") && FORBIDDEN_RUNTIME_TRACE_TOKENS.includes(value)) {
+      tokens.add(value);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const item of value) collectForbiddenRuntimeTraceTokens(item, tokens, parentKey, semanticPayload);
+    return;
+  }
+  const entries = Object.entries(value);
+  const objectSemanticPayload = entries.some(([key, child]) => {
+    if (parentKey !== "args" && FORBIDDEN_RUNTIME_TRACE_KEYS.has(key)) return true;
+    return (key === "kind" || key === "type" || key === "category") && typeof child === "string" && FORBIDDEN_RUNTIME_TRACE_TOKENS.includes(child);
+  });
+  for (const [key, child] of entries) {
+    if (parentKey !== "args" && FORBIDDEN_RUNTIME_TRACE_KEYS.has(key)) {
+      tokens.add(key);
+    }
+    if (key === "target" || key === "variable" || key === "function") continue;
+    collectForbiddenRuntimeTraceTokens(child, tokens, key, semanticPayload || objectSemanticPayload);
+  }
+}
+function unsupportedForbiddenPayload(label, value) {
+  const tokens = forbiddenRuntimeTraceTokens(value);
+  if (tokens.length === 0) return null;
+  return `${label} contains forbidden runtime trace token(s): ${tokens.join(", ")}`;
+}
+function javaNativeTracePayloadKind(event) {
+  if (!event.startsWith("trace:")) return null;
+  try {
+    const parsed = JSON.parse(normalizeJavaNativeTraceJsonPayload(event.slice("trace:".length)));
+    if (parsed.kind === "line") return "line";
+    if (parsed.kind === "call") return "call";
+    if (parsed.kind === "return") return "return";
+    if (parsed.kind === "exception") return "exception";
+    if (parsed.kind === "timeout") return "timeout";
+    if (parsed.kind === "stdout") return "stdout";
+    if (parsed.kind === "snapshot") return "snapshot";
+    if (parsed.kind === "read") return "read";
+    if (parsed.kind === "write") return "write";
+    if (parsed.kind === "mutate") return "mutate";
+  } catch {
+    return null;
+  }
+  return null;
+}
+function summarizeJavaRawEmissions(events) {
+  const kinds = [];
+  const unsupported = [];
+  for (const [index, event] of events.entries()) {
+    if (event.startsWith("trace:")) {
+      try {
+        const parsed = JSON.parse(normalizeJavaNativeTraceJsonPayload(event.slice("trace:".length)));
+        const forbiddenPayload = unsupportedForbiddenPayload(`java trace event ${index}`, parsed);
+        if (forbiddenPayload) {
+          unsupported.push(forbiddenPayload);
+          continue;
+        }
+      } catch {
+      }
+    }
+    const nativeKind = javaNativeTracePayloadKind(event);
+    if (nativeKind) {
+      kinds.push(nativeKind);
+      continue;
+    }
+    unsupported.push(event);
+  }
+  return {
+    language: "java",
+    kinds: sortedUnique(kinds),
+    unsupported
+  };
+}
+function assertSupportedRawEmissions(summary, label) {
+  if (summary.unsupported.length > 0) {
+    throw new Error(
+      `${label} emitted unsupported raw runtime payloads:
+${summary.unsupported.slice(0, 20).join("\n")}`
+    );
+  }
+}
+
+// packages/harness-core/src/trace-adapters/java.ts
+function isNativeJavaTraceEvent(event) {
+  return event.startsWith("trace:");
+}
+function stripInlineComments(line, inBlockComment) {
+  let result = "";
+  let index = 0;
+  let inBlock = inBlockComment;
+  while (index < line.length) {
+    const current = line[index];
+    const next = index + 1 < line.length ? line[index + 1] : "";
+    if (inBlock) {
+      if (current === "*" && next === "/") {
+        inBlock = false;
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      inBlock = true;
+      index += 2;
+      continue;
+    }
+    if (current === "/" && next === "/") break;
+    result += current;
+    index += 1;
+  }
+  return { text: result, inBlockComment: inBlock };
+}
+function isMethodDeclarationLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+  if (trimmed.startsWith("@")) return false;
+  if (!trimmed.includes("(") || !trimmed.includes(")")) return false;
+  if (trimmed.endsWith(";")) return false;
+  if (trimmed.includes("->")) return false;
+  if (/^(?:if|for|while|switch|catch|do|try|else|return|throw|new)\b/.test(trimmed)) return false;
+  if (!/[A-Za-z_][A-Za-z0-9_]*\s*\([^{};]*\)/.test(trimmed)) return false;
+  return /(?:\{\s*)?$/.test(trimmed);
+}
+function buildLocalDeclarationNamesByLine(sourceText) {
+  const namesByLine = /* @__PURE__ */ new Map();
+  if (typeof sourceText !== "string" || sourceText.length === 0) return namesByLine;
+  const lines = sourceText.split(/\r?\n/);
+  let inBlockComment = false;
+  for (let index = 0; index < lines.length; index += 1) {
+    const { text, inBlockComment: nextInBlockComment } = stripInlineComments(lines[index] ?? "", inBlockComment);
+    inBlockComment = nextInBlockComment;
+    if (isMethodDeclarationLine(text)) continue;
+    const names = [];
+    const declarationPattern = /\b(?:final\s+)?(?:[A-Za-z_][A-Za-z0-9_.$]*(?:\s*<[^;=(){}]+>)?(?:\s*\[\])?)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=/g;
+    for (const match of text.matchAll(declarationPattern)) {
+      if (match[1]) names.push(match[1]);
+    }
+    if (names.length > 0) namesByLine.set(index + 1, names);
+  }
+  return namesByLine;
+}
+function removeSameLineMutationDeclarationSnapshotEvents(events, sourceText) {
+  const declarationNamesByLine = buildLocalDeclarationNamesByLine(sourceText);
+  if (declarationNamesByLine.size === 0) return events;
+  const mutationVariablesByLine = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind !== "mutate" || typeof event.line !== "number" || !("variable" in event.target)) continue;
+    const variables = mutationVariablesByLine.get(event.line) ?? /* @__PURE__ */ new Set();
+    variables.add(event.target.variable);
+    mutationVariablesByLine.set(event.line, variables);
+  }
+  if (mutationVariablesByLine.size === 0) return events;
+  return events.filter((event) => {
+    if (event.kind !== "snapshot" || typeof event.line !== "number" || !("variable" in event.target)) return true;
+    const declaredNames = declarationNamesByLine.get(event.line);
+    if (!declaredNames?.includes(event.target.variable)) return true;
+    const mutationVariables = mutationVariablesByLine.get(event.line);
+    return mutationVariables?.has(event.target.variable) === true;
+  });
+}
+function collectJavaLineDeclarationsForHeaderExpansion(line) {
+  const names = [];
+  const declarationPattern = /\b(?:final\s+)?((?:boolean|byte|char|short|int|long|float|double|String|Object|[A-Za-z_][A-Za-z0-9_<>.?]*(?:\s*<[^,;=(){}:]+>)?)\s*(?:\[\s*\])*)\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?==)/g;
+  const skippedNames = /* @__PURE__ */ new Set(["class", "interface", "enum", "record", "return", "new"]);
+  for (const match of line.matchAll(declarationPattern)) {
+    const typeSource = match[1] ?? "";
+    const name = match[2];
+    if (!name || skippedNames.has(name) || name.startsWith("__tracecode")) continue;
+    if (typeSource.includes("[")) continue;
+    names.push(name);
+  }
+  return names;
+}
+function collectJavaControlHeaderDeclarations(line) {
+  const forMatch = /\bfor\s*\(\s*(?:final\s+)?(?:[A-Za-z_][A-Za-z0-9_<>.?]*(?:\s*<[^;=(){}:]+>)?|\w+(?:\s*\[\s*\])*)\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:=|:)/.exec(line);
+  return forMatch?.[1] ? [forMatch[1]] : [];
+}
+function buildJavaControlHeaderInfo(sourceText) {
+  if (typeof sourceText !== "string" || sourceText.length === 0) return null;
+  const lines = sourceText.split(/\r?\n/);
+  const loopBodyLineToHeader = /* @__PURE__ */ new Map();
+  const headerLineToExcludedVariables = /* @__PURE__ */ new Map();
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const isLoopHeader = /\b(?:for|while)\s*\(/.test(line);
+    const isControlHeader = /\b(?:for|while|if|else\s+if)\s*\(/.test(line);
+    if (!isControlHeader || !line.includes("{")) continue;
+    for (let bodyIndex = index + 1; bodyIndex < lines.length; bodyIndex += 1) {
+      const trimmed = (lines[bodyIndex] ?? "").trim();
+      if (trimmed.length === 0) continue;
+      if (trimmed.startsWith("}")) break;
+      const headerInfo = {
+        line: index + 1,
+        excludedVariables: new Set(collectJavaLineDeclarationsForHeaderExpansion(lines[bodyIndex] ?? "")),
+        headerVariables: new Set(collectJavaControlHeaderDeclarations(line))
+      };
+      if (isLoopHeader) loopBodyLineToHeader.set(bodyIndex + 1, headerInfo);
+      headerLineToExcludedVariables.set(index + 1, headerInfo.excludedVariables);
+      break;
+    }
+  }
+  if (loopBodyLineToHeader.size === 0 && headerLineToExcludedVariables.size === 0) return null;
+  return { loopBodyLineToHeader, headerLineToExcludedVariables };
+}
+function eventLine(event) {
+  return typeof event.line === "number" && Number.isFinite(event.line) && event.line > 0 ? event.line : null;
+}
+function eventSnapshotVariable(event) {
+  if (event.kind !== "snapshot") return null;
+  const target = event.target;
+  if (!target || typeof target !== "object" || !("variable" in target)) return null;
+  const variable = target.variable;
+  return typeof variable === "string" && variable.length > 0 ? variable : null;
+}
+function cloneRuntimeEventAtLine(event, line) {
+  return { ...event, line };
+}
+function expandJavaLoopHeaderTraceEvents(events, sourceText) {
+  if (events.length === 0) return events;
+  const controlHeaderInfo = buildJavaControlHeaderInfo(sourceText);
+  if (!controlHeaderInfo) return events;
+  const { loopBodyLineToHeader, headerLineToExcludedVariables } = controlHeaderInfo;
+  const expanded = [];
+  const latestSnapshotByVariable = /* @__PURE__ */ new Map();
+  let lastLineEventLine = null;
+  for (let index = 0; index < events.length; index += 1) {
+    const event = events[index];
+    const line = eventLine(event);
+    const snapshotVariable = eventSnapshotVariable(event);
+    if (line !== null && snapshotVariable && headerLineToExcludedVariables.get(line)?.has(snapshotVariable)) {
+      continue;
+    }
+    const headerInfo = line === null ? void 0 : loopBodyLineToHeader.get(line);
+    const headerLine = headerInfo?.line;
+    if (headerInfo && typeof headerLine === "number" && event.kind === "line" && lastLineEventLine !== headerLine) {
+      expanded.push(cloneRuntimeEventAtLine(event, headerLine));
+      for (const [variable, snapshotEvent] of latestSnapshotByVariable) {
+        if (headerInfo.excludedVariables.has(variable)) continue;
+        expanded.push(cloneRuntimeEventAtLine(snapshotEvent, headerLine));
+      }
+      lastLineEventLine = headerLine;
+    }
+    if (headerInfo && typeof headerLine === "number" && event.kind === "line") {
+      for (let lookahead = index + 1; lookahead < events.length; lookahead += 1) {
+        if (eventLine(events[lookahead]) !== line) break;
+        const variable = eventSnapshotVariable(events[lookahead]);
+        if (!variable || !headerInfo.headerVariables.has(variable)) continue;
+        expanded.push(cloneRuntimeEventAtLine(events[lookahead], headerLine));
+      }
+    }
+    expanded.push(event);
+    if (event.kind === "line") {
+      lastLineEventLine = line;
+    }
+    if (snapshotVariable) {
+      latestSnapshotByVariable.set(snapshotVariable, event);
+    }
+  }
+  return expanded;
+}
+function nativeJavaTraceEventsToTrace(events, sourceText, options = {}) {
+  const runId = options.runId ?? "java:run";
+  let parsedEvents = events.map((event) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(normalizeJavaNativeTraceJsonPayload(event.slice("trace:".length)));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid Java native runtime trace event: ${message}
+${event.slice(0, 500)}`);
+    }
+    return {
+      ...parsed,
+      runId,
+      ...options.file ? { file: options.file } : {}
+    };
+  });
+  parsedEvents = removeSameLineMutationDeclarationSnapshotEvents(parsedEvents, sourceText);
+  parsedEvents = expandJavaLoopHeaderTraceEvents(parsedEvents, sourceText);
+  return {
+    schemaVersion: RUNTIME_TRACE_SCHEMA_VERSION,
+    language: "java",
+    runId,
+    events: parsedEvents,
+    lineEventCount: parsedEvents.filter((event) => event.kind === "line").length,
+    traceStepCount: parsedEvents.length
+  };
+}
+function javaTraceHooksEventsToRuntimeTrace(events, sourceText, options = {}) {
+  assertSupportedRawEmissions(summarizeJavaRawEmissions(events), "java");
+  if (events.length === 0) {
+    return {
+      schemaVersion: RUNTIME_TRACE_SCHEMA_VERSION,
+      language: "java",
+      runId: options.runId ?? "java:run",
+      events: [],
+      lineEventCount: 0,
+      traceStepCount: 0
+    };
+  }
+  if (!events.every(isNativeJavaTraceEvent)) {
+    throw new Error("Java TraceHooks must emit native runtime trace events. Unsupported line=... events are no longer supported.");
+  }
+  return nativeJavaTraceEventsToTrace(events, sourceText, options);
+}
+
 // packages/harness-browser/src/java-worker-client.ts
+var EXECUTION_TIMEOUT_MS2 = 2e4;
 var TRACING_TIMEOUT_MS2 = 25e3;
-var INIT_TIMEOUT_MS2 = 25e3;
+var INIT_TIMEOUT_MS2 = 12e4;
 var MESSAGE_TIMEOUT_MS2 = 3e4;
 var WORKER_READY_TIMEOUT_MS2 = 1e4;
+var JAVA_DEFAULT_FILE = "solution.java";
 var JavaWorkerClient = class {
   constructor(options) {
     this.options = options;
@@ -980,6 +1495,7 @@ var JavaWorkerClient = class {
   messageId = 0;
   isInitializing = false;
   initPromise = null;
+  warmupPromise = null;
   workerReadyPromise = null;
   workerReadyResolve = null;
   workerReadyReject = null;
@@ -1004,6 +1520,22 @@ var JavaWorkerClient = class {
         this.workerReadyResolve?.();
         this.workerReadyResolve = null;
         this.workerReadyReject = null;
+        logRuntimeDiagnostic("info", {
+          component: "JavaWorkerClient",
+          runtime: "java",
+          phase: "worker-ready",
+          message: "Java worker is ready."
+        }, { enabled: this.debug });
+        return;
+      }
+      if (type === "idle-timeout") {
+        logRuntimeDiagnostic("info", {
+          component: "JavaWorkerClient",
+          runtime: "java",
+          phase: "idle-timeout",
+          message: "Java worker closed after idle timeout."
+        }, { enabled: this.debug });
+        this.terminateAndReset(new Error("Java worker closed after idle timeout"));
         return;
       }
       if (!id) return;
@@ -1018,6 +1550,18 @@ var JavaWorkerClient = class {
       pending.resolve(payload);
     };
     this.worker.onerror = (error) => {
+      logRuntimeDiagnostic("error", {
+        component: "JavaWorkerClient",
+        runtime: "java",
+        phase: "worker-error",
+        message: "Java worker emitted an error event.",
+        detail: {
+          message: error.message,
+          filename: error.filename,
+          lineno: error.lineno,
+          colno: error.colno
+        }
+      });
       const workerError = new Error(error.message || "Java worker error");
       this.workerReadyReject?.(workerError);
       this.workerReadyResolve = null;
@@ -1042,6 +1586,13 @@ var JavaWorkerClient = class {
         const timeoutError = new Error(
           `Java worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS2 / 1e3)}s)`
         );
+        logRuntimeDiagnostic("warn", {
+          component: "JavaWorkerClient",
+          runtime: "java",
+          phase: "worker-ready-timeout",
+          message: "Java worker did not send worker-ready before the timeout.",
+          detail: { timeoutMs: WORKER_READY_TIMEOUT_MS2 }
+        }, { enabled: this.debug });
         this.terminateAndReset(timeoutError);
         reject(timeoutError);
       }, WORKER_READY_TIMEOUT_MS2);
@@ -1071,6 +1622,13 @@ var JavaWorkerClient = class {
         const pending2 = this.pendingMessages.get(id);
         if (!pending2) return;
         this.pendingMessages.delete(id);
+        logRuntimeDiagnostic("warn", {
+          component: "JavaWorkerClient",
+          runtime: "java",
+          phase: "worker-request-timeout",
+          message: "Java worker request timed out.",
+          detail: { id, type, timeoutMs }
+        }, { enabled: this.debug });
         pending2.reject(new Error(`Worker request timed out: ${type}`));
       }, timeoutMs);
       const pending = this.pendingMessages.get(id);
@@ -1084,6 +1642,13 @@ var JavaWorkerClient = class {
       const timeoutId = globalThis.setTimeout(() => {
         if (settled) return;
         settled = true;
+        logRuntimeDiagnostic("warn", {
+          component: "JavaWorkerClient",
+          runtime: "java",
+          phase: "execution-timeout",
+          message: "Java execution timed out; terminating worker.",
+          detail: { timeoutMs }
+        }, { enabled: this.debug });
         this.terminateAndReset();
         reject(
           new Error(
@@ -1111,6 +1676,7 @@ var JavaWorkerClient = class {
       this.worker = null;
     }
     this.initPromise = null;
+    this.warmupPromise = null;
     this.isInitializing = false;
     this.workerReadyPromise = null;
     this.workerReadyResolve = null;
@@ -1128,7 +1694,26 @@ var JavaWorkerClient = class {
       return this.init();
     }
     this.isInitializing = true;
-    this.initPromise = this.sendMessage("init", void 0, INIT_TIMEOUT_MS2);
+    this.initPromise = (async () => {
+      try {
+        return await this.sendMessage("init", this.workerOptionsPayload(), INIT_TIMEOUT_MS2);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const shouldRetry = message.includes("Worker request timed out: init") || message.includes("Worker was terminated") || message.includes("Java worker error") || message.includes("failed to initialize in time");
+        if (!shouldRetry) {
+          throw error;
+        }
+        logRuntimeDiagnostic("warn", {
+          component: "JavaWorkerClient",
+          runtime: "java",
+          phase: "init-retry",
+          message: "Java worker init failed; resetting worker and retrying once.",
+          detail: { message }
+        }, { enabled: this.debug });
+        this.terminateAndReset(error instanceof Error ? error : new Error(message));
+        return this.sendMessage("init", this.workerOptionsPayload(), INIT_TIMEOUT_MS2);
+      }
+    })();
     try {
       return await this.initPromise;
     } catch (error) {
@@ -1138,9 +1723,29 @@ var JavaWorkerClient = class {
       this.isInitializing = false;
     }
   }
+  workerOptionsPayload() {
+    return this.options.workerIdleTimeoutMs === void 0 ? {} : { idleTimeoutMs: this.options.workerIdleTimeoutMs };
+  }
+  async warmup() {
+    if (this.warmupPromise) return this.warmupPromise;
+    this.warmupPromise = (async () => {
+      try {
+        await this.init();
+        return await this.sendMessage(
+          "warmup",
+          this.workerOptionsPayload(),
+          INIT_TIMEOUT_MS2
+        );
+      } catch (error) {
+        this.warmupPromise = null;
+        throw error;
+      }
+    })();
+    return this.warmupPromise;
+  }
   async executeWithTracing(code, functionName, inputs, options, executionStyle) {
     await this.init();
-    return this.executeWithTimeout(
+    const result = await this.executeWithTimeout(
       () => this.sendMessage(
         "execute-with-tracing",
         { code, functionName, inputs, options, executionStyle },
@@ -1148,668 +1753,1225 @@ var JavaWorkerClient = class {
       ),
       TRACING_TIMEOUT_MS2
     );
+    return {
+      ...result,
+      trace: result.success ? javaTraceHooksEventsToRuntimeTrace(result.events, result.sourceText, {
+        runId: "java:run",
+        file: JAVA_DEFAULT_FILE
+      }) : createEmptyRuntimeTrace("java", { runId: "java:run", file: JAVA_DEFAULT_FILE })
+    };
   }
   async executeCode(code, functionName, inputs, options, executionStyle) {
-    const result = await this.executeWithTracing(code, functionName, inputs, options, executionStyle);
+    return this.executeCodeMessage("execute-code", code, functionName, inputs, options, executionStyle);
+  }
+  async executeCodeMessage(type, code, functionName, inputs, options, executionStyle) {
+    await this.init();
+    const result = await this.executeWithTimeout(
+      () => this.sendMessage(
+        type,
+        { code, functionName, inputs, options, executionStyle },
+        EXECUTION_TIMEOUT_MS2 + 5e3
+      ),
+      EXECUTION_TIMEOUT_MS2
+    );
     if (!result.success) {
       return {
         success: false,
         output: null,
         error: result.error ?? "Java execution failed",
         ...result.errorLine !== void 0 ? { errorLine: result.errorLine } : {},
-        consoleOutput: result.consoleOutput
+        consoleOutput: result.consoleOutput ?? [],
+        timings: result.timings
       };
     }
     return {
       success: true,
       output: result.output,
-      consoleOutput: result.consoleOutput
+      consoleOutput: result.consoleOutput ?? [],
+      timings: result.timings
     };
   }
   async executeCodeInterviewMode(code, functionName, inputs, options, executionStyle) {
-    return this.executeCode(code, functionName, inputs, options, executionStyle);
+    return this.executeCodeMessage("execute-code-interview", code, functionName, inputs, options, executionStyle);
   }
   terminate() {
     this.terminateAndReset();
   }
 };
 
-// packages/harness-core/src/trace-adapters/java.ts
-function parseScalar(raw) {
-  if (raw === "null") return null;
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  if (/^-?\d+$/.test(raw)) return Number.parseInt(raw, 10);
-  if (/^-?\d+\.\d+$/.test(raw)) return Number.parseFloat(raw);
-  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("[") && raw.endsWith("]") || raw.startsWith("{") && raw.endsWith("}")) {
-    try {
-      return JSON.parse(raw);
-    } catch {
-    }
-  }
-  return raw;
-}
-function normalizeJavaSerializedResult(output) {
-  if (typeof output !== "string") {
-    return output;
-  }
-  try {
-    return JSON.parse(output);
-  } catch {
-    return output;
+// packages/harness-browser/src/java-runtime-client.ts
+var JAVA_DEFAULT_FILE2 = "solution.java";
+var JavaRuntimeClient = class {
+  constructor(workerClient) {
+    this.workerClient = workerClient;
   }
-}
-function parseKeyValuePairs(fragment) {
-  const variables = {};
-  const matches = Array.from(fragment.matchAll(/\b([A-Za-z_][A-Za-z0-9_.]*)=/g));
-  for (let index = 0; index < matches.length; index += 1) {
-    const match = matches[index];
-    const rawKey = match[1];
-    const valueStart = (match.index ?? 0) + match[0].length;
-    const valueEnd = index + 1 < matches.length ? matches[index + 1].index ?? fragment.length : fragment.length;
-    const rawValue = fragment.slice(valueStart, valueEnd).trim();
-    if (!rawKey || rawValue === void 0) continue;
-    if (rawKey === "method") continue;
-    variables[rawKey.replaceAll(".", "_")] = parseScalar(rawValue);
-  }
-  return variables;
-}
-function extractLineMetadata(event) {
-  const match = event.match(/^line=(\d+)(?:\s+(.*))?$/);
-  if (!match) {
-    return { line: 1, payload: event };
+  async init() {
+    return this.workerClient.init();
   }
-  return {
-    line: Number.parseInt(match[1], 10),
-    payload: match[2] ?? ""
-  };
-}
-function stripInlineComments(line, inBlockComment) {
-  let result = "";
-  let index = 0;
-  let inBlock = inBlockComment;
-  while (index < line.length) {
-    const current = line[index];
-    const next = index + 1 < line.length ? line[index + 1] : "";
-    if (inBlock) {
-      if (current === "*" && next === "/") {
-        inBlock = false;
-        index += 2;
-        continue;
+  async executeWithTracing(code, functionName, inputs, options, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+      request: "trace",
+      executionStyle,
+      functionName
+    });
+    const rawResult = await this.workerClient.executeWithTracing(
+      code,
+      functionName ?? "",
+      inputs,
+      options,
+      executionStyle
+    );
+    if (!rawResult.success) {
+      return {
+        success: false,
+        error: rawResult.error ?? "Java tracing failed",
+        ...rawResult.errorLine !== void 0 ? { errorLine: rawResult.errorLine } : {},
+        trace: createEmptyRuntimeTrace("java", { runId: "java:run", file: JAVA_DEFAULT_FILE2 }),
+        executionTimeMs: rawResult.executionTimeMs,
+        consoleOutput: rawResult.consoleOutput,
+        ...rawResult.traceLimitExceeded !== void 0 ? { traceLimitExceeded: rawResult.traceLimitExceeded } : {},
+        ...rawResult.timeoutReason ? { timeoutReason: rawResult.timeoutReason } : {},
+        lineEventCount: 0,
+        traceStepCount: 0,
+        timings: rawResult.timings
+      };
+    }
+    return {
+      success: true,
+      output: rawResult.output,
+      trace: rawResult.trace,
+      consoleOutput: rawResult.consoleOutput,
+      executionTimeMs: rawResult.executionTimeMs,
+      ...rawResult.traceLimitExceeded !== void 0 ? { traceLimitExceeded: rawResult.traceLimitExceeded } : {},
+      ...rawResult.timeoutReason ? { timeoutReason: rawResult.timeoutReason } : {},
+      lineEventCount: rawResult.trace.lineEventCount,
+      traceStepCount: rawResult.trace.traceStepCount,
+      timings: rawResult.timings
+    };
+  }
+  async executeCode(code, functionName, inputs, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+      request: "execute",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCode(
+      code,
+      functionName,
+      inputs,
+      void 0,
+      executionStyle
+    );
+  }
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+      request: "interview",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCodeInterviewMode(
+      code,
+      functionName,
+      inputs,
+      void 0,
+      executionStyle
+    );
+  }
+};
+function createJavaRuntimeClient(workerClient) {
+  return new JavaRuntimeClient(workerClient);
+}
+
+// packages/harness-browser/src/csharp-worker-client.ts
+var EXECUTION_TIMEOUT_MS3 = 2e4;
+var TRACING_TIMEOUT_MS3 = 2e4;
+var INTERVIEW_MODE_TIMEOUT_MS2 = 5e3;
+var INIT_TIMEOUT_MS3 = 45e3;
+var MESSAGE_TIMEOUT_MS3 = 3e4;
+var WORKER_READY_TIMEOUT_MS3 = 1e4;
+var CSHARP_DEFAULT_FILE = "solution.cs";
+var CSHARP_LEGACY_USER_FILE = "UserCode.cs";
+function isCSharpUserFile(file) {
+  return Boolean(file?.endsWith(CSHARP_DEFAULT_FILE) || file?.endsWith(CSHARP_LEGACY_USER_FILE));
+}
+function isCSharpUserDiagnostic(diagnostic) {
+  return isCSharpUserFile(diagnostic.file);
+}
+function normalizeCSharpTraceEventFile(event) {
+  return isCSharpUserFile(event.file) ? { ...event, file: CSHARP_DEFAULT_FILE } : event;
+}
+var CSharpWorkerClient = class {
+  constructor(options) {
+    this.options = options;
+    this.debug = options.debug ?? process.env.NODE_ENV === "development";
+    this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS3;
+    this.executionTimeoutMs = options.executionTimeoutMs ?? EXECUTION_TIMEOUT_MS3;
+    this.tracingTimeoutMs = options.tracingTimeoutMs ?? TRACING_TIMEOUT_MS3;
+    this.interviewTimeoutMs = options.interviewTimeoutMs ?? INTERVIEW_MODE_TIMEOUT_MS2;
+  }
+  worker = null;
+  pendingMessages = /* @__PURE__ */ new Map();
+  messageId = 0;
+  isInitializing = false;
+  initPromise = null;
+  warmupPromise = null;
+  workerReadyPromise = null;
+  workerReadyResolve = null;
+  workerReadyReject = null;
+  debug;
+  initTimeoutMs;
+  executionTimeoutMs;
+  tracingTimeoutMs;
+  interviewTimeoutMs;
+  isSupported() {
+    return typeof Worker !== "undefined";
+  }
+  getWorker() {
+    if (this.worker) return this.worker;
+    if (!this.isSupported()) {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    this.workerReadyPromise = new Promise((resolve, reject) => {
+      this.workerReadyResolve = resolve;
+      this.workerReadyReject = (error) => reject(error);
+    });
+    const workerUrl = this.debug && !this.options.workerUrl.includes("?") ? `${this.options.workerUrl}?dev=${Date.now()}` : this.options.workerUrl;
+    this.worker = new Worker(workerUrl, { type: "module" });
+    this.worker.onmessage = (event) => {
+      const { id, type, payload } = event.data;
+      if (type === "worker-ready") {
+        this.workerReadyResolve?.();
+        this.workerReadyResolve = null;
+        this.workerReadyReject = null;
+        logRuntimeDiagnostic("info", {
+          component: "CSharpWorkerClient",
+          runtime: "csharp",
+          phase: "worker-ready",
+          message: "C# worker is ready."
+        }, { enabled: this.debug });
+        return;
+      }
+      if (type === "idle-timeout") {
+        logRuntimeDiagnostic("info", {
+          component: "CSharpWorkerClient",
+          runtime: "csharp",
+          phase: "idle-timeout",
+          message: "C# worker closed after idle timeout."
+        }, { enabled: this.debug });
+        this.terminateAndReset(new Error("C# worker closed after idle timeout"));
+        return;
+      }
+      if (!id) return;
+      const pending = this.pendingMessages.get(id);
+      if (!pending) return;
+      this.pendingMessages.delete(id);
+      if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+      if (type === "error") {
+        pending.reject(new Error(payload.error));
+        return;
+      }
+      pending.resolve(payload);
+    };
+    this.worker.onerror = (error) => {
+      logRuntimeDiagnostic("error", {
+        component: "CSharpWorkerClient",
+        runtime: "csharp",
+        phase: "worker-error",
+        message: "C# worker emitted an error event.",
+        detail: {
+          message: error.message,
+          filename: error.filename,
+          lineno: error.lineno,
+          colno: error.colno
+        }
+      });
+      const workerError = new Error(error.message || "C# worker error");
+      this.workerReadyReject?.(workerError);
+      this.workerReadyResolve = null;
+      this.workerReadyReject = null;
+      for (const [, pending] of this.pendingMessages) {
+        if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+        pending.reject(workerError);
+      }
+      this.pendingMessages.clear();
+      this.terminateAndReset(workerError);
+    };
+    return this.worker;
+  }
+  async waitForWorkerReady() {
+    const readyPromise = this.workerReadyPromise;
+    if (!readyPromise) return;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const timeoutError = new Error(
+          `C# worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS3 / 1e3)}s)`
+        );
+        logRuntimeDiagnostic("warn", {
+          component: "CSharpWorkerClient",
+          runtime: "csharp",
+          phase: "worker-ready-timeout",
+          message: "C# worker did not send worker-ready before the timeout.",
+          detail: { timeoutMs: WORKER_READY_TIMEOUT_MS3 }
+        }, { enabled: this.debug });
+        this.terminateAndReset(timeoutError);
+        reject(timeoutError);
+      }, WORKER_READY_TIMEOUT_MS3);
+      readyPromise.then(() => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve();
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
+  }
+  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS3) {
+    const worker = this.getWorker();
+    await this.waitForWorkerReady();
+    const id = String(++this.messageId);
+    return new Promise((resolve, reject) => {
+      this.pendingMessages.set(id, {
+        resolve,
+        reject
+      });
+      const timeoutId = globalThis.setTimeout(() => {
+        const pending2 = this.pendingMessages.get(id);
+        if (!pending2) return;
+        this.pendingMessages.delete(id);
+        logRuntimeDiagnostic("warn", {
+          component: "CSharpWorkerClient",
+          runtime: "csharp",
+          phase: "worker-request-timeout",
+          message: "C# worker request timed out.",
+          detail: { id, type, timeoutMs }
+        }, { enabled: this.debug });
+        pending2.reject(new Error(`Worker request timed out: ${type}`));
+      }, timeoutMs);
+      const pending = this.pendingMessages.get(id);
+      if (pending) pending.timeoutId = timeoutId;
+      worker.postMessage({ id, type, payload });
+    });
+  }
+  async executeWithTimeout(executor, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        logRuntimeDiagnostic("warn", {
+          component: "CSharpWorkerClient",
+          runtime: "csharp",
+          phase: "execution-timeout",
+          message: "C# execution timed out; terminating worker.",
+          detail: { timeoutMs }
+        }, { enabled: this.debug });
+        this.terminateAndReset();
+        reject(new Error(`C# execution timed out after ${Math.round(timeoutMs / 1e3)} seconds.`));
+      }, timeoutMs);
+      executor().then((result) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  terminateAndReset(reason = new Error("Worker was terminated")) {
+    this.workerReadyReject?.(reason);
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.initPromise = null;
+    this.warmupPromise = null;
+    this.isInitializing = false;
+    this.workerReadyPromise = null;
+    this.workerReadyResolve = null;
+    this.workerReadyReject = null;
+    for (const [, pending] of this.pendingMessages) {
+      if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+      pending.reject(reason);
+    }
+    this.pendingMessages.clear();
+  }
+  shouldRetryInit(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("timed out") || message.includes("Worker request timed out") || message.includes("worker error") || message.includes("Failed to fetch") || message.includes("was terminated") || message.includes("closed after idle timeout");
+  }
+  sendInitMessage() {
+    return this.sendMessage(
+      "init",
+      { assetBaseUrl: this.options.assetBaseUrl, ...this.workerOptionsPayload() },
+      this.initTimeoutMs
+    );
+  }
+  workerOptionsPayload() {
+    return this.options.workerIdleTimeoutMs === void 0 ? {} : { idleTimeoutMs: this.options.workerIdleTimeoutMs };
+  }
+  async init() {
+    if (this.initPromise) return this.initPromise;
+    if (this.isInitializing) {
+      await new Promise((resolve) => globalThis.setTimeout(resolve, 100));
+      return this.init();
+    }
+    this.isInitializing = true;
+    this.initPromise = (async () => {
+      try {
+        return await this.sendInitMessage();
+      } catch (error) {
+        if (!this.shouldRetryInit(error)) throw error;
+        this.terminateAndReset(error instanceof Error ? error : new Error(String(error)));
+        return this.sendInitMessage();
+      }
+    })();
+    try {
+      return await this.initPromise;
+    } catch (error) {
+      this.initPromise = null;
+      throw error;
+    } finally {
+      this.isInitializing = false;
+    }
+  }
+  async warmup() {
+    if (this.warmupPromise) return this.warmupPromise;
+    this.warmupPromise = (async () => {
+      try {
+        await this.init();
+        return await this.sendMessage(
+          "warmup",
+          { assetBaseUrl: this.options.assetBaseUrl, ...this.workerOptionsPayload() },
+          this.initTimeoutMs
+        );
+      } catch (error) {
+        this.warmupPromise = null;
+        throw error;
+      }
+    })();
+    return this.warmupPromise;
+  }
+  async executeCode(code, functionName, inputs, executionStyle) {
+    await this.init();
+    const result = await this.executeWithTimeout(
+      () => this.sendMessage(
+        "execute-code",
+        {
+          code,
+          functionName,
+          inputs,
+          executionStyle,
+          assetBaseUrl: this.options.assetBaseUrl,
+          timeoutMs: Math.max(100, this.executionTimeoutMs - 1e3),
+          ...this.workerOptionsPayload()
+        },
+        this.executionTimeoutMs + 5e3
+      ),
+      this.executionTimeoutMs
+    );
+    if (!result.success) {
+      const firstUserDiagnostic = result.diagnostics?.find(isCSharpUserDiagnostic);
+      return {
+        success: false,
+        output: null,
+        error: result.error ?? "C# execution failed",
+        ...firstUserDiagnostic ? { errorLine: firstUserDiagnostic.line } : {},
+        consoleOutput: result.consoleOutput ?? [],
+        timings: result.timings
+      };
+    }
+    return {
+      success: true,
+      output: result.output,
+      consoleOutput: result.consoleOutput ?? [],
+      timings: result.timings
+    };
+  }
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle) {
+    await this.init();
+    let result;
+    try {
+      result = await this.executeWithTimeout(
+        () => this.sendMessage(
+          "execute-code-interview",
+          {
+            code,
+            functionName,
+            inputs,
+            executionStyle,
+            assetBaseUrl: this.options.assetBaseUrl,
+            timeoutMs: Math.max(100, this.interviewTimeoutMs - 1e3),
+            ...this.workerOptionsPayload()
+          },
+          this.interviewTimeoutMs + 5e3
+        ),
+        this.interviewTimeoutMs
+      );
+    } catch {
+      return {
+        success: false,
+        output: null,
+        error: "Time Limit Exceeded",
+        timeoutReason: "client-timeout",
+        diagnosticStage: "interview",
+        consoleOutput: [],
+        timings: { totalMs: this.interviewTimeoutMs }
+      };
+    }
+    if (!result.success) {
+      const firstUserDiagnostic = result.diagnostics?.find(isCSharpUserDiagnostic);
+      if (this.isInterviewTimeoutLike(result)) {
+        return {
+          success: false,
+          output: null,
+          error: "Time Limit Exceeded",
+          timeoutReason: result.timeoutReason ?? "client-timeout",
+          diagnosticStage: "interview",
+          consoleOutput: result.consoleOutput ?? [],
+          timings: result.timings
+        };
       }
-      index += 1;
-      continue;
+      return {
+        success: false,
+        output: null,
+        error: result.error ?? "C# execution failed",
+        ...firstUserDiagnostic ? { errorLine: firstUserDiagnostic.line } : {},
+        consoleOutput: result.consoleOutput ?? [],
+        timings: result.timings
+      };
     }
-    if (current === "/" && next === "*") {
-      inBlock = true;
-      index += 2;
-      continue;
+    return {
+      success: true,
+      output: result.output,
+      consoleOutput: result.consoleOutput ?? [],
+      timings: result.timings
+    };
+  }
+  async executeWithTracing(code, functionName, inputs, options, executionStyle) {
+    await this.init();
+    let result;
+    try {
+      result = await this.executeWithTimeout(
+        () => this.sendMessage(
+          "execute-with-tracing",
+          {
+            code,
+            functionName,
+            inputs,
+            executionStyle,
+            assetBaseUrl: this.options.assetBaseUrl,
+            timeoutMs: Math.max(100, this.tracingTimeoutMs - 1e3),
+            maxTraceSteps: options?.maxTraceSteps,
+            maxLineEvents: options?.maxLineEvents,
+            maxSingleLineHits: options?.maxSingleLineHits,
+            maxStoredEvents: options?.maxStoredEvents,
+            minimalTrace: options?.minimalTrace,
+            ...this.workerOptionsPayload()
+          },
+          this.tracingTimeoutMs + 5e3
+        ),
+        this.tracingTimeoutMs
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const trace2 = this.createTrace([
+        {
+          kind: "timeout",
+          runId: "csharp:run",
+          file: CSHARP_DEFAULT_FILE,
+          message
+        }
+      ]);
+      return {
+        success: false,
+        output: null,
+        error: message,
+        trace: trace2,
+        executionTimeMs: this.tracingTimeoutMs,
+        consoleOutput: [],
+        traceLimitExceeded: true,
+        timeoutReason: "client-timeout",
+        lineEventCount: trace2.lineEventCount,
+        traceStepCount: trace2.traceStepCount,
+        timings: { totalMs: this.tracingTimeoutMs }
+      };
     }
-    if (current === "/" && next === "/") {
-      break;
+    const consoleOutput = result.consoleOutput ?? [];
+    const events = [
+      ...result.events ?? [],
+      ...consoleOutput.map((text) => ({
+        kind: "stdout",
+        runId: "csharp:run",
+        file: CSHARP_DEFAULT_FILE,
+        text
+      }))
+    ];
+    const trace = this.createTrace(events);
+    if (!result.success) {
+      const firstUserDiagnostic = result.diagnostics?.find(isCSharpUserDiagnostic);
+      return {
+        success: false,
+        output: null,
+        error: result.error ?? "C# execution failed",
+        ...firstUserDiagnostic ? { errorLine: firstUserDiagnostic.line } : {},
+        trace,
+        executionTimeMs: result.executionTimeMs ?? 0,
+        consoleOutput,
+        ...result.traceLimitExceeded !== void 0 ? { traceLimitExceeded: result.traceLimitExceeded } : {},
+        ...result.timeoutReason ? { timeoutReason: result.timeoutReason } : {},
+        lineEventCount: trace.lineEventCount,
+        traceStepCount: trace.traceStepCount,
+        timings: result.timings
+      };
     }
-    result += current;
-    index += 1;
+    return {
+      success: true,
+      output: result.output,
+      trace,
+      executionTimeMs: result.executionTimeMs ?? 0,
+      consoleOutput,
+      ...result.traceLimitExceeded !== void 0 ? { traceLimitExceeded: result.traceLimitExceeded } : {},
+      ...result.timeoutReason ? { timeoutReason: result.timeoutReason } : {},
+      lineEventCount: trace.lineEventCount,
+      traceStepCount: trace.traceStepCount,
+      timings: result.timings
+    };
   }
-  return { text: result, inBlockComment: inBlock };
-}
-function isMethodDeclarationLine(line) {
-  const trimmed = line.trim();
-  if (!trimmed) return false;
-  if (trimmed.startsWith("@")) return false;
-  if (!trimmed.includes("(") || !trimmed.includes(")")) return false;
-  if (trimmed.endsWith(";")) return false;
-  if (trimmed.includes("->")) return false;
-  if (/^(?:if|for|while|switch|catch|do|try|else|return|throw|new)\b/.test(trimmed)) {
-    return false;
+  createTrace(events) {
+    return {
+      schemaVersion: RUNTIME_TRACE_SCHEMA_VERSION,
+      language: "csharp",
+      runId: "csharp:run",
+      events: events.map(normalizeCSharpTraceEventFile),
+      lineEventCount: events.filter((event) => event.kind === "line").length,
+      traceStepCount: events.length
+    };
   }
-  if (!/[A-Za-z_][A-Za-z0-9_]*\s*\([^{};]*\)/.test(trimmed)) {
-    return false;
+  isInterviewTimeoutLike(result) {
+    if (result.timeoutReason) return true;
+    const normalized = String(result.error ?? "").toLowerCase();
+    return normalized.includes("timed out") || normalized.includes("trace-limit") || normalized.includes("line-limit") || normalized.includes("single-line-limit") || normalized.includes("recursion-limit") || normalized.includes("memory-limit");
   }
-  return /(?:\{\s*)?$/.test(trimmed);
-}
-function buildLineRemap(sourceText) {
-  if (typeof sourceText !== "string" || sourceText.length === 0) {
-    return null;
+  terminate() {
+    this.terminateAndReset();
   }
-  const lines = sourceText.split(/\r?\n/);
-  const executable = /* @__PURE__ */ new Set();
-  let inBlockComment = false;
-  for (let index = 0; index < lines.length; index += 1) {
-    const { text, inBlockComment: nextInBlockComment } = stripInlineComments(lines[index] ?? "", inBlockComment);
-    inBlockComment = nextInBlockComment;
-    if (text.trim().length > 0) {
-      executable.add(index + 1);
-    }
+};
+
+// packages/harness-browser/src/csharp-runtime-client.ts
+var CSharpRuntimeClient = class {
+  constructor(workerClient) {
+    this.workerClient = workerClient;
   }
-  if (executable.size === 0) {
-    return null;
+  async init() {
+    return this.workerClient.init();
   }
-  const nextExecutableAtOrAfter = new Array(lines.length + 2).fill(null);
-  let nextExecutable = null;
-  for (let line = lines.length; line >= 1; line -= 1) {
-    if (executable.has(line)) {
-      nextExecutable = line;
-    }
-    nextExecutableAtOrAfter[line] = nextExecutable;
+  async executeWithTracing(code, functionName, inputs, options, executionStyle = "solution-method") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("csharp"), {
+      request: "trace",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeWithTracing(
+      code,
+      functionName ?? "",
+      inputs,
+      options,
+      executionStyle
+    );
   }
-  const previousExecutableAtOrBefore = new Array(lines.length + 2).fill(null);
-  let previousExecutable = null;
-  for (let line = 1; line <= lines.length; line += 1) {
-    if (executable.has(line)) {
-      previousExecutable = line;
-    }
-    previousExecutableAtOrBefore[line] = previousExecutable;
+  async executeCode(code, functionName, inputs, executionStyle = "solution-method") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("csharp"), {
+      request: "execute",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCode(
+      code,
+      functionName,
+      inputs,
+      executionStyle
+    );
   }
-  const remap = /* @__PURE__ */ new Map();
-  for (let line = 1; line <= lines.length; line += 1) {
-    if (executable.has(line)) continue;
-    const forward = nextExecutableAtOrAfter[line];
-    const backward = previousExecutableAtOrBefore[line];
-    const target = forward ?? backward;
-    if (target !== null && target !== line) {
-      remap.set(line, target);
-    }
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "solution-method") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("csharp"), {
+      request: "interview",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCodeInterviewMode(
+      code,
+      functionName,
+      inputs,
+      executionStyle
+    );
   }
-  return remap;
+};
+function createCSharpRuntimeClient(workerClient) {
+  return new CSharpRuntimeClient(workerClient);
 }
-function buildMethodDeclarationLineSet(sourceText) {
-  if (typeof sourceText !== "string" || sourceText.length === 0) {
-    return null;
+
+// packages/harness-browser/src/cpp-worker-client.ts
+var CppClientTimeoutError = class extends Error {
+  constructor(message, stage, timeoutMs) {
+    super(message);
+    this.stage = stage;
+    this.timeoutMs = timeoutMs;
+    this.name = "CppClientTimeoutError";
   }
-  const declarationLines = /* @__PURE__ */ new Set();
-  const lines = sourceText.split(/\r?\n/);
-  let inBlockComment = false;
-  for (let index = 0; index < lines.length; index += 1) {
-    const { text, inBlockComment: nextInBlockComment } = stripInlineComments(lines[index] ?? "", inBlockComment);
-    inBlockComment = nextInBlockComment;
-    if (isMethodDeclarationLine(text)) {
-      declarationLines.add(index + 1);
-    }
+};
+var INIT_TIMEOUT_MS4 = 12e4;
+var EXECUTION_TIMEOUT_MS4 = 6e4;
+var TRACING_TIMEOUT_MS4 = 6e4;
+var INTERVIEW_MODE_TIMEOUT_MS3 = 3e4;
+var MESSAGE_TIMEOUT_MS4 = 3e4;
+var WORKER_READY_TIMEOUT_MS4 = 1e4;
+var CPP_DEFAULT_FILE = "solution.cpp";
+var CppWorkerClient = class {
+  constructor(options) {
+    this.options = options;
+    this.debug = options.debug ?? process.env.NODE_ENV === "development";
+    this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS4;
+    this.executionTimeoutMs = options.executionTimeoutMs ?? EXECUTION_TIMEOUT_MS4;
+    this.tracingTimeoutMs = options.tracingTimeoutMs ?? TRACING_TIMEOUT_MS4;
+    this.interviewTimeoutMs = options.interviewTimeoutMs ?? INTERVIEW_MODE_TIMEOUT_MS3;
+    this.compilerFrameUrl = options.compilerFrameUrl;
   }
-  return declarationLines;
-}
-function parseAccessEvent(payload) {
-  const isEphemeralOutputArrayName = (name) => /^(output|outputs)$/i.test(name);
-  const cellRead = payload.match(/^access ([A-Za-z_][A-Za-z0-9_]*)\[(\d+)\]\[(\d+)\]=(.+)$/);
-  if (cellRead) {
-    return [{
-      variable: cellRead[1],
-      kind: "cell-read",
-      indices: [Number.parseInt(cellRead[2], 10), Number.parseInt(cellRead[3], 10)],
-      pathDepth: 2
-    }];
-  }
-  const indexedRead = payload.match(/^access ([A-Za-z_][A-Za-z0-9_]*)\[(\d+)\]=(.+)$/);
-  if (indexedRead) {
-    return [{
-      variable: indexedRead[1],
-      kind: "indexed-read",
-      indices: [Number.parseInt(indexedRead[2], 10)],
-      pathDepth: 1
-    }];
-  }
-  const cellWrite = payload.match(/^write-array ([A-Za-z_][A-Za-z0-9_]*)\[(\d+)\]\[(\d+)\]=(.+)$/);
-  if (cellWrite) {
-    return [{
-      variable: cellWrite[1],
-      kind: "cell-write",
-      indices: [Number.parseInt(cellWrite[2], 10), Number.parseInt(cellWrite[3], 10)],
-      pathDepth: 2
-    }];
-  }
-  const indexedWrite = payload.match(/^write-array ([A-Za-z_][A-Za-z0-9_]*)\[(\d+)\]=(.+)$/);
-  if (indexedWrite) {
-    if (isEphemeralOutputArrayName(indexedWrite[1])) {
-      return void 0;
-    }
-    return [{
-      variable: indexedWrite[1],
-      kind: "indexed-write",
-      indices: [Number.parseInt(indexedWrite[2], 10)],
-      pathDepth: 1
-    }];
-  }
-  const mutatingCall = payload.match(/^mutate ([A-Za-z_][A-Za-z0-9_]*) method=([A-Za-z_][A-Za-z0-9_]*)$/);
-  if (mutatingCall) {
-    return [{
-      variable: mutatingCall[1],
-      kind: "mutating-call",
-      method: mutatingCall[2],
-      pathDepth: 1
-    }];
-  }
-  const indexedMutatingCall = payload.match(/^mutate-indexed ([A-Za-z_][A-Za-z0-9_]*)\[(\d+)\] method=([A-Za-z_][A-Za-z0-9_]*)$/);
-  if (indexedMutatingCall) {
-    return [{
-      variable: indexedMutatingCall[1],
-      kind: "mutating-call",
-      indices: [Number.parseInt(indexedMutatingCall[2], 10)],
-      method: indexedMutatingCall[3],
-      pathDepth: 1
-    }];
-  }
-  const keyedCall = payload.match(/^keyed-call ([A-Za-z_][A-Za-z0-9_]*) method=([A-Za-z_][A-Za-z0-9_]*)(?:\s+.*)?$/);
-  if (keyedCall) {
-    return [{
-      variable: keyedCall[1],
-      kind: "mutating-call",
-      method: keyedCall[2],
-      pathDepth: 1
-    }];
-  }
-  return void 0;
-}
-function parseStructureState(payload) {
-  const match = payload.match(/^state (linked-list|tree|graph-adjacency) ([A-Za-z_][A-Za-z0-9_]*)=(.+)$/);
-  if (!match) return null;
-  return {
-    structure: match[1],
-    variable: match[2],
-    value: JSON.parse(match[3])
-  };
-}
-function parseObjectState(payload) {
-  const match = payload.match(/^object-state ([A-Za-z_][A-Za-z0-9_]*)=(.+)$/);
-  if (!match) return null;
-  return {
-    variable: match[1],
-    visualization: JSON.parse(match[2])
-  };
-}
-function parseMapState(payload) {
-  const match = payload.match(/^map-state ([A-Za-z_][A-Za-z0-9_]*)=(.+)$/);
-  if (!match) return null;
-  return {
-    variable: match[1],
-    visualization: JSON.parse(match[2])
-  };
-}
-function parseSetState(payload) {
-  const match = payload.match(/^set-state ([A-Za-z_][A-Za-z0-9_]*)=(.+)$/);
-  if (!match) return null;
-  return {
-    variable: match[1],
-    visualization: JSON.parse(match[2])
-  };
-}
-function parseObjectFieldEvent(payload) {
-  const match = payload.match(/^(access|write) ([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)=(.+)$/);
-  if (!match) return null;
-  return {
-    variable: match[2],
-    field: match[3],
-    value: parseScalar(match[4])
-  };
-}
-function isArrayLengthAccessEvent(payload) {
-  return /^access [A-Za-z_][A-Za-z0-9_]*\.length=\d+$/.test(payload);
-}
-function buildFieldVisualization(event) {
-  return {
-    objectKinds: {
-      [event.variable]: "object"
-    },
-    hashMaps: [
-      {
-        name: event.variable,
-        kind: "object",
-        objectClassName: event.field === "next" || event.field === "prev" ? "ListNode" : event.field === "left" || event.field === "right" ? "TreeNode" : void 0,
-        objectId: `${event.variable}-object`,
-        highlightedKey: event.field,
-        entries: [{ key: event.field, value: event.value, highlight: true }]
+  worker = null;
+  pendingMessages = /* @__PURE__ */ new Map();
+  messageId = 0;
+  initPromise = null;
+  warmupPromise = null;
+  workerReadyPromise = null;
+  workerReadyResolve = null;
+  workerReadyReject = null;
+  debug;
+  initTimeoutMs;
+  executionTimeoutMs;
+  tracingTimeoutMs;
+  interviewTimeoutMs;
+  compilerFrameUrl;
+  activeCompilerFrames = /* @__PURE__ */ new Set();
+  compilerFrame = null;
+  compilerFrameReadyPromise = null;
+  compilerFrameReadyResolve = null;
+  compilerFrameReadyReject = null;
+  compilerFrameTargetOrigin = "";
+  compilerFrameRequestId = 0;
+  compilerFrameMessageHandler = null;
+  pendingCompilerFrameRequests = /* @__PURE__ */ new Map();
+  isSupported() {
+    return typeof Worker !== "undefined";
+  }
+  getWorker() {
+    if (this.worker) return this.worker;
+    if (!this.isSupported()) {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    this.workerReadyPromise = new Promise((resolve, reject) => {
+      this.workerReadyResolve = resolve;
+      this.workerReadyReject = (error) => reject(error);
+    });
+    const workerUrl = this.debug && !this.options.workerUrl.includes("?") ? `${this.options.workerUrl}?dev=${Date.now()}` : this.options.workerUrl;
+    this.worker = new Worker(workerUrl, { type: "module" });
+    this.worker.onmessage = (event) => {
+      const { id, type, payload } = event.data;
+      if (type === "worker-ready") {
+        this.workerReadyResolve?.();
+        this.workerReadyResolve = null;
+        this.workerReadyReject = null;
+        logRuntimeDiagnostic("info", {
+          component: "CppWorkerClient",
+          runtime: "cpp",
+          phase: "worker-ready",
+          message: "C++ worker is ready."
+        }, { enabled: this.debug });
+        return;
       }
-    ]
-  };
-}
-function callStacksEqual(left, right) {
-  return JSON.stringify(left ?? []) === JSON.stringify(right ?? []);
-}
-function mergeVisualizationPayloads(left, right) {
-  if (!left) return right;
-  if (!right) return left;
-  return {
-    ...left,
-    ...right,
-    objectKinds: {
-      ...left.objectKinds ?? {},
-      ...right.objectKinds ?? {}
-    },
-    hashMaps: [
-      ...left.hashMaps ?? [],
-      ...right.hashMaps ?? []
-    ]
-  };
-}
-function maybeMergeConsecutiveLineStep(trace, nextStep) {
-  if (nextStep.event !== "line") {
-    return false;
+      if (type === "idle-timeout") {
+        logRuntimeDiagnostic("info", {
+          component: "CppWorkerClient",
+          runtime: "cpp",
+          phase: "idle-timeout",
+          message: "C++ worker closed after idle timeout."
+        }, { enabled: this.debug });
+        this.terminateAndReset(new Error("C++ worker closed after idle timeout"));
+        return;
+      }
+      if (type === "compile-request") {
+        this.handleCompileRequest(event.data).catch((error) => {
+          if (!event.data.requestId) return;
+          this.worker?.postMessage({
+            type: "compile-response",
+            requestId: event.data.requestId,
+            payload: { success: false, error: error instanceof Error ? error.message : String(error) }
+          });
+        });
+        return;
+      }
+      if (!id) return;
+      const pending = this.pendingMessages.get(id);
+      if (!pending) return;
+      this.pendingMessages.delete(id);
+      if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+      if (type === "error") {
+        pending.reject(new Error(payload.error));
+        return;
+      }
+      pending.resolve(payload);
+    };
+    this.worker.onerror = (error) => {
+      logRuntimeDiagnostic("error", {
+        component: "CppWorkerClient",
+        runtime: "cpp",
+        phase: "worker-error",
+        message: "C++ worker emitted an error event.",
+        detail: {
+          message: error.message,
+          filename: error.filename,
+          lineno: error.lineno,
+          colno: error.colno
+        }
+      });
+      const workerError = new Error(error.message || "C++ worker error");
+      this.workerReadyReject?.(workerError);
+      this.workerReadyResolve = null;
+      this.workerReadyReject = null;
+      this.terminateAndReset(workerError);
+    };
+    return this.worker;
+  }
+  async waitForWorkerReady() {
+    const readyPromise = this.workerReadyPromise;
+    if (!readyPromise) return;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const timeoutError = new Error(
+          `C++ worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS4 / 1e3)}s)`
+        );
+        logRuntimeDiagnostic("warn", {
+          component: "CppWorkerClient",
+          runtime: "cpp",
+          phase: "worker-ready-timeout",
+          message: "C++ worker did not send worker-ready before the timeout.",
+          detail: { timeoutMs: WORKER_READY_TIMEOUT_MS4 }
+        }, { enabled: this.debug });
+        this.terminateAndReset(timeoutError);
+        reject(timeoutError);
+      }, WORKER_READY_TIMEOUT_MS4);
+      readyPromise.then(() => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve();
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
   }
-  const previous = trace.at(-1);
-  if (!previous || previous.event !== "line") {
-    return false;
+  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS4) {
+    const worker = this.getWorker();
+    await this.waitForWorkerReady();
+    const id = String(++this.messageId);
+    return new Promise((resolve, reject) => {
+      this.pendingMessages.set(id, {
+        resolve,
+        reject
+      });
+      const timeoutId = globalThis.setTimeout(() => {
+        const pending2 = this.pendingMessages.get(id);
+        if (!pending2) return;
+        this.pendingMessages.delete(id);
+        logRuntimeDiagnostic("warn", {
+          component: "CppWorkerClient",
+          runtime: "cpp",
+          phase: "worker-request-timeout",
+          message: "C++ worker request timed out.",
+          detail: { id, type, timeoutMs }
+        }, { enabled: this.debug });
+        pending2.reject(new Error(`Worker request timed out: ${type}`));
+      }, timeoutMs);
+      const pending = this.pendingMessages.get(id);
+      if (pending) pending.timeoutId = timeoutId;
+      worker.postMessage({ id, type, payload });
+    });
   }
-  if (previous.line !== nextStep.line || previous.function !== nextStep.function) {
-    return false;
+  async executeWithTimeout(executor, timeoutMs, stage) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const timeoutLabel = stage === "trace" ? "tracing" : stage === "interview" ? "interview execution" : "compile/run";
+        const timeoutError = new CppClientTimeoutError(
+          `C++ ${timeoutLabel} timed out after ${Math.round(timeoutMs / 1e3)} seconds.`,
+          stage,
+          timeoutMs
+        );
+        logRuntimeDiagnostic("warn", {
+          component: "CppWorkerClient",
+          runtime: "cpp",
+          phase: "execution-timeout",
+          message: "C++ execution timed out; terminating worker.",
+          detail: { timeoutMs, stage }
+        }, { enabled: this.debug });
+        this.terminateAndReset(timeoutError);
+        reject(timeoutError);
+      }, timeoutMs);
+      executor().then((result) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
   }
-  if (!callStacksEqual(previous.callStack, nextStep.callStack)) {
-    return false;
+  isClientTimeout(error) {
+    return error instanceof CppClientTimeoutError || error instanceof Error && error.message.includes("C++") && error.message.includes("timed out");
   }
-  previous.variables = { ...previous.variables ?? {}, ...nextStep.variables ?? {} };
-  if (nextStep.accesses?.length) {
-    previous.accesses = [...previous.accesses ?? [], ...nextStep.accesses];
+  timeoutCodeResult(error) {
+    const timeoutError = error instanceof CppClientTimeoutError ? error : null;
+    return {
+      success: false,
+      output: null,
+      error: error instanceof Error ? error.message : String(error),
+      consoleOutput: [],
+      timeoutReason: "client-timeout",
+      diagnosticStage: timeoutError?.stage === "interview" ? "interview" : "runtime",
+      timings: { totalMs: timeoutError?.timeoutMs ?? this.executionTimeoutMs }
+    };
   }
-  previous.visualization = mergeVisualizationPayloads(previous.visualization, nextStep.visualization);
-  return true;
-}
-function filterStructuredVariables(variables) {
-  if (!variables) {
-    return void 0;
+  timeoutTraceResult(error) {
+    const timeoutError = error instanceof CppClientTimeoutError ? error : null;
+    const trace = createEmptyRuntimeTrace("cpp", { runId: "cpp:run", file: CPP_DEFAULT_FILE });
+    trace.events = [
+      {
+        kind: "timeout",
+        runId: "cpp:run",
+        file: CPP_DEFAULT_FILE,
+        message: error instanceof Error ? error.message : String(error)
+      }
+    ];
+    trace.traceStepCount = 1;
+    return {
+      success: false,
+      output: null,
+      error: error instanceof Error ? error.message : String(error),
+      trace,
+      executionTimeMs: timeoutError?.timeoutMs ?? this.tracingTimeoutMs,
+      consoleOutput: [],
+      traceLimitExceeded: true,
+      timeoutReason: "client-timeout",
+      lineEventCount: 0,
+      traceStepCount: 1,
+      timings: { totalMs: timeoutError?.timeoutMs ?? this.tracingTimeoutMs }
+    };
   }
-  const isEphemeralOutputArrayName = (name) => /^(output|outputs)$/i.test(name);
-  const entries = Object.entries(variables).filter(([name, value]) => {
-    if (value === null || typeof value !== "object") {
-      return false;
-    }
-    if (!Array.isArray(value)) {
-      return true;
+  terminateAndReset(reason = new Error("Worker was terminated")) {
+    this.workerReadyReject?.(reason);
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
     }
-    if (Array.isArray(value[0])) {
-      return true;
+    this.initPromise = null;
+    this.warmupPromise = null;
+    this.workerReadyPromise = null;
+    this.workerReadyResolve = null;
+    this.workerReadyReject = null;
+    for (const [, pending] of this.pendingMessages) {
+      if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+      pending.reject(reason);
     }
-    return !isEphemeralOutputArrayName(name);
-  });
-  if (entries.length === 0) {
-    return void 0;
-  }
-  return Object.fromEntries(entries);
-}
-function appendJavaTraceStep(trace, step, pendingAccesses, options = {}) {
-  const nextStep = pendingAccesses.length > 0 ? { ...step, accesses: [...pendingAccesses] } : step;
-  pendingAccesses.length = 0;
-  if (options.allowMerge !== false && maybeMergeConsecutiveLineStep(trace, nextStep)) {
-    return;
+    this.pendingMessages.clear();
+    this.clearCompilerFrames();
   }
-  trace.push(nextStep);
-}
-function mergeIntoPreviousMatchingLineStep(trace, line, currentFunction, currentCallStack, patch) {
-  const candidate = trace.at(-1);
-  if (!candidate || candidate.event !== "line") {
-    return false;
+  shouldRetryInit(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("timed out") || message.includes("Worker request timed out") || message.includes("worker error") || message.includes("Failed to fetch") || message.includes("was terminated") || message.includes("closed after idle timeout");
   }
-  if (candidate.line !== line || candidate.function !== currentFunction) {
-    return false;
+  sendInitMessage() {
+    return this.sendMessage(
+      "init",
+      {
+        assets: {
+          clangWasmUrl: this.options.clangWasmUrl,
+          lldWasmUrl: this.options.lldWasmUrl,
+          sysrootUrl: this.options.sysrootUrl,
+          runtimeHeaderUrl: this.options.runtimeHeaderUrl,
+          compilerBundleUrl: this.options.compilerBundleUrl,
+          compilerFrameEnabled: Boolean(this.compilerFrameUrl && typeof document !== "undefined"),
+          compilerFrameUrl: this.compilerFrameUrl,
+          compilerWorkerUrl: this.options.compilerWorkerUrl
+        },
+        ...this.workerOptionsPayload()
+      },
+      this.initTimeoutMs
+    );
   }
-  if (!callStacksEqual(candidate.callStack, currentCallStack)) {
-    return false;
+  async init() {
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      try {
+        return await this.sendInitMessage();
+      } catch (error) {
+        if (!this.shouldRetryInit(error)) throw error;
+        this.terminateAndReset(error instanceof Error ? error : new Error(String(error)));
+        return this.sendInitMessage();
+      }
+    })();
+    try {
+      return await this.initPromise;
+    } catch (error) {
+      this.initPromise = null;
+      throw error;
+    }
   }
-  candidate.variables = { ...candidate.variables ?? {}, ...patch.variables ?? {} };
-  if (patch.accesses?.length) {
-    candidate.accesses = [...candidate.accesses ?? [], ...patch.accesses];
+  workerOptionsPayload() {
+    return this.options.workerIdleTimeoutMs === void 0 ? {} : { idleTimeoutMs: this.options.workerIdleTimeoutMs };
   }
-  candidate.visualization = mergeVisualizationPayloads(candidate.visualization, patch.visualization);
-  return true;
-}
-function mergeAccessesIntoPreviousMatchingLineStep(trace, line, currentFunction, currentCallStack, accesses) {
-  return mergeIntoPreviousMatchingLineStep(trace, line, currentFunction, currentCallStack, {
-    variables: void 0,
-    accesses,
-    visualization: void 0
-  });
-}
-function eventsToRawTrace(events, sourceText) {
-  const trace = [];
-  const variables = {};
-  const objectKinds = {};
-  const stack = [];
-  const pendingAccesses = [];
-  let currentFunction = "<module>";
-  let previousRawLine = null;
-  const lineRemap = buildLineRemap(sourceText);
-  const declarationLines = buildMethodDeclarationLineSet(sourceText);
-  for (const rawEvent of events) {
-    if (rawEvent === "clear" || rawEvent === "reset") continue;
-    const metadata = extractLineMetadata(rawEvent);
-    const previousEventRawLine = previousRawLine;
-    previousRawLine = metadata.line;
-    const line = lineRemap?.get(metadata.line) ?? metadata.line;
-    const payload = metadata.payload;
-    const isDeclarationLine = declarationLines?.has(line) === true;
-    if (payload.startsWith("call ")) {
-      const match = payload.match(/^call\s+(\S+)(?:\s+(.*))?$/);
-      const functionName = match?.[1] ?? currentFunction;
-      const argsFragment = match?.[2] ?? "";
-      const args = parseKeyValuePairs(argsFragment);
-      Object.assign(variables, args);
-      currentFunction = functionName || currentFunction;
-      stack.push({ function: currentFunction, line, args });
-      appendJavaTraceStep(trace, {
-        line,
-        event: "call",
-        function: currentFunction,
-        variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } }))
-      }, pendingAccesses);
-      continue;
-    }
-    if (payload.startsWith("return ")) {
-      const match = payload.match(/^return\s+(\S+)(?:\s+value=(.*))?$/);
-      const functionName = match?.[1] ?? currentFunction;
-      const returnValue = match?.[2] !== void 0 ? parseScalar(match[2].trim()) : void 0;
-      const returnVariables = functionName === "<module>" ? { ...variables } : filterStructuredVariables(variables) ?? {};
-      appendJavaTraceStep(trace, {
-        line,
-        event: "return",
-        function: functionName || currentFunction,
-        variables: returnVariables,
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })),
-        ...returnValue !== void 0 ? { returnValue } : {}
-      }, pendingAccesses);
-      stack.pop();
-      currentFunction = stack[stack.length - 1]?.function ?? "<module>";
-      continue;
-    }
-    if (isDeclarationLine) {
-      continue;
+  async warmup() {
+    if (this.warmupPromise) return this.warmupPromise;
+    this.warmupPromise = (async () => {
+      try {
+        await this.init();
+        return await this.sendMessage("warmup", this.workerOptionsPayload(), this.initTimeoutMs);
+      } catch (error) {
+        this.warmupPromise = null;
+        throw error;
+      }
+    })();
+    return this.warmupPromise;
+  }
+  clearCompilerFrames(reason = new Error("C++ compiler frame was closed")) {
+    this.compilerFrameReadyReject?.(reason);
+    this.compilerFrameReadyPromise = null;
+    this.compilerFrameReadyResolve = null;
+    this.compilerFrameReadyReject = null;
+    if (this.compilerFrameMessageHandler) {
+      globalThis.removeEventListener("message", this.compilerFrameMessageHandler);
+      this.compilerFrameMessageHandler = null;
     }
-    if (payload.length === 0) {
-      appendJavaTraceStep(trace, {
-        line,
-        event: "line",
-        function: currentFunction,
-        variables: { ...variables },
-        ...stack.length > 0 ? { callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })) } : {}
-      }, pendingAccesses, { allowMerge: previousEventRawLine !== metadata.line });
-      continue;
+    for (const [, pending] of this.pendingCompilerFrameRequests) {
+      globalThis.clearTimeout(pending.timeoutId);
+      pending.resolve({ success: false, error: reason.message });
     }
-    const structureState = parseStructureState(payload);
-    if (structureState) {
-      variables[structureState.variable] = structureState.value;
-      objectKinds[structureState.variable] = structureState.structure;
-      appendJavaTraceStep(trace, {
-        line,
-        event: "line",
-        function: currentFunction,
-        variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })),
-        visualization: {
-          objectKinds: { ...objectKinds }
-        }
-      }, pendingAccesses);
-      continue;
+    this.pendingCompilerFrameRequests.clear();
+    this.compilerFrame = null;
+    this.compilerFrameTargetOrigin = "";
+    for (const frame of this.activeCompilerFrames) {
+      frame.remove();
     }
-    const objectState = parseObjectState(payload);
-    if (objectState) {
-      variables[objectState.variable] = { __ref__: objectState.visualization.objectId ?? `${objectState.variable}-object` };
-      appendJavaTraceStep(trace, {
-        line,
-        event: "line",
-        function: currentFunction,
-        variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })),
-        visualization: {
-          objectKinds: { [objectState.variable]: "object" },
-          hashMaps: [objectState.visualization]
-        }
-      }, pendingAccesses);
-      continue;
+    this.activeCompilerFrames.clear();
+  }
+  async handleCompileRequest(message) {
+    if (!message.requestId) return;
+    const worker = this.worker;
+    if (!worker) return;
+    const result = await this.compileInFrame(message.payload);
+    const transfer = result?.programBuffer instanceof ArrayBuffer ? [result.programBuffer] : [];
+    worker.postMessage(
+      {
+        type: "compile-response",
+        requestId: message.requestId,
+        payload: result
+      },
+      transfer
+    );
+  }
+  ensureCompilerFrame() {
+    if (!this.compilerFrameUrl || typeof document === "undefined") {
+      return Promise.reject(new Error("C++ compiler frame is not available."));
     }
-    const mapState = parseMapState(payload);
-    if (mapState) {
-      const entries = mapState.visualization.entries.map((entry) => [entry.key, entry.value]);
-      variables[mapState.variable] = { __type__: "map", entries };
-      appendJavaTraceStep(trace, {
-        line,
-        event: "line",
-        function: currentFunction,
-        variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })),
-        visualization: {
-          objectKinds: { [mapState.variable]: "map" },
-          hashMaps: [mapState.visualization]
+    if (this.compilerFrame && this.compilerFrameReadyPromise) return this.compilerFrameReadyPromise;
+    const frameUrl = new URL(this.compilerFrameUrl, globalThis.location?.href);
+    this.compilerFrameTargetOrigin = frameUrl.origin;
+    const iframe = document.createElement("iframe");
+    iframe.src = frameUrl.href;
+    iframe.style.display = "none";
+    iframe.setAttribute("aria-hidden", "true");
+    this.compilerFrame = iframe;
+    this.activeCompilerFrames.add(iframe);
+    this.compilerFrameReadyPromise = new Promise((resolve, reject) => {
+      let settled = false;
+      let timeoutId;
+      const finishReady = () => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        this.compilerFrameReadyResolve = null;
+        this.compilerFrameReadyReject = null;
+        resolve();
+      };
+      const onMessage = (event) => {
+        if (event.source !== iframe.contentWindow) return;
+        if (event.origin !== this.compilerFrameTargetOrigin) return;
+        if (event.data?.type === "frame-ready") {
+          finishReady();
+          return;
         }
-      }, pendingAccesses);
-      continue;
+        const requestId = event.data?.id;
+        if (!requestId) return;
+        const pending = this.pendingCompilerFrameRequests.get(requestId);
+        if (!pending) return;
+        this.pendingCompilerFrameRequests.delete(requestId);
+        globalThis.clearTimeout(pending.timeoutId);
+        const response = event.data;
+        pending.resolve(response.payload ?? { success: false, error: "C++ compiler frame returned an empty response." });
+      };
+      this.compilerFrameMessageHandler = onMessage;
+      timeoutId = globalThis.setTimeout(() => {
+        const error = new Error("C++ compiler frame request timed out.");
+        this.clearCompilerFrames(error);
+        reject(error);
+      }, this.initTimeoutMs);
+      this.compilerFrameReadyResolve = finishReady;
+      this.compilerFrameReadyReject = (error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error);
+      };
+      globalThis.addEventListener("message", onMessage);
+      document.body.appendChild(iframe);
+    });
+    return this.compilerFrameReadyPromise;
+  }
+  async compileInFrame(payload) {
+    try {
+      await this.ensureCompilerFrame();
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
-    const setState = parseSetState(payload);
-    if (setState) {
-      const values = setState.visualization.entries.map((entry) => entry.key);
-      variables[setState.variable] = { __type__: "set", values };
-      appendJavaTraceStep(trace, {
-        line,
-        event: "line",
-        function: currentFunction,
-        variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })),
-        visualization: {
-          objectKinds: { [setState.variable]: "set" },
-          hashMaps: [setState.visualization]
-        }
-      }, pendingAccesses);
-      continue;
+    const iframe = this.compilerFrame;
+    const frameWindow = iframe?.contentWindow;
+    if (!frameWindow) {
+      return { success: false, error: "C++ compiler frame is not available." };
     }
-    if (isArrayLengthAccessEvent(payload)) {
-      continue;
+    return new Promise((resolve) => {
+      const requestId = `compile-${++this.compilerFrameRequestId}`;
+      const timeoutId = globalThis.setTimeout(() => {
+        this.pendingCompilerFrameRequests.delete(requestId);
+        resolve({ success: false, error: "C++ compiler frame request timed out." });
+      }, this.initTimeoutMs);
+      this.pendingCompilerFrameRequests.set(requestId, { resolve, timeoutId });
+      frameWindow.postMessage(
+        {
+          id: requestId,
+          type: "compile",
+          payload
+        },
+        this.compilerFrameTargetOrigin
+      );
+    });
+  }
+  async executeCode(code, functionName, inputs, executionStyle) {
+    await this.init();
+    try {
+      return await this.executeWithTimeout(
+        () => this.sendMessage(
+          "compile-run",
+          { code, functionName, inputs, executionStyle },
+          this.executionTimeoutMs + 5e3
+        ),
+        this.executionTimeoutMs,
+        "compile-run"
+      );
+    } catch (error) {
+      if (this.isClientTimeout(error)) return this.timeoutCodeResult(error);
+      throw error;
     }
-    const accesses = parseAccessEvent(payload);
-    if (accesses) {
-      const currentCallStack = stack.length > 0 ? stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })) : void 0;
-      if (mergeAccessesIntoPreviousMatchingLineStep(trace, line, currentFunction, currentCallStack, accesses)) {
-        continue;
-      }
-      pendingAccesses.push(...accesses);
-      continue;
+  }
+  async executeWithTracing(code, functionName, inputs, options, executionStyle) {
+    await this.init();
+    try {
+      return await this.executeWithTimeout(
+        () => this.sendMessage(
+          "execute-with-tracing",
+          { code, functionName, inputs, options, executionStyle },
+          this.tracingTimeoutMs + 5e3
+        ),
+        this.tracingTimeoutMs,
+        "trace"
+      );
+    } catch (error) {
+      if (this.isClientTimeout(error)) return this.timeoutTraceResult(error);
+      throw error;
     }
-    const objectField = parseObjectFieldEvent(payload);
-    if (objectField) {
-      variables[objectField.variable] = { __ref__: `${objectField.variable}-object` };
-      const currentCallStack = stack.length > 0 ? stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })) : void 0;
-      if (mergeIntoPreviousMatchingLineStep(trace, line, currentFunction, currentCallStack, {
-        variables: { ...variables },
-        accesses: void 0,
-        visualization: buildFieldVisualization(objectField)
-      })) {
-        continue;
-      }
-      appendJavaTraceStep(trace, {
-        line,
-        event: "line",
-        function: currentFunction,
-        variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })),
-        visualization: buildFieldVisualization(objectField)
-      }, pendingAccesses);
-      continue;
+  }
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle) {
+    await this.init();
+    try {
+      return await this.executeWithTimeout(
+        () => this.sendMessage(
+          "execute-code-interview",
+          { code, functionName, inputs, executionStyle },
+          this.interviewTimeoutMs + 5e3
+        ),
+        this.interviewTimeoutMs,
+        "interview"
+      );
+    } catch {
+      return {
+        success: false,
+        output: null,
+        error: "Time Limit Exceeded",
+        timeoutReason: "client-timeout",
+        diagnosticStage: "interview",
+        consoleOutput: [],
+        timings: { totalMs: this.interviewTimeoutMs }
+      };
     }
-    Object.assign(variables, parseKeyValuePairs(payload));
-    appendJavaTraceStep(trace, {
-      line,
-      event: "line",
-      function: currentFunction,
-      variables: { ...variables },
-      ...stack.length > 0 ? { callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })) } : {}
-    }, pendingAccesses);
   }
-  if (pendingAccesses.length > 0 && trace.length > 0) {
-    const last = trace[trace.length - 1];
-    last.accesses = [...last.accesses ?? [], ...pendingAccesses];
+  terminate() {
+    this.terminateAndReset();
   }
-  return trace;
-}
-function buildJavaExecutionResult(output, events, executionTimeMs = 0, traceLimitExceeded, timeoutReason, maxTraceSteps, sourceText, options = {}) {
-  const trace = eventsToRawTrace(events, sourceText);
-  return {
-    success: true,
-    output: options.outputIsSerialized === false ? output : normalizeJavaSerializedResult(output),
-    trace,
-    executionTimeMs,
-    consoleOutput: [],
-    ...traceLimitExceeded !== void 0 ? { traceLimitExceeded } : {},
-    ...maxTraceSteps !== void 0 ? { maxTraceSteps } : {},
-    ...timeoutReason ? { timeoutReason } : {},
-    lineEventCount: trace.filter((step) => step.event === "line").length,
-    traceStepCount: trace.length
-  };
-}
-function adaptJavaTraceExecutionResult(result) {
-  return adaptTraceExecutionResult("java", result);
-}
+};
 
-// packages/harness-browser/src/java-runtime-client.ts
-var JavaRuntimeClient = class {
+// packages/harness-browser/src/cpp-runtime-client.ts
+var CppRuntimeClient = class {
   constructor(workerClient) {
     this.workerClient = workerClient;
   }
   async init() {
     return this.workerClient.init();
   }
-  async executeWithTracing(code, functionName, inputs, options, executionStyle = "function") {
-    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+  async executeWithTracing(code, functionName, inputs, options, executionStyle = "solution-method") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("cpp"), {
       request: "trace",
       executionStyle,
       functionName
     });
-    const rawResult = await this.workerClient.executeWithTracing(
+    return this.workerClient.executeWithTracing(
       code,
       functionName ?? "",
       inputs,
       options,
       executionStyle
     );
-    if (!rawResult.success) {
-      return {
-        success: false,
-        error: rawResult.error ?? "Java tracing failed",
-        ...rawResult.errorLine !== void 0 ? { errorLine: rawResult.errorLine } : {},
-        trace: [],
-        executionTimeMs: rawResult.executionTimeMs,
-        consoleOutput: rawResult.consoleOutput,
-        ...rawResult.traceLimitExceeded !== void 0 ? { traceLimitExceeded: rawResult.traceLimitExceeded } : {},
-        ...rawResult.timeoutReason ? { timeoutReason: rawResult.timeoutReason } : {},
-        lineEventCount: 0,
-        traceStepCount: 0
-      };
-    }
-    const adapted = adaptJavaTraceExecutionResult(
-      buildJavaExecutionResult(
-        rawResult.output,
-        rawResult.events,
-        rawResult.executionTimeMs,
-        rawResult.traceLimitExceeded,
-        rawResult.timeoutReason,
-        void 0,
-        rawResult.sourceText,
-        { outputIsSerialized: false }
-      )
-    );
-    return {
-      ...adapted,
-      consoleOutput: rawResult.consoleOutput,
-      executionTimeMs: rawResult.executionTimeMs
-    };
   }
-  async executeCode(code, functionName, inputs, executionStyle = "function") {
-    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+  async executeCode(code, functionName, inputs, executionStyle = "solution-method") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("cpp"), {
       request: "execute",
       executionStyle,
       functionName
@@ -1818,12 +2980,11 @@ var JavaRuntimeClient = class {
       code,
       functionName,
       inputs,
-      void 0,
       executionStyle
     );
   }
-  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "function") {
-    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "solution-method") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("cpp"), {
       request: "interview",
       executionStyle,
       functionName
@@ -1832,23 +2993,22 @@ var JavaRuntimeClient = class {
       code,
       functionName,
       inputs,
-      void 0,
       executionStyle
     );
   }
 };
-function createJavaRuntimeClient(workerClient) {
-  return new JavaRuntimeClient(workerClient);
+function createCppRuntimeClient(workerClient) {
+  return new CppRuntimeClient(workerClient);
 }
 
 // packages/harness-browser/src/pyodide-worker-client.ts
-var EXECUTION_TIMEOUT_MS2 = 1e4;
-var INTERVIEW_MODE_TIMEOUT_MS2 = 5e3;
-var TRACING_TIMEOUT_MS3 = 3e4;
-var INIT_TIMEOUT_MS3 = 12e4;
-var MESSAGE_TIMEOUT_MS3 = 2e4;
-var WORKER_READY_TIMEOUT_MS3 = 1e4;
-var PyodideWorkerClient = class {
+var EXECUTION_TIMEOUT_MS5 = 1e4;
+var INTERVIEW_MODE_TIMEOUT_MS4 = 5e3;
+var TRACING_TIMEOUT_MS5 = 3e4;
+var INIT_TIMEOUT_MS5 = 12e4;
+var MESSAGE_TIMEOUT_MS5 = 2e4;
+var WORKER_READY_TIMEOUT_MS5 = 1e4;
+var PythonWorkerClient = class {
   constructor(options) {
     this.options = options;
     this.debug = options.debug ?? process.env.NODE_ENV === "development";
@@ -1858,6 +3018,7 @@ var PyodideWorkerClient = class {
   messageId = 0;
   isInitializing = false;
   initPromise = null;
+  warmupPromise = null;
   workerReadyPromise = null;
   workerReadyResolve = null;
   workerReadyReject = null;
@@ -1888,11 +3049,22 @@ var PyodideWorkerClient = class {
         this.workerReadyResolve?.();
         this.workerReadyResolve = null;
         this.workerReadyReject = null;
-        if (this.debug) console.log("[PyodideWorkerClient] worker-ready");
+        logRuntimeDiagnostic("info", {
+          component: "PythonWorkerClient",
+          runtime: "python",
+          phase: "worker-ready",
+          message: "Python worker is ready."
+        }, { enabled: this.debug });
         return;
       }
       if (this.debug && !id) {
-        console.log("[PyodideWorkerClient] event", { type, payload });
+        logRuntimeDiagnostic("debug", {
+          component: "PythonWorkerClient",
+          runtime: "python",
+          phase: "worker-event",
+          message: "Python worker emitted an unsolicited event.",
+          detail: { type, payload }
+        }, { enabled: this.debug });
       }
       if (id) {
         const pending = this.pendingMessages.get(id);
@@ -1902,14 +3074,31 @@ var PyodideWorkerClient = class {
           if (type === "error") {
             pending.reject(new Error(payload.error));
           } else {
-            if (this.debug) console.log("[PyodideWorkerClient] recv", { id, type });
+            logRuntimeDiagnostic("debug", {
+              component: "PythonWorkerClient",
+              runtime: "python",
+              phase: "worker-response",
+              message: "Python worker response received.",
+              detail: { id, type }
+            }, { enabled: this.debug });
             pending.resolve(payload);
           }
         }
       }
     };
     this.worker.onerror = (error) => {
-      console.error("[PyodideWorkerClient] Worker error:", error);
+      logRuntimeDiagnostic("error", {
+        component: "PythonWorkerClient",
+        runtime: "python",
+        phase: "worker-error",
+        message: "Python worker emitted an error event.",
+        detail: {
+          message: error.message,
+          filename: error.filename,
+          lineno: error.lineno,
+          colno: error.colno
+        }
+      });
       const workerError = new Error("Worker error");
       this.workerReadyReject?.(workerError);
       this.workerReadyResolve = null;
@@ -1937,14 +3126,18 @@ var PyodideWorkerClient = class {
         if (settled) return;
         settled = true;
         const timeoutError = new Error(
-          `Python worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS3 / 1e3)}s)`
+          `Python worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS5 / 1e3)}s)`
         );
-        if (this.debug) {
-          console.warn("[PyodideWorkerClient] worker-ready timeout", { timeoutMs: WORKER_READY_TIMEOUT_MS3 });
-        }
+        logRuntimeDiagnostic("warn", {
+          component: "PythonWorkerClient",
+          runtime: "python",
+          phase: "worker-ready-timeout",
+          message: "Python worker did not send worker-ready before the timeout.",
+          detail: { timeoutMs: WORKER_READY_TIMEOUT_MS5 }
+        }, { enabled: this.debug });
         this.terminateAndReset(timeoutError);
         reject(timeoutError);
-      }, WORKER_READY_TIMEOUT_MS3);
+      }, WORKER_READY_TIMEOUT_MS5);
       readyPromise.then(() => {
         if (settled) return;
         settled = true;
@@ -1961,7 +3154,7 @@ var PyodideWorkerClient = class {
   /**
    * Send a message to the worker and wait for a response
    */
-  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS3) {
+  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS5) {
     const worker = this.getWorker();
     await this.waitForWorkerReady();
     const id = String(++this.messageId);
@@ -1970,12 +3163,24 @@ var PyodideWorkerClient = class {
         resolve,
         reject
       });
-      if (this.debug) console.log("[PyodideWorkerClient] send", { id, type });
+      logRuntimeDiagnostic("debug", {
+        component: "PythonWorkerClient",
+        runtime: "python",
+        phase: "worker-request",
+        message: "Sending request to Python worker.",
+        detail: { id, type }
+      }, { enabled: this.debug });
       const timeoutId = globalThis.setTimeout(() => {
         const pending2 = this.pendingMessages.get(id);
         if (!pending2) return;
         this.pendingMessages.delete(id);
-        if (this.debug) console.warn("[PyodideWorkerClient] timeout", { id, type });
+        logRuntimeDiagnostic("warn", {
+          component: "PythonWorkerClient",
+          runtime: "python",
+          phase: "worker-request-timeout",
+          message: "Python worker request timed out.",
+          detail: { id, type, timeoutMs }
+        }, { enabled: this.debug });
         pending2.reject(new Error(`Worker request timed out: ${type}`));
       }, timeoutMs);
       const pending = this.pendingMessages.get(id);
@@ -1986,15 +3191,19 @@ var PyodideWorkerClient = class {
   /**
    * Execute code with a timeout - terminates worker if execution takes too long
    */
-  async executeWithTimeout(executor, timeoutMs = EXECUTION_TIMEOUT_MS2) {
+  async executeWithTimeout(executor, timeoutMs = EXECUTION_TIMEOUT_MS5) {
     return new Promise((resolve, reject) => {
       let settled = false;
       const timeoutId = globalThis.setTimeout(() => {
         if (settled) return;
         settled = true;
-        if (this.debug) {
-          console.warn("[PyodideWorkerClient] Execution timeout - terminating worker");
-        }
+        logRuntimeDiagnostic("warn", {
+          component: "PythonWorkerClient",
+          runtime: "python",
+          phase: "execution-timeout",
+          message: "Python execution timed out; terminating worker.",
+          detail: { timeoutMs }
+        }, { enabled: this.debug });
         this.terminateAndReset();
         const seconds = Math.round(timeoutMs / 1e3);
         reject(new Error(`Execution timed out (possible infinite loop). Code execution was stopped after ${seconds} seconds.`));
@@ -2022,6 +3231,7 @@ var PyodideWorkerClient = class {
       this.worker = null;
     }
     this.initPromise = null;
+    this.warmupPromise = null;
     this.isInitializing = false;
     this.workerReadyPromise = null;
     this.workerReadyResolve = null;
@@ -2032,7 +3242,7 @@ var PyodideWorkerClient = class {
     this.pendingMessages.clear();
   }
   /**
-   * Initialize Pyodide in the worker
+   * Initialize the Python worker. Runtime loading is lazy unless warmup() is called.
    */
   async init() {
     if (this.initPromise) {
@@ -2045,18 +3255,22 @@ var PyodideWorkerClient = class {
     this.isInitializing = true;
     this.initPromise = (async () => {
       try {
-        return await this.sendMessage("init", void 0, INIT_TIMEOUT_MS3);
+        return await this.sendMessage("init", void 0, INIT_TIMEOUT_MS5);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         const shouldRetry = message.includes("Worker request timed out: init") || message.includes("Worker was terminated") || message.includes("Worker error") || message.includes("failed to initialize in time");
         if (!shouldRetry) {
           throw error;
         }
-        if (this.debug) {
-          console.warn("[PyodideWorkerClient] init failed, resetting worker and retrying once", { message });
-        }
+        logRuntimeDiagnostic("warn", {
+          component: "PythonWorkerClient",
+          runtime: "python",
+          phase: "init-retry",
+          message: "Python worker init failed; resetting worker and retrying once.",
+          detail: { message }
+        }, { enabled: this.debug });
         this.terminateAndReset();
-        return this.sendMessage("init", void 0, INIT_TIMEOUT_MS3);
+        return this.sendMessage("init", void 0, INIT_TIMEOUT_MS5);
       }
     })();
     try {
@@ -2069,6 +3283,19 @@ var PyodideWorkerClient = class {
       this.isInitializing = false;
     }
   }
+  async warmup() {
+    if (this.warmupPromise) return this.warmupPromise;
+    this.warmupPromise = (async () => {
+      try {
+        await this.init();
+        return await this.sendMessage("warmup", void 0, INIT_TIMEOUT_MS5);
+      } catch (error) {
+        this.warmupPromise = null;
+        throw error;
+      }
+    })();
+    return this.warmupPromise;
+  }
   /**
    * Execute Python code with tracing for step-by-step visualization
    * @param options.maxLineEvents - Max line events before abort (for complexity analysis, use higher values)
@@ -2083,9 +3310,9 @@ var PyodideWorkerClient = class {
           inputs,
           executionStyle,
           options
-        }, TRACING_TIMEOUT_MS3 + 5e3),
+        }, TRACING_TIMEOUT_MS5 + 5e3),
         // Message timeout slightly longer than execution timeout
-        TRACING_TIMEOUT_MS3
+        TRACING_TIMEOUT_MS5
       );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -2094,8 +3321,8 @@ var PyodideWorkerClient = class {
         return {
           success: false,
           error: errorMessage,
-          trace: [],
-          executionTimeMs: TRACING_TIMEOUT_MS3,
+          trace: createEmptyRuntimeTrace("python", { runId: "python:run", file: "solution.py" }),
+          executionTimeMs: TRACING_TIMEOUT_MS5,
           consoleOutput: [],
           traceLimitExceeded: true,
           timeoutReason: "client-timeout",
@@ -2117,8 +3344,8 @@ var PyodideWorkerClient = class {
         functionName,
         inputs,
         executionStyle
-      }, EXECUTION_TIMEOUT_MS2 + 5e3),
-      EXECUTION_TIMEOUT_MS2
+      }, EXECUTION_TIMEOUT_MS5 + 5e3),
+      EXECUTION_TIMEOUT_MS5
     );
   }
   /**
@@ -2134,8 +3361,8 @@ var PyodideWorkerClient = class {
           functionName,
           inputs,
           executionStyle
-        }, INTERVIEW_MODE_TIMEOUT_MS2 + 2e3),
-        INTERVIEW_MODE_TIMEOUT_MS2
+        }, INTERVIEW_MODE_TIMEOUT_MS4 + 2e3),
+        INTERVIEW_MODE_TIMEOUT_MS4
       );
       if (!result.success && result.error) {
         const normalizedError = result.error.toLowerCase();
@@ -2190,11 +3417,6 @@ var PyodideWorkerClient = class {
   }
 };
 
-// packages/harness-core/src/trace-adapters/python.ts
-function adaptPythonTraceExecutionResult(result) {
-  return adaptTraceExecutionResult("python", result);
-}
-
 // packages/harness-browser/src/python-runtime-client.ts
 var PythonRuntimeClient = class {
   constructor(workerClient) {
@@ -2209,14 +3431,13 @@ var PythonRuntimeClient = class {
       executionStyle,
       functionName
     });
-    const rawResult = await this.workerClient.executeWithTracing(
+    return this.workerClient.executeWithTracing(
       code,
       functionName,
       inputs,
       options,
       executionStyle
     );
-    return adaptPythonTraceExecutionResult(rawResult);
   }
   async executeCode(code, functionName, inputs, executionStyle = "function") {
     assertRuntimeRequestSupported(getLanguageRuntimeProfile("python"), {
@@ -2257,7 +3478,17 @@ var DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS = Object.freeze({
   pythonSnippets: "generated-python-harness-snippets.js",
   javascriptWorker: "javascript-worker.js",
   javaWorker: "java-worker.js",
-  typescriptCompiler: "vendor/typescript.js"
+  csharpWorker: "csharp-worker.js",
+  csharpAssetBaseUrl: "vendor/csharp",
+  typescriptCompiler: "vendor/typescript.js",
+  cppWorker: "cpp-worker.js",
+  cppCompilerFrame: "cpp-compiler-frame.html",
+  cppCompilerWorker: "cpp-compiler-worker.js",
+  cppClangWasm: "",
+  cppLldWasm: "",
+  cppSysroot: "",
+  cppRuntimeHeader: "cpp/tracecode_runtime.hpp",
+  cppCompilerBundle: "vendor/cpp/yowasp/bundle.js"
 });
 function isExplicitAssetPath(pathname) {
   return pathname.startsWith("/") || pathname.startsWith("./") || pathname.startsWith("../") || pathname.startsWith("http://") || pathname.startsWith("https://") || pathname.startsWith("data:") || pathname.startsWith("blob:");
@@ -2269,6 +3500,9 @@ function trimLeadingSlash(value) {
   return value.replace(/^\/+/, "");
 }
 function resolveAssetPath(baseUrl, pathname) {
+  if (pathname === "") {
+    return "";
+  }
   if (isExplicitAssetPath(pathname)) {
     return pathname;
   }
@@ -2291,9 +3525,34 @@ function resolveBrowserHarnessAssets(options = {}) {
       assets.javascriptWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.javascriptWorker
     ),
     javaWorker: resolveAssetPath(assetBaseUrl, assets.javaWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.javaWorker),
+    csharpWorker: resolveAssetPath(assetBaseUrl, assets.csharpWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.csharpWorker),
+    csharpAssetBaseUrl: resolveAssetPath(
+      assetBaseUrl,
+      assets.csharpAssetBaseUrl ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.csharpAssetBaseUrl
+    ),
     typescriptCompiler: resolveAssetPath(
       assetBaseUrl,
       assets.typescriptCompiler ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.typescriptCompiler
+    ),
+    cppWorker: resolveAssetPath(assetBaseUrl, assets.cppWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.cppWorker),
+    cppCompilerFrame: resolveAssetPath(
+      assetBaseUrl,
+      assets.cppCompilerFrame ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.cppCompilerFrame
+    ),
+    cppCompilerWorker: resolveAssetPath(
+      assetBaseUrl,
+      assets.cppCompilerWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.cppCompilerWorker
+    ),
+    cppClangWasm: resolveAssetPath(assetBaseUrl, assets.cppClangWasm ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.cppClangWasm),
+    cppLldWasm: resolveAssetPath(assetBaseUrl, assets.cppLldWasm ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.cppLldWasm),
+    cppSysroot: resolveAssetPath(assetBaseUrl, assets.cppSysroot ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.cppSysroot),
+    cppRuntimeHeader: resolveAssetPath(
+      assetBaseUrl,
+      assets.cppRuntimeHeader ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.cppRuntimeHeader
+    ),
+    cppCompilerBundle: resolveAssetPath(
+      assetBaseUrl,
+      assets.cppCompilerBundle ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.cppCompilerBundle
     )
   };
 }
@@ -2305,10 +3564,12 @@ var BrowserHarnessRuntime = class {
   pythonWorkerClient;
   javaScriptWorkerClient;
   javaWorkerClient;
+  csharpWorkerClient;
+  cppWorkerClient;
   clients;
   constructor(options = {}) {
     this.assets = resolveBrowserHarnessAssets(options);
-    this.pythonWorkerClient = new PyodideWorkerClient({
+    this.pythonWorkerClient = new PythonWorkerClient({
       workerUrl: this.assets.pythonWorker,
       debug: options.debug
     });
@@ -2318,13 +3579,38 @@ var BrowserHarnessRuntime = class {
     });
     this.javaWorkerClient = new JavaWorkerClient({
       workerUrl: this.assets.javaWorker,
-      debug: options.debug
+      debug: options.debug,
+      workerIdleTimeoutMs: options.java?.workerIdleTimeoutMs
+    });
+    this.csharpWorkerClient = new CSharpWorkerClient({
+      workerUrl: this.assets.csharpWorker,
+      assetBaseUrl: this.assets.csharpAssetBaseUrl,
+      debug: options.debug,
+      workerIdleTimeoutMs: options.csharp?.workerIdleTimeoutMs
+    });
+    this.cppWorkerClient = new CppWorkerClient({
+      workerUrl: this.assets.cppWorker,
+      compilerFrameUrl: this.assets.cppCompilerFrame,
+      compilerWorkerUrl: this.assets.cppCompilerWorker,
+      clangWasmUrl: this.assets.cppClangWasm,
+      lldWasmUrl: this.assets.cppLldWasm,
+      sysrootUrl: this.assets.cppSysroot,
+      runtimeHeaderUrl: this.assets.cppRuntimeHeader,
+      compilerBundleUrl: this.assets.cppCompilerBundle,
+      debug: options.debug,
+      initTimeoutMs: options.cpp?.initTimeoutMs,
+      executionTimeoutMs: options.cpp?.executionTimeoutMs,
+      tracingTimeoutMs: options.cpp?.tracingTimeoutMs,
+      interviewTimeoutMs: options.cpp?.interviewTimeoutMs,
+      workerIdleTimeoutMs: options.cpp?.workerIdleTimeoutMs
     });
     this.clients = {
       python: createPythonRuntimeClient(this.pythonWorkerClient),
       javascript: createJavaScriptRuntimeClient("javascript", this.javaScriptWorkerClient),
       typescript: createJavaScriptRuntimeClient("typescript", this.javaScriptWorkerClient),
-      java: createJavaRuntimeClient(this.javaWorkerClient)
+      java: createJavaRuntimeClient(this.javaWorkerClient),
+      csharp: createCSharpRuntimeClient(this.csharpWorkerClient),
+      cpp: createCppRuntimeClient(this.cppWorkerClient)
     };
   }
   getClient(language) {
@@ -2340,9 +3626,33 @@ var BrowserHarnessRuntime = class {
   getSupportedLanguageProfiles() {
     return getSupportedLanguageProfiles();
   }
+  getLanguageInfo(language) {
+    return getLanguageRuntimeInfo(language);
+  }
+  getSupportedLanguageInfos() {
+    return getSupportedLanguageRuntimeInfos();
+  }
   isLanguageSupported(language) {
     return isLanguageSupported(language);
   }
+  warmLanguage(language) {
+    if (language === "python") {
+      return this.pythonWorkerClient.warmup();
+    }
+    if (language === "java") {
+      return this.javaWorkerClient.warmup();
+    }
+    if (language === "cpp") {
+      return this.cppWorkerClient.warmup();
+    }
+    if (language === "csharp") {
+      return this.csharpWorkerClient.warmup();
+    }
+    if (language === "typescript") {
+      return this.javaScriptWorkerClient.warmup("typescript");
+    }
+    return this.getClient(language).init();
+  }
   disposeLanguage(language) {
     if (language === "python") {
       this.pythonWorkerClient.terminate();
@@ -2352,12 +3662,22 @@ var BrowserHarnessRuntime = class {
       this.javaWorkerClient.terminate();
       return;
     }
+    if (language === "csharp") {
+      this.csharpWorkerClient.terminate();
+      return;
+    }
+    if (language === "cpp") {
+      this.cppWorkerClient.terminate();
+      return;
+    }
     this.javaScriptWorkerClient.terminate();
   }
   dispose() {
     this.pythonWorkerClient.terminate();
     this.javaScriptWorkerClient.terminate();
     this.javaWorkerClient.terminate();
+    this.csharpWorkerClient.terminate();
+    this.cppWorkerClient.terminate();
   }
 };
 function createBrowserHarness(options = {}) {
@@ -2365,12 +3685,16 @@ function createBrowserHarness(options = {}) {
 }
 export {
   DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS,
+  LANGUAGE_RUNTIME_INFOS,
   LANGUAGE_RUNTIME_PROFILES,
   SUPPORTED_LANGUAGES,
+  SUPPORTED_LANGUAGE_RUNTIME_INFOS,
   assertRuntimeRequestSupported,
   createBrowserHarness,
+  getLanguageRuntimeInfo,
   getLanguageRuntimeProfile,
   getSupportedLanguageProfiles,
+  getSupportedLanguageRuntimeInfos,
   isLanguageSupported,
   resolveBrowserHarnessAssets
 };