@tracecode/harness 0.5.1 → 0.6.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // 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",
@@ -120,7 +120,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 {};
@@ -184,8 +216,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 {
@@ -197,7 +285,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
@@ -256,6 +344,513 @@ 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);
+}
+
 // packages/harness-browser/src/javascript-worker-client.ts
 var EXECUTION_TIMEOUT_MS = 7e3;
 var INTERVIEW_MODE_TIMEOUT_MS = 5e3;
@@ -582,6 +1177,7 @@ var PYTHON_RUNTIME_PROFILE = {
         maxTraceSteps: true,
         maxLineEvents: true,
         maxSingleLineHits: true,
+        maxStoredEvents: true,
         minimalTrace: true
       },
       fidelity: {
@@ -643,6 +1239,7 @@ var JAVASCRIPT_RUNTIME_PROFILE = {
         maxTraceSteps: true,
         maxLineEvents: true,
         maxSingleLineHits: true,
+        maxStoredEvents: true,
         minimalTrace: true
       },
       fidelity: {
@@ -704,6 +1301,7 @@ var TYPESCRIPT_RUNTIME_PROFILE = {
         maxTraceSteps: true,
         maxLineEvents: true,
         maxSingleLineHits: true,
+        maxStoredEvents: true,
         minimalTrace: true
       },
       fidelity: {
@@ -734,10 +1332,78 @@ var TYPESCRIPT_RUNTIME_PROFILE = {
     }
   }
 };
+var JAVA_RUNTIME_PROFILE = {
+  language: "java",
+  maturity: "experimental",
+  capabilities: {
+    execution: {
+      styles: {
+        function: true,
+        solutionMethod: true,
+        opsClass: true,
+        script: false,
+        interviewMode: true
+      },
+      timeouts: {
+        clientTimeouts: true,
+        runtimeTimeouts: true
+      }
+    },
+    tracing: {
+      supported: true,
+      events: {
+        line: true,
+        call: true,
+        return: true,
+        exception: true,
+        stdout: false,
+        timeout: true
+      },
+      controls: {
+        maxTraceSteps: true,
+        maxLineEvents: false,
+        maxSingleLineHits: false,
+        maxStoredEvents: true,
+        minimalTrace: false
+      },
+      fidelity: {
+        preciseLineMapping: true,
+        stableFunctionNames: true,
+        callStack: true
+      }
+    },
+    diagnostics: {
+      compileErrors: true,
+      runtimeErrors: true,
+      mappedErrorLines: false,
+      stackTraces: true
+    },
+    structures: {
+      treeNodeRefs: true,
+      listNodeRefs: true,
+      mapSerialization: true,
+      setSerialization: true,
+      graphSerialization: false,
+      cycleReferences: true
+    },
+    visualization: {
+      runtimePayloads: true,
+      objectKinds: true,
+      hashMaps: true,
+      stepVisualization: true
+    }
+  },
+  notes: [
+    "Java currently supports the browser-local Java 17 lane for function, solution-method, and ops-class execution.",
+    "Interview-mode Java reuses the same browser-local execution path and remains experimental in the first harness slice.",
+    "Script-style Java is not enabled yet."
+  ]
+};
 var LANGUAGE_RUNTIME_PROFILES = {
   python: PYTHON_RUNTIME_PROFILE,
   javascript: JAVASCRIPT_RUNTIME_PROFILE,
-  typescript: TYPESCRIPT_RUNTIME_PROFILE
+  typescript: TYPESCRIPT_RUNTIME_PROFILE,
+  java: JAVA_RUNTIME_PROFILE
 };
 var SUPPORTED_LANGUAGES = Object.freeze(
   Object.keys(LANGUAGE_RUNTIME_PROFILES)
@@ -814,13 +1480,307 @@ function createJavaScriptRuntimeClient(runtimeLanguage, workerClient) {
   return new JavaScriptRuntimeClient(runtimeLanguage, workerClient);
 }
 
+// packages/harness-browser/src/java-worker-client.ts
+var TRACING_TIMEOUT_MS2 = 25e3;
+var INIT_TIMEOUT_MS2 = 25e3;
+var MESSAGE_TIMEOUT_MS2 = 3e4;
+var WORKER_READY_TIMEOUT_MS2 = 1e4;
+var JavaWorkerClient = class {
+  constructor(options) {
+    this.options = options;
+    this.debug = options.debug ?? process.env.NODE_ENV === "development";
+  }
+  worker = null;
+  pendingMessages = /* @__PURE__ */ new Map();
+  messageId = 0;
+  isInitializing = false;
+  initPromise = null;
+  workerReadyPromise = null;
+  workerReadyResolve = null;
+  workerReadyReject = null;
+  debug;
+  isSupported() {
+    return typeof Worker !== "undefined";
+  }
+  getWorker() {
+    if (this.worker) return this.worker;
+    if (!this.isSupported()) {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    this.workerReadyPromise = new Promise((resolve, reject) => {
+      this.workerReadyResolve = resolve;
+      this.workerReadyReject = (error) => reject(error);
+    });
+    const workerUrl = this.debug && !this.options.workerUrl.includes("?") ? `${this.options.workerUrl}?dev=${Date.now()}` : this.options.workerUrl;
+    this.worker = new Worker(workerUrl);
+    this.worker.onmessage = (event) => {
+      const { id, type, payload } = event.data;
+      if (type === "worker-ready") {
+        this.workerReadyResolve?.();
+        this.workerReadyResolve = null;
+        this.workerReadyReject = null;
+        return;
+      }
+      if (!id) return;
+      const pending = this.pendingMessages.get(id);
+      if (!pending) return;
+      this.pendingMessages.delete(id);
+      if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+      if (type === "error") {
+        pending.reject(new Error(payload.error));
+        return;
+      }
+      pending.resolve(payload);
+    };
+    this.worker.onerror = (error) => {
+      const workerError = new Error(error.message || "Java worker error");
+      this.workerReadyReject?.(workerError);
+      this.workerReadyResolve = null;
+      this.workerReadyReject = null;
+      for (const [, pending] of this.pendingMessages) {
+        if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+        pending.reject(workerError);
+      }
+      this.pendingMessages.clear();
+      this.terminateAndReset(workerError);
+    };
+    return this.worker;
+  }
+  async waitForWorkerReady() {
+    const readyPromise = this.workerReadyPromise;
+    if (!readyPromise) return;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const timeoutError = new Error(
+          `Java worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS2 / 1e3)}s)`
+        );
+        this.terminateAndReset(timeoutError);
+        reject(timeoutError);
+      }, WORKER_READY_TIMEOUT_MS2);
+      readyPromise.then(() => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve();
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
+  }
+  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS2) {
+    const worker = this.getWorker();
+    await this.waitForWorkerReady();
+    const id = String(++this.messageId);
+    return new Promise((resolve, reject) => {
+      this.pendingMessages.set(id, {
+        resolve,
+        reject
+      });
+      const timeoutId = globalThis.setTimeout(() => {
+        const pending2 = this.pendingMessages.get(id);
+        if (!pending2) return;
+        this.pendingMessages.delete(id);
+        pending2.reject(new Error(`Worker request timed out: ${type}`));
+      }, timeoutMs);
+      const pending = this.pendingMessages.get(id);
+      if (pending) pending.timeoutId = timeoutId;
+      worker.postMessage({ id, type, payload });
+    });
+  }
+  async executeWithTimeout(executor, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timeoutId = globalThis.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        this.terminateAndReset();
+        reject(
+          new Error(
+            `Java execution timed out after ${Math.round(timeoutMs / 1e3)} seconds.`
+          )
+        );
+      }, timeoutMs);
+      executor().then((result) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  terminateAndReset(reason = new Error("Worker was terminated")) {
+    this.workerReadyReject?.(reason);
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.initPromise = null;
+    this.isInitializing = false;
+    this.workerReadyPromise = null;
+    this.workerReadyResolve = null;
+    this.workerReadyReject = null;
+    for (const [, pending] of this.pendingMessages) {
+      if (pending.timeoutId) globalThis.clearTimeout(pending.timeoutId);
+      pending.reject(reason);
+    }
+    this.pendingMessages.clear();
+  }
+  async init() {
+    if (this.initPromise) return this.initPromise;
+    if (this.isInitializing) {
+      await new Promise((resolve) => globalThis.setTimeout(resolve, 100));
+      return this.init();
+    }
+    this.isInitializing = true;
+    this.initPromise = this.sendMessage("init", void 0, INIT_TIMEOUT_MS2);
+    try {
+      return await this.initPromise;
+    } catch (error) {
+      this.initPromise = null;
+      throw error;
+    } finally {
+      this.isInitializing = false;
+    }
+  }
+  async executeWithTracing(code, functionName, inputs, options, executionStyle) {
+    await this.init();
+    return this.executeWithTimeout(
+      () => this.sendMessage(
+        "execute-with-tracing",
+        { code, functionName, inputs, options, executionStyle },
+        TRACING_TIMEOUT_MS2 + 5e3
+      ),
+      TRACING_TIMEOUT_MS2
+    );
+  }
+  async executeCode(code, functionName, inputs, options, executionStyle) {
+    const result = await this.executeWithTracing(code, functionName, inputs, options, executionStyle);
+    if (!result.success) {
+      return {
+        success: false,
+        output: null,
+        error: result.error ?? "Java execution failed",
+        ...result.errorLine !== void 0 ? { errorLine: result.errorLine } : {},
+        consoleOutput: result.consoleOutput
+      };
+    }
+    return {
+      success: true,
+      output: result.output,
+      consoleOutput: result.consoleOutput
+    };
+  }
+  async executeCodeInterviewMode(code, functionName, inputs, options, executionStyle) {
+    return this.executeCode(code, functionName, inputs, options, executionStyle);
+  }
+  terminate() {
+    this.terminateAndReset();
+  }
+};
+
+// packages/harness-browser/src/java-runtime-client.ts
+var JavaRuntimeClient = class {
+  constructor(workerClient) {
+    this.workerClient = workerClient;
+  }
+  async init() {
+    return this.workerClient.init();
+  }
+  async executeWithTracing(code, functionName, inputs, options, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+      request: "trace",
+      executionStyle,
+      functionName
+    });
+    const rawResult = await this.workerClient.executeWithTracing(
+      code,
+      functionName ?? "",
+      inputs,
+      options,
+      executionStyle
+    );
+    if (!rawResult.success) {
+      return {
+        success: false,
+        error: rawResult.error ?? "Java tracing failed",
+        ...rawResult.errorLine !== void 0 ? { errorLine: rawResult.errorLine } : {},
+        trace: [],
+        executionTimeMs: rawResult.executionTimeMs,
+        consoleOutput: rawResult.consoleOutput,
+        ...rawResult.traceLimitExceeded !== void 0 ? { traceLimitExceeded: rawResult.traceLimitExceeded } : {},
+        ...rawResult.timeoutReason ? { timeoutReason: rawResult.timeoutReason } : {},
+        lineEventCount: 0,
+        traceStepCount: 0
+      };
+    }
+    const adapted = adaptJavaTraceExecutionResult(
+      buildJavaExecutionResult(
+        rawResult.output,
+        rawResult.events,
+        rawResult.executionTimeMs,
+        rawResult.traceLimitExceeded,
+        rawResult.timeoutReason,
+        void 0,
+        rawResult.sourceText
+      )
+    );
+    return {
+      ...adapted,
+      consoleOutput: rawResult.consoleOutput,
+      executionTimeMs: rawResult.executionTimeMs
+    };
+  }
+  async executeCode(code, functionName, inputs, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+      request: "execute",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCode(
+      code,
+      functionName,
+      inputs,
+      void 0,
+      executionStyle
+    );
+  }
+  async executeCodeInterviewMode(code, functionName, inputs, executionStyle = "function") {
+    assertRuntimeRequestSupported(getLanguageRuntimeProfile("java"), {
+      request: "interview",
+      executionStyle,
+      functionName
+    });
+    return this.workerClient.executeCodeInterviewMode(
+      code,
+      functionName,
+      inputs,
+      void 0,
+      executionStyle
+    );
+  }
+};
+function createJavaRuntimeClient(workerClient) {
+  return new JavaRuntimeClient(workerClient);
+}
+
 // packages/harness-browser/src/pyodide-worker-client.ts
 var EXECUTION_TIMEOUT_MS2 = 1e4;
 var INTERVIEW_MODE_TIMEOUT_MS2 = 5e3;
-var TRACING_TIMEOUT_MS2 = 3e4;
-var INIT_TIMEOUT_MS2 = 12e4;
-var MESSAGE_TIMEOUT_MS2 = 2e4;
-var WORKER_READY_TIMEOUT_MS2 = 1e4;
+var TRACING_TIMEOUT_MS3 = 3e4;
+var INIT_TIMEOUT_MS3 = 12e4;
+var MESSAGE_TIMEOUT_MS3 = 2e4;
+var WORKER_READY_TIMEOUT_MS3 = 1e4;
 var PyodideWorkerClient = class {
   constructor(options) {
     this.options = options;
@@ -910,14 +1870,14 @@ var PyodideWorkerClient = class {
         if (settled) return;
         settled = true;
         const timeoutError = new Error(
-          `Python worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS2 / 1e3)}s)`
+          `Python worker failed to initialize in time (${Math.round(WORKER_READY_TIMEOUT_MS3 / 1e3)}s)`
         );
         if (this.debug) {
-          console.warn("[PyodideWorkerClient] worker-ready timeout", { timeoutMs: WORKER_READY_TIMEOUT_MS2 });
+          console.warn("[PyodideWorkerClient] worker-ready timeout", { timeoutMs: WORKER_READY_TIMEOUT_MS3 });
         }
         this.terminateAndReset(timeoutError);
         reject(timeoutError);
-      }, WORKER_READY_TIMEOUT_MS2);
+      }, WORKER_READY_TIMEOUT_MS3);
       readyPromise.then(() => {
         if (settled) return;
         settled = true;
@@ -934,7 +1894,7 @@ var PyodideWorkerClient = class {
   /**
    * Send a message to the worker and wait for a response
    */
-  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS2) {
+  async sendMessage(type, payload, timeoutMs = MESSAGE_TIMEOUT_MS3) {
     const worker = this.getWorker();
     await this.waitForWorkerReady();
     const id = String(++this.messageId);
@@ -1018,7 +1978,7 @@ var PyodideWorkerClient = class {
     this.isInitializing = true;
     this.initPromise = (async () => {
       try {
-        return await this.sendMessage("init", void 0, INIT_TIMEOUT_MS2);
+        return await this.sendMessage("init", void 0, INIT_TIMEOUT_MS3);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         const shouldRetry = message.includes("Worker request timed out: init") || message.includes("Worker was terminated") || message.includes("Worker error") || message.includes("failed to initialize in time");
@@ -1029,7 +1989,7 @@ var PyodideWorkerClient = class {
           console.warn("[PyodideWorkerClient] init failed, resetting worker and retrying once", { message });
         }
         this.terminateAndReset();
-        return this.sendMessage("init", void 0, INIT_TIMEOUT_MS2);
+        return this.sendMessage("init", void 0, INIT_TIMEOUT_MS3);
       }
     })();
     try {
@@ -1056,9 +2016,9 @@ var PyodideWorkerClient = class {
           inputs,
           executionStyle,
           options
-        }, TRACING_TIMEOUT_MS2 + 5e3),
+        }, TRACING_TIMEOUT_MS3 + 5e3),
         // Message timeout slightly longer than execution timeout
-        TRACING_TIMEOUT_MS2
+        TRACING_TIMEOUT_MS3
       );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1068,7 +2028,7 @@ var PyodideWorkerClient = class {
           success: false,
           error: errorMessage,
           trace: [],
-          executionTimeMs: TRACING_TIMEOUT_MS2,
+          executionTimeMs: TRACING_TIMEOUT_MS3,
           consoleOutput: [],
           traceLimitExceeded: true,
           timeoutReason: "client-timeout",
@@ -1224,6 +2184,7 @@ var DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS = Object.freeze({
   pythonRuntimeCore: "pyodide/runtime-core.js",
   pythonSnippets: "generated-python-harness-snippets.js",
   javascriptWorker: "javascript-worker.js",
+  javaWorker: "java-worker.js",
   typescriptCompiler: "vendor/typescript.js"
 });
 function isExplicitAssetPath(pathname) {
@@ -1257,6 +2218,7 @@ function resolveBrowserHarnessAssets(options = {}) {
       assetBaseUrl,
       assets.javascriptWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.javascriptWorker
     ),
+    javaWorker: resolveAssetPath(assetBaseUrl, assets.javaWorker ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.javaWorker),
     typescriptCompiler: resolveAssetPath(
       assetBaseUrl,
       assets.typescriptCompiler ?? DEFAULT_BROWSER_HARNESS_ASSET_RELATIVE_PATHS.typescriptCompiler
@@ -1270,6 +2232,7 @@ var BrowserHarnessRuntime = class {
   supportedLanguages = SUPPORTED_LANGUAGES;
   pythonWorkerClient;
   javaScriptWorkerClient;
+  javaWorkerClient;
   clients;
   constructor(options = {}) {
     this.assets = resolveBrowserHarnessAssets(options);
@@ -1281,10 +2244,15 @@ var BrowserHarnessRuntime = class {
       workerUrl: this.assets.javascriptWorker,
       debug: options.debug
     });
+    this.javaWorkerClient = new JavaWorkerClient({
+      workerUrl: this.assets.javaWorker,
+      debug: options.debug
+    });
     this.clients = {
       python: createPythonRuntimeClient(this.pythonWorkerClient),
       javascript: createJavaScriptRuntimeClient("javascript", this.javaScriptWorkerClient),
-      typescript: createJavaScriptRuntimeClient("typescript", this.javaScriptWorkerClient)
+      typescript: createJavaScriptRuntimeClient("typescript", this.javaScriptWorkerClient),
+      java: createJavaRuntimeClient(this.javaWorkerClient)
     };
   }
   getClient(language) {
@@ -1308,11 +2276,16 @@ var BrowserHarnessRuntime = class {
       this.pythonWorkerClient.terminate();
       return;
     }
+    if (language === "java") {
+      this.javaWorkerClient.terminate();
+      return;
+    }
     this.javaScriptWorkerClient.terminate();
   }
   dispose() {
     this.pythonWorkerClient.terminate();
     this.javaScriptWorkerClient.terminate();
+    this.javaWorkerClient.terminate();
   }
 };
 function createBrowserHarness(options = {}) {
@@ -2824,9 +3797,13 @@ export {
   TEMPLATE_PYTHON_TRACE_SERIALIZE_FUNCTION,
   TYPESCRIPT_RUNTIME_DECLARATIONS,
   adaptJavaScriptTraceExecutionResult,
+  adaptJavaTraceExecutionResult as adaptJavaSpikeTraceExecutionResult,
+  adaptJavaTraceExecutionResult,
   adaptPythonTraceExecutionResult,
   adaptTraceExecutionResult,
   assertRuntimeRequestSupported,
+  buildJavaExecutionResult,
+  buildJavaExecutionResult as buildJavaSpikeExecutionResult,
   createBrowserHarness,
   executeJavaScriptCode,
   executeJavaScriptWithTracing,
@@ -2838,6 +3815,8 @@ export {
   getSupportedLanguageProfiles,
   identifyConversions,
   isLanguageSupported,
+  normalizeJavaTraceContract as normalizeJavaSpikeTraceContract,
+  normalizeJavaTraceContract,
   normalizeRuntimeTraceContract,
   resolveBrowserHarnessAssets,
   stableStringifyRuntimeTraceContract,