@tracecode/harness 0.16.3 → 0.16.5

package/dist/judge.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": {
@@ -13074,7 +13074,7 @@ var init_runtime_language_info_data = __esm({
           "versionLabel": "Python 3.13.2",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.3"
+            "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": {
@@ -13101,7 +13101,7 @@ var init_runtime_language_info_data = __esm({
           "versionLabel": "JavaScript (ECMAScript 2023)",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.3"
+            "version": "0.16.5"
           },
           "runtime": {
             "name": "TraceKernel JavaScript runtime",
@@ -13193,7 +13193,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.3"
+            "version": "0.16.5"
           },
           "description": `TypeScript 5.9.3 is compiled with the TypeScript compiler and executed by TraceKernel's JavaScript runtime.
 
@@ -13293,7 +13293,7 @@ The compiled output runs on the same TraceKernel execution lane as JavaScript su
           "versionLabel": "Java 23",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.3"
+            "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": {
@@ -13330,7 +13330,7 @@ The compiled output runs on the same TraceKernel execution lane as JavaScript su
           "versionLabel": "C# 14",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.3"
+            "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": {
@@ -13359,7 +13359,7 @@ The compiled output runs on the same TraceKernel execution lane as JavaScript su
           "versionLabel": "C++23",
           "executionPlatform": {
             "name": "TraceKernel",
-            "version": "0.16.3"
+            "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": {
@@ -13524,7 +13524,7 @@ var init_runtime_open_source_info_data = __esm({
                 {
                   "kind": "modifications",
                   "label": "Runtime modifications",
-                  "url": "https://github.com/tracecodeapp/harness/tree/v0.16.3/workers/python/pyodide-0.29.3"
+                  "url": "https://github.com/tracecodeapp/harness/tree/v0.16.5/workers/python/pyodide-0.29.3"
                 }
               ]
             }
@@ -15043,6 +15043,81 @@ var init_runtime_profiles = __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/runtime-capability-guards.ts
 function isScriptRequest(functionName) {
   if (functionName == null) return true;
@@ -15138,7 +15213,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@tracecode/harness",
-      version: "0.16.3",
+      version: "0.16.5",
       license: "AGPL-3.0-only",
       homepage: "https://tracecode.app",
       repository: {
@@ -15206,6 +15281,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",
@@ -15269,10 +15353,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",
@@ -19839,6 +19923,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();
@@ -29277,6 +29362,466 @@ var init_tracejvm_runtime_assets = __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 bytes2 = new TextEncoder().encode(value);
+      writer.int32(bytes2.byteLength);
+      writer.bytes(bytes2);
+      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, bytes2) {
+  const reader = new WireReader(bytes2);
+  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(bytes2) {
+        const next2 = this.length + bytes2;
+        if (!Number.isSafeInteger(bytes2) || bytes2 < 0 || next2 > TRACECLR_WIRE_LIMITS.maxBytes) {
+          throw new RangeError(`TraceCLR wire payload exceeds ${TRACECLR_WIRE_LIMITS.maxBytes} bytes.`);
+        }
+        if (next2 > this.buffer.byteLength) {
+          let capacity3 = this.buffer.byteLength;
+          while (capacity3 < next2) 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 = next2;
+        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(bytes2) {
+        if (bytes2.byteLength > TRACECLR_WIRE_LIMITS.maxBytes) {
+          throw new RangeError(`TraceCLR wire payload exceeds ${TRACECLR_WIRE_LIMITS.maxBytes} bytes.`);
+        }
+        this.view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
+      }
+      take(bytes2) {
+        if (this.offset + bytes2 > this.view.byteLength) {
+          throw new RangeError("TraceCLR wire payload ended unexpectedly.");
+        }
+        const offset = this.offset;
+        this.offset += bytes2;
+        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, {
@@ -29305,6 +29850,7 @@ var init_csharp_worker_client = __esm({
     init_internal();
     init_internal();
     init_internal();
+    init_traceclr_wire();
     EXECUTION_TIMEOUT_MS4 = 2e4;
     TRACING_TIMEOUT_MS4 = 2e4;
     INIT_TIMEOUT_MS4 = 45e3;
@@ -29671,12 +30217,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()
@@ -29686,6 +30237,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);
         });
       }
@@ -29697,6 +30259,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(
@@ -29704,6 +30270,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),
@@ -29719,6 +30286,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,
@@ -29908,6 +30486,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);
@@ -29935,6 +30514,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();
@@ -29953,6 +30547,7 @@ function createCppPreparedExecutionProvider(options) {
         const result = await client.init();
         assertGeneration(expectedGeneration);
         standbyClient = client;
+        scheduleCompilerPrewarm();
         return {
           success: result.success,
           loadTimeMs: result.loadTimeMs
@@ -29964,6 +30559,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();
@@ -30094,6 +30695,7 @@ function createCppPreparedExecutionProvider(options) {
     },
     reset() {
       assertActive();
+      cancelScheduledCompilerPrewarm();
       generation += 1;
       for (const forceDispose of [...activePrograms]) forceDispose();
       for (const client of [...ownedClients]) retireClient(client);
@@ -30101,6 +30703,7 @@ function createCppPreparedExecutionProvider(options) {
     },
     terminate() {
       if (terminated) return;
+      cancelScheduledCompilerPrewarm();
       generation += 1;
       terminated = true;
       for (const forceDispose of [...activePrograms]) forceDispose();
@@ -31553,8 +32156,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`;
@@ -31621,7 +32246,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."),
@@ -31799,7 +32423,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."),
@@ -31870,6 +32493,14 @@ var init_tracecc_compiler_service = __esm({
           }, this.requestTimeoutMs);
           worker.onmessage = (event) => {
             const message = event.data;
+            if (message.type === "idle-timeout") {
+              if (generation === this.generation) {
+                this.reset(
+                  new Error("TraceCC compiler Worker closed after idle timeout.")
+                );
+              }
+              return;
+            }
             if (message.type === "worker-ready") {
               globalThis.clearTimeout(readyTimeout);
               resolve();
@@ -31997,36 +32628,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,
@@ -32055,18 +32668,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,
@@ -32082,8 +32686,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,
@@ -32091,7 +32694,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 = () => {
@@ -32115,6 +32720,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();
@@ -117855,9 +118461,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(fd3, buffer, readOffset, readLength, readPosition);
+          const bytesRead = fsApi.readSync(fd3, buffer, readOffset, readLength2, readPosition);
           return { bytesRead, buffer };
         },
         readFile: async (encoding) => readFileFromHandle(encoding),
@@ -125115,14 +125721,7 @@ function preflightAssets(language, surface, csharpPreparedAuthority) {
         "runnerDependencies"
       ];
     case "cpp":
-      return [
-        "worker",
-        "runtimeHeader",
-        "compilerWasm",
-        "linkerWasm",
-        "sysroot",
-        "compilerResources"
-      ];
+      return [];
   }
 }
 function detectEngine(userAgent = globalThis.navigator?.userAgent ?? "") {
@@ -125790,6 +126389,7 @@ function withPreparedProgramReuse(delegate, options = {}) {
 }
 
 // packages/runtime-browser/src/browser-runtime-host.ts
+init_background_work_scheduler();
 function resolveHostContext(options) {
   return resolveBrowserRuntimeLifecycleContext(options, {
     optionsName: "CreateBrowserRuntimeHostOptions",
@@ -125881,6 +126481,8 @@ var BrowserRuntimeHostImplementation = class {
   environment;
   supportedLanguages;
   #preparedProviders = /* @__PURE__ */ new Map();
+  #providerInitializers = /* @__PURE__ */ new Map();
+  #warmEntries = /* @__PURE__ */ new Map();
   #leases = [];
   #leaseByLanguage = /* @__PURE__ */ new Map();
   #readinessByLanguage = /* @__PURE__ */ new Map();
@@ -125922,16 +126524,25 @@ var BrowserRuntimeHostImplementation = class {
             language,
             preparedProvider
           );
+          const safeProvider = safePreparedProvider(
+            language,
+            preparedProvider,
+            () => this.#assertActive(),
+            () => this.#ensureLanguageReady(language)
+          );
+          this.#providerInitializers.set(
+            language,
+            () => safeProvider.init()
+          );
           this.#preparedProviders.set(
             language,
-            withPreparedProgramReuse(
-              safePreparedProvider(
-                language,
-                preparedProvider,
-                () => this.#assertActive(),
-                () => this.#ensureLanguageReady(language)
-              )
-            )
+            withPreparedProgramReuse({
+              init: () => this.#promoteLanguageWarm(language),
+              prepareProgram: async (call) => {
+                await this.#promoteLanguageWarm(language);
+                return safeProvider.prepareProgram(call);
+              }
+            })
           );
           this.#leaseByLanguage.set(language, lease);
         }
@@ -125978,6 +126589,41 @@ var BrowserRuntimeHostImplementation = class {
       throw new Error("Browser runtime host has been disposed.");
     }
   }
+  #warmEntry(language) {
+    const existing = this.#warmEntries.get(language);
+    if (existing) return existing;
+    const initialize = this.#providerInitializers.get(language);
+    if (!initialize) {
+      throw new Error(
+        `Prepared runtime for language "${language}" is not registered.`
+      );
+    }
+    let warmResult;
+    const task = createPromotableBrowserBackgroundTask(async () => {
+      warmResult = await initialize();
+    });
+    const result = task.wait().then(() => {
+      if (!warmResult) {
+        throw new Error(
+          `Browser runtime for ${JSON.stringify(language)} completed warmup without a result.`
+        );
+      }
+      return warmResult;
+    });
+    const entry = { task, result };
+    this.#warmEntries.set(language, entry);
+    void result.catch(() => {
+      if (this.#warmEntries.get(language) === entry) {
+        this.#warmEntries.delete(language);
+      }
+    });
+    return entry;
+  }
+  async #promoteLanguageWarm(language) {
+    const entry = this.#warmEntry(language);
+    await entry.task.promote();
+    return entry.result;
+  }
   isLanguageSupported(language) {
     return this.supportedLanguages.includes(language);
   }
@@ -126045,6 +126691,17 @@ var BrowserRuntimeHostImplementation = class {
       runtimes: Object.freeze(runtimes)
     });
   }
+  prewarmLanguage(language) {
+    this.#assertActive();
+    if (!this.supportedLanguages.includes(language)) {
+      return Promise.reject(
+        new Error(
+          `Runtime for language "${language}" is not selected in this browser environment.`
+        )
+      );
+    }
+    return this.#warmEntry(language).result;
+  }
   warmLanguage(language) {
     this.#assertActive();
     if (!this.supportedLanguages.includes(language)) {
@@ -126054,16 +126711,20 @@ var BrowserRuntimeHostImplementation = class {
         )
       );
     }
-    return this.#preparedProviders.get(language).init();
+    return this.#promoteLanguageWarm(language);
   }
   disposeLanguage(language) {
     if (this.#disposed || !this.supportedLanguages.includes(language)) return;
+    this.#warmEntries.get(language)?.task.cancel();
+    this.#warmEntries.delete(language);
     this.#preparedProviders.get(language)?.flushPreparedProgramCache();
     this.#leaseByLanguage.get(language)?.disposeLanguage(language);
   }
   dispose() {
     if (this.#disposed) return;
     this.#disposed = true;
+    for (const entry of this.#warmEntries.values()) entry.task.cancel();
+    this.#warmEntries.clear();
     this.#readinessByLanguage.clear();
     for (const provider of this.#preparedProviders.values()) {
       provider.flushPreparedProgramCache();
@@ -126903,6 +127564,7 @@ init_execution_host();
 init_runtime_language_info();
 
 // packages/runtime-python/src/python-runtime-image.ts
+init_internal();
 function fetchOptions(descriptor3, signal) {
   return {
     cache: "force-cache",
@@ -126943,8 +127605,114 @@ function createPythonRuntimeImageFactory(options) {
   let disposed = false;
   let imagePromise = null;
   let activeBuildController = null;
+  let activeBootstrapWorker = null;
+  let activeBootstrapCancellation = null;
+  const buildInWorker = () => new Promise((resolve, reject) => {
+    if (!options.workerUrl) {
+      reject(new Error("Python runtime-image bootstrap requires a worker URL."));
+      return;
+    }
+    const workerFormat = options.workerFormat ?? "classic";
+    let workerUrl = appendWorkerUrlQueryParameter(
+      options.workerUrl,
+      "tracecodePythonRole",
+      "runtime-image"
+    );
+    if (workerFormat === "module") {
+      workerUrl = appendWorkerUrlQueryParameter(
+        workerUrl,
+        "tracecodePythonWorkerFormat",
+        "module"
+      );
+    }
+    const worker = options.workerFactory ? options.workerFactory(
+      workerUrl,
+      workerFormat === "module" ? { type: "module" } : void 0
+    ) : new Worker(
+      workerUrl,
+      workerFormat === "module" ? { type: "module" } : void 0
+    );
+    activeBootstrapWorker = worker;
+    const id3 = "python-runtime-image";
+    const protocolToken = createWorkerProtocolToken();
+    let requested = false;
+    let settled = false;
+    const finish = (operation) => {
+      if (settled) return;
+      settled = true;
+      globalThis.clearTimeout(timeoutId);
+      worker.terminate();
+      if (activeBootstrapWorker === worker) activeBootstrapWorker = null;
+      activeBootstrapCancellation = null;
+      operation();
+    };
+    const timeoutId = globalThis.setTimeout(() => {
+      finish(() => reject(
+        new Error(
+          `Python runtime image acquisition timed out after ${timeoutMs}ms.`
+        )
+      ));
+    }, timeoutMs);
+    activeBootstrapCancellation = () => {
+      finish(() => reject(
+        new Error("Python runtime image factory was disposed while loading.")
+      ));
+    };
+    worker.onerror = (event) => {
+      finish(() => reject(
+        new Error(
+          event.message || "Python runtime-image bootstrap Worker crashed."
+        )
+      ));
+    };
+    worker.onmessage = (event) => {
+      const message = event.data;
+      if (message?.type === "worker-ready" && !requested) {
+        requested = true;
+        worker.postMessage({
+          id: id3,
+          type: "build-runtime-image",
+          protocolToken,
+          payload: {
+            source: "tracecode-python-runtime-image-v1",
+            descriptor: options.descriptor
+          }
+        });
+        return;
+      }
+      if (message?.id !== id3 || message.protocolToken !== protocolToken) {
+        return;
+      }
+      if (message.type === "error") {
+        finish(() => reject(
+          new Error(
+            message.payload?.error || "Python runtime-image bootstrap failed."
+          )
+        ));
+        return;
+      }
+      if (message.type !== "runtime-image-result") return;
+      const image = message.payload?.runtimeImage;
+      if (image?.protocolVersion !== PYTHON_RUNTIME_IMAGE_PROTOCOL_VERSION || !(image.compiledModule instanceof WebAssembly.Module) || !(image.snapshot instanceof Uint8Array) || image.snapshot.byteLength === 0 || typeof image.pythonHashSeed !== "string" || image.pythonHashSeed.length === 0) {
+        finish(() => reject(
+          new Error("Python runtime-image bootstrap returned an invalid image.")
+        ));
+        return;
+      }
+      finish(() => resolve(Object.freeze(image)));
+    };
+  });
   const build = async () => {
     if (disposed) throw new Error("Python runtime image factory is disposed.");
+    if (options.workerUrl) {
+      const image = await buildInWorker();
+      if (disposed) {
+        throw new Error(
+          "Python runtime image factory was disposed while loading."
+        );
+      }
+      return image;
+    }
     const controller = new AbortController();
     activeBuildController = controller;
     let timeoutId;
@@ -127062,6 +127830,10 @@ function createPythonRuntimeImageFactory(options) {
       disposed = true;
       activeBuildController?.abort();
       activeBuildController = null;
+      activeBootstrapCancellation?.();
+      activeBootstrapCancellation = null;
+      activeBootstrapWorker?.terminate();
+      activeBootstrapWorker = null;
       imagePromise = null;
     }
   });
@@ -127188,9 +127960,15 @@ function createPythonBrowserRuntimeProvider(options = {}) {
         );
       }
       const createRuntimeImageFactory = () => createPythonRuntimeImageFactory({
-        descriptor: runtimeImageDescriptor
+        descriptor: runtimeImageDescriptor,
+        workerUrl: context2.assets.pythonWorker,
+        ...workerFactory ? { workerFactory } : {},
+        ...pythonManifest?.workerFormat ? { workerFormat: pythonManifest.workerFormat } : {}
       });
       let runtimeImageFactory = createRuntimeImageFactory();
+      const runtimeImageWorkerPreflight = context2.preflight("python", [
+        "worker"
+      ]);
       const workerOptions = () => ({
         workerUrl: context2.assets.pythonWorker,
         ...workerFactory ? { workerFactory } : {},
@@ -127231,6 +128009,7 @@ function createPythonBrowserRuntimeProvider(options = {}) {
       const lease = {
         preparedProviders,
         preflightLanguage: async () => {
+          await runtimeImageWorkerPreflight();
           await runtimeImageFactory.acquire();
         },
         disposeLanguage: () => {
@@ -129576,9 +130355,9 @@ var CSharpRuntimeClient = class {
   get preparedCompiler() {
     return this.preparedAuthority?.compiler ?? this.workerClient;
   }
-  async withPreparedRunner(execute) {
+  async withPreparedRunner(tier, execute) {
     if (!this.preparedAuthority) return execute(this.workerClient);
-    const runner = this.preparedAuthority.createRunner();
+    const runner = this.preparedAuthority.createRunner(tier);
     try {
       return await execute(runner);
     } finally {
@@ -129586,7 +130365,7 @@ var CSharpRuntimeClient = class {
       this.preparedAuthority.releaseRunner(runner);
     }
   }
-  async withFreshPreparedRunners(inputBatch, execute, signal) {
+  async withFreshPreparedRunners(tier, inputBatch, execute, signal) {
     const concurrency = Math.min(
       inputBatch.length,
       this.preparedAuthority?.batchConcurrency ?? 1
@@ -129608,6 +130387,7 @@ var CSharpRuntimeClient = class {
           const inputs = inputBatch[index];
           try {
             results[index] = await this.withPreparedRunner(
+              tier,
               (runner) => execute(runner, inputs, index)
             );
           } catch (reason) {
@@ -129711,6 +130491,17 @@ var CSharpRuntimeClient = class {
         timings: result.timings
       };
     }
+    const preparedRunnerTier = result.preparedRunnerTier;
+    const preparedRunnerReason = result.preparedRunnerReason;
+    if (preparedRunnerTier !== "algorithm-fast" && preparedRunnerTier !== "compatibility" || typeof preparedRunnerReason !== "string" || !preparedRunnerReason || preparedRunnerTier === "algorithm-fast" && !result.traceClrWireContract) {
+      return {
+        kind: "failed",
+        error: "C# preparation completed without a valid runner-tier descriptor.",
+        diagnosticStage: "compile",
+        consoleOutput: result.consoleOutput ?? [],
+        timings: result.timings
+      };
+    }
     let artifact = Object.freeze({
       mode: call.mode,
       code: call.code,
@@ -129719,7 +130510,24 @@ var CSharpRuntimeClient = class {
       ...call.traceOptions ? { traceOptions: Object.freeze({ ...call.traceOptions }) } : {},
       compiledArtifactKey: result.compiledArtifactKey,
       compiledArtifactBase64: result.compiledArtifactBase64,
-      compiledArtifactSha256: result.compiledArtifactSha256
+      compiledArtifactSha256: result.compiledArtifactSha256,
+      preparedRunnerTier,
+      preparedRunnerReason,
+      ...result.traceClrWireContract ? {
+        traceClrWireContract: Object.freeze({
+          parameters: Object.freeze(
+            result.traceClrWireContract.parameters.map(
+              (parameter) => Object.freeze({
+                name: parameter.name,
+                type: Object.freeze({ ...parameter.type })
+              })
+            )
+          ),
+          returnType: Object.freeze({
+            ...result.traceClrWireContract.returnType
+          })
+        })
+      } : {}
     });
     let disposed = false;
     let disposePromise;
@@ -129789,6 +130597,7 @@ var CSharpRuntimeClient = class {
       executeIsolated: (preparedCall) => executeOwned(
         preparedCall,
         (preparedArtifact, forwardedCall) => this.withPreparedRunner(
+          preparedArtifact.preparedRunnerTier,
           (runner) => runner.executePreparedTrace(
             preparedArtifact,
             forwardedCall
@@ -129806,6 +130615,7 @@ var CSharpRuntimeClient = class {
         return executeOwned(
           preparedCall,
           (preparedArtifact, forwardedCall) => this.withFreshPreparedRunners(
+            preparedArtifact.preparedRunnerTier,
             forwardedCall.inputBatch,
             (runner, inputs, index) => runner.executePreparedTrace(
               preparedArtifact,
@@ -129829,12 +130639,14 @@ var CSharpRuntimeClient = class {
       executeIsolated: (preparedCall) => executeOwned(
         preparedCall,
         (preparedArtifact, forwardedCall) => this.withPreparedRunner(
+          preparedArtifact.preparedRunnerTier,
           (runner) => runner.executePreparedCode(preparedArtifact, forwardedCall)
         )
       ),
       executeBatchIsolated: (preparedCall) => executeOwned(
         preparedCall,
         (preparedArtifact, forwardedCall) => this.withFreshPreparedRunners(
+          preparedArtifact.preparedRunnerTier,
           forwardedCall.inputBatch,
           (runner, inputs) => runner.executePreparedCode(preparedArtifact, {
             inputs,
@@ -129911,8 +130723,8 @@ function createCSharpBrowserRuntimeProvider(options = {}) {
       const firefoxPreparedIdleTimeoutMs = isFirefoxBrowser() ? FIREFOX_PREPARED_WORKER_IDLE_TIMEOUT_MS : void 0;
       const compilerIdleTimeoutMs = options.compilerIdleTimeoutMs ?? firefoxPreparedIdleTimeoutMs;
       const runnerIdleTimeoutMs = options.runnerIdleTimeoutMs ?? options.workerIdleTimeoutMs ?? firefoxPreparedIdleTimeoutMs;
-      const dependencyUrls = (collection) => {
-        const descriptors = context2.manifestAssetCollection("csharp", collection);
+      const dependencyUrls = (collection2) => {
+        const descriptors = context2.manifestAssetCollection("csharp", collection2);
         return descriptors ? Object.fromEntries(
           Object.entries(descriptors).map(([name, descriptor3]) => [
             name,
@@ -130074,7 +130886,6 @@ function createCSharpBrowserRuntimeProvider(options = {}) {
         standbyWarmup = warmup;
         return warmup;
       };
-      void ensureStandbyRunner().catch(() => void 0);
       const preparedAuthority = preparedAuthorityEnabled ? {
         compiler,
         batchConcurrency: preparedBatchConcurrency,
@@ -130089,7 +130900,7 @@ function createCSharpBrowserRuntimeProvider(options = {}) {
             loadTimeMs: performance.now() - startedAt
           };
         },
-        createRunner() {
+        createRunner(_tier) {
           if (disposed) {
             throw new Error("C# browser runtime provider has been disposed.");
           }
@@ -137679,15 +138490,15 @@ function evaluateExpression(expression, context2, scope2) {
     }
     case "every":
     case "some": {
-      const collection = resolveValue(expression.collection, context2, scope2);
-      if (!Array.isArray(collection)) {
+      const collection2 = resolveValue(expression.collection, context2, scope2);
+      if (!Array.isArray(collection2)) {
         return Object.freeze({
           expression,
           result: "unknown",
           reason: "The quantified collection is missing or is not an array."
         });
       }
-      const children2 = collection.map(
+      const children2 = collection2.map(
         (item) => evaluateExpression(
           expression.condition,
           context2,
@@ -141119,22 +141930,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,
@@ -142549,6 +143351,7 @@ function createBrowserJudgeHostFromRuntimeHost(host, options = {}) {
     isLanguageSupported: host.isLanguageSupported.bind(host),
     preflightLanguage: host.preflightLanguage.bind(host),
     preflight: host.preflight.bind(host),
+    prewarmLanguage: host.prewarmLanguage.bind(host),
     warmLanguage: host.warmLanguage.bind(host),
     disposeLanguage: host.disposeLanguage.bind(host),
     createJudge: (judgeOptions) => createBrowserRuntimeJudge({