@tracecode/harness 0.5.0 → 0.6.0

package/dist/core.cjs

@@ -22,15 +22,21 @@ 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,
+  normalizeJavaSpikeTraceContract: () => normalizeJavaTraceContract,
+  normalizeJavaTraceContract: () => normalizeJavaTraceContract,
   normalizeRuntimeTraceContract: () => normalizeRuntimeTraceContract,
   stableStringifyRuntimeTraceContract: () => stableStringifyRuntimeTraceContract
 });
 module.exports = __toCommonJS(src_exports);
 
 // packages/harness-core/src/trace-contract.ts
-var RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION = "2026-03-13";
+var RUNTIME_TRACE_CONTRACT_SCHEMA_VERSION = "2026-04-21";
 var TRACE_EVENTS = /* @__PURE__ */ new Set([
   "line",
   "call",
@@ -151,7 +157,39 @@ function normalizeAccesses(accesses) {
     }
     return payload;
   }).filter((access) => access !== null);
-  return normalized.length > 0 ? normalized : void 0;
+  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 {};
@@ -215,8 +253,64 @@ function normalizeTraceStep(step) {
     ...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 normalizedTrace = Array.isArray(result.trace) ? result.trace.map(normalizeTraceStep) : [];
+  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 {
@@ -228,7 +322,7 @@ function normalizeRuntimeTraceContract(language, result) {
     ...typeof result.errorLine === "number" && Number.isFinite(result.errorLine) ? { errorLine: Math.floor(result.errorLine) } : {},
     consoleOutput: normalizedConsole,
     trace: normalizedTrace,
-    ...result.traceLimitExceeded !== void 0 ? { traceLimitExceeded: Boolean(result.traceLimitExceeded) } : {},
+    ...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
@@ -286,12 +380,525 @@ function adaptPythonTraceExecutionResult(result) {
 function adaptJavaScriptTraceExecutionResult(language, result) {
   return adaptTraceExecutionResult(language, result);
 }
+
+// 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 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 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 buildLineRemap(sourceText) {
+  if (typeof sourceText !== "string" || sourceText.length === 0) {
+    return null;
+  }
+  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;
+}
+function buildMethodDeclarationLineSet(sourceText) {
+  if (typeof sourceText !== "string" || sourceText.length === 0) {
+    return null;
+  }
+  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);
+    }
+  }
+  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
+    }];
+  }
+  return void 0;
+}
+function parseStructureState(payload) {
+  const match = payload.match(/^state (linked-list|tree) ([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 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 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 }]
+      }
+    ]
+  };
+}
+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;
+    }
+    if (Array.isArray(value[0])) {
+      return true;
+    }
+    return !isEphemeralOutputArrayName(name);
+  });
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return Object.fromEntries(entries);
+}
+function appendJavaTraceStep(trace, step, pendingAccesses) {
+  const nextStep = pendingAccesses.length > 0 ? { ...step, accesses: [...pendingAccesses] } : step;
+  pendingAccesses.length = 0;
+  if (!maybeMergeConsecutiveLineStep(trace, nextStep)) {
+    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>";
+  const lineRemap = buildLineRemap(sourceText);
+  const declarationLines = buildMethodDeclarationLineSet(sourceText);
+  for (const rawEvent of events) {
+    if (rawEvent === "clear" || rawEvent === "reset") continue;
+    const metadata = extractLineMetadata(rawEvent);
+    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] ?? "";
+      Object.assign(variables, parseKeyValuePairs(argsFragment));
+      currentFunction = functionName || currentFunction;
+      stack.push({ function: currentFunction, line });
+      appendJavaTraceStep(trace, {
+        line,
+        event: "call",
+        function: currentFunction,
+        variables: { ...variables },
+        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: {} }))
+      }, pendingAccesses);
+      continue;
+    }
+    if (payload.startsWith("return ")) {
+      const match = payload.match(/^return\s+(\S+)$/);
+      const functionName = match?.[1] ?? currentFunction;
+      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: {} }))
+      }, 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: {} })) } : {}
+      }, pendingAccesses);
+      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: {} })),
+        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: {} })),
+        visualization: {
+          objectKinds: { [objectState.variable]: "object" },
+          hashMaps: [objectState.visualization]
+        }
+      }, pendingAccesses);
+      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: {} })) : 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: {} })),
+        visualization: buildFieldVisualization(objectField)
+      }, pendingAccesses);
+      continue;
+    }
+    Object.assign(variables, parseKeyValuePairs(payload));
+    const accesses = parseAccessEvent(payload);
+    if (accesses) {
+      const currentCallStack = stack.length > 0 ? stack.map((frame) => ({ function: frame.function, line: frame.line, args: {} })) : void 0;
+      if (mergeAccessesIntoPreviousMatchingLineStep(trace, line, currentFunction, currentCallStack, accesses)) {
+        continue;
+      }
+      pendingAccesses.push(...accesses);
+      continue;
+    }
+    appendJavaTraceStep(trace, {
+      line,
+      event: "line",
+      function: currentFunction,
+      variables: { ...variables },
+      ...stack.length > 0 ? { callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, 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) {
+  const trace = eventsToRawTrace(events, sourceText);
+  return {
+    success: true,
+    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 {
+    ...normalized,
+    language: "java"
+  };
+}
+function adaptJavaTraceExecutionResult(result) {
+  return adaptTraceExecutionResult("java", result);
+}
 // 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,
+  normalizeJavaSpikeTraceContract,
+  normalizeJavaTraceContract,
   normalizeRuntimeTraceContract,
   stableStringifyRuntimeTraceContract
 });