@tracecode/harness 0.6.6 → 0.7.0-beta8

package/dist/core.cjs

@@ -20,383 +20,612 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // packages/harness-core/src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION: () => RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION,
-  adaptJavaScriptTraceExecutionResult: () => adaptJavaScriptTraceExecutionResult,
-  adaptJavaSpikeTraceExecutionResult: () => adaptJavaTraceExecutionResult,
-  adaptJavaTraceExecutionResult: () => adaptJavaTraceExecutionResult,
-  adaptPythonTraceExecutionResult: () => adaptPythonTraceExecutionResult,
-  adaptTraceExecutionResult: () => adaptTraceExecutionResult,
-  buildJavaExecutionResult: () => buildJavaExecutionResult,
-  buildJavaSpikeExecutionResult: () => buildJavaExecutionResult,
+  LANGUAGE_RUNTIME_INFOS: () => LANGUAGE_RUNTIME_INFOS,
+  RUNTIME_TRACE_SCHEMA_VERSION: () => RUNTIME_TRACE_SCHEMA_VERSION,
+  SUPPORTED_LANGUAGE_RUNTIME_INFOS: () => SUPPORTED_LANGUAGE_RUNTIME_INFOS,
+  assertSupportedRawEmissions: () => assertSupportedRawEmissions,
+  buildRuntimeTraceParitySignature: () => buildRuntimeTraceParitySignature,
+  compareRawEmissionParity: () => compareRawEmissionParity,
+  createEmptyRuntimeTrace: () => createEmptyRuntimeTrace,
+  getLanguageRuntimeInfo: () => getLanguageRuntimeInfo,
+  getSupportedLanguageRuntimeInfos: () => getSupportedLanguageRuntimeInfos,
+  javaTraceHooksEventsToRuntimeTrace: () => javaTraceHooksEventsToRuntimeTrace,
+  normalizeJavaNativeTraceJsonPayload: () => normalizeJavaNativeTraceJsonPayload,
   normalizeJavaSerializedResult: () => normalizeJavaSerializedResult,
-  normalizeJavaSpikeTraceContract: () => normalizeJavaTraceContract,
-  normalizeJavaTraceContract: () => normalizeJavaTraceContract,
-  normalizeRuntimeTraceContract: () => normalizeRuntimeTraceContract,
-  stableStringifyRuntimeTraceContract: () => stableStringifyRuntimeTraceContract
+  summarizeJavaRawEmissions: () => summarizeJavaRawEmissions,
+  summarizeRuntimeTraceEmissions: () => summarizeRuntimeTraceEmissions,
+  withRuntimeTraceOptions: () => withRuntimeTraceOptions
 });
 module.exports = __toCommonJS(src_exports);
 
-// 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;
+// 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."
+      }
+    ]
   }
-  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);
+});
+
+// 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.`);
   }
-  if (typeof value === "function") return "<function>";
-  return null;
+  return info;
 }
-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 getSupportedLanguageRuntimeInfos() {
+  return SUPPORTED_LANGUAGE_RUNTIME_INFOS;
 }
-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;
+
+// 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
+  };
 }
-function normalizeRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  return normalizeUnknown(value);
+function sortedUnique(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
-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 sortedUniqueEventKinds(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
-function normalizeCallStackFrame(frame) {
+function withRuntimeTraceOptions(trace, options = {}) {
+  const runId = options.runId ?? trace.runId;
   return {
-    function: normalizeFunctionName(frame?.function),
-    line: normalizeLineNumber(frame?.line, 1),
-    args: normalizeRecord(frame?.args)
+    ...trace,
+    runId,
+    events: trace.events.map((event) => ({
+      ...event,
+      runId,
+      ...options.file ? { file: options.file } : {}
+    }))
   };
 }
-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;
+function buildRuntimeTraceParitySignature(trace) {
+  const lineSequence = [];
+  const eventKindsByLine = /* @__PURE__ */ new Map();
+  const variableSnapshotsByLine = /* @__PURE__ */ new Map();
+  const accessTargetsByLine = /* @__PURE__ */ new Map();
+  const callReturnShape = [];
+  for (const event of trace.events) {
+    if (event.kind === "line" && typeof event.line === "number") {
+      lineSequence.push(event.line);
+    }
+    if (event.kind === "call" || event.kind === "return") {
+      callReturnShape.push(event.kind);
+    }
+    if (typeof event.line === "number") {
+      const kinds = eventKindsByLine.get(event.line) ?? [];
+      kinds.push(event.kind);
+      eventKindsByLine.set(event.line, kinds);
+    }
+    if (event.kind === "snapshot" && "variable" in event.target && typeof event.line === "number") {
+      const variables = variableSnapshotsByLine.get(event.line) ?? [];
+      variables.push(event.target.variable);
+      variableSnapshotsByLine.set(event.line, variables);
+    }
+    if ((event.kind === "read" || event.kind === "write" || event.kind === "mutate") && "variable" in event.target && typeof event.line === "number") {
+      const accesses = accessTargetsByLine.get(event.line) ?? [];
+      accesses.push({
+        kind: event.kind,
+        variable: event.target.variable,
+        pathDepth: "path" in event.target && Array.isArray(event.target.path) ? event.target.path.length : void 0
+      });
+      accessTargetsByLine.set(event.line, accesses);
+    }
   }
   return {
-    ...hashMaps.length > 0 ? { hashMaps } : {},
-    ...objectKinds && Object.keys(objectKinds).length > 0 ? { objectKinds } : {}
+    lineSequence,
+    eventKindsByLine: Object.fromEntries(
+      [...eventKindsByLine.entries()].map(([line, kinds]) => [
+        line,
+        sortedUniqueEventKinds(kinds)
+      ])
+    ),
+    variableSnapshotsByLine: Object.fromEntries(
+      [...variableSnapshotsByLine.entries()].map(([line, variables]) => [
+        line,
+        sortedUnique(variables)
+      ])
+    ),
+    accessTargetsByLine: Object.fromEntries(
+      [...accessTargetsByLine.entries()].map(([line, accesses]) => [
+        line,
+        accesses.sort((left, right) => {
+          const leftKey = `${left.kind}:${left.variable ?? ""}:${left.pathDepth ?? 0}`;
+          const rightKey = `${right.kind}:${right.variable ?? ""}:${right.pathDepth ?? 0}`;
+          return leftKey.localeCompare(rightKey);
+        })
+      ])
+    ),
+    callReturnShape
   };
 }
-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 } : {}
-  };
+
+// packages/harness-core/src/runtime-raw-emission-contract.ts
+function sortedUnique2(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 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);
+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 (variablesWithCellAccess.size === 0) {
-    return trace;
+  if (value === null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const item of value) collectForbiddenRuntimeTraceTokens(item, tokens, parentKey, semanticPayload);
+    return;
   }
-  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 } : {}
-    };
+  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 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
-  };
-}
-function stableStringifyRuntimeTraceContract(value) {
-  return JSON.stringify(normalizeUnknown(value), null, 2);
+function unsupportedForbiddenPayload(label, value) {
+  const tokens = forbiddenRuntimeTraceTokens(value);
+  if (tokens.length === 0) return null;
+  return `${label} contains forbidden runtime trace token(s): ${tokens.join(", ")}`;
 }
-
-// packages/harness-core/src/trace-adapters/shared.ts
-function denormalizeCallStackFrame(frame) {
-  return {
-    function: frame.function,
-    line: frame.line,
-    args: frame.args
-  };
+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 denormalizeTraceStep(step) {
+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 {
-    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 } : {}
+    language: "java",
+    kinds: sortedUnique2(kinds),
+    unsupported
   };
 }
-function adaptTraceExecutionResult(language, result) {
-  const normalized = normalizeRuntimeTraceContract(language, result);
-  const adaptedTrace = normalized.trace.map(denormalizeTraceStep);
+function summarizeRuntimeTraceEmissions(trace) {
+  const kinds = [];
+  const unsupported = [];
+  for (const [index, event] of trace.events.entries()) {
+    const forbiddenPayload = unsupportedForbiddenPayload(`${trace.language} trace event ${index}`, event);
+    if (forbiddenPayload) {
+      unsupported.push(forbiddenPayload);
+      continue;
+    }
+    switch (event.kind) {
+      case "line":
+      case "call":
+      case "return":
+      case "exception":
+      case "timeout":
+      case "stdout":
+      case "snapshot":
+      case "read":
+      case "write":
+      case "mutate":
+        kinds.push(event.kind);
+        break;
+      default:
+        unsupported.push(`${trace.language} trace event ${index} has unsupported kind "${String(event.kind)}"`);
+    }
+  }
   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
+    language: trace.language,
+    kinds: sortedUnique2(kinds),
+    unsupported
   };
 }
-
-// packages/harness-core/src/trace-adapters/python.ts
-function adaptPythonTraceExecutionResult(result) {
-  return adaptTraceExecutionResult("python", result);
+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/javascript.ts
-function adaptJavaScriptTraceExecutionResult(language, result) {
-  return adaptTraceExecutionResult(language, result);
+function parityKinds(summary) {
+  return summary.kinds;
 }
-
-// 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 {
+function compareRawEmissionParity(reference, summaries) {
+  const expected = new Set(parityKinds(reference));
+  const mismatches = [];
+  for (const summary of summaries) {
+    if (summary.language === reference.language) continue;
+    const actual = new Set(parityKinds(summary));
+    const missing = [...expected].filter((kind) => !actual.has(kind)).sort((left, right) => left.localeCompare(right));
+    const extra = [...actual].filter((kind) => !expected.has(kind)).sort((left, right) => left.localeCompare(right));
+    if (missing.length > 0 || extra.length > 0) {
+      mismatches.push({ language: summary.language, missing, extra });
     }
   }
-  return raw;
+  return mismatches;
 }
+
+// packages/harness-core/src/trace-adapters/java.ts
 function normalizeJavaSerializedResult(output) {
   if (typeof output !== "string") {
     return output;
@@ -407,30 +636,8 @@ function normalizeJavaSerializedResult(output) {
     return output;
   }
 }
-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 };
-  }
-  return {
-    line: Number.parseInt(match[1], 10),
-    payload: match[2] ?? ""
-  };
+function isNativeJavaTraceEvent(event) {
+  return event.startsWith("trace:");
 }
 function stripInlineComments(line, inBlockComment) {
   let result = "";
@@ -453,9 +660,7 @@ function stripInlineComments(line, inBlockComment) {
       index += 2;
       continue;
     }
-    if (current === "/" && next === "/") {
-      break;
-    }
+    if (current === "/" && next === "/") break;
     result += current;
     index += 1;
   }
@@ -468,532 +673,208 @@ function isMethodDeclarationLine(line) {
   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;
-  }
+  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 buildLineRemap(sourceText) {
-  if (typeof sourceText !== "string" || sourceText.length === 0) {
-    return null;
-  }
+function buildLocalDeclarationNamesByLine(sourceText) {
+  const namesByLine = /* @__PURE__ */ new Map();
+  if (typeof sourceText !== "string" || sourceText.length === 0) return namesByLine;
   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);
-    }
-  }
-  if (executable.size === 0) {
-    return null;
-  }
-  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;
-  }
-  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;
-  }
-  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);
-    }
-  }
-  return remap;
+    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 buildMethodDeclarationLineSet(sourceText) {
-  if (typeof sourceText !== "string" || sourceText.length === 0) {
-    return null;
-  }
-  const declarationLines = /* @__PURE__ */ new Set();
+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/);
-  let inBlockComment = false;
+  const loopBodyLineToHeader = /* @__PURE__ */ new Map();
+  const headerLineToExcludedVariables = /* @__PURE__ */ new Map();
   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);
+    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;
     }
   }
-  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;
+  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;
     }
-    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 }]
+    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));
       }
-    ]
-  };
-}
-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;
-  }
-  const previous = trace.at(-1);
-  if (!previous || previous.event !== "line") {
-    return false;
-  }
-  if (previous.line !== nextStep.line || previous.function !== nextStep.function) {
-    return false;
-  }
-  if (!callStacksEqual(previous.callStack, nextStep.callStack)) {
-    return false;
-  }
-  previous.variables = { ...previous.variables ?? {}, ...nextStep.variables ?? {} };
-  if (nextStep.accesses?.length) {
-    previous.accesses = [...previous.accesses ?? [], ...nextStep.accesses];
-  }
-  previous.visualization = mergeVisualizationPayloads(previous.visualization, nextStep.visualization);
-  return true;
-}
-function filterStructuredVariables(variables) {
-  if (!variables) {
-    return void 0;
-  }
-  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;
+    expanded.push(event);
+    if (event.kind === "line") {
+      lastLineEventLine = line;
     }
-    if (Array.isArray(value[0])) {
-      return true;
+    if (snapshotVariable) {
+      latestSnapshotByVariable.set(snapshotVariable, event);
     }
-    return !isEphemeralOutputArrayName(name);
-  });
-  if (entries.length === 0) {
-    return void 0;
   }
-  return Object.fromEntries(entries);
+  return expanded;
 }
-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;
-  }
-  trace.push(nextStep);
-}
-function mergeIntoPreviousMatchingLineStep(trace, line, currentFunction, currentCallStack, patch) {
-  const candidate = trace.at(-1);
-  if (!candidate || candidate.event !== "line") {
-    return false;
-  }
-  if (candidate.line !== line || candidate.function !== currentFunction) {
-    return false;
-  }
-  if (!callStacksEqual(candidate.callStack, currentCallStack)) {
-    return false;
-  }
-  candidate.variables = { ...candidate.variables ?? {}, ...patch.variables ?? {} };
-  if (patch.accesses?.length) {
-    candidate.accesses = [...candidate.accesses ?? [], ...patch.accesses];
-  }
-  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;
-    }
-    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;
-    }
-    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;
-    }
-    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;
-    }
-    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]
-        }
-      }, pendingAccesses);
-      continue;
-    }
-    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;
-    }
-    if (isArrayLengthAccessEvent(payload)) {
-      continue;
-    }
-    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;
-    }
-    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;
+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)}`);
     }
-    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];
-  }
-  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 normalizeJavaTraceContract(result) {
-  const normalized = normalizeRuntimeTraceContract(
-    "java",
-    buildJavaExecutionResult(
-      result.output,
-      result.events,
-      0,
-      result.traceLimitExceeded,
-      result.timeoutReason,
-      void 0,
-      result.sourceText
-    )
-  );
+    return {
+      ...parsed,
+      runId,
+      ...options.file ? { file: options.file } : {}
+    };
+  });
+  parsedEvents = removeSameLineMutationDeclarationSnapshotEvents(parsedEvents, sourceText);
+  parsedEvents = expandJavaLoopHeaderTraceEvents(parsedEvents, sourceText);
   return {
-    ...normalized,
-    language: "java"
+    schemaVersion: RUNTIME_TRACE_SCHEMA_VERSION,
+    language: "java",
+    runId,
+    events: parsedEvents,
+    lineEventCount: parsedEvents.filter((event) => event.kind === "line").length,
+    traceStepCount: parsedEvents.length
   };
 }
-function adaptJavaTraceExecutionResult(result) {
-  return adaptTraceExecutionResult("java", result);
+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);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION,
-  adaptJavaScriptTraceExecutionResult,
-  adaptJavaSpikeTraceExecutionResult,
-  adaptJavaTraceExecutionResult,
-  adaptPythonTraceExecutionResult,
-  adaptTraceExecutionResult,
-  buildJavaExecutionResult,
-  buildJavaSpikeExecutionResult,
+  LANGUAGE_RUNTIME_INFOS,
+  RUNTIME_TRACE_SCHEMA_VERSION,
+  SUPPORTED_LANGUAGE_RUNTIME_INFOS,
+  assertSupportedRawEmissions,
+  buildRuntimeTraceParitySignature,
+  compareRawEmissionParity,
+  createEmptyRuntimeTrace,
+  getLanguageRuntimeInfo,
+  getSupportedLanguageRuntimeInfos,
+  javaTraceHooksEventsToRuntimeTrace,
+  normalizeJavaNativeTraceJsonPayload,
   normalizeJavaSerializedResult,
-  normalizeJavaSpikeTraceContract,
-  normalizeJavaTraceContract,
-  normalizeRuntimeTraceContract,
-  stableStringifyRuntimeTraceContract
+  summarizeJavaRawEmissions,
+  summarizeRuntimeTraceEmissions,
+  withRuntimeTraceOptions
 });
 //# sourceMappingURL=core.cjs.map