@tracecode/harness 0.16.4 → 0.16.5

package/dist/tracekernel.cjs

@@ -1132,7 +1132,7 @@ var init_Array = __esm({
       }
       return out;
     });
-    fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
+    fromIterable = (collection2) => Array.isArray(collection2) ? collection2 : Array.from(collection2);
     ensure = (self2) => Array.isArray(self2) ? self2 : [self2];
     prepend = /* @__PURE__ */ dual(2, (self2, head4) => [head4, ...self2]);
     append = /* @__PURE__ */ dual(2, (self2, last3) => [...self2, last3]);
@@ -9877,17 +9877,17 @@ var init_redBlackTree = __esm({
     });
     keysForward = (self2) => keys3(self2, Direction.Forward);
     keys3 = (self2, direction) => {
-      const begin = self2[Symbol.iterator]();
+      const begin2 = self2[Symbol.iterator]();
       let count = 0;
       return {
         [Symbol.iterator]: () => keys3(self2, direction),
         next: () => {
           count++;
-          const entry = begin.key;
+          const entry = begin2.key;
           if (direction === Direction.Forward) {
-            begin.moveNext();
+            begin2.moveNext();
           } else {
-            begin.movePrev();
+            begin2.movePrev();
           }
           switch (entry._tag) {
             case "None": {
@@ -13521,7 +13521,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@tracecode/harness",
-      version: "0.16.4",
+      version: "0.16.5",
       license: "AGPL-3.0-only",
       homepage: "https://tracecode.app",
       repository: {
@@ -13589,6 +13589,15 @@ var init_package = __esm({
         "build:browser-host": "pnpm exec tsup --config tsup.browser-host.config.ts",
         "build:tracekernel": "pnpm exec tsup --config tsup.tracekernel.config.ts",
         "generate:runtime-info": "pnpm exec tsx --tsconfig tsconfig.base.json scripts/generate-runtime-language-info.ts",
+        "generate:traceclr-profile": "node scripts/generate-traceclr-algorithm-profile.mjs",
+        "audit:traceclr-corpus": "node scripts/audit-traceclr-corpus.mjs",
+        "build:traceclr-product-corpus": "node scripts/create-traceclr-product-corpus.mjs",
+        "check:traceclr-profile": "node --test tests/test-traceclr-algorithm-profile.mjs tests/test-traceclr-profile-policy.mjs && node --import tsx tests/test-traceclr-wire-codec.ts",
+        "check:traceclr-product-profile": "node scripts/generate-traceclr-algorithm-profile.mjs --check && pnpm check:traceclr-profile",
+        "build:traceclr-wire-probe": "dotnet build tools/TraceCode.TraceClrWireProbe/TraceCode.TraceClrWireProbe.csproj -c Release && dotnet build tools/TraceCode.TraceClrHostileProbe/TraceCode.TraceClrHostileProbe.csproj -c Release && dotnet publish packages/runtime-csharp/dotnet/TraceCode.CSharpAlgorithmRunner/TraceCode.CSharpAlgorithmRunner.csproj -c Release",
+        "test:traceclr-wire-browser": "pnpm build:traceclr-wire-probe && TRACECODE_TRACECLR_BROWSER_ENGINE=chromium node --import tsx tests/test-traceclr-wire-runner-browser.ts && TRACECODE_TRACECLR_BROWSER_ENGINE=firefox node --import tsx tests/test-traceclr-wire-runner-browser.ts && TRACECODE_TRACECLR_BROWSER_ENGINE=webkit node --import tsx tests/test-traceclr-wire-runner-browser.ts",
+        "bench:traceclr-tiers": "pnpm build:traceclr-wire-probe && pnpm materialize:csharp-role-assets && node --import tsx scripts/benchmark-traceclr-runtime-tiers.ts",
+        "bench:traceclr-tiers:matrix": "pnpm build:traceclr-wire-probe && pnpm materialize:csharp-role-assets && for engine in chromium firefox webkit; do TRACECODE_TRACECLR_BROWSER_ENGINE=$engine node --import tsx scripts/benchmark-traceclr-runtime-tiers.ts || exit; done",
         "generate:runtime-open-source-info": "pnpm exec tsx --tsconfig tsconfig.base.json scripts/generate-runtime-open-source-info.ts",
         "generate:python-harness": "pnpm exec tsx --tsconfig tsconfig.base.json scripts/generate-python-harness-artifacts.ts",
         "generate:runtime-assets-lock": "node --import tsx scripts/generate-runtime-assets-lock.mjs",
@@ -13652,10 +13661,10 @@ var init_package = __esm({
         "test:java-runtime": "pnpm exec tsx --tsconfig tsconfig.base.json tests/test-java-runtime.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-java-project-filesystem.ts && node --import tsx --test tests/test-java-jar-manifest.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-java-project-provider.ts && TSX_TSCONFIG_PATH=tsconfig.base.json node --import tsx --test tests/test-java-prepared-provider.ts",
         "test:java-prepared-provider": "TSX_TSCONFIG_PATH=tsconfig.base.json node --import tsx --test tests/test-java-prepared-provider.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-java-prepared-provider-browser.ts",
         "test:tracejvm-semantic-trace": "node --import tsx tests/test-tracejvm-semantic-trace-matrix.ts",
-        "test:csharp-runtime": "pnpm exec tsx --tsconfig tsconfig.base.json scripts/validate-csharp-runtime-role-assets.ts && TSX_TSCONFIG_PATH=tsconfig.base.json node --import tsx --test tests/test-csharp-role-artifacts.ts tests/test-csharp-managed-assembly-packs.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-runtime.ts && TSX_TSCONFIG_PATH=tsconfig.base.json node --import tsx --test tests/test-csharp-prepared-provider.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-project-fs-parity.ts",
+        "test:csharp-runtime": "pnpm check:traceclr-profile && pnpm exec tsx --tsconfig tsconfig.base.json scripts/validate-csharp-runtime-role-assets.ts && TSX_TSCONFIG_PATH=tsconfig.base.json node --import tsx --test tests/test-csharp-role-artifacts.ts tests/test-csharp-managed-assembly-packs.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-runtime.ts && TSX_TSCONFIG_PATH=tsconfig.base.json node --import tsx --test tests/test-csharp-prepared-provider.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-project-fs-parity.ts",
         "test:csharp-role-assets": "pnpm materialize:csharp-role-assets && TSX_TSCONFIG_PATH=tsconfig.base.json node --import tsx --test tests/test-csharp-role-artifacts.ts tests/test-csharp-managed-assembly-packs.ts && pnpm exec tsx --tsconfig tsconfig.base.json scripts/validate-csharp-runtime-role-assets.ts",
         "test:csharp-worker-browser": "pnpm materialize:csharp-role-assets && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-worker-client-http.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-worker-browser.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-worker-lifecycle-browser.ts && pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-prepared-boundary-browser.ts",
-        "test:csharp-worker-browser-matrix": "pnpm materialize:csharp-role-assets && TRACECODE_CSHARP_BROWSER_SMOKE=1 TRACECODE_CSHARP_BROWSER_ENGINE=chromium pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-worker-browser.ts && TRACECODE_CSHARP_BROWSER_SMOKE=1 TRACECODE_CSHARP_BROWSER_ENGINE=firefox pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-worker-browser.ts && TRACECODE_CSHARP_BROWSER_SMOKE=1 TRACECODE_CSHARP_BROWSER_ENGINE=webkit pnpm exec tsx --tsconfig tsconfig.base.json tests/test-csharp-worker-browser.ts",
+        "test:csharp-worker-browser-matrix": "pnpm materialize:csharp-role-assets && for engine in chromium firefox webkit; do TSX_TSCONFIG_PATH=tsconfig.base.json TRACECODE_CSHARP_BROWSER_SMOKE=1 TRACECODE_CSHARP_BROWSER_ENGINE=$engine node --import tsx tests/test-csharp-worker-browser.ts && TSX_TSCONFIG_PATH=tsconfig.base.json TRACECODE_CSHARP_BROWSER_ENGINE=$engine node --import tsx tests/test-csharp-prepared-boundary-browser.ts || exit; done",
         "test:cpp-runtime": "pnpm exec tsx --tsconfig tsconfig.base.json tests/test-cpp-runtime.ts",
         "test:cpp-conformance": "pnpm exec tsx --tsconfig tsconfig.base.json tests/test-cpp-conformance.ts",
         "test:cpp-script-lambda-trace": "pnpm exec tsx --tsconfig tsconfig.base.json tests/test-cpp-script-lambda-trace.ts",
@@ -13791,7 +13800,7 @@ var init_runtime_language_info_data = __esm({
           "versionLabel": "Python 3.13.2",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.4"
+            "version": "0.16.5"
           },
           "description": "Python 3.13.2 runs in TraceKernel's isolated Python runtime.\n\nCommon algorithm helpers are imported automatically, including array, bisect, collections, functools, heapq, itertools. Other standard-library modules can be imported normally.\n\nOptional third-party packages are consumer-owned runtime assets and are available only when declared by the TraceKernel runtime manifest.",
           "runtime": {
@@ -13818,7 +13827,7 @@ var init_runtime_language_info_data = __esm({
           "versionLabel": "JavaScript (ECMAScript 2023)",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.4"
+            "version": "0.16.5"
           },
           "runtime": {
             "name": "TraceKernel JavaScript runtime",
@@ -13910,7 +13919,7 @@ Binary Search Tree, Trie, and Graph are bundled too, but are not exposed globall
           "versionLabel": "TypeScript 5.9.3",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.4"
+            "version": "0.16.5"
           },
           "description": `TypeScript 5.9.3 is compiled with the TypeScript compiler and executed by TraceKernel's JavaScript runtime.
 
@@ -14010,7 +14019,7 @@ The compiled output runs on the same TraceKernel execution lane as JavaScript su
           "versionLabel": "Java 23",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.4"
+            "version": "0.16.5"
           },
           "description": "Java 23 is compiled with javac 23 and executed by the Java runtime on TraceKernel.\n\nCommon imports are added automatically: java.util.*, java.io.*, java.math.*, java.util.stream.*, javafx.util.Pair.",
           "runtime": {
@@ -14047,7 +14056,7 @@ The compiled output runs on the same TraceKernel execution lane as JavaScript su
           "versionLabel": "C# 14",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.4"
+            "version": "0.16.5"
           },
           "description": "C# 14 source is compiled and executed by TraceKernel's isolated C# runtime.\n\nCommon namespaces are imported automatically: System, System.Collections, System.Collections.Generic, System.IO, System.Linq, System.Numerics, System.Text, System.Text.RegularExpressions.",
           "runtime": {
@@ -14076,7 +14085,7 @@ The compiled output runs on the same TraceKernel execution lane as JavaScript su
           "versionLabel": "C++23",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.4"
+            "version": "0.16.5"
           },
           "description": "C++ source is compiled using the C++23 standard.\n\nSubmissions compile to WebAssembly and run in TraceKernel's WASI execution lane. The compiler currently uses -O0 and -fno-exceptions, with a fixed program stack size.\n\nCommon standard library headers are included automatically, including <algorithm>, <array>, <bitset>, <climits>, <cmath>, <cstdint>, <functional>, <limits>, <numeric>, <sstream>, <tuple>, <vector>, <unordered_map>, <unordered_set> and more.",
           "runtime": {
@@ -14241,7 +14250,7 @@ var init_runtime_open_source_info_data = __esm({
                 {
                   "kind": "modifications",
                   "label": "Runtime modifications",
-                  "url": "https://github.com/tracecodeapp/harness/tree/v0.16.4/workers/python/pyodide-0.29.3"
+                  "url": "https://github.com/tracecodeapp/harness/tree/v0.16.5/workers/python/pyodide-0.29.3"
                 }
               ]
             }
@@ -102564,6 +102573,81 @@ var init_browser_client_env = __esm({
   }
 });
 
+// packages/runtime-browser/src/background-work-scheduler.ts
+function createPromotableBrowserBackgroundTask(work) {
+  let permanentlyCancelled = false;
+  let task = null;
+  let idleHandle = null;
+  let backgroundController = null;
+  let resolveCompletion;
+  let rejectCompletion;
+  const completion = new Promise((resolve, reject) => {
+    resolveCompletion = resolve;
+    rejectCompletion = reject;
+  });
+  void completion.catch(() => void 0);
+  const start = () => {
+    if (permanentlyCancelled) return Promise.resolve();
+    if (!task) {
+      task = Promise.resolve().then(work);
+      task.then(resolveCompletion, rejectCompletion);
+      void task.catch(() => void 0);
+    }
+    return task;
+  };
+  const cancelPendingCallback = () => {
+    if (idleHandle !== null && typeof globalThis.cancelIdleCallback === "function") {
+      globalThis.cancelIdleCallback(idleHandle);
+      idleHandle = null;
+    }
+    backgroundController?.abort();
+    backgroundController = null;
+  };
+  if (typeof globalThis.requestIdleCallback === "function") {
+    idleHandle = globalThis.requestIdleCallback(() => {
+      idleHandle = null;
+      void start();
+    });
+  } else {
+    const scheduler = globalThis.scheduler;
+    if (scheduler?.postTask) {
+      backgroundController = new AbortController();
+      void scheduler.postTask(
+        () => {
+          backgroundController = null;
+          return start();
+        },
+        {
+          priority: "background",
+          signal: backgroundController.signal
+        }
+      ).catch(() => void 0);
+    }
+  }
+  return {
+    promote: () => {
+      cancelPendingCallback();
+      return start();
+    },
+    wait: () => completion,
+    cancel: () => {
+      if (permanentlyCancelled) return;
+      permanentlyCancelled = true;
+      cancelPendingCallback();
+      if (!task) {
+        rejectCompletion(
+          new DOMException("Browser background work was cancelled.", "AbortError")
+        );
+      }
+    }
+  };
+}
+var init_background_work_scheduler = __esm({
+  "packages/runtime-browser/src/background-work-scheduler.ts"() {
+    "use strict";
+  }
+});
+
 // packages/runtime-browser/src/host-artifact-cache.ts
 function handleHostArtifactCacheRequest(options) {
   const { cache, message, worker, validateProtocolToken } = options;
@@ -104618,6 +104702,7 @@ var init_internal = __esm({
   "packages/runtime-browser/src/internal.ts"() {
     "use strict";
     init_browser_client_env();
+    init_background_work_scheduler();
     init_execution_host();
     init_host_artifact_cache();
     init_kernel_http_async();
@@ -114811,9 +114896,9 @@ function createBrowserFsPromisesApi(requestState, filesystemState, fsApi) {
           const options = typeof bufferOrOptions === "object" && bufferOrOptions !== null && !ArrayBuffer.isView(bufferOrOptions) ? bufferOrOptions : void 0;
           const buffer = options?.buffer ?? (ArrayBuffer.isView(bufferOrOptions) ? bufferOrOptions : BrowserBuffer.alloc(16 * 1024));
           const readOffset = options?.offset ?? offset;
-          const readLength = options?.length ?? length3 ?? buffer.byteLength - readOffset;
+          const readLength2 = options?.length ?? length3 ?? buffer.byteLength - readOffset;
           const readPosition = options !== void 0 ? options.position : position;
-          const bytesRead = fsApi.readSync(fd5, buffer, readOffset, readLength, readPosition);
+          const bytesRead = fsApi.readSync(fd5, buffer, readOffset, readLength2, readPosition);
           return { bytesRead, buffer };
         },
         readFile: async (encoding) => readFileFromHandle(encoding),
@@ -120890,6 +120975,466 @@ var init_project_browser4 = __esm({
   }
 });
 
+// packages/runtime-csharp/src/traceclr-wire.ts
+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, set6) {
+  const items = set6 && 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 values3 = collection(value, type.name === "set");
+    writer.int32(values3.length);
+    for (const item of values3) writeValue(writer, type.element, item, depth + 1);
+    return;
+  }
+  if (type.kind === "list-node") {
+    if (value === null) {
+      writer.int32(-1);
+      return;
+    }
+    const values3 = 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);
+        values3.push(node.val ?? node.value);
+        node = node.next ?? null;
+        if (values3.length > TRACECLR_WIRE_LIMITS.maxCollectionItems) throw new RangeError("TraceCLR ListNode is too long.");
+      }
+    }
+    writer.int32(values3.length);
+    for (const item of values3) 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 values4 = [];
+      const nodes = [value];
+      for (let index = 0; index < nodes.length; index++) {
+        const node = nodes[index];
+        if (node === null) {
+          values4.push(null);
+          continue;
+        }
+        if (typeof node !== "object") throw new TypeError("TraceCLR TreeNode nodes must be objects or null.");
+        const typed = node;
+        values4.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 (values4.at(-1) === null) values4.pop();
+      rawValues = values4;
+    } else {
+      throw new TypeError("TraceCLR TreeNode inputs must be level-order arrays or node objects.");
+    }
+    const values3 = collection(rawValues, false);
+    writer.int32(values3.length);
+    for (const item of values3) {
+      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 values3 = type.name === "set" && value instanceof Set ? [...value] : value;
+    if (!Array.isArray(values3)) {
+      throw new TypeError(`TraceCLR ${type.name} result did not decode to a collection.`);
+    }
+    return values3.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 length3 = reader.int32();
+  if (length3 === -1) return null;
+  if (length3 < 0 || length3 > TRACECLR_WIRE_LIMITS.maxCollectionItems) {
+    throw new RangeError(`Invalid TraceCLR collection length: ${length3}.`);
+  }
+  return length3;
+}
+function readByteLength(reader) {
+  const length3 = reader.int32();
+  if (length3 === -1) return null;
+  if (length3 < 0 || length3 > TRACECLR_WIRE_LIMITS.maxBytes) {
+    throw new RangeError(`Invalid TraceCLR byte length: ${length3}.`);
+  }
+  return length3;
+}
+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 length3 = readLength(reader);
+    if (length3 === null) return null;
+    const values3 = Array.from({ length: length3 }, () => readValue(reader, type.element, depth + 1));
+    return type.name === "set" ? new Set(values3) : values3;
+  }
+  if (type.kind === "list-node") {
+    const length3 = readLength(reader);
+    return length3 === null ? null : Array.from({ length: length3 }, () => reader.int32());
+  }
+  if (type.kind === "tree-node") {
+    const length3 = readLength(reader);
+    if (length3 === null) return null;
+    const values3 = Array.from({ length: length3 }, () => reader.uint8() === 0 ? null : reader.int32());
+    while (values3.at(-1) === null) values3.pop();
+    return values3;
+  }
+  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 length3 = readByteLength(reader);
+      return length3 === null ? null : new TextDecoder("utf-8", { fatal: true }).decode(reader.bytes(length3));
+    }
+  }
+}
+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);
+}
+var WIRE_MAGIC, TRACECLR_WIRE_LIMITS, WireWriter, WireReader;
+var init_traceclr_wire = __esm({
+  "packages/runtime-csharp/src/traceclr-wire.ts"() {
+    "use strict";
+    WIRE_MAGIC = 827802452;
+    TRACECLR_WIRE_LIMITS = Object.freeze({
+      maxBytes: 16 * 1024 * 1024,
+      maxCollectionItems: 1e6,
+      maxDepth: 128
+    });
+    WireWriter = class {
+      buffer = new ArrayBuffer(256);
+      view = new DataView(this.buffer);
+      length = 0;
+      reserve(bytes) {
+        const next3 = this.length + bytes;
+        if (!Number.isSafeInteger(bytes) || bytes < 0 || next3 > TRACECLR_WIRE_LIMITS.maxBytes) {
+          throw new RangeError(`TraceCLR wire payload exceeds ${TRACECLR_WIRE_LIMITS.maxBytes} bytes.`);
+        }
+        if (next3 > this.buffer.byteLength) {
+          let capacity3 = this.buffer.byteLength;
+          while (capacity3 < next3) capacity3 = Math.min(TRACECLR_WIRE_LIMITS.maxBytes, capacity3 * 2);
+          const replacement = new ArrayBuffer(capacity3);
+          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 = next3;
+        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));
+      }
+    };
+    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(length3) {
+        return new Uint8Array(this.view.buffer, this.view.byteOffset + this.take(length3), length3);
+      }
+      done() {
+        if (this.offset !== this.view.byteLength) {
+          throw new RangeError(`TraceCLR wire payload has ${this.view.byteLength - this.offset} trailing bytes.`);
+        }
+      }
+    };
+  }
+});
+
 // packages/runtime-csharp/src/csharp-worker-client.ts
 var csharp_worker_client_exports = {};
 __export(csharp_worker_client_exports, {
@@ -120918,6 +121463,7 @@ var init_csharp_worker_client = __esm({
     init_internal();
     init_internal();
     init_internal();
+    init_traceclr_wire();
     EXECUTION_TIMEOUT_MS2 = 2e4;
     TRACING_TIMEOUT_MS2 = 2e4;
     INIT_TIMEOUT_MS2 = 45e3;
@@ -121284,12 +121830,17 @@ var init_csharp_worker_client = __esm({
       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(
             andThen4(
               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()
@@ -121299,6 +121850,17 @@ var init_csharp_worker_client = __esm({
             )
           );
           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);
         });
       }
@@ -121310,6 +121872,10 @@ var init_csharp_worker_client = __esm({
         }
         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(
             andThen4(
@@ -121317,6 +121883,7 @@ var init_csharp_worker_client = __esm({
                 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),
@@ -121332,6 +121899,17 @@ var init_csharp_worker_client = __esm({
           } 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,
@@ -122910,6 +123488,7 @@ function createCppPreparedExecutionProvider(options) {
   let terminated = false;
   const ownedClients = /* @__PURE__ */ new Set();
   const activePrograms = /* @__PURE__ */ new Set();
+  let scheduledCompilerPrewarm = null;
   const createClient = () => {
     const client = options.createWorkerClient();
     ownedClients.add(client);
@@ -122937,6 +123516,21 @@ function createCppPreparedExecutionProvider(options) {
     standbyClient = null;
     return client;
   };
+  const cancelScheduledCompilerPrewarm = () => {
+    scheduledCompilerPrewarm?.cancel();
+    scheduledCompilerPrewarm = null;
+  };
+  const scheduleCompilerPrewarm = () => {
+    if (terminated || scheduledCompilerPrewarm || !options.prewarmCompiler || !options.scheduleCompilerPrewarm) {
+      return;
+    }
+    const expectedGeneration = generation;
+    scheduledCompilerPrewarm = options.scheduleCompilerPrewarm(async () => {
+      assertGeneration(expectedGeneration);
+      await options.prewarmCompiler?.();
+      assertGeneration(expectedGeneration);
+    });
+  };
   return {
     async init() {
       assertActive();
@@ -122955,6 +123549,7 @@ function createCppPreparedExecutionProvider(options) {
         const result = await client.init();
         assertGeneration(expectedGeneration);
         standbyClient = client;
+        scheduleCompilerPrewarm();
         return {
           success: result.success,
           loadTimeMs: result.loadTimeMs
@@ -122966,6 +123561,12 @@ function createCppPreparedExecutionProvider(options) {
     },
     async prepareProgram(call) {
       const expectedGeneration = generation;
+      const compilerPrewarm = scheduledCompilerPrewarm;
+      scheduledCompilerPrewarm = null;
+      if (compilerPrewarm) {
+        await compilerPrewarm.promote().catch(() => void 0);
+        assertGeneration(expectedGeneration);
+      }
       const client = acquireClient();
       try {
         await client.init();
@@ -123096,6 +123697,7 @@ function createCppPreparedExecutionProvider(options) {
     },
     reset() {
       assertActive();
+      cancelScheduledCompilerPrewarm();
       generation += 1;
       for (const forceDispose of [...activePrograms]) forceDispose();
       for (const client of [...ownedClients]) retireClient(client);
@@ -123103,6 +123705,7 @@ function createCppPreparedExecutionProvider(options) {
     },
     terminate() {
       if (terminated) return;
+      cancelScheduledCompilerPrewarm();
       generation += 1;
       terminated = true;
       for (const forceDispose of [...activePrograms]) forceDispose();
@@ -123202,8 +123805,30 @@ var init_tracecc_compiler_service = __esm({
       requestTimeoutMs;
       artifactCache = /* @__PURE__ */ new Map();
       artifactCacheBytes = 0;
+      /**
+       * Fetch and verify the immutable compiler inputs inside the trusted compiler
+       * Worker without compiling or instantiating TraceCC. A foreground compile
+       * joins the Worker's immutable byte cache.
+       */
+      async prewarmAssets(shard = "narrow") {
+        await this.ensureWorker();
+        const selected = this.options.shards[shard];
+        const result = await this.send("prewarm-trusted-tracecc-assets", {
+          ...this.traceccAssets(
+            selected,
+            `/tracecc-assets/${shard}.pch`,
+            `/tracecc-assets/${shard}.o`
+          ),
+          source: "tracecc-prewarm-assets-v1"
+        });
+        if (result.success !== true) {
+          throw new Error(
+            typeof result.error === "string" ? result.error : "TraceCC compiler asset prewarm failed."
+          );
+        }
+      }
       async warmup(shard = "narrow") {
-        await this.options.assetPreflight?.(shard);
+        await this.prewarmAssets(shard);
         await this.ensureWorker();
         const selected = this.options.shards[shard];
         const pchPath = `/tracecc-assets/${shard}.pch`;
@@ -123270,7 +123895,6 @@ var init_tracecc_compiler_service = __esm({
               ""
             );
             const shard = traceccShardForDriver(strippedSource);
-            await this.options.assetPreflight?.(shard);
             if (signal?.aborted || generation !== this.generation) {
               throw Object.assign(
                 new Error("TraceCC compilation was cancelled."),
@@ -123448,7 +124072,6 @@ var init_tracecc_compiler_service = __esm({
             error: "TraceCC trusted Project compilation only accepts compile requests."
           };
         }
-        await this.options.commonAssetPreflight?.();
         if (signal?.aborted || generation !== this.generation) {
           throw Object.assign(
             new Error("TraceCC Project compilation was cancelled."),
@@ -123654,36 +124277,18 @@ function createTraceCCBrowserCompilerService(compiler, context2) {
     ...DEFAULT_TRACECC_RESOURCE_NAMES,
     ...compiler.resourceNames ?? {}
   };
-  const commonCompilerAssetNames = [
-    "runtimeHeader",
-    "compilerWasm",
-    "linkerWasm",
-    "sysroot"
-  ];
-  const commonAssetPreflight = () => context2.preflight(commonCompilerAssetNames);
   const compilerIntegrity = context2.assets.cppCompilerIntegrity;
   if (!compilerIntegrity) {
     throw new Error(
       "TraceCC requires exact compiler integrity entries from a C++ runtime manifest."
     );
   }
-  const shardAssetPreflight = (shard) => {
-    const prefix = shard === "map" ? "map" : shard;
-    return context2.preflight([
-      ...commonCompilerAssetNames,
-      `compilerResources.${resourceNames[`${prefix}Pch`]}`,
-      `compilerResources.${resourceNames[`${prefix}PchSource`]}`,
-      `compilerResources.${resourceNames[`${prefix}RuntimeObject`]}`
-    ]);
-  };
   return new TraceCCCompilerService({
     workerUrl: context2.assets.cppWorker,
     compilerUrl: context2.assets.cppCompilerWasm,
     resourcesUrl: context2.assets.cppSysroot,
     runtimeHeaderUrl: context2.assets.cppRuntimeHeader,
     compilerIntegrity,
-    commonAssetPreflight,
-    assetPreflight: shardAssetPreflight,
     shards: {
       narrow: traceccShardAssets(
         traceccResources,
@@ -123712,18 +124317,9 @@ function createCppBrowserRuntimeProvider(options = {}) {
     create(context2) {
       const workerFactory = context2.workerFactoryFor("cpp");
       const compiler = options.compiler ?? {};
-      const commonCompilerAssetNames = [
-        "runtimeHeader",
-        "compilerWasm",
-        "linkerWasm",
-        "sysroot"
-      ];
-      const runtimeAssetPreflight = context2.preflight("cpp", commonCompilerAssetNames);
       const workerOptions = {
         workerUrl: context2.assets.cppWorker,
         ...workerFactory ? { workerFactory } : {},
-        assetPreflight: context2.preflight("cpp", ["worker"]),
-        runtimeAssetPreflight,
         compilerWasmUrl: context2.assets.cppCompilerWasm,
         linkerWasmUrl: context2.assets.cppLinkerWasm,
         sysrootUrl: context2.assets.cppSysroot,
@@ -123739,8 +124335,7 @@ function createCppBrowserRuntimeProvider(options = {}) {
       };
       const compilerService = createTraceCCBrowserCompilerService(compiler, {
         assets: context2.assets,
-        ...workerFactory ? { workerFactory } : {},
-        preflight: (assetNames) => context2.preflight("cpp", assetNames)()
+        ...workerFactory ? { workerFactory } : {}
       });
       const createWorkerClient = () => new CppWorkerClient({
         ...workerOptions,
@@ -123748,7 +124343,9 @@ function createCppBrowserRuntimeProvider(options = {}) {
       });
       const preparedProvider = createCppPreparedExecutionProvider({
         createWorkerClient,
-        warmCompilerOnInit: true
+        warmCompilerOnInit: false,
+        prewarmCompiler: () => compilerService.prewarmAssets(),
+        scheduleCompilerPrewarm: createPromotableBrowserBackgroundTask
       });
       const preparedProviders = /* @__PURE__ */ new Map([["cpp", preparedProvider]]);
       const terminateCompiler = () => {
@@ -123772,6 +124369,7 @@ var DEFAULT_TRACECC_RESOURCE_NAMES;
 var init_browser_runtime_provider = __esm({
   "packages/runtime-cpp/src/browser-runtime-provider.ts"() {
     "use strict";
+    init_internal();
     init_cpp_prepared_provider();
     init_cpp_worker_client();
     init_tracecc_compiler_service();
@@ -219567,22 +220165,13 @@ async function createBrowserProjectWorkspace(options = {}) {
       } : {}
     };
     const cppCompilerWorkerFactory = executionHost && isExecutionHosted("cpp") ? executionHost.workerFactory : void 0;
-    const cppRuntimeAssetPreflight = () => runtimeAssetPreflight.preflight("cpp", [
-      "runtimeHeader",
-      "compilerWasm",
-      "linkerWasm",
-      "sysroot"
-    ]);
     const traceccCompilerService = cppProvider && !injectedCppProvider ? cppProvider[2].createTraceCCBrowserCompilerService({}, {
       assets,
-      ...cppCompilerWorkerFactory ? { workerFactory: cppCompilerWorkerFactory } : {},
-      preflight: (assetNames) => runtimeAssetPreflight.preflight("cpp", assetNames)
+      ...cppCompilerWorkerFactory ? { workerFactory: cppCompilerWorkerFactory } : {}
     }) : void 0;
     const cppWorkerOptions = {
       workerUrl: assets.cppWorker,
       ...cppCompilerWorkerFactory ? { workerFactory: cppCompilerWorkerFactory } : {},
-      assetPreflight: () => runtimeAssetPreflight.preflight("cpp", ["worker"]),
-      runtimeAssetPreflight: cppRuntimeAssetPreflight,
       compilerWasmUrl: assets.cppCompilerWasm,
       linkerWasmUrl: assets.cppLinkerWasm,
       sysrootUrl: assets.cppSysroot,
@@ -219786,14 +220375,7 @@ function preflightAssets(language, surface, csharpPreparedAuthority) {
         "runnerDependencies"
       ];
     case "cpp":
-      return [
-        "worker",
-        "runtimeHeader",
-        "compilerWasm",
-        "linkerWasm",
-        "sysroot",
-        "compilerResources"
-      ];
+      return [];
   }
 }
 function detectEngine(userAgent = globalThis.navigator?.userAgent ?? "") {