@tracecode/harness 0.16.4 → 0.16.6

package/CHANGELOG.md

@@ -6,6 +6,42 @@ This repo uses Git tags as release boundaries. Version notes below summarize wha
 
 ## [Unreleased]
 
+## [0.16.6] - 2026-08-14
+
+### Fixed
+
+- Exposed the Java external-compiler endpoint through the public browser Judge
+  options, preserving a warm trusted compiler alongside disposable learner
+  runners in server-hosted browser authorities.
+
+## [0.16.5] - 2026-08-12
+
+### Added
+
+- Added the in-repo TraceCLR algorithm profile, derived from the product C#
+  corpus, with deterministic compatibility checks, an explicit binary wire
+  boundary, and a trace-capable minimal runner used as evidence for the
+  optimized execution tier.
+
+### Changed
+
+- C# prepared execution now selects either the optimized algorithm runner or
+  the broad compatibility runner before learner code starts. The selected
+  tier never falls through to the other runner after a learner failure, and
+  both tiers preserve the same output, tracing, limits, and isolation
+  contracts.
+- Browser runtime prewarming now begins as promotable idle work. A foreground
+  compile promotes the same pending work instead of starting a second warmup.
+- C++ toolchain asset loading, integrity validation, PCH registration, and
+  compiler initialization now stay inside the compiler Worker. Python runtime
+  image fetching and Wasm compilation likewise run in a short-lived bootstrap
+  Worker before the immutable image is retained at provider scope.
+
+### Fixed
+
+- Prevented Python and C++ preflight from blocking the browser page thread
+  during Practice loading while preserving fast warmed first execution.
+
 ## [0.16.4] - 2026-08-11
 
 ### Fixed

package/README.md

@@ -246,10 +246,12 @@ collapsed runtime-information section; full transitive notices remain in the
 versioned engine release.
 
 The default Python Judge deployment is self-contained under `/workers` after
-`sync-assets`. It retains immutable CPython startup state at provider scope,
-leases one clean Worker to a submission for preparation plus its case batch,
-and then terminates that Worker. A custom Python runtime manifest must include
-an engine-matched `runtimeImage`; missing or cross-engine images fail closed.
+`sync-assets`. A short-lived bootstrap Worker fetches and compiles the immutable
+CPython startup image, then transfers it to provider scope without performing
+runtime-image work on the page thread. The provider leases one clean Worker to
+a submission for preparation plus its case batch, and then terminates that
+Worker. A custom Python runtime manifest must include an engine-matched
+`runtimeImage`; missing or cross-engine images fail closed.
 Project Python processes continue to use the general TraceKernel process path
 because their modules, filesystem, stdin, servers, and lifetime are
 user-controlled.

package/dist/{browser-runtime-provider-OGJQLGXU.js → browser-runtime-provider-KPQBQ4EG.js}

@@ -2,14 +2,14 @@ var define = undefined;
 import {
   createCppBrowserRuntimeProvider,
   createTraceCCBrowserCompilerService
-} from "./chunk-RCOPAMVR.js";
-import "./chunk-AAKNIYV6.js";
-import "./chunk-Y72C46GE.js";
-import "./chunk-DTLDQQHA.js";
+} from "./chunk-J2KGF5PU.js";
+import "./chunk-46XZQOHV.js";
+import "./chunk-GXTDL2ML.js";
+import "./chunk-5KH5ABPQ.js";
 import "./chunk-C2RUZCIL.js";
 import "./chunk-756Z7C6D.js";
 export {
   createCppBrowserRuntimeProvider,
   createTraceCCBrowserCompilerService
 };
-//# sourceMappingURL=browser-runtime-provider-OGJQLGXU.js.map
+//# sourceMappingURL=browser-runtime-provider-KPQBQ4EG.js.map

package/dist/{chunk-AAKNIYV6.js → chunk-46XZQOHV.js}

@@ -4,7 +4,7 @@ import {
   liftCodeBatchOutcome,
   liftCodeOutcome,
   liftTraceOutcome
-} from "./chunk-Y72C46GE.js";
+} from "./chunk-GXTDL2ML.js";
 import {
   WorkerCrashedError,
   WorkerReadyTimeoutError,
@@ -21,7 +21,7 @@ import {
   logRuntimeDiagnostic,
   restoreTransferredTraceEvents,
   traceEventTransferRequest
-} from "./chunk-DTLDQQHA.js";
+} from "./chunk-5KH5ABPQ.js";
 import {
   andThen,
   catchIf,
@@ -1370,4 +1370,4 @@ var CppWorkerClient = class {
 export {
   CppWorkerClient
 };
-//# sourceMappingURL=chunk-AAKNIYV6.js.map
+//# sourceMappingURL=chunk-46XZQOHV.js.map

package/dist/{chunk-6LE4KEMZ.js → chunk-4PN5YD6J.js}

@@ -4,7 +4,7 @@ import {
   liftCodeBatchOutcome,
   liftTraceOutcome,
   withRuntimeTraceOptions
-} from "./chunk-Y72C46GE.js";
+} from "./chunk-GXTDL2ML.js";
 import {
   HostArtifactCache,
   WorkerCrashedError,
@@ -20,7 +20,7 @@ import {
   logRuntimeDiagnostic,
   restoreTransferredTraceEvents,
   traceEventTransferRequest
-} from "./chunk-DTLDQQHA.js";
+} from "./chunk-5KH5ABPQ.js";
 import {
   _void,
   andThen,
@@ -31,6 +31,460 @@ import {
   tryPromise
 } from "./chunk-C2RUZCIL.js";
 
+// packages/runtime-csharp/src/traceclr-wire.ts
+var WIRE_MAGIC = 827802452;
+var TRACECLR_WIRE_LIMITS = Object.freeze({
+  maxBytes: 16 * 1024 * 1024,
+  maxCollectionItems: 1e6,
+  maxDepth: 128
+});
+var WireWriter = class {
+  buffer = new ArrayBuffer(256);
+  view = new DataView(this.buffer);
+  length = 0;
+  reserve(bytes) {
+    const next = this.length + bytes;
+    if (!Number.isSafeInteger(bytes) || bytes < 0 || next > TRACECLR_WIRE_LIMITS.maxBytes) {
+      throw new RangeError(`TraceCLR wire payload exceeds ${TRACECLR_WIRE_LIMITS.maxBytes} bytes.`);
+    }
+    if (next > this.buffer.byteLength) {
+      let capacity = this.buffer.byteLength;
+      while (capacity < next) capacity = Math.min(TRACECLR_WIRE_LIMITS.maxBytes, capacity * 2);
+      const replacement = new ArrayBuffer(capacity);
+      new Uint8Array(replacement).set(new Uint8Array(this.buffer, 0, this.length));
+      this.buffer = replacement;
+      this.view = new DataView(replacement);
+    }
+    const offset = this.length;
+    this.length = next;
+    return offset;
+  }
+  uint8(value) {
+    const offset = this.reserve(1);
+    this.view.setUint8(offset, value);
+  }
+  int8(value) {
+    const offset = this.reserve(1);
+    this.view.setInt8(offset, value);
+  }
+  int16(value) {
+    const offset = this.reserve(2);
+    this.view.setInt16(offset, value, true);
+  }
+  uint16(value) {
+    const offset = this.reserve(2);
+    this.view.setUint16(offset, value, true);
+  }
+  int32(value) {
+    const offset = this.reserve(4);
+    this.view.setInt32(offset, value, true);
+  }
+  uint32(value) {
+    const offset = this.reserve(4);
+    this.view.setUint32(offset, value, true);
+  }
+  int64(value) {
+    const offset = this.reserve(8);
+    this.view.setBigInt64(offset, value, true);
+  }
+  uint64(value) {
+    const offset = this.reserve(8);
+    this.view.setBigUint64(offset, value, true);
+  }
+  float32(value) {
+    const offset = this.reserve(4);
+    this.view.setFloat32(offset, value, true);
+  }
+  float64(value) {
+    const offset = this.reserve(8);
+    this.view.setFloat64(offset, value, true);
+  }
+  bytes(value) {
+    const offset = this.reserve(value.byteLength);
+    new Uint8Array(this.buffer, offset, value.byteLength).set(value);
+  }
+  finish() {
+    return new Uint8Array(this.buffer.slice(0, this.length));
+  }
+};
+var WireReader = class {
+  view;
+  offset = 0;
+  constructor(bytes) {
+    if (bytes.byteLength > TRACECLR_WIRE_LIMITS.maxBytes) {
+      throw new RangeError(`TraceCLR wire payload exceeds ${TRACECLR_WIRE_LIMITS.maxBytes} bytes.`);
+    }
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  take(bytes) {
+    if (this.offset + bytes > this.view.byteLength) {
+      throw new RangeError("TraceCLR wire payload ended unexpectedly.");
+    }
+    const offset = this.offset;
+    this.offset += bytes;
+    return offset;
+  }
+  uint8() {
+    return this.view.getUint8(this.take(1));
+  }
+  int8() {
+    return this.view.getInt8(this.take(1));
+  }
+  int16() {
+    return this.view.getInt16(this.take(2), true);
+  }
+  uint16() {
+    return this.view.getUint16(this.take(2), true);
+  }
+  int32() {
+    return this.view.getInt32(this.take(4), true);
+  }
+  uint32() {
+    return this.view.getUint32(this.take(4), true);
+  }
+  int64() {
+    return this.view.getBigInt64(this.take(8), true);
+  }
+  uint64() {
+    return this.view.getBigUint64(this.take(8), true);
+  }
+  float32() {
+    return this.view.getFloat32(this.take(4), true);
+  }
+  float64() {
+    return this.view.getFloat64(this.take(8), true);
+  }
+  bytes(length) {
+    return new Uint8Array(this.view.buffer, this.view.byteOffset + this.take(length), length);
+  }
+  done() {
+    if (this.offset !== this.view.byteLength) {
+      throw new RangeError(`TraceCLR wire payload has ${this.view.byteLength - this.offset} trailing bytes.`);
+    }
+  }
+};
+function parseWireType(text, depth = 0) {
+  if (depth > TRACECLR_WIRE_LIMITS.maxDepth) throw new RangeError("TraceCLR wire type is too deeply nested.");
+  if (text === "list-node<int32>") return { kind: "list-node" };
+  if (text === "tree-node<int32>") return { kind: "tree-node" };
+  for (const name of ["array", "list", "set"]) {
+    const prefix = `${name}<`;
+    if (text.startsWith(prefix) && text.endsWith(">")) {
+      return { kind: "container", name, element: parseWireType(text.slice(prefix.length, -1), depth + 1) };
+    }
+  }
+  const scalars = /* @__PURE__ */ new Set([
+    "void",
+    "null",
+    "bool",
+    "char",
+    "uint8",
+    "int8",
+    "int16",
+    "uint16",
+    "int32",
+    "uint32",
+    "int64",
+    "uint64",
+    "float32",
+    "float64",
+    "string"
+  ]);
+  if (!scalars.has(text)) throw new TypeError(`Unsupported TraceCLR wire type: ${text}`);
+  return { kind: "scalar", name: text };
+}
+function integer(value, minimum, maximum, label) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new TypeError(`${label} must be an integer between ${minimum} and ${maximum}.`);
+  }
+  return value;
+}
+function integer64(value, signed) {
+  let converted = null;
+  if (typeof value === "bigint") {
+    converted = value;
+  } else if (typeof value === "number" && Number.isInteger(value)) {
+    const jsonDecimal = JSON.stringify(value);
+    if (jsonDecimal !== void 0) converted = BigInt(jsonDecimal);
+  }
+  const minimum = signed ? -(1n << 63n) : 0n;
+  const maximum = signed ? (1n << 63n) - 1n : (1n << 64n) - 1n;
+  if (converted === null || converted < minimum || converted > maximum) {
+    throw new TypeError(`${signed ? "int64" : "uint64"} must be a bigint or integer number in range.`);
+  }
+  return converted;
+}
+function floatingPoint(value, label) {
+  if (typeof value === "number") return Object.is(value, -0) ? 0 : value;
+  if (value === "NaN") return Number.NaN;
+  if (value === "Infinity") return Number.POSITIVE_INFINITY;
+  if (value === "-Infinity") return Number.NEGATIVE_INFINITY;
+  throw new TypeError(`${label} must be numeric or a named floating-point literal.`);
+}
+function collection(value, set) {
+  const items = set && value instanceof Set ? [...value] : value;
+  if (!Array.isArray(items)) throw new TypeError("TraceCLR collection values must be arrays or Sets.");
+  if (items.length > TRACECLR_WIRE_LIMITS.maxCollectionItems) {
+    throw new RangeError(`TraceCLR collection exceeds ${TRACECLR_WIRE_LIMITS.maxCollectionItems} items.`);
+  }
+  return items;
+}
+function writeValue(writer, type, value, depth) {
+  if (depth > TRACECLR_WIRE_LIMITS.maxDepth) throw new RangeError("TraceCLR value is too deeply nested.");
+  if (type.kind === "container") {
+    if (value === null) {
+      writer.int32(-1);
+      return;
+    }
+    const values = collection(value, type.name === "set");
+    writer.int32(values.length);
+    for (const item of values) writeValue(writer, type.element, item, depth + 1);
+    return;
+  }
+  if (type.kind === "list-node") {
+    if (value === null) {
+      writer.int32(-1);
+      return;
+    }
+    const values = Array.isArray(value) ? value : [];
+    if (!Array.isArray(value)) {
+      const seen = /* @__PURE__ */ new Set();
+      let node = value;
+      while (node !== null) {
+        if (typeof node !== "object" || seen.has(node)) throw new TypeError("TraceCLR ListNode must be acyclic.");
+        seen.add(node);
+        values.push(node.val ?? node.value);
+        node = node.next ?? null;
+        if (values.length > TRACECLR_WIRE_LIMITS.maxCollectionItems) throw new RangeError("TraceCLR ListNode is too long.");
+      }
+    }
+    writer.int32(values.length);
+    for (const item of values) writer.int32(integer(item, -2147483648, 2147483647, "ListNode value"));
+    return;
+  }
+  if (type.kind === "tree-node") {
+    if (value === null) {
+      writer.int32(-1);
+      return;
+    }
+    let rawValues;
+    if (Array.isArray(value)) {
+      rawValues = value;
+    } else if (typeof value === "object") {
+      const values2 = [];
+      const nodes = [value];
+      for (let index = 0; index < nodes.length; index++) {
+        const node = nodes[index];
+        if (node === null) {
+          values2.push(null);
+          continue;
+        }
+        if (typeof node !== "object") throw new TypeError("TraceCLR TreeNode nodes must be objects or null.");
+        const typed = node;
+        values2.push(typed.val ?? typed.value);
+        nodes.push(typed.left ?? null, typed.right ?? null);
+        if (nodes.length > TRACECLR_WIRE_LIMITS.maxCollectionItems) throw new RangeError("TraceCLR TreeNode is too large.");
+      }
+      while (values2.at(-1) === null) values2.pop();
+      rawValues = values2;
+    } else {
+      throw new TypeError("TraceCLR TreeNode inputs must be level-order arrays or node objects.");
+    }
+    const values = collection(rawValues, false);
+    writer.int32(values.length);
+    for (const item of values) {
+      writer.uint8(item === null ? 0 : 1);
+      if (item !== null) writer.int32(integer(item, -2147483648, 2147483647, "TreeNode value"));
+    }
+    return;
+  }
+  switch (type.name) {
+    case "void":
+      return;
+    case "null":
+      if (value !== null) throw new TypeError("TraceCLR null result must be null.");
+      writer.uint8(0);
+      return;
+    case "bool":
+      if (typeof value !== "boolean") throw new TypeError("bool must be boolean.");
+      writer.uint8(value ? 1 : 0);
+      return;
+    case "char": {
+      if (typeof value !== "string" || value.length !== 1) throw new TypeError("char must be one UTF-16 code unit.");
+      writer.uint16(value.charCodeAt(0));
+      return;
+    }
+    case "uint8":
+      writer.uint8(integer(value, 0, 255, "uint8"));
+      return;
+    case "int8":
+      writer.int8(integer(value, -128, 127, "int8"));
+      return;
+    case "int16":
+      writer.int16(integer(value, -32768, 32767, "int16"));
+      return;
+    case "uint16":
+      writer.uint16(integer(value, 0, 65535, "uint16"));
+      return;
+    case "int32":
+      writer.int32(integer(value, -2147483648, 2147483647, "int32"));
+      return;
+    case "uint32":
+      writer.uint32(integer(value, 0, 4294967295, "uint32"));
+      return;
+    case "int64":
+      writer.int64(integer64(value, true));
+      return;
+    case "uint64":
+      writer.uint64(integer64(value, false));
+      return;
+    case "float32":
+      writer.float32(floatingPoint(value, "float32"));
+      return;
+    case "float64":
+      writer.float64(floatingPoint(value, "float64"));
+      return;
+    case "string": {
+      if (value === null) {
+        writer.int32(-1);
+        return;
+      }
+      if (typeof value !== "string") throw new TypeError("string must be a string or null.");
+      const bytes = new TextEncoder().encode(value);
+      writer.int32(bytes.byteLength);
+      writer.bytes(bytes);
+      return;
+    }
+  }
+}
+function normalizePortableResult(type, value) {
+  if (value === null || value === void 0) return value;
+  if (type.kind === "container") {
+    const values = type.name === "set" && value instanceof Set ? [...value] : value;
+    if (!Array.isArray(values)) {
+      throw new TypeError(`TraceCLR ${type.name} result did not decode to a collection.`);
+    }
+    return values.map((item) => normalizePortableResult(type.element, item));
+  }
+  if (type.kind === "scalar" && (type.name === "int64" || type.name === "uint64")) {
+    if (typeof value !== "bigint") {
+      throw new TypeError(`TraceCLR ${type.name} result did not decode to a bigint.`);
+    }
+    return Number(value);
+  }
+  if (type.kind === "scalar" && (type.name === "float32" || type.name === "float64")) {
+    if (typeof value !== "number") {
+      throw new TypeError(`TraceCLR ${type.name} result did not decode to a number.`);
+    }
+    if (Number.isNaN(value)) return "NaN";
+    if (value === Number.POSITIVE_INFINITY) return "Infinity";
+    if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+  }
+  return value;
+}
+function readLength(reader) {
+  const length = reader.int32();
+  if (length === -1) return null;
+  if (length < 0 || length > TRACECLR_WIRE_LIMITS.maxCollectionItems) {
+    throw new RangeError(`Invalid TraceCLR collection length: ${length}.`);
+  }
+  return length;
+}
+function readByteLength(reader) {
+  const length = reader.int32();
+  if (length === -1) return null;
+  if (length < 0 || length > TRACECLR_WIRE_LIMITS.maxBytes) {
+    throw new RangeError(`Invalid TraceCLR byte length: ${length}.`);
+  }
+  return length;
+}
+function readValue(reader, type, depth) {
+  if (depth > TRACECLR_WIRE_LIMITS.maxDepth) throw new RangeError("TraceCLR value is too deeply nested.");
+  if (type.kind === "container") {
+    const length = readLength(reader);
+    if (length === null) return null;
+    const values = Array.from({ length }, () => readValue(reader, type.element, depth + 1));
+    return type.name === "set" ? new Set(values) : values;
+  }
+  if (type.kind === "list-node") {
+    const length = readLength(reader);
+    return length === null ? null : Array.from({ length }, () => reader.int32());
+  }
+  if (type.kind === "tree-node") {
+    const length = readLength(reader);
+    if (length === null) return null;
+    const values = Array.from({ length }, () => reader.uint8() === 0 ? null : reader.int32());
+    while (values.at(-1) === null) values.pop();
+    return values;
+  }
+  switch (type.name) {
+    case "void":
+      return void 0;
+    case "null":
+      if (reader.uint8() !== 0) throw new RangeError("Invalid TraceCLR null marker.");
+      return null;
+    case "bool": {
+      const value = reader.uint8();
+      if (value > 1) throw new RangeError("Invalid TraceCLR bool.");
+      return value === 1;
+    }
+    case "char":
+      return String.fromCharCode(reader.uint16());
+    case "uint8":
+      return reader.uint8();
+    case "int8":
+      return reader.int8();
+    case "int16":
+      return reader.int16();
+    case "uint16":
+      return reader.uint16();
+    case "int32":
+      return reader.int32();
+    case "uint32":
+      return reader.uint32();
+    case "int64":
+      return reader.int64();
+    case "uint64":
+      return reader.uint64();
+    case "float32":
+      return reader.float32();
+    case "float64":
+      return reader.float64();
+    case "string": {
+      const length = readByteLength(reader);
+      return length === null ? null : new TextDecoder("utf-8", { fatal: true }).decode(reader.bytes(length));
+    }
+  }
+}
+function begin(writer) {
+  writer.uint32(WIRE_MAGIC);
+}
+function verify(reader) {
+  if (reader.uint32() !== WIRE_MAGIC) throw new RangeError("TraceCLR wire magic/version mismatch.");
+}
+function encodeTraceClrWireInputs(contract, inputs) {
+  const writer = new WireWriter();
+  begin(writer);
+  writer.uint16(contract.parameters.length);
+  const positionalInputs = Object.values(inputs);
+  for (const [index, parameter] of contract.parameters.entries()) {
+    const value = Object.prototype.hasOwnProperty.call(inputs, parameter.name) ? inputs[parameter.name] : positionalInputs[index];
+    if (value === void 0 && !Object.prototype.hasOwnProperty.call(inputs, parameter.name) && index >= positionalInputs.length) {
+      throw new TypeError(`Missing TraceCLR input: ${parameter.name}`);
+    }
+    writeValue(writer, parseWireType(parameter.type.wireType), value, 0);
+  }
+  return writer.finish();
+}
+function decodeTraceClrWireResult(contract, bytes) {
+  const reader = new WireReader(bytes);
+  verify(reader);
+  const type = parseWireType(contract.returnType.wireType);
+  const value = readValue(reader, type, 0);
+  reader.done();
+  return normalizePortableResult(type, value);
+}
+
 // packages/runtime-csharp/src/csharp-worker-client.ts
 var EXECUTION_TIMEOUT_MS = 2e4;
 var TRACING_TIMEOUT_MS = 2e4;
@@ -407,12 +861,17 @@ var CSharpWorkerClient = class {
   async executePreparedCode(prepared, call) {
     return this.runPreparedExecutionGeneration(call.signal, async () => {
       const wallClockMs = call.limits?.wallClockMs ?? this.executionTimeoutMs;
+      const inputBytes = prepared.preparedRunnerTier === "algorithm-fast" ? encodeTraceClrWireInputs(
+        prepared.traceClrWireContract,
+        call.inputs
+      ) : void 0;
       const program = this.preparedReadyEffect().pipe(
         andThen(
           this.core.withExecutionDeadline(
             this.sendCommandEffect("execute-prepared-code", {
               prepared,
               inputs: call.inputs,
+              ...inputBytes ? { inputBytes } : {},
               assetBaseUrl: this.options.assetBaseUrl,
               timeoutMs: Math.max(100, wallClockMs - 1e3),
               ...this.workerOptionsPayload()
@@ -422,6 +881,17 @@ var CSharpWorkerClient = class {
         )
       );
       const result = await this.core.runClientEffect(program, call.signal);
+      if (prepared.preparedRunnerTier === "algorithm-fast" && result.success) {
+        if (!(result.outputBytes instanceof Uint8Array)) {
+          throw new TypeError(
+            "The algorithm-fast C# runner returned no binary output payload."
+          );
+        }
+        result.output = decodeTraceClrWireResult(
+          prepared.traceClrWireContract,
+          result.outputBytes
+        );
+      }
       return this.toCodeExecutionResult(result);
     });
   }
@@ -433,6 +903,10 @@ var CSharpWorkerClient = class {
     }
     return this.runPreparedExecutionGeneration(call.signal, async () => {
       const wallClockMs = call.limits?.wallClockMs ?? this.resolveTracingTimeoutMs(prepared.functionName, prepared.executionStyle);
+      const inputBytes = prepared.preparedRunnerTier === "algorithm-fast" ? encodeTraceClrWireInputs(
+        prepared.traceClrWireContract,
+        call.inputs
+      ) : void 0;
       let result;
       const program = this.preparedReadyEffect().pipe(
         andThen(
@@ -440,6 +914,7 @@ var CSharpWorkerClient = class {
             this.sendCommandEffect("execute-prepared-trace", {
               prepared,
               inputs: call.inputs,
+              ...inputBytes ? { inputBytes } : {},
               ...call.recordTrace === void 0 ? {} : { tracingEnabled: call.recordTrace },
               assetBaseUrl: this.options.assetBaseUrl,
               timeoutMs: Math.max(100, wallClockMs - 1e3),
@@ -455,6 +930,17 @@ var CSharpWorkerClient = class {
       } catch (error) {
         return this.traceClientFailure(error, wallClockMs);
       }
+      if (prepared.preparedRunnerTier === "algorithm-fast" && result.success) {
+        if (!(result.outputBytes instanceof Uint8Array)) {
+          throw new TypeError(
+            "The algorithm-fast C# trace runner returned no binary output payload."
+          );
+        }
+        result.output = decodeTraceClrWireResult(
+          prepared.traceClrWireContract,
+          result.outputBytes
+        );
+      }
       return this.toTraceExecutionResult(
         result,
         prepared.traceOptions,
@@ -638,4 +1124,4 @@ var CSharpWorkerClient = class {
 export {
   CSharpWorkerClient
 };
-//# sourceMappingURL=chunk-6LE4KEMZ.js.map
+//# sourceMappingURL=chunk-4PN5YD6J.js.map