@tracecode/harness 0.6.2 → 0.6.6

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to this project are documented here.
 
 This repo uses Git tags as release boundaries. Version notes below summarize what shipped in each tagged release.
 
+## [0.6.6] - 2026-04-27
+
+### Fixed
+
+- Improved Java worker rewrite-failure handling so parser failures are surfaced as user-facing syntax errors instead of opaque Java object strings.
+- Added a compile probe fallback when Java source rewriting fails, allowing harness clients to receive compiler stderr/stdout diagnostics in the standard failed execution payload.
+
+## [0.6.5] - 2026-04-26
+
+### Added
+
+- Added Java visualizer harness support for public runtime trace metadata used by the app visualization path.
+
+### Fixed
+
+- Improved Java trace bookkeeping parity so emitted trace steps line up with the shared runtime contract.
+- Fixed Python runtime access attribution regressions caught while validating cross-language visualization parity.
+- Preserved Java script-mode tracing behavior through the updated harness assets.
+
+### Notes
+
+- `0.6.5` skips `0.6.4` intentionally because this release bundles the larger Java visualization compatibility update.
+
 ## [0.6.2] - 2026-04-23
 
 ### Added

package/dist/browser.cjs

@@ -1223,6 +1223,16 @@ function parseScalar(raw) {
   }
   return raw;
 }
+function normalizeJavaSerializedResult(output) {
+  if (typeof output !== "string") {
+    return output;
+  }
+  try {
+    return JSON.parse(output);
+  } catch {
+    return output;
+  }
+}
 function parseKeyValuePairs(fragment) {
   const variables = {};
   const matches = Array.from(fragment.matchAll(/\b([A-Za-z_][A-Za-z0-9_.]*)=/g));
@@ -1403,10 +1413,29 @@ function parseAccessEvent(payload) {
       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) ([A-Za-z_][A-Za-z0-9_]*)=(.+)$/);
+  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],
@@ -1422,6 +1451,22 @@ function parseObjectState(payload) {
     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;
@@ -1431,6 +1476,9 @@ function parseObjectFieldEvent(payload) {
     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: {
@@ -1510,12 +1558,13 @@ function filterStructuredVariables(variables) {
   }
   return Object.fromEntries(entries);
 }
-function appendJavaTraceStep(trace, step, pendingAccesses) {
+function appendJavaTraceStep(trace, step, pendingAccesses, options = {}) {
   const nextStep = pendingAccesses.length > 0 ? { ...step, accesses: [...pendingAccesses] } : step;
   pendingAccesses.length = 0;
-  if (!maybeMergeConsecutiveLineStep(trace, nextStep)) {
-    trace.push(nextStep);
+  if (options.allowMerge !== false && maybeMergeConsecutiveLineStep(trace, nextStep)) {
+    return;
   }
+  trace.push(nextStep);
 }
 function mergeIntoPreviousMatchingLineStep(trace, line, currentFunction, currentCallStack, patch) {
   const candidate = trace.at(-1);
@@ -1549,11 +1598,14 @@ function eventsToRawTrace(events, sourceText) {
   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;
@@ -1561,28 +1613,31 @@ function eventsToRawTrace(events, sourceText) {
       const match = payload.match(/^call\s+(\S+)(?:\s+(.*))?$/);
       const functionName = match?.[1] ?? currentFunction;
       const argsFragment = match?.[2] ?? "";
-      Object.assign(variables, parseKeyValuePairs(argsFragment));
+      const args = parseKeyValuePairs(argsFragment);
+      Object.assign(variables, args);
       currentFunction = functionName || currentFunction;
-      stack.push({ function: currentFunction, line });
+      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: {} }))
+        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+)$/);
+      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: {} }))
+        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>";
@@ -1597,8 +1652,8 @@ function eventsToRawTrace(events, sourceText) {
         event: "line",
         function: currentFunction,
         variables: { ...variables },
-        ...stack.length > 0 ? { callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: {} })) } : {}
-      }, pendingAccesses);
+        ...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);
@@ -1610,7 +1665,7 @@ function eventsToRawTrace(events, sourceText) {
         event: "line",
         function: currentFunction,
         variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: {} })),
+        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })),
         visualization: {
           objectKinds: { ...objectKinds }
         }
@@ -1625,7 +1680,7 @@ function eventsToRawTrace(events, sourceText) {
         event: "line",
         function: currentFunction,
         variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: {} })),
+        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })),
         visualization: {
           objectKinds: { [objectState.variable]: "object" },
           hashMaps: [objectState.visualization]
@@ -1633,10 +1688,56 @@ function eventsToRawTrace(events, sourceText) {
       }, 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: {} })) : void 0;
+      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,
@@ -1649,27 +1750,18 @@ function eventsToRawTrace(events, sourceText) {
         event: "line",
         function: currentFunction,
         variables: { ...variables },
-        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: {} })),
+        callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.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: {} })) } : {}
+      ...stack.length > 0 ? { callStack: stack.map((frame) => ({ function: frame.function, line: frame.line, args: { ...frame.args } })) } : {}
     }, pendingAccesses);
   }
   if (pendingAccesses.length > 0 && trace.length > 0) {
@@ -1678,11 +1770,11 @@ function eventsToRawTrace(events, sourceText) {
   }
   return trace;
 }
-function buildJavaExecutionResult(output, events, executionTimeMs = 0, traceLimitExceeded, timeoutReason, maxTraceSteps, sourceText) {
+function buildJavaExecutionResult(output, events, executionTimeMs = 0, traceLimitExceeded, timeoutReason, maxTraceSteps, sourceText, options = {}) {
   const trace = eventsToRawTrace(events, sourceText);
   return {
     success: true,
-    output,
+    output: options.outputIsSerialized === false ? output : normalizeJavaSerializedResult(output),
     trace,
     executionTimeMs,
     consoleOutput: [],
@@ -1740,7 +1832,8 @@ var JavaRuntimeClient = class {
         rawResult.traceLimitExceeded,
         rawResult.timeoutReason,
         void 0,
-        rawResult.sourceText
+        rawResult.sourceText,
+        { outputIsSerialized: false }
       )
     );
     return {