@tracecode/harness 0.9.8 → 0.9.9

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project are documented here.
 
 This repo uses Git tags as release boundaries. Version notes below summarize what shipped in each tagged release.
 
+## [0.9.9] - 2026-07-05
+
+### Added
+
+- Added a unified kernel journal: one append-only, absolutely-ordered log (a single sequence counter) of every kernel-observed transaction — filesystem writes, process `exec`/`exit`, and HTTP requests — emitted only from kernel-internal observation points, so in-workspace code cannot forge entries and every event is attributed by actor/pid. `Authorization` is stored as a non-reversible fingerprint (never the raw value), and `externalHttp` responses may attach an opaque `annotation`. The journal is exposed both live on the workspace event stream (`kernel-journal` events, ordered consistently with buffered output) and as a queryable `journal(sinceSeq?)` snapshot. HTTP journal records additionally carry redacted grading metadata: idempotency-key and request/response body fingerprints, plus `Content-Type`, `Retry-After`, and `X-RateLimit-*` values.
+- Added a virtual-network host registry (`resolveHost`) and a `ping` reachability command: loopback, in-workspace HTTP listeners, and `externalHttp`-allowlisted hosts all resolve through one primitive with deterministic, hash-derived synthetic IP and latency (no wall clock or RNG). `ping` produces ping-shaped output and fails gracefully with an unknown-host error instead of a raw kernel throw.
+
+### Changed
+
+- Unified host reachability across `curl`, `ping`, and `workspace.http.request` through `resolveHost`: an unknown host now returns a typed `EHOSTUNREACH` (rendered by `curl` as exit 7, "Host unreachable") rather than leaking a raw kernel error, while a known host with a closed port still returns `ECONNREFUSED`; host allowlist/blocklist policy is unchanged. Also corrected the diagnostic port reported for failed HTTPS connections.
+- Optimized C++ and C# batch execution: test cases that are safe to co-execute now share a single compile-and-run pass, with an automatic per-case fallback when a batch requires isolation.
+
+### Fixed
+
+- Fixed `curl` URL scheme resolution and replaced raw kernel HTTP errors with typed ones so nothing leaks to the terminal: bare hostnames, `host:port`, and `localhost:3000` now resolve correctly, unsupported schemes return a proper `curl` protocol error, and malformed requests surface as graceful `curl` diagnostics instead of a raw `EINVAL`.
+
 ## [0.9.8] - 2026-07-04
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tracecode/harness",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "license": "AGPL-3.0-only",
   "homepage": "https://tracecode.app",
   "repository": {

package/workers/cpp/cpp-worker.js

@@ -10518,6 +10518,80 @@ async function handleCompileRun(payload) {
   }
 }
 
+function cppBatchIsolationReason(source) {
+  const text = stripComments(String(source ?? ''));
+  if (/\b(?:static|thread_local)\b/.test(text)) {
+    return 'static-storage';
+  }
+  if (cppHasFileScopeMutableDeclaration(text)) {
+    return 'file-scope-state';
+  }
+  return '';
+}
+
+function cppHasFileScopeMutableDeclaration(source) {
+  let depth = 0;
+  let statement = '';
+
+  const considerStatement = (rawStatement) => {
+    const normalized = rawStatement
+      .replace(/#[^\n]*(?:\n|$)/g, '')
+      .replace(/\s+/g, ' ')
+      .trim();
+    if (!normalized) return false;
+    if (/^(?:using|typedef|template|class|struct|enum|namespace|extern\s+"C")\b/.test(normalized)) return false;
+    if (/\b(?:const|constexpr)\b/.test(normalized)) return false;
+    if (/\(/.test(normalized)) return false;
+    if (/^(?:return|if|for|while|switch|do|break|continue)\b/.test(normalized)) return false;
+    return /^(?:inline\s+|volatile\s+|mutable\s+|unsigned\s+|signed\s+|long\s+|short\s+)*[A-Za-z_:][A-Za-z0-9_:<>,\s*&]*\s+[*&\s]*[A-Za-z_][A-Za-z0-9_]*(?:\s*(?:=|,|\[|;))/.test(normalized);
+  };
+
+  for (const char of source) {
+    if (depth === 0) {
+      statement += char;
+    }
+    if (char === '{') {
+      depth += 1;
+      continue;
+    }
+    if (char === '}') {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth === 0 && char === ';') {
+      if (considerStatement(statement)) return true;
+      statement = '';
+    }
+  }
+
+  return false;
+}
+
+function cppOpsClassBatchIsolationReason(inputBatch) {
+  if (!Array.isArray(inputBatch) || inputBatch.length <= 1) return '';
+  const firstOperations = Array.isArray(inputBatch[0]?.operations)
+    ? inputBatch[0].operations
+    : Array.isArray(inputBatch[0]?.ops)
+      ? inputBatch[0].ops
+      : [];
+  for (let caseIndex = 1; caseIndex < inputBatch.length; caseIndex += 1) {
+    const operations = Array.isArray(inputBatch[caseIndex]?.operations)
+      ? inputBatch[caseIndex].operations
+      : Array.isArray(inputBatch[caseIndex]?.ops)
+        ? inputBatch[caseIndex].ops
+        : [];
+    if (operations.length !== firstOperations.length) {
+      return 'heterogeneous-ops-class';
+    }
+    for (let operationIndex = 0; operationIndex < operations.length; operationIndex += 1) {
+      if (operations[operationIndex] !== firstOperations[operationIndex]) {
+        return 'heterogeneous-ops-class';
+      }
+    }
+  }
+  return '';
+}
+
 async function handleCompileRunBatch(payload) {
   const startedAt = now();
   const source = payload && typeof payload.code === 'string' ? payload.code : '';
@@ -10562,17 +10636,94 @@ async function handleCompileRunBatch(payload) {
     };
   }
 
-  const results = [];
-  for (const inputs of inputBatch) {
-    results.push(await handleCompileRun({ ...payload, inputs, executionStyle }));
+  const isolationReason = executionStyle === 'ops-class'
+    ? (cppOpsClassBatchIsolationReason(inputBatch) || cppBatchIsolationReason(source))
+    : cppBatchIsolationReason(source);
+  if (isolationReason) {
+    const results = [];
+    for (const inputs of inputBatch) {
+      results.push(await handleCompileRun({ ...payload, inputs, executionStyle }));
+    }
+    const success = results.every((result) => result.success === true);
+    return {
+      success,
+      results,
+      consoleOutput: results.flatMap((result) => result.consoleOutput ?? []),
+      ...(success ? {} : { error: results.find((result) => result.success !== true)?.error ?? 'C++ batch execution failed.' }),
+      timings: {
+        ...baseTimings(),
+        batchMode: 'per-case-fallback',
+        batchCaseCount: inputBatch.length,
+        batchFallbackReason: isolationReason,
+      },
+    };
+  }
+
+  let preparedDriverSource;
+  try {
+    preparedDriverSource = executionStyle === 'ops-class'
+      ? buildOpsClassBatchDriverSource(source, functionName, inputBatch, { executionStyle })
+      : buildBatchDriverSource(source, functionName, inputBatch, { executionStyle });
+  } catch (error) {
+    return failedBatchResult(error instanceof Error ? error.message : String(error));
+  }
+
+  const batchTimings = (timings = {}) => ({
+    ...timings,
+    totalMs: elapsedMs(startedAt),
+    batchMode: 'compile-once',
+    batchCaseCount: inputBatch.length,
+  });
+
+  const failedBatchEntries = (result) => inputBatch.map(() => ({
+    success: false,
+    output: null,
+    error: result?.error ?? 'C++ batch execution failed.',
+    consoleOutput: result?.consoleOutput ?? [],
+    timings: result?.timings ?? {},
+  }));
+
+  const result = await compileAndRun(source, functionName, {}, {
+    executionStyle,
+    preparedDriverSource,
+    stdinText: JSON.stringify(inputBatch),
+  });
+
+  if (!result?.success) {
+    return {
+      success: false,
+      results: failedBatchEntries(result),
+      consoleOutput: result?.consoleOutput ?? [],
+      error: result?.error ?? 'C++ batch execution failed.',
+      timings: batchTimings(result?.timings),
+    };
   }
-  const success = results.every((result) => result.success === true);
+
+  if (!Array.isArray(result.output) || result.output.length !== inputBatch.length) {
+    const error = `C++ batch driver returned ${Array.isArray(result.output) ? result.output.length : 'non-array'} results for ${inputBatch.length} cases.`;
+    return {
+      success: false,
+      results: failedBatchEntries({ ...result, error }),
+      consoleOutput: result.consoleOutput ?? [],
+      error,
+      timings: batchTimings(result.timings),
+    };
+  }
+
+  const results = result.output.map((output, index) => ({
+    success: true,
+    output,
+    consoleOutput: index === 0 ? (result.consoleOutput ?? []) : [],
+    executionTimeMs: index === 0 ? result.executionTimeMs : 0,
+    timings: index === 0
+      ? { ...(result.timings ?? {}), batchCaseIndex: index }
+      : { runMs: 0, totalMs: 0, compileCacheHit: true, batchCaseIndex: index },
+  }));
   return {
-    success,
+    success: true,
     results,
-    consoleOutput: results.flatMap((result) => result.consoleOutput ?? []),
-    ...(success ? {} : { error: results.find((result) => result.success !== true)?.error ?? 'C++ batch execution failed.' }),
-    timings: { ...baseTimings(), batchMode: 'per-case-isolated', batchCaseCount: inputBatch.length },
+    consoleOutput: result.consoleOutput ?? [],
+    timings: batchTimings(result.timings),
   };
 }
 

package/workers/csharp/csharp-worker.js

@@ -1807,11 +1807,173 @@ function indentCSharpSource(code, spaces = 4) {
     .join('\n');
 }
 
+function splitCSharpParameterList(source) {
+  const parameters = [];
+  let current = '';
+  let genericDepth = 0;
+  let bracketDepth = 0;
+  for (const char of String(source ?? '')) {
+    if (char === '<') genericDepth += 1;
+    else if (char === '>') genericDepth = Math.max(0, genericDepth - 1);
+    else if (char === '[') bracketDepth += 1;
+    else if (char === ']') bracketDepth = Math.max(0, bracketDepth - 1);
+    if (char === ',' && genericDepth === 0 && bracketDepth === 0) {
+      parameters.push(current.trim());
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) parameters.push(current.trim());
+  return parameters;
+}
+
+function parseCSharpBatchParameter(source, index) {
+  let withoutDefault = String(source ?? '').replace(/=.*/, '').trim();
+  while (/^\s*\[[^\]]+\]\s*/.test(withoutDefault)) {
+    withoutDefault = withoutDefault.replace(/^\s*\[[^\]]+\]\s*/, '').trim();
+  }
+  if (!withoutDefault) return null;
+  const parts = withoutDefault.split(/\s+/).filter(Boolean);
+  let modifier = '';
+  while (parts.length > 0 && ['this', 'params', 'ref', 'out', 'in'].includes(parts[0])) {
+    const next = parts.shift();
+    if (next === 'ref' || next === 'out' || next === 'in') modifier = next;
+  }
+  const name = csharpIdentifier(parts.pop());
+  const type = parts.join(' ').trim();
+  if (!name || !type) return null;
+  return { name, type, modifier, index };
+}
+
+function parseCSharpBatchCallableSignature(code, functionName) {
+  const requestedMethodName = csharpIdentifier(functionName);
+  if (!requestedMethodName) return null;
+  const escapedName = requestedMethodName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const pattern = new RegExp(
+    `((?:(?:public|private|protected|internal|static|virtual|override|sealed|new|async|extern|partial)\\s+)*)` +
+      `([A-Za-z_][A-Za-z0-9_<>.,?\\[\\]\\s]*?)\\s+(${escapedName})\\s*\\(([^)]*)\\)`,
+    'im'
+  );
+  const match = pattern.exec(String(code ?? ''));
+  if (!match) return null;
+  const methodName = csharpIdentifier(match[3]) ?? requestedMethodName;
+  const parameters = splitCSharpParameterList(match[4])
+    .map((parameter, index) => parseCSharpBatchParameter(parameter, index));
+  if (parameters.some((parameter) => !parameter)) return null;
+  return {
+    methodName,
+    returnType: match[2].trim(),
+    isStatic: /\bstatic\b/.test(match[1] || ''),
+    parameters,
+  };
+}
+
+function buildCSharpDirectBatchScriptSource(payload) {
+  const code = String(payload?.code ?? '');
+  const executionStyle = payload?.executionStyle ?? 'solution-method';
+  const functionName = String(payload?.functionName ?? '');
+  if (!functionName.trim() || executionStyle === 'ops-class') return null;
+  const signature = parseCSharpBatchCallableSignature(code, functionName);
+  if (!signature) return null;
+  const declarations = [];
+  const argumentsList = [];
+  for (const parameter of signature.parameters) {
+    const localName = `__tracecodeArg${parameter.index}`;
+    if (parameter.modifier === 'out') {
+      declarations.push(`    ${parameter.type} ${localName} = default!;`);
+    } else {
+      declarations.push(`    var ${localName} = TraceCode.Internal.TraceCodeJsonInput.Read<${parameter.type}>(${csharpStringLiteral(parameter.name)}, ${parameter.index});`);
+    }
+    argumentsList.push(`${parameter.modifier ? `${parameter.modifier} ` : ''}${localName}`);
+  }
+  const receiver = executionStyle === 'function'
+    ? ''
+    : signature.isStatic
+      ? 'Solution.'
+      : '__tracecodeSolution.';
+  const solutionDeclaration = executionStyle === 'function' || signature.isStatic
+    ? ''
+    : '    var __tracecodeSolution = new Solution();\n';
+  const callExpression = `${receiver}${signature.methodName}(${argumentsList.join(', ')})`;
+  const returnsVoid = signature.returnType === 'void';
+  const invocation = returnsVoid
+    ? `    ${callExpression};\n    return ${signature.parameters.length > 0 ? '__tracecodeArg0' : 'null'};`
+    : `    return ${callExpression};`;
+
+  return `${code}
+
+object? result;
+{
+    var __tracecodeBatchCases = TraceCode.Internal.TraceCodeJsonInput.Read<System.Text.Json.JsonElement[]>("__tracecodeBatchInputs", 0) ?? System.Array.Empty<System.Text.Json.JsonElement>();
+    var __tracecodeBatchResults = new System.Collections.Generic.List<object?>();
+
+    foreach (var __tracecodeBatchCase in __tracecodeBatchCases)
+    {
+        var __tracecodeBatchClock = System.Diagnostics.Stopwatch.StartNew();
+        var __tracecodeOriginalOut = System.Console.Out;
+        using var __tracecodeCaseOut = new System.IO.StringWriter();
+        try
+        {
+            System.Console.SetOut(__tracecodeCaseOut);
+            __TraceCodeSetCurrentInputsJson(__tracecodeBatchCase.GetRawText());
+            object? __tracecodeOutput = __TraceCodeRunBatchCase();
+            __tracecodeBatchClock.Stop();
+            __tracecodeBatchResults.Add(new System.Collections.Generic.Dictionary<string, object?>
+            {
+                ["success"] = true,
+                ["output"] = __tracecodeOutput,
+                ["consoleOutput"] = __TraceCodeSplitConsole(__tracecodeCaseOut.ToString()),
+                ["timings"] = new System.Collections.Generic.Dictionary<string, object?> { ["runMs"] = __tracecodeBatchClock.Elapsed.TotalMilliseconds },
+            });
+        }
+        catch (System.Exception __tracecodeError)
+        {
+            __tracecodeBatchClock.Stop();
+            __tracecodeBatchResults.Add(new System.Collections.Generic.Dictionary<string, object?>
+            {
+                ["success"] = false,
+                ["error"] = __tracecodeError.GetBaseException().Message,
+                ["output"] = null,
+                ["consoleOutput"] = __TraceCodeSplitConsole(__tracecodeCaseOut.ToString()),
+                ["timings"] = new System.Collections.Generic.Dictionary<string, object?> { ["runMs"] = __tracecodeBatchClock.Elapsed.TotalMilliseconds },
+            });
+        }
+        finally
+        {
+            System.Console.SetOut(__tracecodeOriginalOut);
+        }
+    }
+
+    result = __tracecodeBatchResults;
+}
+
+object? __TraceCodeRunBatchCase()
+{
+${solutionDeclaration}${declarations.join('\n')}
+${invocation}
+}
+
+void __TraceCodeSetCurrentInputsJson(string __tracecodeInputsJson)
+{
+    var __tracecodeField = typeof(TraceCode.CSharpHost.CompilerHost).GetField(
+        "currentInputsJson",
+        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
+    __tracecodeField?.SetValue(null, __tracecodeInputsJson);
+}
+
+string[] __TraceCodeSplitConsole(string __tracecodeText) =>
+    __tracecodeText.Replace("\\r\\n", "\\n", System.StringComparison.Ordinal).Split('\\n', System.StringSplitOptions.RemoveEmptyEntries);
+`;
+}
+
 function buildCSharpBatchScriptSource(payload) {
   const code = String(payload?.code ?? '');
   const executionStyle = payload?.executionStyle ?? 'solution-method';
   const functionName = String(payload?.functionName ?? '');
   const functionNameLiteral = csharpStringLiteral(functionName);
+  const directBatchSource = buildCSharpDirectBatchScriptSource(payload);
+  if (directBatchSource) return directBatchSource;
 
   if (executionStyle === 'ops-class') {
     const className = csharpIdentifier(functionName);
@@ -2243,6 +2405,17 @@ function normalizeCSharpBatchEntry(entry, timings = {}) {
   };
 }
 
+function csharpBatchIsolationReason(payload) {
+  if (payload?.executionStyle === 'ops-class') {
+    return 'ops-class-reflection';
+  }
+  const code = String(payload?.code ?? '');
+  if (/\bstatic\b/.test(code)) {
+    return 'static-storage';
+  }
+  return '';
+}
+
 async function executeCSharpCodePayload(payload, messageType = 'execute-code') {
   const startedAt = now();
   const request = {
@@ -2315,21 +2488,63 @@ async function executeCSharpCodeBatch(message) {
     };
   }
 
-  const results = [];
-  for (const inputs of inputBatch) {
-    const result = await executeCSharpCodePayload({ ...message.payload, inputs }, 'execute-code');
-    results.push(normalizeCSharpBatchEntry(result, result.timings));
+  const isolationReason = csharpBatchIsolationReason(message.payload ?? {});
+  if (isolationReason) {
+    const results = [];
+    for (const inputs of inputBatch) {
+      const result = await executeCSharpCodePayload({ ...message.payload, inputs }, 'execute-code');
+      results.push(normalizeCSharpBatchEntry(result, result.timings));
+    }
+    const consoleOutput = results.flatMap((entry) => entry.consoleOutput ?? []);
+    const success = results.every((entry) => entry.success === true);
+    return {
+      success,
+      results,
+      consoleOutput,
+      ...(success ? {} : { error: results.find((entry) => entry.success !== true)?.error ?? 'C# batch execution failed.' }),
+      timings: {
+        totalMs: elapsedMs(startedAt),
+        batchMode: 'per-case-fallback',
+        batchCaseCount: inputBatch.length,
+        batchFallbackReason: isolationReason,
+        runMs: results.reduce((sum, entry) => sum + (entry.timings?.runMs ?? 0), 0),
+      },
+    };
   }
+
+  let batchSource;
+  try {
+    batchSource = buildCSharpBatchScriptSource(message.payload ?? {});
+  } catch (error) {
+    return {
+      success: false,
+      results: [],
+      error: error instanceof Error ? error.message : String(error),
+      consoleOutput: [],
+      timings: { totalMs: elapsedMs(startedAt) },
+    };
+  }
+
+  const result = await executeCSharpCodePayload({
+    ...message.payload,
+    code: batchSource,
+    functionName: '',
+    executionStyle: 'function',
+    inputs: { __tracecodeBatchInputs: inputBatch },
+  }, 'execute-code');
+  const batchEntries = Array.isArray(result?.output) ? result.output : [];
+  const results = batchEntries.map((entry) => normalizeCSharpBatchEntry(entry));
   const consoleOutput = results.flatMap((entry) => entry.consoleOutput ?? []);
   const success = results.length === inputBatch.length && results.every((entry) => entry.success === true);
   return {
     success,
     results,
     consoleOutput,
-    ...(success ? {} : { error: results.find((entry) => entry.success !== true)?.error ?? 'C# batch execution failed.' }),
+    ...(success ? {} : { error: result?.error ?? results.find((entry) => entry.success !== true)?.error ?? 'C# batch execution failed.' }),
     timings: {
+      ...(result?.timings && typeof result.timings === 'object' ? result.timings : {}),
       totalMs: elapsedMs(startedAt),
-      batchMode: 'per-case-isolated',
+      batchMode: 'compile-once',
       batchCaseCount: inputBatch.length,
       runMs: results.reduce((sum, entry) => sum + (entry.timings?.runMs ?? 0), 0),
     },

package/workers/javascript/javascript-project-worker.js

@@ -3716,7 +3716,7 @@ function unzipSync(data, opts) {
 // packages/harness-javascript/package.json
 var package_default = {
   name: "@tracecode/harness-javascript",
-  version: "0.9.8",
+  version: "0.9.9",
   description: "JavaScript and TypeScript runtime helpers and browser worker assets for TraceCode harness.",
   license: "AGPL-3.0-only",
   homepage: "https://tracecode.app",