@tracecode/harness 0.6.6 → 0.7.0-beta7

package/workers/java/java-worker.js

@@ -1,23 +1,51 @@
 const CHEERPJ_LOADER_URL = 'https://cjrtnc.leaningtech.com/4.2/loader.js';
-const HELPER_JAR_PATH = '/app/workers/vendor/java-browser-spike-helper.jar';
+const HELPER_JAR_PATH = '/app/workers/vendor/java-browser-helper.jar';
 const JDK17_COMPILER_JAR_PATH = '/app/workers/vendor/jdk.compiler-17.jar';
-const REWRITER_JAR_PATH = '/app/workers/vendor/java-practice-rewriter.jar';
-const REWRITER_BRIDGE_JAR_PATH = '/app/workers/vendor/java-rewrite-bridge.jar';
+const REWRITER_JAR_PATH = '/app/workers/vendor/java-rewriter.jar';
 const JAVAPARSER_JAR_PATH = '/app/workers/vendor/javaparser-core-3.25.10.jar';
 const FULL_CLASSPATH = [
   HELPER_JAR_PATH,
   JDK17_COMPILER_JAR_PATH,
   REWRITER_JAR_PATH,
-  REWRITER_BRIDGE_JAR_PATH,
   JAVAPARSER_JAR_PATH,
 ].join(':');
 const DEFAULT_COMPILER_DEBUG_PROFILE = 'full';
+const DEFAULT_EXECUTE_COMPILER_DEBUG_PROFILE = 'none';
 const DEFAULT_MAX_STORED_EVENTS = 50_000;
-const IDLE_TIMEOUT_MS = 90_000;
+const DEFAULT_IDLE_TIMEOUT_MS = 300_000;
 const SCRIPT_METHOD_NAME = '__tracecodeScript';
+const DYNAMIC_INPUT_PREFIX = '/str/tracecode-java-input';
+const JAVA_DEFAULT_IMPORTS = [
+  'import java.util.*;',
+  'import java.io.*;',
+  'import java.math.*;',
+  'import java.util.stream.*;',
+  'import javafx.util.Pair;',
+];
+const WORKER_DEBUG = (() => {
+  try {
+    return typeof self !== 'undefined' && typeof self.location?.search === 'string' && self.location.search.includes('dev=');
+  } catch {
+    return false;
+  }
+})();
+
+function emitRuntimeDiagnostic(level, phase, message, detail) {
+  if (!WORKER_DEBUG && level !== 'error') return;
+  const method = level === 'error' ? 'error' : level === 'warn' ? 'warn' : level === 'debug' ? 'debug' : 'info';
+  console[method]('[TraceRuntime]', {
+    schema: 'tracecode.runtime-diagnostic.v1',
+    source: 'harness',
+    component: 'JavaWorker',
+    runtime: 'java',
+    phase,
+    message,
+    ...(detail === undefined ? {} : { detail }),
+  });
+}
 
 if (typeof self.importScripts === 'function') {
-  self.importScripts('java-source-augmentations.cjs');
+  self.importScripts('java-source-augmentations.js');
 }
 
 let workerReadyPromise = null;
@@ -27,13 +55,26 @@ let helperLibraryPromise = null;
 let compileLibraryClassPromise = null;
 let rewriteLibraryClassPromise = null;
 let idleGeneration = 0;
-let hostWarmupPromise = null;
 let initLoadTimeMs = null;
+let idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS;
+let runWarmupPromise = null;
 
 function postMessageResponse(message) {
   self.postMessage(message);
 }
 
+function javaDefaultImportsBlock() {
+  return JAVA_DEFAULT_IMPORTS.join('\n');
+}
+
+function addJavaDefaultImportsToPackagedSource(source) {
+  const importBlock = javaDefaultImportsBlock();
+  return String(source).replace(
+    /^(package\s+[A-Za-z_][A-Za-z0-9_.]*\s*;\s*\n+)/,
+    `$1${importBlock}\n`
+  );
+}
+
 function formatWorkerErrorMessage(error) {
   if (error instanceof Error && typeof error.message === 'string' && error.message.length > 0) {
     return error.message;
@@ -119,7 +160,14 @@ function resetIdleTimer() {
     if (generation !== idleGeneration) return;
     postMessageResponse({ type: 'idle-timeout' });
     self.close();
-  }, IDLE_TIMEOUT_MS);
+  }, idleTimeoutMs);
+}
+
+function applyWorkerOptions(payload) {
+  const nextIdleTimeoutMs = Number(payload?.idleTimeoutMs);
+  if (Number.isFinite(nextIdleTimeoutMs) && nextIdleTimeoutMs > 0) {
+    idleTimeoutMs = Math.max(1_000, Math.floor(nextIdleTimeoutMs));
+  }
 }
 
 function assertSupportedExecutionStyle(executionStyle) {
@@ -150,6 +198,8 @@ function isRecord(value) {
 
 function isListNodeShape(value) {
   if (!isRecord(value)) return false;
+  const typeName = typeof value.__type__ === 'string' ? value.__type__ : typeof value.__class__ === 'string' ? value.__class__ : null;
+  if (typeName && typeName !== 'ListNode' && typeName !== 'object') return false;
   if (!('val' in value || 'value' in value)) return false;
   if ('next' in value) return true;
   return typeof value.__id__ === 'string' && value.__id__.startsWith('list-');
@@ -157,19 +207,43 @@ function isListNodeShape(value) {
 
 function isTreeNodeShape(value) {
   if (!isRecord(value)) return false;
+  const typeName = typeof value.__type__ === 'string' ? value.__type__ : typeof value.__class__ === 'string' ? value.__class__ : null;
+  if (typeName && typeName !== 'TreeNode' && typeName !== 'object') return false;
   if (!('val' in value || 'value' in value)) return false;
   if ('left' in value || 'right' in value) return true;
   return typeof value.__id__ === 'string' && value.__id__.startsWith('tree-');
 }
 
-function detectFeatures(source, input) {
+function detectFeatures(source, input, options = {}) {
   const values = Object.values(input ?? {});
   return {
     hasList: /\bListNode\b/.test(source) || values.some((value) => isListNodeShape(value)),
     hasTree: /\bTreeNode\b/.test(source) || values.some((value) => isTreeNodeShape(value)),
+    hasCustomObject: values.some((value) => containsCustomObjectLiteral(value)),
+    hasMap: values.some((value) => containsPlainObjectLiteral(value)),
+    hasDynamicInputs: options.hasDynamicInputs === true,
   };
 }
 
+function containsCustomObjectLiteral(value) {
+  if (Array.isArray(value)) return value.some((entry) => containsCustomObjectLiteral(entry));
+  if (!isRecord(value)) return false;
+  const typeName = typeof value.__type__ === 'string' ? value.__type__ : typeof value.__class__ === 'string' ? value.__class__ : null;
+  if (typeName && typeName !== 'TreeNode' && typeName !== 'ListNode' && typeName !== 'object') return true;
+  return Object.values(value).some((entry) => containsCustomObjectLiteral(entry));
+}
+
+function containsPlainObjectLiteral(value) {
+  if (Array.isArray(value)) return value.some((entry) => containsPlainObjectLiteral(entry));
+  if (!isRecord(value)) return false;
+  const typeName = typeof value.__type__ === 'string' ? value.__type__ : typeof value.__class__ === 'string' ? value.__class__ : null;
+  if (!typeName) return true;
+  if (typeName !== 'TreeNode' && typeName !== 'ListNode' && typeName !== 'object') return false;
+  return Object.entries(value)
+    .filter(([key]) => key !== '__type__' && key !== '__class__' && key !== '__id__')
+    .some(([, entry]) => containsPlainObjectLiteral(entry));
+}
+
 function toJavaScalarLiteral(value) {
   if (value === null) return 'null';
   if (typeof value === 'number' || typeof value === 'boolean') return String(value);
@@ -177,6 +251,23 @@ function toJavaScalarLiteral(value) {
   throw new Error(`Unsupported scalar literal: ${JSON.stringify(value)}`);
 }
 
+function toJavaScalarLiteralForType(value, expectedType) {
+  const normalized = expectedType ? stripGenericType(expectedType) : null;
+  if ((normalized === 'long' || normalized === 'Long') && typeof value === 'number' && Number.isInteger(value)) {
+    return `${String(value)}L`;
+  }
+  if ((normalized === 'double' || normalized === 'Double') && typeof value === 'number') {
+    return Number.isInteger(value) ? `${String(value)}.0` : String(value);
+  }
+  if ((normalized === 'float' || normalized === 'Float') && typeof value === 'number') {
+    return `${Number.isInteger(value) ? `${String(value)}.0` : String(value)}f`;
+  }
+  if (normalized === 'char' && typeof value === 'string' && value.length === 1) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+  }
+  return toJavaScalarLiteral(value);
+}
+
 function toJavaArrayLiteral(value) {
   if (value.length === 0) return 'new int[] {}';
   if (value.every((entry) => typeof entry === 'number' && Number.isInteger(entry))) {
@@ -226,6 +317,78 @@ function extractTypeArguments(typeSource) {
   return parts.map((part) => part.trim()).filter(Boolean);
 }
 
+function splitTopLevelCommaList(source) {
+  const parts = [];
+  let depth = 0;
+  let current = '';
+  for (const ch of source) {
+    if (ch === '<' || ch === '(' || ch === '[') depth += 1;
+    if (ch === '>' || ch === ')' || ch === ']') depth -= 1;
+    if (ch === ',' && depth === 0) {
+      parts.push(current);
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+  if (current) parts.push(current);
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+
+function normalizedJavaInputType(typeSource) {
+  return String(typeSource || 'Object')
+    .replace(/\bfinal\b/g, '')
+    .replace(/\s+/g, '')
+    .replace(/\.\.\.$/, '[]');
+}
+
+function isDynamicJavaScalarType(typeSource, value) {
+  const normalized = normalizedJavaInputType(typeSource);
+  if (
+    ['byte', 'Byte', 'short', 'Short', 'int', 'Integer', 'long', 'Long', 'float', 'Float', 'double', 'Double'].includes(normalized)
+  ) {
+    return typeof value === 'number';
+  }
+  if (normalized === 'boolean' || normalized === 'Boolean') {
+    return typeof value === 'boolean';
+  }
+  if (normalized === 'String') {
+    return typeof value === 'string';
+  }
+  if (normalized === 'char' || normalized === 'Character') {
+    return typeof value === 'string' && value.length === 1;
+  }
+  return false;
+}
+
+function isDynamicJavaInputType(typeSource, value) {
+  const normalized = normalizedJavaInputType(typeSource);
+  if (normalized.endsWith('[]')) {
+    if (!Array.isArray(value)) return false;
+    const elementType = normalized.slice(0, -2);
+    return value.every((entry) => isDynamicJavaInputType(elementType, entry));
+  }
+  return isDynamicJavaScalarType(normalized, value);
+}
+
+function dynamicJavaInputExpression(typeSource, inputPath) {
+  const normalized = normalizedJavaInputType(typeSource);
+  const quotedPath = JSON.stringify(inputPath);
+  if (normalized.endsWith('[]')) {
+    return `((${normalized}) readJsonInput(${quotedPath}, ${normalized}.class))`;
+  }
+  if (normalized === 'byte' || normalized === 'Byte') return `((Number) readJsonInput(${quotedPath}, Byte.class)).byteValue()`;
+  if (normalized === 'short' || normalized === 'Short') return `((Number) readJsonInput(${quotedPath}, Short.class)).shortValue()`;
+  if (normalized === 'int' || normalized === 'Integer') return `((Number) readJsonInput(${quotedPath}, Integer.class)).intValue()`;
+  if (normalized === 'long' || normalized === 'Long') return `((Number) readJsonInput(${quotedPath}, Long.class)).longValue()`;
+  if (normalized === 'float' || normalized === 'Float') return `((Number) readJsonInput(${quotedPath}, Float.class)).floatValue()`;
+  if (normalized === 'double' || normalized === 'Double') return `((Number) readJsonInput(${quotedPath}, Double.class)).doubleValue()`;
+  if (normalized === 'boolean' || normalized === 'Boolean') return `((Boolean) readJsonInput(${quotedPath}, Boolean.class)).booleanValue()`;
+  if (normalized === 'char' || normalized === 'Character') return `((Character) readJsonInput(${quotedPath}, Character.class)).charValue()`;
+  if (normalized === 'String') return `((String) readJsonInput(${quotedPath}, String.class))`;
+  return null;
+}
+
 function toJavaTypedArrayLiteral(value, expectedType) {
   const normalized = stripGenericType(expectedType);
   if (!normalized.endsWith('[]')) {
@@ -268,7 +431,81 @@ function toJavaTypedArrayLiteral(value, expectedType) {
 
 function toJavaListLiteral(value, expectedType) {
   const [elementType = 'Object'] = extractTypeArguments(expectedType);
-  return `java.util.List.of(${value.map((entry) => buildJavaExpression(entry, elementType)).join(', ')})`;
+  return `new java.util.ArrayList<${elementType}>(java.util.Arrays.asList(${value.map((entry) => buildJavaExpression(entry, elementType)).join(', ')}))`;
+}
+
+function toJavaMapLiteral(value, expectedType) {
+  const [keyType = 'String', valueType = 'Object'] = extractTypeArguments(expectedType);
+  const entries = Object.entries(value)
+    .map(([key, child]) => `new Object[] { ${buildJavaExpression(key, keyType)}, ${buildJavaExpression(child, valueType)} }`);
+  return `typedMap(new Object[][] { ${entries.join(', ')} })`;
+}
+
+function toJavaObjectExpression(value) {
+  if (Array.isArray(value)) {
+    return `new java.util.ArrayList<Object>(java.util.Arrays.asList(${value.map((entry) => toJavaObjectExpression(entry)).join(', ')}))`;
+  }
+  if (isRecord(value)) {
+    return toJavaDynamicObjectExpression(value);
+  }
+  return toJavaScalarLiteral(value);
+}
+
+function customObjectTypeName(value) {
+  if (!isRecord(value)) return null;
+  const typeName = typeof value.__type__ === 'string' ? value.__type__ : typeof value.__class__ === 'string' ? value.__class__ : null;
+  if (!typeName || typeName === 'TreeNode' || typeName === 'ListNode' || typeName === 'object') return null;
+  return typeName;
+}
+
+function toJavaObjectFieldsExpression(value) {
+  const entries = Object.entries(value)
+    .filter(([key]) => key !== '__type__' && key !== '__class__' && key !== '__id__')
+    .map(([key, child]) => `new Object[] { ${JSON.stringify(key)}, ${toJavaDynamicObjectExpression(child)} }`);
+  return `objectFields(new Object[][] { ${entries.join(', ')} })`;
+}
+
+function toJavaDynamicObjectExpression(value) {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) {
+    return `new java.util.ArrayList<Object>(java.util.Arrays.asList(${value.map((entry) => toJavaDynamicObjectExpression(entry)).join(', ')}))`;
+  }
+  if (isRecord(value)) {
+    const typeName = customObjectTypeName(value);
+    if (typeName) {
+      return `materializeObject(${JSON.stringify(typeName)}, ${toJavaObjectFieldsExpression(value)})`;
+    }
+    const entries = Object.entries(value)
+      .filter(([key]) => key !== '__type__' && key !== '__class__' && key !== '__id__')
+      .map(([key, child]) => `new Object[] { ${JSON.stringify(key)}, ${toJavaDynamicObjectExpression(child)} }`);
+    return `objectFields(new Object[][] { ${entries.join(', ')} })`;
+  }
+  return toJavaScalarLiteral(value);
+}
+
+function inputValueForParameter(input, key, index) {
+  if (Object.prototype.hasOwnProperty.call(input, key)) return input[key];
+  return Object.values(input)[index];
+}
+
+function inputArgumentsForParameters(rawArgs, parameters) {
+  if (parameters.length === 0) return [];
+  if (Array.isArray(rawArgs)) return rawArgs;
+  if (isRecord(rawArgs) && parameters.length > 0) {
+    return parameters.map((parameter, index) => inputValueForParameter(rawArgs, parameter.name, index));
+  }
+  return [];
+}
+
+function uniqueJavaIdentifier(baseName, usedNames) {
+  let candidate = baseName;
+  let suffix = 0;
+  while (usedNames.has(candidate)) {
+    suffix += 1;
+    candidate = `${baseName}${suffix}`;
+  }
+  usedNames.add(candidate);
+  return candidate;
 }
 
 function listLiteral(value) {
@@ -320,17 +557,18 @@ function listGraphExpression(head) {
 
   const values = nodes.map((node) => {
     const rawVal = node.val ?? node.value ?? 0;
-    if (typeof rawVal !== 'number' || !Number.isInteger(rawVal)) {
-      throw new Error(`Unsupported list node value: ${JSON.stringify(rawVal)}`);
-    }
     return rawVal;
   });
 
-  return `buildList(new int[] { ${values.join(', ')} }, new int[] { ${nextIndices.join(', ')} })`;
+  return `buildList(new Object[] { ${values.map((value) => toJavaScalarLiteral(value)).join(', ')} }, new int[] { ${nextIndices.join(', ')} })`;
 }
 
 function listExpression(value) {
-  return `TraceHooks.reindexListIds(${listGraphExpression(value)})`;
+  return listGraphExpression(value);
+}
+
+function listArrayExpression(value) {
+  return `buildList(new Object[] { ${value.map((entry) => toJavaScalarLiteral(entry)).join(', ')} }, sequentialNextIndices(${value.length}))`;
 }
 
 function treeExpression(value) {
@@ -340,9 +578,29 @@ function treeExpression(value) {
   return `tree(${toJavaScalarLiteral(rawVal)}, ${left}, ${right})`;
 }
 
+function treeLevelOrderExpression(value) {
+  if (!value.every((entry) => entry === null || (typeof entry === 'number' && Number.isInteger(entry)))) {
+    throw new Error(`Unsupported tree node value: ${JSON.stringify(value.find((entry) => entry !== null && (typeof entry !== 'number' || !Number.isInteger(entry))))}`);
+  }
+  const values = value.map((entry) => (entry === null ? 'null' : String(entry))).join(', ');
+  return `buildTree(new Integer[] { ${values} })`;
+}
+
 function buildJavaExpression(value, expectedType) {
   const normalizedType = expectedType ? stripGenericType(expectedType) : null;
+  if (value === null || typeof value !== 'object') {
+    return toJavaScalarLiteralForType(value, normalizedType);
+  }
   if (Array.isArray(value)) {
+    if (normalizedType === 'Object') {
+      return toJavaObjectExpression(value);
+    }
+    if (normalizedType === 'ListNode') {
+      return listArrayExpression(value);
+    }
+    if (normalizedType === 'TreeNode') {
+      return treeLevelOrderExpression(value);
+    }
     if (normalizedType?.startsWith('List<')) {
       return toJavaListLiteral(value, normalizedType);
     }
@@ -353,34 +611,299 @@ function buildJavaExpression(value, expectedType) {
   }
   if (isRecord(value) && normalizedType === 'ListNode') return listExpression(value);
   if (isRecord(value) && normalizedType === 'TreeNode') return treeExpression(value);
+  if (isRecord(value) && normalizedType?.startsWith('Map<')) return toJavaMapLiteral(value, normalizedType);
+  if (isRecord(value) && customObjectTypeName(value)) {
+    return `((${normalizedType ?? customObjectTypeName(value)}) ${toJavaDynamicObjectExpression(value)})`;
+  }
   if (isListNodeShape(value)) return listExpression(value);
   if (isTreeNodeShape(value)) return treeExpression(value);
   return toJavaScalarLiteral(value);
 }
 
+function buildDynamicInputHelperMethods() {
+  return `
+  private static Object readJsonInput(String path, Class<?> targetType) {
+    try {
+      String source = java.nio.file.Files.readString(java.nio.file.Paths.get(path), java.nio.charset.StandardCharsets.UTF_8);
+      return coerceJsonInput(new __TracecodeJsonParser(source).parse(), targetType);
+    } catch (java.io.IOException error) {
+      throw new RuntimeException("Unable to read TraceCode input " + path, error);
+    }
+  }
+
+  private static Object coerceJsonInput(Object value, Class<?> targetType) {
+    if (value == null) return null;
+    if (targetType.isArray()) {
+      java.util.List<?> list = (java.util.List<?>) value;
+      Class<?> componentType = targetType.getComponentType();
+      Object array = java.lang.reflect.Array.newInstance(componentType, list.size());
+      for (int i = 0; i < list.size(); i++) {
+        java.lang.reflect.Array.set(array, i, coerceJsonInput(list.get(i), componentType));
+      }
+      return array;
+    }
+    if ((targetType == byte.class || targetType == Byte.class) && value instanceof Number) return ((Number) value).byteValue();
+    if ((targetType == short.class || targetType == Short.class) && value instanceof Number) return ((Number) value).shortValue();
+    if ((targetType == int.class || targetType == Integer.class) && value instanceof Number) return ((Number) value).intValue();
+    if ((targetType == long.class || targetType == Long.class) && value instanceof Number) return ((Number) value).longValue();
+    if ((targetType == float.class || targetType == Float.class) && value instanceof Number) return ((Number) value).floatValue();
+    if ((targetType == double.class || targetType == Double.class) && value instanceof Number) return ((Number) value).doubleValue();
+    if ((targetType == boolean.class || targetType == Boolean.class) && value instanceof Boolean) return value;
+    if ((targetType == char.class || targetType == Character.class) && value instanceof String && ((String) value).length() == 1) {
+      return ((String) value).charAt(0);
+    }
+    if (targetType == String.class && value instanceof String) return value;
+    return value;
+  }
+
+  private static final class __TracecodeJsonParser {
+    private final String source;
+    private int index = 0;
+
+    __TracecodeJsonParser(String source) {
+      this.source = source == null || source.isEmpty() ? "null" : source;
+    }
+
+    Object parse() {
+      skipWhitespace();
+      Object value = parseValue();
+      skipWhitespace();
+      if (index != source.length()) {
+        throw new IllegalArgumentException("Unexpected trailing JSON input");
+      }
+      return value;
+    }
+
+    private Object parseValue() {
+      skipWhitespace();
+      char ch = peek();
+      if (ch == '"') return parseString();
+      if (ch == '[') return parseArray();
+      if (ch == '{') return parseObject();
+      if (ch == '-' || (ch >= '0' && ch <= '9')) return parseNumber();
+      if (consume("true")) return Boolean.TRUE;
+      if (consume("false")) return Boolean.FALSE;
+      if (consume("null")) return null;
+      throw new IllegalArgumentException("Invalid JSON input");
+    }
+
+    private java.util.List<Object> parseArray() {
+      expect('[');
+      java.util.ArrayList<Object> values = new java.util.ArrayList<>();
+      skipWhitespace();
+      if (peek() == ']') {
+        index++;
+        return values;
+      }
+      while (true) {
+        values.add(parseValue());
+        skipWhitespace();
+        char separator = take();
+        if (separator == ']') return values;
+        if (separator != ',') throw new IllegalArgumentException("Invalid JSON array");
+      }
+    }
+
+    private java.util.LinkedHashMap<String, Object> parseObject() {
+      expect('{');
+      java.util.LinkedHashMap<String, Object> values = new java.util.LinkedHashMap<>();
+      skipWhitespace();
+      if (peek() == '}') {
+        index++;
+        return values;
+      }
+      while (true) {
+        skipWhitespace();
+        String key = parseString();
+        skipWhitespace();
+        expect(':');
+        values.put(key, parseValue());
+        skipWhitespace();
+        char separator = take();
+        if (separator == '}') return values;
+        if (separator != ',') throw new IllegalArgumentException("Invalid JSON object");
+      }
+    }
+
+    private String parseString() {
+      expect('"');
+      StringBuilder out = new StringBuilder();
+      while (true) {
+        char ch = take();
+        if (ch == '"') return out.toString();
+        if (ch != '\\\\') {
+          out.append(ch);
+          continue;
+        }
+        char escaped = take();
+        switch (escaped) {
+          case '"': out.append('"'); break;
+          case '\\\\': out.append('\\\\'); break;
+          case '/': out.append('/'); break;
+          case 'b': out.append('\\b'); break;
+          case 'f': out.append('\\f'); break;
+          case 'n': out.append('\\n'); break;
+          case 'r': out.append('\\r'); break;
+          case 't': out.append('\\t'); break;
+          case 'u':
+            int codePoint = 0;
+            for (int i = 0; i < 4; i++) {
+              codePoint = (codePoint << 4) + Character.digit(take(), 16);
+            }
+            out.append((char) codePoint);
+            break;
+          default:
+            throw new IllegalArgumentException("Invalid JSON string escape");
+        }
+      }
+    }
+
+    private Number parseNumber() {
+      int start = index;
+      if (peek() == '-') index++;
+      while (peek() >= '0' && peek() <= '9') index++;
+      boolean floating = false;
+      if (peek() == '.') {
+        floating = true;
+        index++;
+        while (peek() >= '0' && peek() <= '9') index++;
+      }
+      if (peek() == 'e' || peek() == 'E') {
+        floating = true;
+        index++;
+        if (peek() == '+' || peek() == '-') index++;
+        while (peek() >= '0' && peek() <= '9') index++;
+      }
+      String raw = source.substring(start, index);
+      return floating ? Double.valueOf(raw) : Long.valueOf(raw);
+    }
+
+    private boolean consume(String literal) {
+      if (!source.startsWith(literal, index)) return false;
+      index += literal.length();
+      return true;
+    }
+
+    private void skipWhitespace() {
+      while (index < source.length() && Character.isWhitespace(source.charAt(index))) index++;
+    }
+
+    private char peek() {
+      return index < source.length() ? source.charAt(index) : '\\0';
+    }
+
+    private char take() {
+      if (index >= source.length()) throw new IllegalArgumentException("Unexpected end of JSON input");
+      return source.charAt(index++);
+    }
+
+    private void expect(char expected) {
+      char actual = take();
+      if (actual != expected) throw new IllegalArgumentException("Unexpected JSON character");
+    }
+  }`;
+}
+
 function buildHelperMethods(features) {
+  if (features.skipInputMaterializers) {
+    return '';
+  }
   const members = [];
+  if (features.hasDynamicInputs) {
+    members.push(buildDynamicInputHelperMethods());
+  }
+  if (features.hasList || features.hasCustomObject) {
+    members.push(`
+  private static Object coerceMaterializedValue(Object value, Class<?> targetType) {
+    if (value == null) {
+      return null;
+    }
+    if (targetType.isInstance(value)) {
+      return value;
+    }
+    if (targetType.isArray() && value instanceof java.util.List<?>) {
+      java.util.List<?> list = (java.util.List<?>) value;
+      Class<?> componentType = targetType.getComponentType();
+      Object array = java.lang.reflect.Array.newInstance(componentType, list.size());
+      for (int i = 0; i < list.size(); i++) {
+        java.lang.reflect.Array.set(array, i, coerceMaterializedValue(list.get(i), componentType));
+      }
+      return array;
+    }
+    if ((targetType == int.class || targetType == Integer.class) && value instanceof Number) return ((Number) value).intValue();
+    if ((targetType == long.class || targetType == Long.class) && value instanceof Number) return ((Number) value).longValue();
+    if ((targetType == double.class || targetType == Double.class) && value instanceof Number) return ((Number) value).doubleValue();
+    if ((targetType == float.class || targetType == Float.class) && value instanceof Number) return ((Number) value).floatValue();
+    if ((targetType == short.class || targetType == Short.class) && value instanceof Number) return ((Number) value).shortValue();
+    if ((targetType == byte.class || targetType == Byte.class) && value instanceof Number) return ((Number) value).byteValue();
+    if ((targetType == boolean.class || targetType == Boolean.class) && value instanceof Boolean) return value;
+    if ((targetType == char.class || targetType == Character.class) && value instanceof String && ((String) value).length() == 1) {
+      return ((String) value).charAt(0);
+    }
+    return value;
+  }`);
+  }
   if (features.hasList) {
     members.push(`
-  private static ListNode list(int val, ListNode next) {
-    ListNode node = new ListNode(val);
-    node.next = next;
-    return node;
+  private static ListNode list(Object val, ListNode next) {
+    try {
+      for (java.lang.reflect.Constructor<?> ctor : ListNode.class.getDeclaredConstructors()) {
+        Class<?>[] parameterTypes = ctor.getParameterTypes();
+        if (parameterTypes.length == 2 && parameterTypes[1] == ListNode.class) {
+          ctor.setAccessible(true);
+          return (ListNode) ctor.newInstance(coerceMaterializedValue(val, parameterTypes[0]), next);
+        }
+      }
+      for (java.lang.reflect.Constructor<?> ctor : ListNode.class.getDeclaredConstructors()) {
+        Class<?>[] parameterTypes = ctor.getParameterTypes();
+        if (parameterTypes.length == 1) {
+          ctor.setAccessible(true);
+          ListNode node = (ListNode) ctor.newInstance(coerceMaterializedValue(val, parameterTypes[0]));
+          try {
+            java.lang.reflect.Field nextField = ListNode.class.getDeclaredField("next");
+            nextField.setAccessible(true);
+            nextField.set(node, next);
+          } catch (Exception ignored) {
+          }
+          return node;
+        }
+      }
+      java.lang.reflect.Constructor<ListNode> ctor = ListNode.class.getDeclaredConstructor();
+      ctor.setAccessible(true);
+      ListNode node = ctor.newInstance();
+      java.lang.reflect.Field valField = ListNode.class.getDeclaredField("val");
+      valField.setAccessible(true);
+      valField.set(node, coerceMaterializedValue(val, valField.getType()));
+      java.lang.reflect.Field nextField = ListNode.class.getDeclaredField("next");
+      nextField.setAccessible(true);
+      nextField.set(node, next);
+      return node;
+    } catch (Exception error) {
+      throw new RuntimeException("Unable to materialize ListNode", error);
+    }
   }
 
-  private static ListNode buildList(int[] values, int[] nextIndices) {
+  private static ListNode buildList(Object[] values, int[] nextIndices) {
     if (values.length == 0) {
       return null;
     }
     ListNode[] nodes = new ListNode[values.length];
     for (int i = 0; i < values.length; i++) {
-      nodes[i] = new ListNode(values[i]);
+      nodes[i] = list(values[i], null);
     }
     for (int i = 0; i < values.length; i++) {
       int nextIndex = nextIndices[i];
       nodes[i].next = nextIndex >= 0 ? nodes[nextIndex] : null;
     }
     return nodes[0];
+  }
+
+  private static int[] sequentialNextIndices(int length) {
+    int[] indices = new int[length];
+    for (int i = 0; i < length; i++) {
+      indices[i] = i + 1 < length ? i + 1 : -1;
+    }
+    return indices;
   }`);
   }
   if (features.hasTree) {
@@ -390,33 +913,220 @@ function buildHelperMethods(features) {
     node.left = left;
     node.right = right;
     return node;
+  }
+
+  private static TreeNode buildTree(Integer[] values) {
+    if (values.length == 0 || values[0] == null) {
+      return null;
+    }
+    TreeNode root = new TreeNode(values[0]);
+    java.util.Queue<TreeNode> queue = new java.util.ArrayDeque<>();
+    queue.add(root);
+    int index = 1;
+    while (!queue.isEmpty() && index < values.length) {
+      TreeNode current = queue.remove();
+      if (values[index] != null) {
+        current.left = new TreeNode(values[index]);
+        queue.add(current.left);
+      }
+      index++;
+      if (index < values.length && values[index] != null) {
+        current.right = new TreeNode(values[index]);
+        queue.add(current.right);
+      }
+      index++;
+    }
+    return root;
   }`);
+  }
+  if (features.hasMap || features.hasCustomObject) {
+    members.push(`
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  private static <K, V> java.util.LinkedHashMap<K, V> typedMap(Object[][] entries) {
+    java.util.LinkedHashMap<K, V> map = new java.util.LinkedHashMap<>();
+    for (Object[] entry : entries) {
+      map.put((K) entry[0], (V) entry[1]);
+    }
+    return map;
+  }
+`);
+  }
+  if (features.hasCustomObject) {
+    members.push(`
+
+  private static java.util.LinkedHashMap<String, Object> objectFields(Object[][] entries) {
+    java.util.LinkedHashMap<String, Object> fields = new java.util.LinkedHashMap<>();
+    for (Object[] entry : entries) {
+      fields.put((String) entry[0], entry[1]);
+    }
+    return fields;
+  }
+
+  private static Object materializeObject(String typeName, java.util.LinkedHashMap<String, Object> fields) {
+    try {
+      Class<?> cls = Class.forName(new Object() {}.getClass().getPackageName() + "." + typeName);
+      Object[] values = fields.values().toArray();
+      for (java.lang.reflect.Constructor<?> ctor : cls.getDeclaredConstructors()) {
+        if (ctor.getParameterCount() != values.length) {
+          continue;
+        }
+        try {
+          Class<?>[] parameterTypes = ctor.getParameterTypes();
+          Object[] args = new Object[values.length];
+          for (int i = 0; i < values.length; i++) {
+            args[i] = coerceMaterializedValue(values[i], parameterTypes[i]);
+          }
+          ctor.setAccessible(true);
+          return ctor.newInstance(args);
+        } catch (Exception ignored) {
+        }
+      }
+      for (java.lang.reflect.Constructor<?> ctor : cls.getDeclaredConstructors()) {
+        if (ctor.getParameterCount() != 1 || values.length == 0) {
+          continue;
+        }
+        try {
+          Class<?>[] parameterTypes = ctor.getParameterTypes();
+          ctor.setAccessible(true);
+          Object instance = ctor.newInstance(coerceMaterializedValue(values[0], parameterTypes[0]));
+          for (java.util.Map.Entry<String, Object> entry : fields.entrySet()) {
+            try {
+              java.lang.reflect.Field field = cls.getDeclaredField(entry.getKey());
+              field.setAccessible(true);
+              field.set(instance, coerceMaterializedValue(entry.getValue(), field.getType()));
+            } catch (NoSuchFieldException ignored) {
+            }
+          }
+          return instance;
+        } catch (Exception ignored) {
+        }
+      }
+      java.lang.reflect.Constructor<?> noArg = cls.getDeclaredConstructor();
+      noArg.setAccessible(true);
+      Object instance = noArg.newInstance();
+      for (java.util.Map.Entry<String, Object> entry : fields.entrySet()) {
+        java.lang.reflect.Field field = cls.getDeclaredField(entry.getKey());
+        field.setAccessible(true);
+        field.set(instance, coerceMaterializedValue(entry.getValue(), field.getType()));
+      }
+      return instance;
+    } catch (Exception error) {
+      throw new RuntimeException("Unable to materialize " + typeName, error);
+    }
+  }
+
+`);
   }
   return members.join('\n');
 }
 
+function sourceDeclaresJavaClass(source, className) {
+  const escapedName = String(className).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`\\bclass\\s+${escapedName}\\b`).test(String(source ?? ''));
+}
+
+function buildNodePreludeSource(source, options = {}) {
+  if (options.scriptMode === true) {
+    return '';
+  }
+
+  const declarations = [];
+  if (!sourceDeclaresJavaClass(source, 'ListNode')) {
+    declarations.push(`class ListNode {
+  int val;
+  int value;
+  ListNode next;
+
+  ListNode() {
+    this(0, null);
+  }
+
+  ListNode(int val) {
+    this(val, null);
+  }
+
+  ListNode(int val, ListNode next) {
+    this.val = val;
+    this.value = val;
+    this.next = next;
+  }
+}`);
+  }
+
+  if (!sourceDeclaresJavaClass(source, 'TreeNode')) {
+    declarations.push(`class TreeNode {
+  int val;
+  int value;
+  TreeNode left;
+  TreeNode right;
+
+  TreeNode() {
+    this(0, null, null);
+  }
+
+  TreeNode(int val) {
+    this(val, null, null);
+  }
+
+  TreeNode(int val, TreeNode left, TreeNode right) {
+    this.val = val;
+    this.value = val;
+    this.left = left;
+    this.right = right;
+  }
+}`);
+  }
+
+  return declarations.length > 0 ? `${declarations.join('\n\n')}\n\n` : '';
+}
+
 function extractMethodParameters(source, methodName) {
+  return extractMethodParameterOverloads(source, methodName)[0] ?? [];
+}
+
+function extractMethodParameterOverloads(source, methodName) {
   const compact = source.replace(/\s+/g, ' ');
   const escapedMethod = methodName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const match = compact.match(new RegExp(`\\b${escapedMethod}\\s*\\(([^)]*)\\)`));
-  if (!match || !match[1] || !match[1].trim()) {
-    return [];
+  const overloads = [];
+  const pattern = new RegExp(`\\b${escapedMethod}\\s*\\(([^)]*)\\)`, 'g');
+  for (const match of compact.matchAll(pattern)) {
+    const rawParameters = match[1]?.trim();
+    if (!rawParameters) {
+      overloads.push([]);
+      continue;
+    }
+    overloads.push(
+      splitTopLevelCommaList(rawParameters)
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .map((segment) => {
+          const lastSpace = segment.lastIndexOf(' ');
+          if (lastSpace === -1) {
+            return { type: segment, name: segment };
+          }
+          return {
+            type: segment.slice(0, lastSpace).trim(),
+            name: segment.slice(lastSpace + 1).trim(),
+          };
+        })
+    );
   }
+  return overloads;
+}
 
-  return match[1]
-    .split(',')
-    .map((segment) => segment.trim())
-    .filter(Boolean)
-    .map((segment) => {
-      const lastSpace = segment.lastIndexOf(' ');
-      if (lastSpace === -1) {
-        return { type: segment, name: segment };
-      }
-      return {
-        type: segment.slice(0, lastSpace).trim(),
-        name: segment.slice(lastSpace + 1).trim(),
-      };
-    });
+function extractMethodParametersForArguments(source, methodName, rawArgs) {
+  const args = Array.isArray(rawArgs) ? rawArgs : [];
+  const overloads = extractMethodParameterOverloads(source, methodName);
+  return overloads.find((parameters) => parameters.length === args.length) ?? overloads[0] ?? [];
+}
+
+function extractMethodReturnType(source, methodName) {
+  const compact = source.replace(/\s+/g, ' ');
+  const escapedMethod = methodName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = compact.match(
+    new RegExp(`\\b(?:public|private|protected|static|final|synchronized|abstract|native|strictfp|\\s)*([A-Za-z_][A-Za-z0-9_<>,.?\\[\\]\\s]*)\\s+${escapedMethod}\\s*\\(`)
+  );
+  return match?.[1]?.trim() ?? null;
 }
 
 function indentBlock(source, spaces = 2) {
@@ -507,7 +1217,68 @@ function findMatchingParen(source, openIndex) {
   return closeIndex;
 }
 
+function findMatchingBrace(source, openIndex) {
+  let depth = 0;
+  let closeIndex = -1;
+  scanJavaCode(source, openIndex, source.length, (index, ch) => {
+    if (ch === '{') depth += 1;
+    if (ch === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        closeIndex = index;
+        return false;
+      }
+    }
+    return undefined;
+  });
+  return closeIndex;
+}
+
 function findSingleStatementEnd(source, bodyStart) {
+  let cursor = bodyStart;
+  while (/\s/.test(source[cursor] ?? '')) cursor += 1;
+  if (startsWithJavaKeyword(source, cursor, 'if')) {
+    let headerStart = cursor + 'if'.length;
+    while (/\s/.test(source[headerStart] ?? '')) headerStart += 1;
+    if (source[headerStart] === '(') {
+      const closeParen = findMatchingParen(source, headerStart);
+      if (closeParen >= 0) {
+        let nestedBodyStart = closeParen + 1;
+        while (/\s/.test(source[nestedBodyStart] ?? '')) nestedBodyStart += 1;
+        if (source[nestedBodyStart] === '{') {
+          const closeBrace = findMatchingBrace(source, nestedBodyStart);
+          if (closeBrace >= 0) return closeBrace;
+        }
+        if (source[nestedBodyStart] && source[nestedBodyStart] !== ';') {
+          return findSingleStatementEnd(source, nestedBodyStart);
+        }
+      }
+    }
+  }
+  const loopKeyword = startsWithJavaKeyword(source, cursor, 'for')
+    ? 'for'
+    : startsWithJavaKeyword(source, cursor, 'while')
+      ? 'while'
+      : null;
+  if (loopKeyword) {
+    let headerStart = cursor + loopKeyword.length;
+    while (/\s/.test(source[headerStart] ?? '')) headerStart += 1;
+    if (source[headerStart] === '(') {
+      const closeParen = findMatchingParen(source, headerStart);
+      if (closeParen >= 0) {
+        let nestedBodyStart = closeParen + 1;
+        while (/\s/.test(source[nestedBodyStart] ?? '')) nestedBodyStart += 1;
+        if (source[nestedBodyStart] === '{') {
+          const closeBrace = findMatchingBrace(source, nestedBodyStart);
+          if (closeBrace >= 0) return closeBrace;
+        }
+        if (source[nestedBodyStart] && source[nestedBodyStart] !== ';') {
+          return findSingleStatementEnd(source, nestedBodyStart);
+        }
+      }
+    }
+  }
+
   let parenDepth = 0;
   let bracketDepth = 0;
   let braceDepth = 0;
@@ -537,14 +1308,64 @@ function startsWithJavaKeyword(source, index, keyword) {
   return !after || !isJavaIdentifierPart(after);
 }
 
-function wrapSingleStatementLoopBodies(source) {
-  const inserts = [];
+function braceDeltaForLine(line) {
+  let delta = 0;
+  scanJavaCode(line, 0, line.length, (_index, ch) => {
+    if (ch === '{') delta += 1;
+    if (ch === '}') delta -= 1;
+    return undefined;
+  });
+  return delta;
+}
+
+function isUnbracedLoopHeaderLine(line) {
+  const trimmed = line.trim();
+  return /^(?:for|while)\s*\(.*\)\s*$/.test(trimmed) && !trimmed.includes('{') && !trimmed.endsWith(';');
+}
+
+function startsBracedLoopLine(line) {
+  const trimmed = line.trim();
+  return /^(?:for|while)\s*\(.*\)\s*\{/.test(trimmed);
+}
+
+function wrapNestedBracedLoopBodies(source) {
+  const lines = source.split(/\r?\n/);
+  const output = [];
+  let changed = false;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? '';
+    const next = lines[index + 1] ?? '';
+    if (!isUnbracedLoopHeaderLine(line) || !startsBracedLoopLine(next)) {
+      output.push(line);
+      continue;
+    }
+
+    changed = true;
+    output.push(`${line} {`);
+    index += 1;
+    let depth = 0;
+    for (; index < lines.length; index += 1) {
+      const nestedLine = lines[index] ?? '';
+      output.push(nestedLine);
+      depth += braceDeltaForLine(nestedLine);
+      if (depth <= 0) break;
+    }
+    output.push(`${line.match(/^\s*/)?.[0] ?? ''}}`);
+  }
+  return changed ? output.join('\n') : source;
+}
+
+function wrapSingleStatementLoopBodies(source) {
+  source = wrapNestedBracedLoopBodies(source);
+  const inserts = [];
   scanJavaCode(source, 0, source.length, (index) => {
     const keyword = source.startsWith('for', index)
       ? 'for'
       : source.startsWith('while', index)
         ? 'while'
-        : null;
+        : source.startsWith('if', index)
+          ? 'if'
+          : null;
     if (!keyword) return undefined;
 
     const before = index > 0 ? source[index - 1] : '';
@@ -565,7 +1386,6 @@ function wrapSingleStatementLoopBodies(source) {
     const bodyChar = source[bodyStart];
     if (!bodyChar || bodyChar === '{' || bodyChar === ';') return closeParen;
     if (
-      startsWithJavaKeyword(source, bodyStart, 'if') ||
       startsWithJavaKeyword(source, bodyStart, 'switch') ||
       startsWithJavaKeyword(source, bodyStart, 'synchronized') ||
       startsWithJavaKeyword(source, bodyStart, 'try')
@@ -593,7 +1413,7 @@ function wrapSingleStatementLoopBodies(source) {
     output += insertsByIndex.get(index) ?? '';
     if (index < source.length) output += source[index];
   }
-  return output;
+  return output === source ? output : wrapSingleStatementLoopBodies(output);
 }
 
 function splitTopLevelJavaList(value) {
@@ -675,6 +1495,13 @@ function escapeRegExp(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+function parseNativeTraceLine(line) {
+  const match = line.match(/TraceHooks\.emit(?:Line|Call|Return)AtLine\((\d+)\b/);
+  if (!match) return null;
+  const lineNumber = Number.parseInt(match[1], 10);
+  return Number.isFinite(lineNumber) && lineNumber > 0 ? lineNumber : null;
+}
+
 function augmentTraceCallArgumentSnapshots(source) {
   const lines = source.split('\n');
   const methodStack = [];
@@ -697,14 +1524,14 @@ function augmentTraceCallArgumentSnapshots(source) {
     let nextLine = line;
     if (currentMethod && !currentMethod.patchedCall && currentMethod.params.length > 0) {
       const callPattern = new RegExp(
-        `^(\\s*)TraceHooks\\.emit\\((\"line=\\d+ call ${escapeRegExp(currentMethod.name)}\").*\\);\\s*$`
+        `^(\\s*)TraceHooks\\.emitCallAtLine\\((\\d+),\\s*"${escapeRegExp(currentMethod.name)}",\\s*([^)]*)\\);\\s*$`
       );
       const callMatch = line.match(callPattern);
       if (callMatch) {
         const serializedArgs = currentMethod.params
           .map((paramName) => ` + " ${paramName}=" + TraceHooks.serializeResult(${paramName})`)
           .join('');
-        nextLine = `${callMatch[1]}TraceHooks.emit(${callMatch[2]}${serializedArgs});`;
+        nextLine = `${callMatch[1]}TraceHooks.emitCallAtLine(${callMatch[2]}, "${currentMethod.name}", ""${serializedArgs});`;
         currentMethod.patchedCall = true;
       }
     }
@@ -720,6 +1547,389 @@ function augmentTraceCallArgumentSnapshots(source) {
   }).join('\n');
 }
 
+function collectJavaLocalDeclarations(line) {
+  const names = [];
+  const trimmedLine = String(line).trim();
+  if (trimmedLine.startsWith('//') || trimmedLine.startsWith('/*') || trimmedLine.startsWith('*')) {
+    return 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 = 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')) {
+      names.push(name);
+    }
+  }
+  const enhancedForMatch = line.match(
+    /\bfor\s*\(\s*(?: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*:/
+  );
+  const enhancedForType = enhancedForMatch?.[1] ?? '';
+  const enhancedForName = enhancedForMatch?.[2];
+  if (enhancedForName && !skippedNames.has(enhancedForName) && !enhancedForName.startsWith('__tracecode')) {
+    names.push(enhancedForName);
+  }
+  return names;
+}
+
+function visibleJavaLocalNames(scopeStack) {
+  const names = [];
+  const seen = new Set();
+  for (const scope of scopeStack) {
+    for (const name of scope.names) {
+      if (!seen.has(name)) {
+        names.push(name);
+        seen.add(name);
+      }
+    }
+  }
+  return names;
+}
+
+function isUnbracedForDeclarationLine(line) {
+  return /^\s*for\s*\(/.test(line) && !(line.includes('{'));
+}
+
+function isControlHeaderDeclarationLine(line) {
+  return /^\s*(?:for|if|while|switch|catch)\s*\(/.test(line);
+}
+
+function traceEmitAlreadyIncludesVariable(emitExpression, name) {
+  return new RegExp(`\\b${escapeRegExp(name)}=`).test(emitExpression);
+}
+
+function appendJavaLocalSnapshotsToEmitLine(line, scopeStack) {
+  const visibleNames = visibleJavaLocalNames(scopeStack);
+  if (visibleNames.length === 0 || !line.includes('TraceHooks.emitLineAtLine(')) {
+    return line;
+  }
+
+  return line.replace(/TraceHooks\.emitLineAtLine\((\d+)(?:,\s*([^;]*?))?\);/g, (match, lineNumber, snapshotExpression) => {
+    const emitExpression = snapshotExpression ?? '';
+    const additions = visibleNames
+      .filter((name) => !traceEmitAlreadyIncludesVariable(emitExpression, name))
+      .map((name) => ` + " ${name}=" + TraceHooks.serializeResult(${name})`)
+      .join('');
+    if (!additions) return match;
+    const prefix = emitExpression.trim().length > 0 ? emitExpression.trim() : '""';
+    return `TraceHooks.emitLineAtLine(${Number.parseInt(lineNumber, 10)}, ${prefix}${additions});`;
+  });
+}
+
+function appendJavaLocalSnapshotsAfterMutations(line, scopeStack) {
+  const visibleNames = visibleJavaLocalNames(scopeStack);
+  if (visibleNames.length === 0 || !line.includes('TraceHooks.emitMutatingCallAtLine(')) {
+    return line;
+  }
+
+  return line.replace(
+    /(TraceHooks\.emitMutatingCallAtLine\((\d+),[^;]+;\s*)/g,
+    (match, statement, lineNumber) => {
+      const additions = visibleNames
+        .map((name) => ` + " ${name}=" + TraceHooks.serializeResult(${name})`)
+        .join('');
+      return `${statement} TraceHooks.emitLineAtLine(${lineNumber}, ""${additions});`;
+    }
+  );
+}
+
+function guardJavaLineEmit(line) {
+  return line.replace(
+    /^(\s*)TraceHooks\.emitLineAtLine\((.+)\);\s*$/,
+    (_match, indent, argsSource) => `${indent}if (!TraceHooks.traceLimitExceeded()) TraceHooks.emitLineAtLine(${argsSource});`
+  );
+}
+
+function appendJavaScalarDeclarationWrites(line, lineNumber) {
+  if (line.includes('TraceHooks.emitScalarWriteAtLine(')) return line;
+  if (/TraceHooks\.read[A-Za-z0-9_]*AtLine\(/.test(line)) return line;
+  if (/^\s*(?:for|if|while|switch|catch)\s*\(/.test(line)) return line;
+  if (!/;\s*$/.test(line)) return line;
+  const declarations = collectJavaLocalDeclarations(line);
+  if (declarations.length === 0) return line;
+  const indent = line.match(/^(\s*)/)?.[1] ?? '';
+  const writes = declarations
+    .map((name) => `${indent}TraceHooks.emitScalarWriteAtLine(${lineNumber}, "${name}", ${name});`)
+    .join('\n');
+  return `${line}\n${writes}`;
+}
+
+function appendJavaPendingScalarDeclarationWrites(line, lineNumber, declarations) {
+  if (!Array.isArray(declarations) || declarations.length === 0) return line;
+  if (!/;\s*$/.test(line)) return line;
+  const indent = line.match(/^(\s*)/)?.[1] ?? '';
+  const writes = declarations
+    .map((name) => `${indent}TraceHooks.emitScalarWriteAtLine(${lineNumber}, "${name}", ${name});`)
+    .join('\n');
+  return writes ? `${line}\n${writes}` : line;
+}
+
+function augmentJavaLocalSnapshots(source) {
+  const lines = source.split('\n');
+  const output = [];
+  const scopeStack = [];
+  let currentTraceLine = null;
+  let pendingScalarDeclarationWrites = null;
+  let methodDepth = 0;
+  const methodStartPattern =
+    /^(\s*)(?:(?:public|private|protected|static|final|synchronized)\s+)*(?:[A-Za-z_][A-Za-z0-9_<>\[\], ?]*\s+)+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*\{\s*$/;
+
+  for (const line of lines) {
+    if (methodDepth <= 0) {
+      const methodMatch = line.match(methodStartPattern);
+      if (methodMatch) {
+        methodDepth = Math.max(0, braceDelta(line));
+        const params = parseJavaParameterNames(methodMatch[3] ?? '');
+        scopeStack.length = 0;
+        scopeStack.push({ names: params });
+        output.push(line);
+        if (methodDepth <= 0) {
+          scopeStack.length = 0;
+          pendingScalarDeclarationWrites = null;
+        }
+        continue;
+      }
+      output.push(line);
+      continue;
+    }
+
+    const leadingClosingCount = line.match(/^\s*}+/)?.[0].replace(/\s/g, '').length ?? 0;
+    for (let index = 0; index < leadingClosingCount; index += 1) {
+      if (scopeStack.length > 0) scopeStack.pop();
+    }
+
+    const transformedLine = guardJavaLineEmit(appendJavaLocalSnapshotsAfterMutations(
+      appendJavaLocalSnapshotsToEmitLine(line, scopeStack),
+      scopeStack
+    ));
+    output.push(transformedLine);
+    const emittedTraceLine = parseNativeTraceLine(output[output.length - 1]);
+    if (emittedTraceLine !== null) currentTraceLine = emittedTraceLine;
+
+    const declarations = collectJavaLocalDeclarations(line);
+    if (declarations.length > 0 && currentTraceLine !== null) {
+      const lastIndex = output.length - 1;
+      output[lastIndex] = appendJavaScalarDeclarationWrites(output[lastIndex], currentTraceLine);
+      if (
+        !isControlHeaderDeclarationLine(line) &&
+        line.includes('=') &&
+        !/;\s*$/.test(line)
+      ) {
+        pendingScalarDeclarationWrites = {
+          lineNumber: currentTraceLine,
+          declarations: [...declarations],
+        };
+      }
+    } else if (pendingScalarDeclarationWrites && /;\s*$/.test(line)) {
+      const lastIndex = output.length - 1;
+      output[lastIndex] = appendJavaPendingScalarDeclarationWrites(
+        output[lastIndex],
+        pendingScalarDeclarationWrites.lineNumber,
+        pendingScalarDeclarationWrites.declarations
+      );
+      pendingScalarDeclarationWrites = null;
+    }
+    const declarationsBelongToCurrentScope =
+      declarations.length > 0 && !isControlHeaderDeclarationLine(line);
+    if (declarationsBelongToCurrentScope) {
+      const currentScope = scopeStack[scopeStack.length - 1];
+      if (currentScope) {
+        for (const name of declarations) {
+          currentScope.names.push(name);
+        }
+      }
+    }
+    const braceCounts = javaBraceCounts(line);
+    const openingCount = braceCounts.open;
+    const closingCount = Math.max(0, braceCounts.close - leadingClosingCount);
+    for (let index = 0; index < openingCount; index += 1) {
+      scopeStack.push({ names: index === 0 && !declarationsBelongToCurrentScope ? declarations : [] });
+    }
+    if (
+      openingCount === 0 &&
+      declarations.length > 0 &&
+      !declarationsBelongToCurrentScope &&
+      !isUnbracedForDeclarationLine(line)
+    ) {
+      const currentScope = scopeStack[scopeStack.length - 1];
+      if (currentScope) {
+        for (const name of declarations) {
+          currentScope.names.push(name);
+        }
+      }
+    }
+    for (let index = 0; index < closingCount; index += 1) {
+      if (scopeStack.length > 0) scopeStack.pop();
+    }
+    methodDepth += braceCounts.delta;
+    if (methodDepth <= 0) {
+      methodDepth = 0;
+      scopeStack.length = 0;
+      pendingScalarDeclarationWrites = null;
+    }
+  }
+
+  return output.join('\n');
+}
+
+function collectJavaObjectDeclarations(line) {
+  const names = [];
+  const declarationPattern =
+    /\b([A-Z][A-Za-z0-9_]*)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*new\s+\1\s*\(/g;
+  for (const match of line.matchAll(declarationPattern)) {
+    if (match[2]) names.push(match[2]);
+  }
+  return names;
+}
+
+function rewriteJavaObjectFieldReads(expression, objectNames, lineNumber) {
+  let output = expression;
+  for (const name of objectNames) {
+    const fieldPattern = new RegExp(`\\b${escapeRegExp(name)}\\.([A-Za-z_][A-Za-z0-9_]*)\\b`, 'g');
+    output = output.replace(fieldPattern, (match, field, offset, fullSource) => {
+      const marker = fullSource.lastIndexOf('TraceHooks.', offset);
+      const delimiter = Math.max(fullSource.lastIndexOf(';', offset), fullSource.lastIndexOf('\n', offset));
+      if (marker > delimiter) return match;
+      const nextChar = fullSource[offset + match.length] ?? '';
+      if (nextChar === '(') return match;
+      return `TraceHooks.readObjectFieldAtLine(${lineNumber}, "${name}", "${field}", ${match})`;
+    });
+  }
+  return output;
+}
+
+function augmentJavaObjectFieldOperations(source) {
+  const lines = source.split('\n');
+  const methodStack = [];
+  const methodStartPattern =
+    /^(\s*)(?:(?:public|private|protected|static|final|synchronized)\s+)*(?:[A-Za-z_][A-Za-z0-9_<>\[\], ?]*\s+)+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*\{\s*$/;
+
+  return lines.map((line) => {
+    const methodMatch = line.match(methodStartPattern);
+    if (methodMatch) {
+      methodStack.push({
+        depth: 1,
+        currentTraceLine: null,
+        objectNames: new Set(),
+      });
+      return line;
+    }
+
+    const currentMethod = methodStack[methodStack.length - 1];
+    let nextLine = line;
+    if (!currentMethod) return nextLine;
+
+    for (const name of collectJavaObjectDeclarations(line)) {
+      currentMethod.objectNames.add(name);
+    }
+
+    const traceLine = parseNativeTraceLine(line);
+    if (traceLine !== null) currentMethod.currentTraceLine = traceLine;
+
+    const lineNumber = currentMethod.currentTraceLine;
+    if (lineNumber !== null && currentMethod.objectNames.size > 0) {
+      for (const name of currentMethod.objectNames) {
+        const writePattern = new RegExp(`^(\\s*)${escapeRegExp(name)}\\.([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*(.+);\\s*$`);
+        const writeMatch = nextLine.match(writePattern);
+        if (writeMatch) {
+          const indent = writeMatch[1] ?? '';
+          const field = writeMatch[2];
+          const rhs = writeMatch[3];
+          nextLine = `${indent}{ ${name}.${field} = ${rhs}; TraceHooks.emitFieldWriteAtLine(${lineNumber}, "${name}", "${field}", ${name}.${field}); }`;
+          break;
+        }
+      }
+
+      const returnMatch = nextLine.match(/^(\s*)return\s+(.+);\s*$/);
+      if (returnMatch) {
+        nextLine = `${returnMatch[1]}return ${rewriteJavaObjectFieldReads(returnMatch[2], currentMethod.objectNames, lineNumber)};`;
+      }
+    }
+
+    currentMethod.depth += braceDelta(nextLine);
+    while (methodStack.length > 0 && methodStack[methodStack.length - 1].depth <= 0) {
+      methodStack.pop();
+    }
+    return nextLine;
+  }).join('\n');
+}
+
+function augmentJavaThrowEvents(source) {
+  const lines = source.split('\n');
+  const methodStack = [];
+  let thrownIndex = 0;
+  const methodStartPattern =
+    /^(\s*)(?:(?:public|private|protected|static|final|synchronized)\s+)*(?:[A-Za-z_][A-Za-z0-9_<>\[\], ?]*\s+)+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*\{\s*$/;
+
+  return lines.map((line) => {
+    const methodMatch = line.match(methodStartPattern);
+    if (methodMatch) {
+      methodStack.push({ depth: 1, currentTraceLine: null });
+      return line;
+    }
+
+    const currentMethod = methodStack[methodStack.length - 1];
+    let nextLine = line;
+    if (!currentMethod) return nextLine;
+
+    const traceLine = parseNativeTraceLine(line);
+    if (traceLine !== null) currentMethod.currentTraceLine = traceLine;
+
+    const throwMatch = nextLine.match(/^(\s*)throw\s+(.+);\s*$/);
+    if (throwMatch && currentMethod.currentTraceLine !== null) {
+      const indent = throwMatch[1] ?? '';
+      const tempName = `__tracecodeThrown${thrownIndex++}`;
+      const expression = throwMatch[2];
+      nextLine = `${indent}{ var ${tempName} = ${expression}; TraceHooks.emitExceptionAtLine(${currentMethod.currentTraceLine}, String.valueOf(${tempName})); throw ${tempName}; }`;
+    }
+
+    currentMethod.depth += braceDelta(nextLine);
+    while (methodStack.length > 0 && methodStack[methodStack.length - 1].depth <= 0) {
+      methodStack.pop();
+    }
+    return nextLine;
+  }).join('\n');
+}
+
+function augmentJavaStdoutEvents(source) {
+  const lines = source.split('\n');
+  const methodStack = [];
+  let stdoutIndex = 0;
+  const methodStartPattern =
+    /^(\s*)(?:(?:public|private|protected|static|final|synchronized)\s+)*(?:[A-Za-z_][A-Za-z0-9_<>\[\], ?]*\s+)+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*\{\s*$/;
+
+  return lines.map((line) => {
+    const methodMatch = line.match(methodStartPattern);
+    if (methodMatch) {
+      methodStack.push({ depth: 1, currentTraceLine: null });
+      return line;
+    }
+
+    const currentMethod = methodStack[methodStack.length - 1];
+    let nextLine = line;
+    if (!currentMethod) return nextLine;
+
+    const traceLine = parseNativeTraceLine(line);
+    if (traceLine !== null) currentMethod.currentTraceLine = traceLine;
+
+    const stdoutMatch = nextLine.match(/^(\s*)System\.out\.println\((.+)\);\s*$/);
+    if (stdoutMatch && currentMethod.currentTraceLine !== null) {
+      const indent = stdoutMatch[1] ?? '';
+      const tempName = `__tracecodeStdout${stdoutIndex++}`;
+      const expression = stdoutMatch[2];
+      nextLine = `${indent}{ var ${tempName} = ${expression}; System.out.println(${tempName}); TraceHooks.emitStdoutAtLine(${currentMethod.currentTraceLine}, String.valueOf(${tempName})); }`;
+    }
+
+    currentMethod.depth += braceDelta(nextLine);
+    while (methodStack.length > 0 && methodStack[methodStack.length - 1].depth <= 0) {
+      methodStack.pop();
+    }
+    return nextLine;
+  }).join('\n');
+}
+
 function augmentArrayLengthReads(source) {
   const lines = source.split('\n');
   const methodStack = [];
@@ -747,9 +1957,9 @@ function augmentArrayLengthReads(source) {
         currentMethod.arrayNames.add(name);
       }
 
-      const traceLineMatch = line.match(/TraceHooks\.emit\("line=(\d+)(?:\s|")/);
-      if (traceLineMatch) {
-        currentMethod.currentTraceLine = Number.parseInt(traceLineMatch[1], 10);
+      const traceLine = parseNativeTraceLine(line);
+      if (traceLine !== null) {
+        currentMethod.currentTraceLine = traceLine;
         currentMethod.hasTraceEmit = true;
       }
 
@@ -801,7 +2011,7 @@ function augmentTraceReturnValueSnapshots(source) {
     const currentMethod = methodStack[methodStack.length - 1];
     if (currentMethod && currentMethod.returnType !== 'void') {
       const returnEmitMatch = line.match(
-        /^(\s*)TraceHooks\.emit\("line=(\d+) return ([A-Za-z_][A-Za-z0-9_]*)"\);\s*$/
+        /^(\s*)TraceHooks\.emitReturnAtLine\((\d+),\s*"([A-Za-z_][A-Za-z0-9_]*)"\);\s*$/
       );
       const nextLine = lines[index + 1] ?? '';
       const returnMatch = nextLine.match(/^(\s*)return\s+(.+);\s*$/);
@@ -811,7 +2021,7 @@ function augmentTraceReturnValueSnapshots(source) {
         const returnExpression = returnMatch[2].trim();
         output.push(`${indent}${currentMethod.returnType} ${tempName} = ${returnExpression};`);
         output.push(
-          `${indent}TraceHooks.emit("line=${returnEmitMatch[2]} return ${currentMethod.name} value=" + TraceHooks.serializeResult(${tempName}));`
+          `${indent}TraceHooks.emitSerializedReturnAtLine(${returnEmitMatch[2]}, "${currentMethod.name}", TraceHooks.serializeResult(${tempName}));`
         );
         output.push(`${returnMatch[1] ?? indent}return ${tempName};`);
         currentMethod.depth += braceDelta(line) + braceDelta(nextLine);
@@ -888,24 +2098,54 @@ function isTopLevelMethodStart(line) {
   return /^(?:public\s+|private\s+|protected\s+)?(?:static\s+)?(?:[\w<>\[\], ?]+\s+)+[A-Za-z_][A-Za-z0-9_]*\s*\([^;]*\)\s*\{/.test(trimmed);
 }
 
-function braceDelta(line) {
-  let delta = 0;
+function isTopLevelTypeStart(line) {
+  const trimmed = line.trim();
+  return /^(?:public\s+|private\s+|protected\s+)?(?:static\s+)?(?:final\s+|abstract\s+)?(?:class|interface|enum|record)\s+[A-Za-z_][A-Za-z0-9_]*\b/.test(trimmed);
+}
+
+function isTopLevelMemberStart(line) {
+  return isTopLevelMethodStart(line) || isTopLevelTypeStart(line);
+}
+
+function javaBraceCounts(line) {
+  let open = 0;
+  let close = 0;
   let quote = null;
+  let escaped = false;
   for (let index = 0; index < line.length; index += 1) {
     const ch = line[index];
-    const prev = index > 0 ? line[index - 1] : '';
+    const next = line[index + 1] ?? '';
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
     if (quote) {
-      if (ch === quote && prev !== '\\') quote = null;
+      if (ch === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '/' && next === '/') break;
+    if (ch === '/' && next === '*') {
+      const end = line.indexOf('*/', index + 2);
+      if (end === -1) break;
+      index = end + 1;
       continue;
     }
     if (ch === '"' || ch === "'") {
       quote = ch;
       continue;
     }
-    if (ch === '{') delta += 1;
-    if (ch === '}') delta -= 1;
+    if (ch === '{') open += 1;
+    if (ch === '}') close += 1;
   }
-  return delta;
+  return { open, close, delta: open - close };
+}
+
+function braceDelta(line) {
+  return javaBraceCounts(line).delta;
 }
 
 function splitScriptMembersAndStatements(lines) {
@@ -915,7 +2155,7 @@ function splitScriptMembersAndStatements(lines) {
   for (let index = 0; index < lines.length; index += 1) {
     const entry = lines[index];
     const line = typeof entry === 'string' ? entry : entry.line;
-    if (statementDepth !== 0 || !isTopLevelMethodStart(line)) {
+    if (statementDepth !== 0 || !isTopLevelMemberStart(line)) {
       statementLines.push(entry);
       statementDepth += braceDelta(line);
       if (statementDepth < 0) statementDepth = 0;
@@ -1040,65 +2280,226 @@ function normalizeJavaRequest(payload) {
     };
   }
 
+  if (payload.executionStyle === 'solution-method') {
+    return {
+      ...payload,
+      sourceText: payload.code,
+      code: wrapSingleStatementLoopBodies(payload.code),
+    };
+  }
+
+  if (payload.executionStyle === 'ops-class') {
+    return {
+      ...payload,
+      sourceText: payload.code,
+      code: wrapSingleStatementLoopBodies(payload.code),
+    };
+  }
+
   if (payload.executionStyle !== 'function') {
     return payload;
   }
 
   return {
     ...payload,
+    sourceText: payload.code,
     code: normalizeFunctionSource(payload.code),
     executionStyle: 'solution-method',
   };
 }
 
-function buildExportsSource(source, functionName, executionStyle, input) {
-  const features = detectFeatures(source, input);
-  const helperMethods = buildHelperMethods(features);
-
-  if (executionStyle === 'ops-class') {
-    const operations = Array.isArray(input.operations) ? input.operations : [];
-    const argumentsList = Array.isArray(input.arguments) ? input.arguments : [];
-    const lines = [
-      `    ${functionName} instance = null;`,
-      '    java.util.List<Object> out = new java.util.ArrayList<>();',
-    ];
-
-    operations.forEach((operation, index) => {
-      const args = Array.isArray(argumentsList[index]) ? argumentsList[index] : [];
-      if (index === 0) {
-        lines.push(`    instance = new ${functionName}(${args.map((arg) => buildJavaExpression(arg)).join(', ')});`);
-        lines.push('    out.add(null);');
-      } else {
-        lines.push(`    out.add(instance.${String(operation)}(${args.map((arg) => buildJavaExpression(arg)).join(', ')}));`);
-      }
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function stableHash(value) {
+  const source = typeof value === 'string' ? value : stableJson(value);
+  let hashA = 0x811c9dc5;
+  let hashB = 0x9e3779b9;
+  for (let index = 0; index < source.length; index += 1) {
+    const code = source.charCodeAt(index);
+    hashA ^= code;
+    hashA = Math.imul(hashA, 0x01000193) >>> 0;
+    hashB ^= code + index;
+    hashB = Math.imul(hashB, 0x85ebca6b) >>> 0;
+  }
+  return `${hashA.toString(36)}${hashB.toString(36)}`;
+}
+
+function dynamicInputEntriesForPayload(payload, compileId) {
+  if (payload.executionStyle === 'ops-class') return [];
+  const parameters = extractMethodParameters(payload.code, payload.functionName);
+  const invocationKeys = parameters.length > 0 ? parameters.map((parameter) => parameter.name) : Object.keys(payload.inputs ?? {});
+  const entries = [];
+  for (let index = 0; index < invocationKeys.length; index += 1) {
+    const key = invocationKeys[index];
+    const parameter = parameters[index];
+    if (!parameter) continue;
+    const value = inputValueForParameter(payload.inputs ?? {}, key, index);
+    if (!isDynamicJavaInputType(parameter.type, value)) continue;
+    const safeName = String(key).replace(/[^A-Za-z0-9_$-]/g, '_');
+    entries.push({
+      key,
+      index,
+      type: parameter.type,
+      value,
+      path: `${DYNAMIC_INPUT_PREFIX}-${compileId}-${index}-${safeName}.json`,
     });
-
-    return `public class Exports {
-${helperMethods}
-
-  public static String run() {
-${lines.join('\n')}
-    return TraceHooks.serializeResult(out);
   }
+  return entries;
 }
-`;
-  }
 
-  const parameters = extractMethodParameters(source, functionName);
-  const invocationArgs = (parameters.length > 0 ? parameters.map((parameter) => parameter.name) : Object.keys(input))
-    .map((key, index) => {
-      const type = parameters[index] ? parameters[index].type : undefined;
-      return buildJavaExpression(input[key], type);
-    })
-    .join(', ');
+function buildJavaCompileSeed(payload, compileMode = 'trace') {
+  if (payload.executionStyle === 'ops-class') {
+    return {
+      compileMode,
+      code: payload.code,
+      functionName: payload.functionName,
+      executionStyle: payload.executionStyle,
+      inputs: payload.inputs ?? {},
+    };
+  }
 
-  return `public class Exports {
-${helperMethods}
+  const parameters = extractMethodParameters(payload.code, payload.functionName);
+  const invocationKeys = parameters.length > 0 ? parameters.map((parameter) => parameter.name) : Object.keys(payload.inputs ?? {});
+  const inputs = {};
+  for (let index = 0; index < invocationKeys.length; index += 1) {
+    const key = invocationKeys[index];
+    const parameter = parameters[index];
+    const value = inputValueForParameter(payload.inputs ?? {}, key, index);
+    inputs[key] = parameter && isDynamicJavaInputType(parameter.type, value)
+      ? { mode: 'dynamic-json-file', type: normalizedJavaInputType(parameter.type) }
+      : { mode: 'literal', value };
+  }
+
+  return {
+    compileMode,
+    code: payload.code,
+    functionName: payload.functionName,
+    executionStyle: payload.executionStyle,
+    scriptMode: payload.scriptMode === true,
+    inputs,
+  };
+}
+
+function buildJavaCompileId(payload, compileMode = 'trace') {
+  return stableHash(buildJavaCompileSeed(payload, compileMode));
+}
+
+function buildJavaBatchCompileId(payload, inputBatch) {
+  return stableHash({
+    compileMode: 'execute-batch',
+    cases: inputBatch.map((inputs) => buildJavaCompileSeed({ ...payload, inputs }, 'execute-batch-case')),
+  });
+}
+
+async function writeDynamicInputFiles(dynamicInputs) {
+  for (const input of dynamicInputs) {
+    await self.cheerpOSAddStringFile(input.path, JSON.stringify(input.value));
+  }
+}
+
+function dynamicInputByKey(dynamicInputs) {
+  const out = new Map();
+  for (const input of dynamicInputs) out.set(input.key, input);
+  return out;
+}
+
+function buildExportsSource(source, functionName, executionStyle, input, options = {}) {
+  const features = {
+    ...detectFeatures(source, input, options),
+    skipInputMaterializers: options.scriptMode === true,
+  };
+  const helperMethods = buildHelperMethods(features);
+  const nodePreludeSource = buildNodePreludeSource(source, options);
+  const dynamicInputsByKey = dynamicInputByKey(options.dynamicInputs ?? []);
+
+  if (executionStyle === 'ops-class') {
+    const operations = Array.isArray(input.operations) ? input.operations : [];
+    const argumentsList = Array.isArray(input.arguments) ? input.arguments : [];
+    const lines = ['    java.util.List<Object> out = new java.util.ArrayList<>();'];
+    const firstOperation = operations.length > 0 ? String(operations[0]) : null;
+    const hasConstructorOperation =
+      firstOperation === functionName ||
+      firstOperation === '__init__' ||
+      firstOperation === 'init' ||
+      (firstOperation !== null && extractMethodReturnType(source, firstOperation) === null);
+    const constructorParameters = extractMethodParametersForArguments(source, functionName, argumentsList[0]);
+    const constructorArgs = hasConstructorOperation
+      ? inputArgumentsForParameters(argumentsList[0], constructorParameters)
+      : [];
+    const constructorInvocationArgs = constructorArgs
+      .map((arg, argIndex) => buildJavaExpression(arg, constructorParameters[argIndex]?.type))
+      .join(', ');
+    lines.push(`    ${functionName} instance = new ${functionName}(${constructorInvocationArgs});`);
+    if (hasConstructorOperation) {
+      lines.push('    out.add(null);');
+    }
+
+    operations.forEach((operation, index) => {
+      if (hasConstructorOperation && index === 0) {
+        return;
+      }
+      const operationName = String(operation);
+      const parameters = extractMethodParametersForArguments(source, operationName, argumentsList[index]);
+      const args = inputArgumentsForParameters(argumentsList[index], parameters);
+      const invocationArgs = args.map((arg, argIndex) => buildJavaExpression(arg, parameters[argIndex]?.type)).join(', ');
+      const returnType = extractMethodReturnType(source, operationName);
+      if (returnType === 'void') {
+        lines.push(`    instance.${operationName}(${invocationArgs});`);
+        lines.push('    out.add(null);');
+      } else {
+        lines.push(`    out.add(instance.${operationName}(${invocationArgs}));`);
+      }
+    });
+
+    return `${nodePreludeSource}public class Exports {
+${helperMethods}
+
+  public static String run() {
+${lines.join('\n')}
+    return TraceHooks.serializeOutputResult(out);
+  }
+}
+`;
+  }
+
+  const parameters = extractMethodParameters(source, functionName);
+  const returnType = extractMethodReturnType(source, functionName);
+  const invocationKeys = parameters.length > 0 ? parameters.map((parameter) => parameter.name) : Object.keys(input);
+  const usedLocalNames = new Set(['solution', ...invocationKeys]);
+  const resultLocalName = uniqueJavaIdentifier('__tracecode_result', usedLocalNames);
+  const materializedArgs = [];
+  for (let index = 0; index < invocationKeys.length; index += 1) {
+    const key = invocationKeys[index];
+    const parameter = parameters[index];
+    const type = parameter ? parameter.type : 'Object';
+    const value = inputValueForParameter(input, key, index);
+    const dynamicInput = dynamicInputsByKey.get(key);
+    const expression = dynamicInput
+      ? dynamicJavaInputExpression(type, dynamicInput.path)
+      : buildJavaExpression(value, type);
+    if (dynamicInput && !expression) {
+      throw new Error(`Unsupported dynamic Java input type: ${type}`);
+    }
+    materializedArgs.push(`    ${type} ${key} = ${expression};`);
+  }
+  const invocationArgs = invocationKeys.join(', ');
+  const invocationLine = returnType === 'void'
+    ? `    solution.${functionName}(${invocationArgs});\n    return TraceHooks.serializeOutputResult(null);`
+    : `    ${returnType || 'Object'} ${resultLocalName} = solution.${functionName}(${invocationArgs});\n    return TraceHooks.serializeOutputResult(${resultLocalName});`;
+
+  return `${nodePreludeSource}public class Exports {
+${helperMethods}
 
   public static String run() {
     Solution solution = new Solution();
-    Object result = solution.${functionName}(${invocationArgs});
-    return TraceHooks.serializeResult(result);
+${materializedArgs.join('\n')}
+${invocationLine}
   }
 }
 `;
@@ -1112,6 +2513,20 @@ function buildExportsClassName(messageId) {
   return `Exports${String(messageId).replace(/[^A-Za-z0-9]/g, '')}`;
 }
 
+function normalizeJavaSerializedOutput(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeJavaSerializedOutput(item));
+  }
+  if (!value || typeof value !== 'object') return value;
+  const output = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (key === '__class__') continue;
+    if (value.__type__ === 'NestedInteger' && key === 'value' && child == null) continue;
+    output[key] = normalizeJavaSerializedOutput(child);
+  }
+  return output;
+}
+
 async function ensureReady() {
   if (!workerReadyPromise) {
     workerReadyPromise = (async () => {
@@ -1131,7 +2546,6 @@ async function ensureReady() {
     })();
   }
   await workerReadyPromise;
-  resetIdleTimer();
 }
 
 async function getHelperLibrary() {
@@ -1145,7 +2559,7 @@ async function getCompileLibraryClass() {
   if (!compileLibraryClassPromise) {
     compileLibraryClassPromise = (async () => {
       const library = await getHelperLibrary();
-      return library.spike.browser.BrowserCompileAndTraceLibrary;
+      return library.tracecode.browser.BrowserCompileAndTraceLibrary;
     })();
   }
   return compileLibraryClassPromise;
@@ -1161,45 +2575,87 @@ async function getRewriteLibraryClass() {
   return rewriteLibraryClassPromise;
 }
 
-async function warmHost() {
-  if (!hostWarmupPromise) {
-    hostWarmupPromise = (async () => {
+async function warmRunHost() {
+  if (!runWarmupPromise) {
+    runWarmupPromise = (async () => {
+      const totalStart = performance.now();
       const libraryClass = await getCompileLibraryClass();
-      const sourcePath = '/str/ExportsTracecodeWarmup.java';
-      const classesDir = '/files/java-worker/__warm__/classes';
-      const warmupSource = `
+      const runSourcePath = '/str/ExportsTracecodeRunWarmup.java';
+      const runClassesDir = '/files/java-worker/__warm_run__/classes';
+      const runWarmupSource = `
 package harness.user.warmup;
 
-public class ExportsTracecodeWarmup {
+import tracecode.user.TraceHooks;
+
+class Solution {
+  int add(int a, int b) {
+    return a + b;
+  }
+}
+
+public class ExportsTracecodeRunWarmup {
   public static String run() {
-    return "0";
+    Solution solution = new Solution();
+    int a = 1;
+    int b = 2;
+    int result = solution.add(a, b);
+    return TraceHooks.serializeOutputResult(result);
   }
 }
 `;
-      await self.cheerpOSAddStringFile(sourcePath, warmupSource);
-      await libraryClass.compileAndTrace(
-        sourcePath,
-        classesDir,
-        'harness.user.warmup.ExportsTracecodeWarmup',
+      await self.cheerpOSAddStringFile(runSourcePath, runWarmupSource);
+      const hostCallStart = performance.now();
+      const reportText = await libraryClass.compileAndRun(
+        runSourcePath,
+        runClassesDir,
+        'harness.user.warmup.ExportsTracecodeRunWarmup',
         HELPER_JAR_PATH,
-        DEFAULT_COMPILER_DEBUG_PROFILE
+        DEFAULT_EXECUTE_COMPILER_DEBUG_PROFILE
       );
+      const hostCallEnd = performance.now();
+      const report = JSON.parse(reportText);
+      const totalEnd = performance.now();
+      if (report.success !== true) {
+        throw new Error(report.runtimeError || report.compilerStderr || report.compilerStdout || 'Java warmup failed');
+      }
+      return {
+        success: true,
+        loadTimeMs: Math.round(totalEnd - totalStart),
+        timings: {
+          totalMs: totalEnd - totalStart,
+          hostCallMs: hostCallEnd - hostCallStart,
+          compileMs: report.compileTimeMs ?? 0,
+          classLoadMs: report.classLoadTimeMs ?? 0,
+          runMs: report.runTimeMs ?? 0,
+          compileCacheHit: report.compileCacheHit ?? false,
+        },
+      };
     })();
   }
-  await hostWarmupPromise;
+  try {
+    return await runWarmupPromise;
+  } catch (error) {
+    runWarmupPromise = null;
+    throw error;
+  }
 }
 
-async function rewriteSource(payload, requestId) {
+async function rewriteSource(payload, compileId, dynamicInputs) {
   const rewriteLibraryClass = await getRewriteLibraryClass();
-  const exportsClassName = buildExportsClassName(requestId);
-  const packageName = buildPackageName(requestId);
+  const exportsClassName = buildExportsClassName(compileId);
+  const packageName = buildPackageName(compileId);
   const exportsSource = buildExportsSource(
     payload.code,
     payload.functionName,
     payload.executionStyle,
-    payload.inputs ?? {}
+    payload.inputs ?? {},
+    {
+      dynamicInputs,
+      hasDynamicInputs: dynamicInputs.length > 0,
+      scriptMode: payload.scriptMode === true,
+    }
   );
-  return rewriteLibraryClass.rewriteSource(
+  const rewrittenSource = await rewriteLibraryClass.rewriteSource(
     payload.code,
     payload.executionStyle,
     payload.functionName,
@@ -1207,13 +2663,106 @@ async function rewriteSource(payload, requestId) {
     exportsClassName,
     packageName
   );
+  return addJavaDefaultImportsToPackagedSource(rewrittenSource);
 }
 
 function normalizePublicClassDeclarations(source) {
-  return String(source).replace(/(^|\n)\s*public\s+class\s+/g, '$1class ');
+  return String(source).replace(/^([ \t]*)public\s+class\s+/gm, '$1class ');
 }
 
-async function collectCompileProbeDiagnostics(source, requestId, options) {
+function buildPlainRunnableSource(payload, compileId, dynamicInputs) {
+  const exportsClassName = buildExportsClassName(compileId);
+  const packageName = buildPackageName(compileId);
+  const exportsSource = buildExportsSource(
+    payload.code,
+    payload.functionName,
+    payload.executionStyle,
+    payload.inputs ?? {},
+    {
+      dynamicInputs,
+      hasDynamicInputs: dynamicInputs.length > 0,
+      scriptMode: payload.scriptMode === true,
+    }
+  ).replaceAll(/\bpublic class Exports\b/g, `public class ${exportsClassName}`);
+
+  return [
+    `package ${packageName};`,
+    '',
+    'import tracecode.user.TraceHooks;',
+    javaDefaultImportsBlock(),
+    '',
+    normalizePublicClassDeclarations(payload.code).trim(),
+    '',
+    exportsSource.trim(),
+    '',
+  ].join('\n');
+}
+
+function buildBatchRunnableSource(payload, compileId, inputBatch, dynamicInputBatch) {
+  const exportsClassName = buildExportsClassName(compileId);
+  const packageName = buildPackageName(compileId);
+  const entryClasses = [];
+  const sourceParts = [
+    `package ${packageName};`,
+    '',
+    'import tracecode.user.TraceHooks;',
+    javaDefaultImportsBlock(),
+    '',
+    normalizePublicClassDeclarations(payload.code).trim(),
+    '',
+  ];
+
+  for (let index = 0; index < inputBatch.length; index += 1) {
+    const className = index === 0 ? exportsClassName : `${exportsClassName}Case${index}`;
+    const dynamicInputs = dynamicInputBatch[index] ?? [];
+    const exportsSource = buildExportsSource(
+      payload.code,
+      payload.functionName,
+      payload.executionStyle,
+      inputBatch[index] ?? {},
+      {
+        dynamicInputs,
+        hasDynamicInputs: dynamicInputs.length > 0,
+        scriptMode: payload.scriptMode === true,
+      }
+    ).replaceAll(
+      /\bpublic class Exports\b/g,
+      `${index === 0 ? 'public class' : 'class'} ${className}`
+    );
+    entryClasses.push(`${packageName}.${className}`);
+    sourceParts.push(exportsSource.trim(), '');
+  }
+
+  return {
+    source: sourceParts.join('\n'),
+    entryClasses,
+  };
+}
+
+function buildCompileProbeSource(payload, requestId, probeClassName, probePackageName) {
+  const exportsSource = buildExportsSource(
+    payload.code,
+    payload.functionName,
+    payload.executionStyle,
+    payload.inputs ?? {},
+    {
+      scriptMode: payload.scriptMode === true,
+    }
+  ).replaceAll(/\bpublic class Exports\b/g, `public class ${probeClassName}`);
+  return [
+    `package ${probePackageName};`,
+    '',
+    'import tracecode.user.TraceHooks;',
+    javaDefaultImportsBlock(),
+    '',
+    normalizePublicClassDeclarations(payload.code).trim(),
+    '',
+    exportsSource.trim(),
+    '',
+  ].join('\n');
+}
+
+async function collectCompileProbeDiagnostics(payload, requestId, options) {
   const probeClassName = buildExportsClassName(`${requestId}RewriteProbe`);
   const probePackageName = buildPackageName(`${requestId}RewriteProbe`);
   const sourcePath = `/str/${probeClassName}.java`;
@@ -1232,7 +2781,10 @@ async function collectCompileProbeDiagnostics(source, requestId, options) {
   }
 
   try {
-    await self.cheerpOSAddStringFile(sourcePath, normalizePublicClassDeclarations(source));
+    await self.cheerpOSAddStringFile(
+      sourcePath,
+      buildCompileProbeSource(payload, requestId, probeClassName, probePackageName)
+    );
   } catch (error) {
     return {
       consoleOutput: [],
@@ -1294,79 +2846,194 @@ async function collectCompileProbeDiagnostics(source, requestId, options) {
 function normalizeScriptTraceEvents(events, scriptMode, userCodeLineCount, sourceLineMap) {
   if (!scriptMode || !Array.isArray(events)) return events;
   return events.map((event) => {
-    let normalizedEvent = String(event)
-      .replace(new RegExp(`\\bcall\\s+${SCRIPT_METHOD_NAME}\\b`, 'g'), 'call <module>')
-      .replace(new RegExp(`\\breturn\\s+${SCRIPT_METHOD_NAME}\\b`, 'g'), 'return <module>');
-
-    const lineMatch = normalizedEvent.match(/^line=(\d+)(.*)$/);
-    if (lineMatch && sourceLineMap && Object.prototype.hasOwnProperty.call(sourceLineMap, lineMatch[1])) {
-      const mappedLine = Number(sourceLineMap[lineMatch[1]]);
-      if (Number.isFinite(mappedLine) && mappedLine > 0) {
-        normalizedEvent = `line=${mappedLine}${lineMatch[2] ?? ''}`;
+    if (String(event).startsWith('trace:')) {
+      try {
+        const parsed = JSON.parse(String(event).slice('trace:'.length));
+        if (parsed.function === SCRIPT_METHOD_NAME) parsed.function = '<module>';
+        if (parsed.kind === 'call' && parsed.function === SCRIPT_METHOD_NAME) parsed.function = '<module>';
+        if (parsed.kind === 'return' && parsed.function === SCRIPT_METHOD_NAME) parsed.function = '<module>';
+        if (
+          typeof parsed.line === 'number' &&
+          sourceLineMap &&
+          Object.prototype.hasOwnProperty.call(sourceLineMap, String(parsed.line))
+        ) {
+          const mappedLine = Number(sourceLineMap[String(parsed.line)]);
+          if (Number.isFinite(mappedLine) && mappedLine > 0) parsed.line = mappedLine;
+        }
+        if (
+          parsed.kind === 'return' &&
+          parsed.function === '<module>' &&
+          Number.isFinite(userCodeLineCount) &&
+          userCodeLineCount > 0 &&
+          parsed.line > userCodeLineCount
+        ) {
+          parsed.line = userCodeLineCount;
+        }
+        return `trace:${JSON.stringify(parsed)}`;
+      } catch {
+        return event;
       }
     }
-
-    const match = normalizedEvent.match(/^line=(\d+)\s+return\s+<module>$/);
-    if (!match || !Number.isFinite(userCodeLineCount) || userCodeLineCount <= 0) {
-      return normalizedEvent;
-    }
-    const line = Number.parseInt(match[1], 10);
-    if (line <= userCodeLineCount) return normalizedEvent;
-    return `line=${userCodeLineCount} return <module>`;
+    return event;
   });
 }
 
 function parseTraceLineNumber(event) {
-  const match = String(event).match(/^line=(\d+)(?:\s|$)/);
-  if (!match) return null;
-  const line = Number.parseInt(match[1], 10);
-  return Number.isFinite(line) && line > 0 ? line : null;
+  if (String(event).startsWith('trace:')) {
+    try {
+      const parsed = JSON.parse(String(event).slice('trace:'.length));
+      const line = Number(parsed.line);
+      return Number.isFinite(line) && line > 0 ? line : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
 }
 
 function isBareTraceLineEvent(event) {
-  return /^line=\d+$/.test(String(event));
+  if (String(event).startsWith('trace:')) {
+    try {
+      const parsed = JSON.parse(String(event).slice('trace:'.length));
+      return parsed.kind === 'line';
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+function buildBareTraceLineEvent(line, templateEvent) {
+  if (String(templateEvent).startsWith('trace:')) {
+    return `trace:${JSON.stringify({ kind: 'line', line })}`;
+  }
+  return `trace:${JSON.stringify({ kind: 'line', line })}`;
+}
+
+function cloneNativeSnapshotEventAtLine(event, line) {
+  if (!String(event).startsWith('trace:')) return null;
+  try {
+    const parsed = JSON.parse(String(event).slice('trace:'.length));
+    if (parsed.kind !== 'snapshot') return null;
+    return `trace:${JSON.stringify({ ...parsed, line })}`;
+  } catch {
+    return null;
+  }
+}
+
+function parseNativeSnapshotVariable(event) {
+  if (!String(event).startsWith('trace:')) return null;
+  try {
+    const parsed = JSON.parse(String(event).slice('trace:'.length));
+    if (parsed.kind !== 'snapshot') return null;
+    const variable = parsed.target && typeof parsed.target.variable === 'string'
+      ? parsed.target.variable
+      : null;
+    return variable;
+  } catch {
+    return null;
+  }
+}
+
+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 = 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 buildLoopBodyLineMap(sourceText) {
+function buildControlHeaderInfo(sourceText) {
   if (typeof sourceText !== 'string' || sourceText.length === 0) return null;
   const lines = sourceText.split(/\r?\n/);
-  const loopBodyLineToHeaderLine = new Map();
+  const loopBodyLineToHeader = new Map();
+  const headerLineToExcludedVariables = new Map();
 
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index];
-    if (!/\b(?:for|while)\s*\(/.test(line) || !line.includes('{')) continue;
+    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;
-      loopBodyLineToHeaderLine.set(bodyIndex + 1, index + 1);
+      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 loopBodyLineToHeaderLine.size > 0 ? loopBodyLineToHeaderLine : null;
+  if (loopBodyLineToHeader.size === 0 && headerLineToExcludedVariables.size === 0) return null;
+  return { loopBodyLineToHeader, headerLineToExcludedVariables };
 }
 
 function expandLoopHeaderTraceEvents(events, sourceText) {
   if (!Array.isArray(events) || events.length === 0) return events;
-  const loopBodyLineToHeaderLine = buildLoopBodyLineMap(sourceText);
-  if (!loopBodyLineToHeaderLine) return events;
+  const controlHeaderInfo = buildControlHeaderInfo(sourceText);
+  if (!controlHeaderInfo) return events;
+  const { loopBodyLineToHeader, headerLineToExcludedVariables } = controlHeaderInfo;
 
   const expanded = [];
-  for (const event of events) {
+  const latestSnapshotByVariable = new Map();
+  for (let index = 0; index < events.length; index += 1) {
+    const event = events[index];
     const line = parseTraceLineNumber(event);
-    const headerLine = line === null ? undefined : loopBodyLineToHeaderLine.get(line);
+    const snapshotVariable = parseNativeSnapshotVariable(event);
+    if (
+      line !== null &&
+      snapshotVariable &&
+      headerLineToExcludedVariables.get(line)?.has(snapshotVariable)
+    ) {
+      continue;
+    }
+    const headerInfo = line === null ? undefined : loopBodyLineToHeader.get(line);
+    const headerLine = headerInfo?.line;
     const previousLine = expanded.length > 0 ? parseTraceLineNumber(expanded[expanded.length - 1]) : null;
     if (headerLine !== undefined && isBareTraceLineEvent(event) && previousLine !== headerLine) {
-      expanded.push(`line=${headerLine}`);
+      expanded.push(buildBareTraceLineEvent(headerLine, event));
+      for (const [variable, snapshotEvent] of latestSnapshotByVariable) {
+        if (headerInfo.excludedVariables.has(variable)) continue;
+        const clonedSnapshot = cloneNativeSnapshotEventAtLine(snapshotEvent, headerLine);
+        if (clonedSnapshot) expanded.push(clonedSnapshot);
+      }
+    }
+    if (headerLine !== undefined && isBareTraceLineEvent(event)) {
+      for (let lookahead = index + 1; lookahead < events.length; lookahead += 1) {
+        if (parseTraceLineNumber(events[lookahead]) !== line) break;
+        const variable = parseNativeSnapshotVariable(events[lookahead]);
+        if (!variable || !headerInfo.headerVariables.has(variable)) continue;
+        const clonedSnapshot = cloneNativeSnapshotEventAtLine(events[lookahead], headerLine);
+        if (clonedSnapshot) expanded.push(clonedSnapshot);
+      }
     }
     expanded.push(event);
+    if (snapshotVariable) {
+      latestSnapshotByVariable.set(snapshotVariable, event);
+    }
   }
   return expanded;
 }
 
-async function runJavaRequest(payload, requestId) {
+function normalizeJavaExecutionPayload(payload) {
   assertSupportedExecutionStyle(payload.executionStyle);
   if (typeof payload.code !== 'string') {
     throw new Error('`code` must be a string');
@@ -1376,32 +3043,58 @@ async function runJavaRequest(payload, requestId) {
     throw new Error('Java execution requires a non-empty functionName or class entry name.');
   }
 
-  const totalStart = performance.now();
-  const rewriteStart = performance.now();
-  let normalizedPayload;
   try {
-    normalizedPayload = normalizeJavaRequest(payload);
+    return normalizeJavaRequest(payload);
   } catch (error) {
     throw makeWorkerStageError('request normalization', error);
   }
+}
+
+function javaReportConsoleOutput(report) {
+  return [report.compilerStdout, report.compilerStderr].filter(
+    (entry) => typeof entry === 'string' && entry.trim().length > 0
+  );
+}
+
+function parseJavaReportOutput(output) {
+  return output ? normalizeJavaSerializedOutput(JSON.parse(output)) : undefined;
+}
+
+async function runJavaTraceRequest(payload, requestId) {
+  const totalStart = performance.now();
+  const rewriteStart = performance.now();
+  const normalizedPayload = normalizeJavaExecutionPayload(payload);
+
+  const compileId = buildJavaCompileId(normalizedPayload, 'trace');
+  const dynamicInputs = dynamicInputEntriesForPayload(normalizedPayload, compileId);
 
   let rewrittenSource;
   try {
-    rewrittenSource = await rewriteSource(normalizedPayload, requestId);
+    rewrittenSource = await rewriteSource(normalizedPayload, compileId, dynamicInputs);
     rewrittenSource = augmentTraceCallArgumentSnapshots(rewrittenSource);
     rewrittenSource = augmentArrayLengthReads(rewrittenSource);
-    rewrittenSource = self.TraceCodeJavaSourceAugmentations.augmentJavaCollectionOperations(rewrittenSource);
+    rewrittenSource = self.TraceCodeJavaSourceAugmentations.augmentJavaCollectionOperations(
+      rewrittenSource,
+      normalizedPayload.sourceText
+    );
+    rewrittenSource = augmentJavaObjectFieldOperations(rewrittenSource);
+    rewrittenSource = augmentJavaStdoutEvents(rewrittenSource);
+    rewrittenSource = augmentJavaThrowEvents(rewrittenSource);
+    rewrittenSource = augmentJavaLocalSnapshots(rewrittenSource);
     rewrittenSource = augmentTraceReturnValueSnapshots(rewrittenSource);
   } catch (error) {
     const rewriteError = formatWorkerErrorMessage(error);
-    const diagnosticProbe = await collectCompileProbeDiagnostics(
-      normalizedPayload.code,
-      requestId,
-      payload.options
-    );
+    const skipDiagnosticProbe = rewriteError.includes('unsupported legacy line= TraceHooks hooks');
+    const diagnosticProbe = skipDiagnosticProbe
+      ? { consoleOutput: [], error: null, hostCallMs: 0, diagnosticError: null }
+      : await collectCompileProbeDiagnostics(
+          normalizedPayload,
+          requestId,
+          payload.options
+        );
     const totalEnd = performance.now();
     const surfacedError =
-      diagnosticProbe.error ??
+      (skipDiagnosticProbe ? null : diagnosticProbe.error) ??
       (rewriteError === 'Java syntax error.'
         ? 'Java syntax error. Check Code Assist for parser details.'
         : `Java source rewrite failed: ${rewriteError}`);
@@ -1421,10 +3114,16 @@ async function runJavaRequest(payload, requestId) {
   }
   const rewriteEnd = performance.now();
 
-  const exportsClassName = buildExportsClassName(requestId);
-  const packageName = buildPackageName(requestId);
+  const exportsClassName = buildExportsClassName(compileId);
+  const packageName = buildPackageName(compileId);
   const sourcePath = `/str/${exportsClassName}.java`;
-  const classesDir = `/files/java-worker/${requestId}/classes`;
+  const classesDir = `/files/java-worker/${compileId}/classes`;
+
+  try {
+    await writeDynamicInputFiles(dynamicInputs);
+  } catch (error) {
+    throw makeWorkerStageError('dynamic input write', error);
+  }
 
   try {
     await self.cheerpOSAddStringFile(sourcePath, rewrittenSource);
@@ -1462,9 +3161,7 @@ async function runJavaRequest(payload, requestId) {
     throw makeWorkerStageError('trace report parse', error);
   }
   const totalEnd = performance.now();
-  const consoleOutput = [report.compilerStdout, report.compilerStderr].filter(
-    (entry) => typeof entry === 'string' && entry.trim().length > 0
-  );
+  const consoleOutput = javaReportConsoleOutput(report);
 
   if (report.success !== true) {
     return {
@@ -1503,7 +3200,7 @@ async function runJavaRequest(payload, requestId) {
 
   return {
     success: true,
-    output: report.output ? JSON.parse(report.output) : undefined,
+    output: parseJavaReportOutput(report.output),
     events: expandLoopHeaderTraceEvents(
       normalizeScriptTraceEvents(
         Array.isArray(report.events) ? report.events : [],
@@ -1535,6 +3232,226 @@ async function runJavaRequest(payload, requestId) {
   };
 }
 
+async function runJavaCodeRequest(payload) {
+  const totalStart = performance.now();
+  const normalizedPayload = normalizeJavaExecutionPayload(payload);
+  const compileId = buildJavaCompileId(normalizedPayload, 'execute');
+  const dynamicInputs = dynamicInputEntriesForPayload(normalizedPayload, compileId);
+  const exportsClassName = buildExportsClassName(compileId);
+  const packageName = buildPackageName(compileId);
+  const sourcePath = `/str/${exportsClassName}.java`;
+  const classesDir = `/files/java-worker/${compileId}/classes`;
+
+  let runnableSource;
+  try {
+    runnableSource = buildPlainRunnableSource(normalizedPayload, compileId, dynamicInputs);
+  } catch (error) {
+    throw makeWorkerStageError('source generation', error);
+  }
+
+  try {
+    await writeDynamicInputFiles(dynamicInputs);
+  } catch (error) {
+    throw makeWorkerStageError('dynamic input write', error);
+  }
+
+  try {
+    await self.cheerpOSAddStringFile(sourcePath, runnableSource);
+  } catch (error) {
+    throw makeWorkerStageError('source file write', error);
+  }
+
+  let compileLibraryClass;
+  try {
+    compileLibraryClass = await getCompileLibraryClass();
+  } catch (error) {
+    throw makeWorkerStageError('compiler bridge load', error);
+  }
+
+  const libraryCallStart = performance.now();
+  let reportText;
+  try {
+    reportText = await compileLibraryClass.compileAndRun(
+      sourcePath,
+      classesDir,
+      `${packageName}.${exportsClassName}`,
+      HELPER_JAR_PATH,
+      DEFAULT_EXECUTE_COMPILER_DEBUG_PROFILE
+    );
+  } catch (error) {
+    throw makeWorkerStageError('compile and run', error);
+  }
+  const libraryCallEnd = performance.now();
+
+  let report;
+  try {
+    report = JSON.parse(reportText);
+  } catch (error) {
+    throw makeWorkerStageError('execution report parse', error);
+  }
+
+  const totalEnd = performance.now();
+  const consoleOutput = javaReportConsoleOutput(report);
+  const timings = {
+    hostCallMs: libraryCallEnd - libraryCallStart,
+    totalMs: totalEnd - totalStart,
+    compileMs: report.compileTimeMs ?? 0,
+    classLoadMs: report.classLoadTimeMs ?? 0,
+    runMs: report.runTimeMs ?? 0,
+    compileCacheHit: report.compileCacheHit ?? false,
+  };
+
+  if (report.success !== true) {
+    return {
+      success: false,
+      output: null,
+      executionTimeMs: totalEnd - totalStart,
+      consoleOutput,
+      error:
+        report.runtimeError ||
+        report.compilerStderr ||
+        report.compilerStdout ||
+        'Java execution failed',
+      timings,
+    };
+  }
+
+  return {
+    success: true,
+    output: parseJavaReportOutput(report.output),
+    executionTimeMs: totalEnd - totalStart,
+    consoleOutput,
+    timings,
+  };
+}
+
+async function runJavaCodeBatchRequest(payload) {
+  const totalStart = performance.now();
+  const inputBatch = Array.isArray(payload.inputBatch)
+    ? payload.inputBatch.map((inputs) => inputs && typeof inputs === 'object' ? inputs : {})
+    : [];
+  if (inputBatch.length === 0) {
+    throw new Error('Java batch execution requires a non-empty inputBatch array.');
+  }
+
+  const normalizedPayload = normalizeJavaExecutionPayload({
+    ...payload,
+    inputs: inputBatch[0] ?? {},
+  });
+  const compileId = buildJavaBatchCompileId(normalizedPayload, inputBatch);
+  const dynamicInputBatch = inputBatch.map((inputs, index) =>
+    dynamicInputEntriesForPayload(
+      { ...normalizedPayload, inputs },
+      `${compileId}-${index}`
+    )
+  );
+  const dynamicInputs = dynamicInputBatch.flat();
+  const exportsClassName = buildExportsClassName(compileId);
+  const sourcePath = `/str/${exportsClassName}.java`;
+  const classesDir = `/files/java-worker/${compileId}/classes`;
+
+  let runnableSource;
+  let entryClasses;
+  try {
+    const batchSource = buildBatchRunnableSource(normalizedPayload, compileId, inputBatch, dynamicInputBatch);
+    runnableSource = batchSource.source;
+    entryClasses = batchSource.entryClasses;
+  } catch (error) {
+    throw makeWorkerStageError('batch source generation', error);
+  }
+
+  try {
+    await writeDynamicInputFiles(dynamicInputs);
+  } catch (error) {
+    throw makeWorkerStageError('dynamic input write', error);
+  }
+
+  try {
+    await self.cheerpOSAddStringFile(sourcePath, runnableSource);
+  } catch (error) {
+    throw makeWorkerStageError('source file write', error);
+  }
+
+  let compileLibraryClass;
+  try {
+    compileLibraryClass = await getCompileLibraryClass();
+  } catch (error) {
+    throw makeWorkerStageError('compiler bridge load', error);
+  }
+
+  const libraryCallStart = performance.now();
+  let reportText;
+  try {
+    reportText = await compileLibraryClass.compileAndRunBatch(
+      sourcePath,
+      classesDir,
+      entryClasses.join('\n'),
+      HELPER_JAR_PATH,
+      DEFAULT_EXECUTE_COMPILER_DEBUG_PROFILE
+    );
+  } catch (error) {
+    throw makeWorkerStageError('compile and run batch', error);
+  }
+  const libraryCallEnd = performance.now();
+
+  let report;
+  try {
+    report = JSON.parse(reportText);
+  } catch (error) {
+    throw makeWorkerStageError('batch execution report parse', error);
+  }
+
+  const totalEnd = performance.now();
+  const consoleOutput = javaReportConsoleOutput(report);
+  const compileMs = report.compileTimeMs ?? 0;
+  const compileCacheHit = report.compileCacheHit ?? false;
+  const rawResults = Array.isArray(report.results) ? report.results : [];
+  const results = rawResults.map((entry) => {
+    const success = entry?.success === true;
+    const classLoadMs = entry?.classLoadTimeMs ?? 0;
+    const runMs = entry?.runTimeMs ?? 0;
+    return {
+      success,
+      output: success ? parseJavaReportOutput(entry.output) : null,
+      consoleOutput,
+      ...(success ? {} : { error: entry?.runtimeError || report.runtimeError || 'Java execution failed' }),
+      timings: {
+        compileMs: 0,
+        classLoadMs,
+        runMs,
+        hostCallMs: 0,
+        totalMs: classLoadMs + runMs,
+        compileCacheHit,
+      },
+    };
+  });
+
+  if (results.length > 0) {
+    results[0].timings = {
+      ...results[0].timings,
+      compileMs,
+      hostCallMs: libraryCallEnd - libraryCallStart,
+      totalMs: totalEnd - totalStart,
+    };
+  }
+
+  return {
+    success: report.success === true,
+    results,
+    executionTimeMs: totalEnd - totalStart,
+    consoleOutput,
+    ...(report.success === true ? {} : { error: report.runtimeError || 'Java batch execution failed' }),
+    timings: {
+      hostCallMs: libraryCallEnd - libraryCallStart,
+      totalMs: totalEnd - totalStart,
+      compileMs,
+      classLoadMs: rawResults.reduce((sum, entry) => sum + (entry?.classLoadTimeMs ?? 0), 0),
+      runMs: rawResults.reduce((sum, entry) => sum + (entry?.runTimeMs ?? 0), 0),
+      compileCacheHit,
+    },
+  };
+}
+
 self.onmessage = (event) => {
   const message = event.data;
   if (!message || typeof message !== 'object') {
@@ -1555,22 +3472,63 @@ self.onmessage = (event) => {
   if (message.type === 'init') {
     queue = queue.then(async () => {
       try {
+        applyWorkerOptions(message.payload);
+        const startedAt = performance.now();
         await ensureReady();
-        await warmHost();
+        const totalMs = performance.now() - startedAt;
         postMessageResponse({
           id: message.id,
           type: 'init',
           payload: {
             success: true,
-            loadTimeMs: Math.round(initLoadTimeMs ?? 0),
+            loadTimeMs: Math.round(totalMs),
+            timings: {
+              totalMs,
+              initMs: initLoadTimeMs ?? 0,
+              warmupMs: 0,
+            },
           },
         });
       } catch (error) {
+        emitRuntimeDiagnostic('error', 'worker-request-failed', 'Java worker init request failed.', {
+          type: message.type,
+          message: formatWorkerErrorMessage(error),
+        });
+        postMessageResponse({
+          id: message.id,
+          type: 'error',
+          payload: { error: formatWorkerErrorMessage(error) },
+        });
+      } finally {
+        resetIdleTimer();
+      }
+    });
+    return;
+  }
+
+  if (message.type === 'warmup') {
+    queue = queue.then(async () => {
+      try {
+        applyWorkerOptions(message.payload);
+        await ensureReady();
+        const result = await warmRunHost();
+        postMessageResponse({
+          id: message.id,
+          type: 'warmup',
+          payload: result,
+        });
+      } catch (error) {
+        emitRuntimeDiagnostic('error', 'worker-request-failed', 'Java worker warmup request failed.', {
+          type: message.type,
+          message: formatWorkerErrorMessage(error),
+        });
         postMessageResponse({
           id: message.id,
           type: 'error',
           payload: { error: formatWorkerErrorMessage(error) },
         });
+      } finally {
+        resetIdleTimer();
       }
     });
     return;
@@ -1579,23 +3537,35 @@ self.onmessage = (event) => {
   if (
     message.type === 'execute-with-tracing' ||
     message.type === 'execute-code' ||
+    message.type === 'execute-code-batch' ||
     message.type === 'execute-code-interview'
   ) {
     queue = queue.then(async () => {
       try {
+        applyWorkerOptions(message.payload);
         await ensureReady();
-        const result = await runJavaRequest(message.payload, message.id);
+        const result = message.type === 'execute-with-tracing'
+          ? await runJavaTraceRequest(message.payload, message.id)
+          : message.type === 'execute-code-batch'
+            ? await runJavaCodeBatchRequest(message.payload)
+            : await runJavaCodeRequest(message.payload);
         postMessageResponse({
           id: message.id,
           type: message.type,
           payload: result,
         });
       } catch (error) {
+        emitRuntimeDiagnostic('error', 'worker-request-failed', 'Java worker execution request failed.', {
+          type: message.type,
+          message: formatWorkerErrorMessage(error),
+        });
         postMessageResponse({
           id: message.id,
           type: 'error',
           payload: { error: formatWorkerErrorMessage(error) },
         });
+      } finally {
+        resetIdleTimer();
       }
     });
     return;
@@ -1603,5 +3573,6 @@ self.onmessage = (event) => {
 };
 
 queueMicrotask(() => {
+  emitRuntimeDiagnostic('info', 'worker-ready', 'Java worker is ready.');
   postMessageResponse({ type: 'worker-ready' });
 });