peachsim 0.1.2209 → 0.1.2213

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.2209 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.2213 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = '', __sootsim_import_meta_filename = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; __sootsim_import_meta_filename = __filename; } catch {}
 "use strict";
 var __create = Object.create;
@@ -14,8 +14,8 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -39,7 +39,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var define_SWIFT_COVERAGE_SOURCE_DIGESTS_default;
 var init_define_SWIFT_COVERAGE_SOURCE_DIGESTS = __esm({
   "<define:__SWIFT_COVERAGE_SOURCE_DIGESTS__>"() {
-    define_SWIFT_COVERAGE_SOURCE_DIGESTS_default = { "swift-coverage/indexdump.ts": "0d82d8eeb96bf377f409ea7e33274c341a710c0e071f6b6e17571a23d8d92412", "swift-coverage/indexing.ts": "633ccf19eec1f382a8847d0ee1dca42a2792a3c60aafd43622ed5152b09b8272", "swift-coverage/types.ts": "bd8fae54ea6c53e110cd8a5d7b57c1d532dd0166e09fdaea63c4f270c3780dd1", "swift-coverage/source.ts": "c151758a9f67631bc61473c375df0dc017da6902a34533b2cf4fc4fd7d19b6ee", "swift-coverage/package.ts": "1f0068be7461fa7c5a7a891faf318f305cbed2e94c19667ba76627f7e5be260b", "swift-coverage/xcode.ts": "65a500b806ce1c3a496de27f2e0ad77287c0f6795c618342c08af647f92af1fa", "swift-coverage/xcode-assets.ts": "99e03b74c961d2449afd58c2cbc415ba91d1d469a4f89e461c137fd6c305b27c", "swift-coverage/xcode-asset-symbols.ts": "1b2a67733bc9d139b351466270205452a6172140bc25080d72619e2952c44671", "swift-coverage/xcode-bridging.ts": "33184be8c5daf6646aa5a1276a4e15531f1be27b7c26f56550e0fbb1fc678a11", "swift-coverage/xcode-packages.ts": "8e6020d17d24474150a5a50d042aca6261819ef75c79680a287a66f395909915", "swift-coverage/xcode-strings.ts": "f2dd4c7cd8ef77035184b0132909c2fa09fd20ed06b7757c2f1f960bfdde031c", "swift-coverage/reader.ts": "da559b67ecd1161dea70c980b5f98f2c55af3550f0714479100fa5e9e813625c", "swift-coverage/provenance.ts": "eb3b41ae8b58b48f6758f084800f188dfb1edb227e483abdd6b80cde66e849b9", "swift-package-manifest.ts": "4b7d4a715cdaf57468ead23f2ff9dce76d02c6a888d73d144d4baa2ae571ba3c", "swift-package.ts": "338cfef9a34a930206ac2e1a8a90b85c8d61f776d9a41e6445dc18e0c5385cdb", "swift-source-file.ts": "93fd659ed63a27b67f54a7c229a7ceb636dc9c59e68414920ba36cff1eda1f94", "swift-toolchain.ts": "25505683ca29a0b380413bf2a5026d4967eacf886e35bc11ece6e15317e5bb02", "home-paths.ts": "673205c02bbc8e342a9b43585a3a1b5f6b64eb5fb474e1a8647e9d2c2e62e67d", "xcode-header-search.ts": "f8c3d557b4eca5ddad32907545353eb7ad53b2ebd0969d9ed8f7275e109a13b1", "xcode-project.ts": "86f79e98323ec065e0e5195324c75ca608f490efbd95dcc25c53d5aa0b9aecc9", "xcode-target-members.ts": "ad7589132bffab265e8a10b64e24484fe88b4a2b1cc0ee19a97f151a002eca77", "xcode-json-project.ts": "41990ebbe4b488eef34e74c4608b4b48e5a5b299ba98ca7fbcfdfa0e77be63b6", "openstep-plist.ts": "74e6ce1dac80c9c318e0e9f5e3e8cd19a898a8820c36fc160609695bcb59dcd3" };
+    define_SWIFT_COVERAGE_SOURCE_DIGESTS_default = { "swift-coverage/indexdump.ts": "0d82d8eeb96bf377f409ea7e33274c341a710c0e071f6b6e17571a23d8d92412", "swift-coverage/indexing.ts": "633ccf19eec1f382a8847d0ee1dca42a2792a3c60aafd43622ed5152b09b8272", "swift-coverage/types.ts": "bd8fae54ea6c53e110cd8a5d7b57c1d532dd0166e09fdaea63c4f270c3780dd1", "swift-coverage/source.ts": "c151758a9f67631bc61473c375df0dc017da6902a34533b2cf4fc4fd7d19b6ee", "swift-coverage/package.ts": "1f0068be7461fa7c5a7a891faf318f305cbed2e94c19667ba76627f7e5be260b", "swift-coverage/xcode.ts": "65a500b806ce1c3a496de27f2e0ad77287c0f6795c618342c08af647f92af1fa", "swift-coverage/xcode-assets.ts": "99e03b74c961d2449afd58c2cbc415ba91d1d469a4f89e461c137fd6c305b27c", "swift-coverage/xcode-asset-symbols.ts": "1b2a67733bc9d139b351466270205452a6172140bc25080d72619e2952c44671", "swift-coverage/xcode-bridging.ts": "33184be8c5daf6646aa5a1276a4e15531f1be27b7c26f56550e0fbb1fc678a11", "swift-coverage/xcode-packages.ts": "8e6020d17d24474150a5a50d042aca6261819ef75c79680a287a66f395909915", "swift-coverage/xcode-strings.ts": "f2dd4c7cd8ef77035184b0132909c2fa09fd20ed06b7757c2f1f960bfdde031c", "swift-coverage/reader.ts": "da559b67ecd1161dea70c980b5f98f2c55af3550f0714479100fa5e9e813625c", "swift-coverage/provenance.ts": "eb3b41ae8b58b48f6758f084800f188dfb1edb227e483abdd6b80cde66e849b9", "swift-package-manifest.ts": "4b7d4a715cdaf57468ead23f2ff9dce76d02c6a888d73d144d4baa2ae571ba3c", "swift-package.ts": "338cfef9a34a930206ac2e1a8a90b85c8d61f776d9a41e6445dc18e0c5385cdb", "swift-source-file.ts": "93fd659ed63a27b67f54a7c229a7ceb636dc9c59e68414920ba36cff1eda1f94", "swift-toolchain.ts": "25505683ca29a0b380413bf2a5026d4967eacf886e35bc11ece6e15317e5bb02", "home-paths.ts": "d1606390f0e8e50f0ff72544eadb3d49dfabf08e004c1218f2998c36fb8995dd", "xcode-header-search.ts": "f8c3d557b4eca5ddad32907545353eb7ad53b2ebd0969d9ed8f7275e109a13b1", "xcode-project.ts": "86f79e98323ec065e0e5195324c75ca608f490efbd95dcc25c53d5aa0b9aecc9", "xcode-target-members.ts": "ad7589132bffab265e8a10b64e24484fe88b4a2b1cc0ee19a97f151a002eca77", "xcode-json-project.ts": "41990ebbe4b488eef34e74c4608b4b48e5a5b299ba98ca7fbcfdfa0e77be63b6", "openstep-plist.ts": "74e6ce1dac80c9c318e0e9f5e3e8cd19a898a8820c36fc160609695bcb59dcd3" };
   }
 });
 
@@ -111,8 +111,8 @@ var require_parse = __commonJS({
       }
       return root;
     };
-    function internalize(holder, name, reviver) {
-      const value = holder[name];
+    function internalize(holder, name2, reviver) {
+      const value = holder[name2];
       if (value != null && typeof value === "object") {
         if (Array.isArray(value)) {
           for (let i = 0; i < value.length; i++) {
@@ -145,7 +145,7 @@ var require_parse = __commonJS({
           }
         }
       }
-      return reviver.call(holder, name, value);
+      return reviver.call(holder, name2, value);
     }
     var lexState;
     var buffer;
@@ -1185,9 +1185,9 @@ function nodeHttpFetch(url, init = {}, redirects = 0) {
           return;
         }
         const headers = new Headers();
-        for (const [name, value] of Object.entries(res.headers)) {
-          if (Array.isArray(value)) for (const entry of value) headers.append(name, entry);
-          else if (value !== void 0) headers.set(name, value);
+        for (const [name2, value] of Object.entries(res.headers)) {
+          if (Array.isArray(value)) for (const entry of value) headers.append(name2, entry);
+          else if (value !== void 0) headers.set(name2, value);
         }
         if (BODYLESS_STATUS.has(status)) {
           res.resume();
@@ -1199,13 +1199,13 @@ function nodeHttpFetch(url, init = {}, redirects = 0) {
         if (codings.every((coding) => DECODABLE_CODINGS.has(coding))) {
           for (const coding of codings.reverse()) {
             let decoder;
-            if (coding === "br") decoder = import_node_zlib2.default.createBrotliDecompress();
+            if (coding === "br") decoder = import_node_zlib3.default.createBrotliDecompress();
             else if (coding === "deflate") {
               let inner;
-              decoder = new import_node_stream.Transform({
+              decoder = new import_node_stream3.Transform({
                 transform(chunk, _encoding, done) {
                   if (!inner) {
-                    inner = (chunk[0] & 15) === 8 ? import_node_zlib2.default.createInflate(TRUNCATION_TOLERANT) : import_node_zlib2.default.createInflateRaw(TRUNCATION_TOLERANT);
+                    inner = (chunk[0] & 15) === 8 ? import_node_zlib3.default.createInflate(TRUNCATION_TOLERANT) : import_node_zlib3.default.createInflateRaw(TRUNCATION_TOLERANT);
                     inner.on("data", (data) => decoder.push(data));
                     inner.on("error", (error) => decoder.destroy(error));
                   }
@@ -1221,8 +1221,8 @@ function nodeHttpFetch(url, init = {}, redirects = 0) {
                   done(error);
                 }
               });
-            } else decoder = import_node_zlib2.default.createGunzip(TRUNCATION_TOLERANT);
-            source = (0, import_node_stream.pipeline)(source, decoder, () => {
+            } else decoder = import_node_zlib3.default.createGunzip(TRUNCATION_TOLERANT);
+            source = (0, import_node_stream3.pipeline)(source, decoder, () => {
             });
           }
         }
@@ -1250,17 +1250,17 @@ function nodeHttpFetch(url, init = {}, redirects = 0) {
     req.end();
   });
 }
-var import_node_http, import_node_https, import_node_stream, import_node_zlib2, BODYLESS_STATUS, TRUNCATION_TOLERANT, MAX_REDIRECTS, DECODABLE_CODINGS;
+var import_node_http, import_node_https, import_node_stream3, import_node_zlib3, BODYLESS_STATUS, TRUNCATION_TOLERANT, MAX_REDIRECTS, DECODABLE_CODINGS;
 var init_node_http_fetch = __esm({
   "src/node-http-fetch.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
     import_node_http = __toESM(require("node:http"), 1);
     import_node_https = __toESM(require("node:https"), 1);
-    import_node_stream = require("node:stream");
-    import_node_zlib2 = __toESM(require("node:zlib"), 1);
+    import_node_stream3 = require("node:stream");
+    import_node_zlib3 = __toESM(require("node:zlib"), 1);
     BODYLESS_STATUS = /* @__PURE__ */ new Set([101, 204, 205, 304]);
-    TRUNCATION_TOLERANT = { finishFlush: import_node_zlib2.default.constants.Z_SYNC_FLUSH };
+    TRUNCATION_TOLERANT = { finishFlush: import_node_zlib3.default.constants.Z_SYNC_FLUSH };
     MAX_REDIRECTS = 5;
     DECODABLE_CODINGS = /* @__PURE__ */ new Set(["gzip", "x-gzip", "deflate", "br"]);
   }
@@ -1275,12 +1275,12 @@ __export(vite_plugin_one_exports, {
 module.exports = __toCommonJS(vite_plugin_one_exports);
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 var import_fs4 = __toESM(require("fs"), 1);
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var import_node_http3 = __toESM(require("node:http"), 1);
 var import_node_https2 = __toESM(require("node:https"), 1);
 var import_node_url2 = require("node:url");
 var import_path4 = __toESM(require("path"), 1);
-var import_promises6 = require("stream/promises");
+var import_promises8 = require("stream/promises");
 
 // ../peach-globals/src/package-versions.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -1302,30 +1302,30 @@ function findBundleFooter(source, prefix) {
 function isFooterBlockLine(source, line, end) {
   return line === end || source.startsWith("globalThis.", line) || source.startsWith("//", line);
 }
-function readFooter(source, prefix, suffix, name) {
+function readFooter(source, prefix, suffix, name2) {
   const start = findBundleFooter(source, prefix);
   if (start < 0) return null;
   const end = source.indexOf("\n", start + 1);
   const line = source.slice(start + 1, end < 0 ? void 0 : end);
-  if (!line.endsWith(suffix)) throw new Error(`${name} footer is truncated`);
+  if (!line.endsWith(suffix)) throw new Error(`${name2} footer is truncated`);
   const value = JSON.parse(
     line.slice(prefix.length, suffix ? -suffix.length : void 0)
   );
-  if (value === null) throw new Error(`${name} footer has no metadata`);
+  if (value === null) throw new Error(`${name2} footer has no metadata`);
   return value;
 }
-function detachFooter(source, prefix, suffix, name) {
+function detachFooter(source, prefix, suffix, name2) {
   const start = findBundleFooter(source, prefix);
   if (start < 0) return { source, value: null };
-  const value = readFooter(source, prefix, suffix, name);
+  const value = readFooter(source, prefix, suffix, name2);
   const end = source.indexOf("\n", start + 1);
   return { source: source.slice(0, start) + (end < 0 ? "" : source.slice(end)), value };
 }
-function insertBundleGlobalFooter(source, name, value) {
-  return insertFooter(source, `globalThis.${name}=`, ";", name, value);
+function insertBundleGlobalFooter(source, name2, value) {
+  return insertFooter(source, `globalThis.${name2}=`, ";", name2, value);
 }
-function insertFooter(source, prefix, suffix, name, value) {
-  source = detachFooter(source, prefix, suffix, name).source;
+function insertFooter(source, prefix, suffix, name2, value) {
+  source = detachFooter(source, prefix, suffix, name2).source;
   const json = JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/<\//g, "<\\/");
   const footer = `
 ${prefix}${json}${suffix}`;
@@ -1342,11 +1342,11 @@ function readPackageVersions(value) {
     throw new Error("invalid package versions");
   }
   const versions = {};
-  for (const [name, version] of Object.entries(value)) {
-    if (name.length === 0 || typeof version !== "string" || version.length === 0) {
+  for (const [name2, version] of Object.entries(value)) {
+    if (name2.length === 0 || typeof version !== "string" || version.length === 0) {
       throw new Error("invalid package versions");
     }
-    versions[name] = version;
+    versions[name2] = version;
   }
   return versions;
 }
@@ -1365,8 +1365,8 @@ function resolveWorkletsStaticFlags(defaults, appManifest) {
     throw new Error("Worklets static flag overrides are malformed");
   }
   const flags = {};
-  for (const [name, value] of Object.entries({ ...defaults, ...overrides })) {
-    flags[name] = String(value) === "true";
+  for (const [name2, value] of Object.entries({ ...defaults, ...overrides })) {
+    flags[name2] = String(value) === "true";
   }
   return JSON.stringify(flags);
 }
@@ -1392,22 +1392,435 @@ var AUTOMATION_SIM_IDLE_REAP_TTL_MS = 5 * 6e4;
 
 // src/cli-runtime.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_crypto = require("node:crypto");
-var import_node_fs2 = require("node:fs");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs6 = require("node:fs");
 var import_node_module = require("node:module");
-var import_node_path2 = require("node:path");
+var import_node_path5 = require("node:path");
 
 // ../contrast-runtime-delivery/src/index.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_child_process3 = require("node:child_process");
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_stream2 = require("node:stream");
+var import_promises2 = require("node:stream/promises");
+var import_node_zlib = __toESM(require("node:zlib"), 1);
 
 // src/process-group.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var import_node_os2 = require("node:os");
+var import_node_path = require("node:path");
+var import_node_stream = require("node:stream");
+var import_promises = require("node:timers/promises");
 
 // src/process-table.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+function linuxClockTicks() {
+  const auxv = (0, import_node_fs.readFileSync)("/proc/self/auxv");
+  const word = (offset) => (0, import_node_os.endianness)() === "LE" ? auxv.readBigUInt64LE(offset) : auxv.readBigUInt64BE(offset);
+  for (let offset = 0; offset + 16 <= auxv.length; offset += 16) {
+    if (word(offset) !== 17n) continue;
+    const ticks = Number(word(offset + 8));
+    if (!Number.isSafeInteger(ticks) || ticks <= 0)
+      throw new Error("unreadable process clock tick rate");
+    return ticks;
+  }
+  throw new Error("missing process clock tick rate");
+}
+var clockTicks;
+function readProcessTable(timeoutMs = 1e4, pid) {
+  if (process.platform === "linux") {
+    clockTicks ??= linuxClockTicks();
+    const boot = /^btime (\d+)$/m.exec((0, import_node_fs.readFileSync)("/proc/stat", "utf8"));
+    if (!boot) throw new Error("unreadable process boot time");
+    const bootMs = Number(boot[1]) * 1e3;
+    const deadline = Date.now() + timeoutMs;
+    const rows2 = [];
+    const names = pid === void 0 ? (0, import_node_fs.readdirSync)("/proc") : [String(pid)];
+    for (const name2 of names) {
+      if (!/^\d+$/.test(name2)) continue;
+      if (Date.now() >= deadline)
+        throw new Error("process inspection exceeded its deadline");
+      let stat;
+      try {
+        stat = (0, import_node_fs.readFileSync)(`/proc/${name2}/stat`, "utf8");
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") continue;
+        throw error;
+      }
+      const fields = stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/);
+      const pgid = Number(fields[2]);
+      const ticks = Number(fields[19]);
+      if (!fields[0] || !Number.isSafeInteger(pgid) || !Number.isSafeInteger(ticks))
+        throw new Error(`unreadable process table row for ${name2}`);
+      rows2.push({
+        pid: Number(name2),
+        pgid,
+        zombie: fields[0] === "Z" || fields[0] === "X",
+        start: bootMs + ticks * 1e3 / clockTicks
+      });
+    }
+    return rows2;
+  }
+  const result = (0, import_node_child_process.spawnSync)(
+    "ps",
+    [
+      ...pid === void 0 ? ["-A"] : ["-p", String(pid)],
+      "-o",
+      "pid=,pgid=,stat=,lstart="
+    ],
+    {
+      encoding: "utf8",
+      env: { ...process.env, LC_ALL: "C", TZ: "UTC" },
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: timeoutMs,
+      killSignal: "SIGKILL"
+    }
+  );
+  if (!result.error && pid !== void 0 && result.status === 1 && !result.stdout.trim() && !result.stderr.trim())
+    return [];
+  if (result.error || result.status !== 0)
+    throw new Error(
+      result.error?.message || result.stderr.trim() || `ps exited ${result.status}`
+    );
+  const rows = result.stdout.split("\n").filter((line) => line.trim()).map((line) => {
+    const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/.exec(line);
+    if (!match) throw new Error(`unreadable process table row: ${line}`);
+    const start = Date.parse(`${match[4]} UTC`);
+    if (Number.isNaN(start))
+      throw new Error(`unreadable process start time "${match[4]}"`);
+    return {
+      pid: Number(match[1]),
+      pgid: Number(match[2]),
+      zombie: match[3].startsWith("Z"),
+      start
+    };
+  });
+  return pid === void 0 ? rows : rows.filter((row) => row.pid === pid);
+}
+
+// src/process-group.ts
+var GRACEFUL_TIMEOUT_MS = 3e3;
+var FORCED_EXIT_TIMEOUT_MS = 1e3;
+var FREEZE_GUARD_NAME = "process-freeze-guard";
+function listProcessChildren(parents, timeoutMs = 3e3) {
+  if (parents.some((pid) => !Number.isInteger(pid) || pid <= 1))
+    throw new Error("process inspection requires valid parent pids");
+  if (parents.length === 0) return [];
+  const deadline = Date.now() + timeoutMs;
+  let children;
+  if (process.platform === "linux") {
+    const lists = [];
+    for (const parent of parents) {
+      try {
+        const tasks = `/proc/${parent}/task`;
+        for (const thread of (0, import_node_fs2.readdirSync)(tasks)) {
+          if (Date.now() >= deadline)
+            throw new Error("process descendant inspection exceeded its deadline");
+          try {
+            lists.push((0, import_node_fs2.readFileSync)(`${tasks}/${thread}/children`, "utf8"));
+          } catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+              throw error;
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+          throw error;
+      }
+    }
+    children = lists.join(" ");
+  } else {
+    const result = (0, import_node_child_process2.spawnSync)("pgrep", ["-P", parents.join(",")], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: Math.max(1, timeoutMs),
+      killSignal: "SIGKILL"
+    });
+    if (result.error || result.status !== 0 && result.status !== 1) {
+      throw new Error(
+        `could not inspect descendants of processes ${parents.join(",")}: ${result.error?.message || result.stderr.trim() || `pgrep exited ${result.status}`}`
+      );
+    }
+    children = result.stdout;
+  }
+  return [...new Set(children.trim().split(/\s+/).map(Number))].filter(
+    (pid) => Number.isInteger(pid) && pid > 1 && !parents.includes(pid)
+  );
+}
+function signalProcessGroup(child, signal) {
+  if (!child.pid) return;
+  try {
+    process.kill(-child.pid, signal);
+  } catch {
+    try {
+      process.kill(child.pid, signal);
+    } catch {
+    }
+  }
+}
+async function protectProcessFreeze(rootPid) {
+  const directory = (0, import_node_fs2.mkdtempSync)((0, import_node_path.join)((0, import_node_os2.tmpdir)(), "peach-process-freeze-"));
+  const journal = (0, import_node_path.join)(directory, "targets");
+  (0, import_node_fs2.writeFileSync)(journal, `group ${rootPid}
+pid ${rootPid}
+`, { mode: 384 });
+  const guard = (0, import_node_child_process2.spawn)(
+    "/bin/sh",
+    [
+      "-c",
+      `
+    (
+    journal=$1
+    cleanup() {
+      trap '' HUP INT TERM
+      while read -r kind pid; do
+        case $kind in
+          group) target=-$pid ;;
+          pid) target=$pid ;;
+          *) continue ;;
+        esac
+        kill -TERM "$target" 2>/dev/null || :
+        kill -CONT "$target" 2>/dev/null || :
+      done < "$journal"
+    }
+    trap 'cleanup; exit 0' HUP INT TERM
+    trap 'rm -f "$journal"; rmdir "\${journal%/*}"' EXIT
+    printf 'ready
+'
+    if ! IFS= read -r command <&3 || [ "$command" != disarm ]; then cleanup; fi
+    ) &
+  `,
+      FREEZE_GUARD_NAME,
+      journal
+    ],
+    {
+      detached: true,
+      // the launcher exits before capture, reparenting the guard outside any
+      // nested target tree. fd 3 survives that exit, unlike child.stdin.
+      stdio: ["ignore", "pipe", "ignore", "pipe"]
+    }
+  );
+  let guardClosed = false;
+  const closed = new Promise(
+    (resolveClose) => guard.once("close", () => {
+      guardClosed = true;
+      resolveClose();
+    })
+  );
+  const control = guard.stdio[3];
+  const output = guard.stdout;
+  if (!(control instanceof import_node_stream.Duplex) || !output) {
+    guard.kill();
+    await closed;
+    (0, import_node_fs2.rmSync)(directory, { recursive: true, force: true });
+    throw new Error("process freeze guard control pipe is unavailable");
+  }
+  control.on("error", () => {
+  });
+  try {
+    await new Promise((resolveReady, reject) => {
+      let readyOutput = "";
+      let launcherExited = false;
+      const ready = () => {
+        if (launcherExited && readyOutput.includes("ready\n")) resolveReady();
+      };
+      output.on("data", (bytes) => {
+        readyOutput += bytes.toString();
+        ready();
+      });
+      guard.once("exit", (code, signal) => {
+        if (code !== 0 || signal !== null) {
+          reject(new Error("process freeze guard launcher failed"));
+          return;
+        }
+        launcherExited = true;
+        ready();
+      });
+      guard.once("error", reject);
+      guard.once(
+        "close",
+        () => reject(new Error("process freeze guard exited before readiness"))
+      );
+    });
+  } catch (error) {
+    control.destroy();
+    await closed;
+    (0, import_node_fs2.rmSync)(directory, { recursive: true, force: true });
+    throw error;
+  }
+  return {
+    record(pid) {
+      if (guardClosed || control.destroyed)
+        throw new Error("process freeze guard exited during capture");
+      (0, import_node_fs2.appendFileSync)(journal, `pid ${pid}
+`);
+    },
+    async release(disarm) {
+      control.end(disarm ? "disarm\n" : void 0);
+      await closed;
+      (0, import_node_fs2.rmSync)(directory, { recursive: true, force: true });
+    }
+  };
+}
+function processesHaveExited(pids, pgid) {
+  const mayExist = [-pgid, ...pids].some((target) => {
+    try {
+      process.kill(target, 0);
+      return true;
+    } catch (error) {
+      return !(error instanceof Error && "code" in error && error.code === "ESRCH");
+    }
+  });
+  if (!mayExist) return true;
+  const knownPids = new Set(pids);
+  try {
+    return !readProcessTable(FORCED_EXIT_TIMEOUT_MS).some(
+      (row) => (row.pgid === pgid || knownPids.has(row.pid)) && !row.zombie
+    );
+  } catch {
+    return false;
+  }
+}
+function groupIsEmpty(pgid) {
+  return processesHaveExited([], pgid);
+}
+async function waitForExit(pids, pgid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const gone = () => processesHaveExited(pids, pgid);
+  while (Date.now() < deadline) {
+    if (gone()) return true;
+    await (0, import_promises.setTimeout)(50);
+  }
+  return gone();
+}
+async function terminateProcessGroup(child, signal = "SIGTERM", gracefulTimeoutMs = GRACEFUL_TIMEOUT_MS) {
+  if (!child.pid) {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+    return;
+  }
+  if (child.exitCode !== null || child.signalCode !== null) {
+    if (groupIsEmpty(child.pid)) return;
+  }
+  const freeze = await protectProcessFreeze(child.pid);
+  const descendants = /* @__PURE__ */ new Set();
+  let inspectionError = null;
+  let signaled = false;
+  let gracefulDeadline = 0;
+  try {
+    signalProcessGroup(child, "SIGSTOP");
+    let parents = [child.pid];
+    const inspectionDeadline = Date.now() + GRACEFUL_TIMEOUT_MS;
+    while (parents.length > 0) {
+      const remaining = inspectionDeadline - Date.now();
+      if (remaining <= 0) {
+        inspectionError = new Error("process descendant inspection exceeded its deadline");
+        break;
+      }
+      let children;
+      try {
+        children = listProcessChildren(parents, remaining);
+      } catch (error) {
+        inspectionError = new Error(`could not inspect descendants: ${String(error)}`);
+        break;
+      }
+      const next = [];
+      for (const descendantPid of children) {
+        if (!descendants.has(descendantPid)) {
+          freeze.record(descendantPid);
+          descendants.add(descendantPid);
+          next.push(descendantPid);
+          try {
+            process.kill(descendantPid, "SIGSTOP");
+          } catch {
+          }
+        }
+      }
+      parents = next;
+    }
+    gracefulDeadline = Date.now() + gracefulTimeoutMs;
+    try {
+      process.kill(child.pid, signal);
+    } catch {
+    }
+    signaled = true;
+  } finally {
+    signalProcessGroup(child, "SIGCONT");
+    for (const pid of descendants) {
+      try {
+        process.kill(pid, "SIGCONT");
+      } catch {
+      }
+    }
+    await freeze.release(signaled);
+  }
+  const pids = [child.pid, ...descendants];
+  let rootExited = child.exitCode !== null || child.signalCode !== null;
+  if (!rootExited) {
+    rootExited = await new Promise((resolveExit) => {
+      const onExit = () => {
+        clearTimeout(deadlineTimer);
+        resolveExit(true);
+      };
+      const deadlineTimer = setTimeout(
+        () => {
+          child.removeListener("exit", onExit);
+          resolveExit(false);
+        },
+        Math.max(0, gracefulDeadline - Date.now())
+      );
+      child.once("exit", onExit);
+      if (child.exitCode !== null || child.signalCode !== null) {
+        child.removeListener("exit", onExit);
+        onExit();
+      }
+    });
+  }
+  if (rootExited) {
+    signalProcessGroup(child, signal);
+    for (const pid of descendants) {
+      try {
+        process.kill(pid, signal);
+      } catch {
+      }
+    }
+  }
+  if (await waitForExit(pids, child.pid, Math.max(0, gracefulDeadline - Date.now()))) {
+    if (inspectionError) throw inspectionError;
+    return;
+  }
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  signalProcessGroup(child, "SIGKILL");
+  const gone = await waitForExit(pids, child.pid, FORCED_EXIT_TIMEOUT_MS);
+  if (!gone) {
+    const survivors = new Error(
+      `process group ${child.pid} exit could not be confirmed after SIGKILL`
+    );
+    if (!inspectionError) throw survivors;
+    throw new Error(`${inspectionError.message}; ${survivors.message}`);
+  }
+  if (inspectionError) throw inspectionError;
+}
 
 // ../contrast-runtime-delivery/src/product.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
 
 // ../contrast-runtime-delivery/src/version.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -1415,8 +1828,562 @@ function isValidRuntimeVersion(value) {
   return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);
 }
 
+// ../contrast-runtime-delivery/src/product.ts
+function listInstalledRuntimes(product) {
+  try {
+    return import_node_fs3.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+  } catch {
+    return [];
+  }
+}
+function runtimeTarballCacheName(product, version) {
+  return import_node_path2.default.posix.basename(product.tarballPath(version));
+}
+function compareSemver(a, b) {
+  const parse7 = (v6) => {
+    const hyphen = v6.indexOf("-");
+    const core = hyphen >= 0 ? v6.slice(0, hyphen) : v6;
+    const pre = hyphen >= 0 ? v6.slice(hyphen + 1) : "";
+    const parts = core.split(".").map((n) => Number.parseInt(n, 10));
+    if (parts.some((n) => !Number.isFinite(n))) return [[Number.POSITIVE_INFINITY], v6];
+    return [parts, pre];
+  };
+  const [an, ap] = parse7(a);
+  const [bn, bp] = parse7(b);
+  for (let i = 0; i < Math.max(an.length, bn.length); i++) {
+    const av = an[i] ?? 0;
+    const bv = bn[i] ?? 0;
+    if (av !== bv) return av - bv;
+  }
+  if (ap === bp) return 0;
+  if (!ap) return 1;
+  if (!bp) return -1;
+  return ap < bp ? -1 : 1;
+}
+
+// ../contrast-runtime-delivery/src/packs.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var RUNTIME_PACKS_FILE = "packs.json";
+var RUNTIME_PACK_MARKER = ".pack";
+var RUNTIME_PACK_PREFIXES = [
+  "engine/fonts/emoji/",
+  "engine/fonts/lang/",
+  "engine/fonts/named/",
+  "engine/fonts/vector-icons/",
+  "engine/fonts/webview/",
+  "engine/kotlin/",
+  "engine/material-symbols/",
+  "engine/pdfjs/",
+  "three-mode/"
+];
+var RUNTIME_MERGE_PACK_DIR = "engine-tenant/";
+var RUNTIME_MERGE_PACK_INSTALL = ".pack-prod";
+var RUNTIME_MERGE_PACK_MERGED = ".merged";
+
+// ../contrast-runtime-delivery/src/index.ts
+var DEFAULT_LOCAL_RUNTIME_RETENTION_COUNT = 2;
+function createRuntimeDelivery(product) {
+  function readConfig2() {
+    try {
+      const parsed = JSON.parse(
+        import_node_fs4.default.readFileSync(product.configFile(), "utf8")
+      );
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  function resolveCdnOrigin(input) {
+    const config = readConfig2();
+    const value = input || process.env[product.env.cdnOrigin] || config.cdnOrigin || product.defaultCdnOrigin;
+    return value.replace(/\/+$/, "");
+  }
+  function resolveChannel(input) {
+    const config = readConfig2();
+    return input || process.env[product.env.channel] || config.runtimeChannel || product.defaultChannel || "stable";
+  }
+  function resolvePin() {
+    if (!product.env.pin) return null;
+    const env = process.env[product.env.pin];
+    if (env && env.trim()) return env.trim();
+    const config = readConfig2();
+    return typeof config.runtimeVersion === "string" && config.runtimeVersion.trim() ? config.runtimeVersion.trim() : null;
+  }
+  function manifestUrl(cdnOrigin) {
+    const url = new URL(`${resolveCdnOrigin(cdnOrigin)}${product.manifestPath}`);
+    url.searchParams.set("t", String(Date.now()));
+    return url.toString();
+  }
+  function tarballUrl(version, cdnOrigin) {
+    return `${resolveCdnOrigin(cdnOrigin)}${product.tarballPath(version)}`;
+  }
+  const UP_TO_DATE_CHECK_TIMEOUT_MS = 2e3;
+  async function fetchManifest(cdnOrigin, timeoutMs) {
+    const url = manifestUrl(cdnOrigin);
+    const res = await fetch(url, {
+      headers: { Accept: "application/json" },
+      // an install is allowed to wait; a best-effort check is not. see
+      // UP_TO_DATE_CHECK_TIMEOUT_MS.
+      ...timeoutMs ? { signal: AbortSignal.timeout(timeoutMs) } : {}
+    });
+    if (!res.ok) {
+      throw new Error(`manifest fetch failed: ${res.status} ${res.statusText} (${url})`);
+    }
+    return await res.json();
+  }
+  function resolveVersion(manifest, opts = {}) {
+    const channel = resolveChannel(opts.channel);
+    const version = opts.version || resolvePin() || manifest.channels[channel]?.latest;
+    if (!version) {
+      throw new Error(
+        `no version specified and channel '${channel}' has no latest entry in the manifest`
+      );
+    }
+    if (!isValidRuntimeVersion(version)) {
+      throw new Error(`invalid runtime version: ${version}`);
+    }
+    const entry = manifest.versions[version];
+    if (!entry) {
+      throw new Error(
+        `version ${version} not found in manifest; available: ${Object.keys(manifest.versions).slice(-10).join(", ") || "(none)"}`
+      );
+    }
+    return { version, channel, entry };
+  }
+  async function isVerifiedInstall(dir) {
+    if (!import_node_fs4.default.existsSync(import_node_path3.default.join(dir, product.installedMarker))) return false;
+    try {
+      await product.verifyInstall?.(dir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async function install(opts = {}) {
+    product.ensureHome();
+    const cdnOrigin = resolveCdnOrigin(opts.cdnOrigin);
+    const manifest = await fetchManifest(cdnOrigin);
+    const { version, channel, entry } = resolveVersion(manifest, opts);
+    const destDir = product.runtimeDir(version);
+    const setActive = opts.setActive !== false;
+    const protectVersions = [version, ...opts.protectVersions ?? []];
+    pruneLocalRetention({ protectVersions });
+    if (!opts.force && await isVerifiedInstall(destDir)) {
+      if (setActive) product.writeActiveRuntime(version);
+      pruneLocalRetention({ protectVersions });
+      return {
+        version,
+        channel,
+        cdnOrigin,
+        runtimeDir: destDir,
+        installed: false,
+        activated: setActive,
+        manifest
+      };
+    }
+    if (!opts.quiet)
+      process.stderr.write(`${product.id}: downloading runtime ${version}\u2026
+`);
+    await installVerifiedTarball({
+      url: entry.tarball || tarballUrl(version, cdnOrigin),
+      digest: { algorithm: "sha256", encoding: "hex", value: entry.sha256 },
+      destDir,
+      installedMarker: product.installedMarker,
+      verify: product.verifyInstall,
+      label: `runtime ${version}`
+    });
+    if (setActive) product.writeActiveRuntime(version);
+    pruneLocalRetention({ protectVersions });
+    return {
+      version,
+      channel,
+      cdnOrigin,
+      runtimeDir: destDir,
+      installed: true,
+      activated: setActive,
+      manifest
+    };
+  }
+  async function updateToLatest(opts = {}) {
+    product.ensureHome();
+    pruneLocalRetention({ protectVersions: opts.protectVersions });
+    const cdnOrigin = resolveCdnOrigin(opts.cdnOrigin);
+    const channel = resolveChannel(opts.channel);
+    const pin = resolvePin();
+    if (pin) {
+      const activeVersion2 = product.readActiveRuntime();
+      const pinInstalled = await isVerifiedInstall(product.runtimeDir(pin));
+      if (activeVersion2 === pin && pinInstalled) {
+        return {
+          checked: true,
+          updated: false,
+          reason: `runtime is pinned to ${pin}`,
+          activeVersion: activeVersion2,
+          latestVersion: pin
+        };
+      }
+      const installed2 = await install({
+        version: pin,
+        channel,
+        cdnOrigin,
+        setActive: false,
+        protectVersions: opts.protectVersions
+      });
+      return {
+        checked: true,
+        updated: true,
+        reason: `runtime is pinned to ${pin}`,
+        activeVersion: pin,
+        latestVersion: pin,
+        install: installed2
+      };
+    }
+    const manifest = await fetchManifest(cdnOrigin);
+    const latestVersion = manifest.channels[channel]?.latest;
+    if (!latestVersion) {
+      return {
+        checked: true,
+        updated: false,
+        reason: `channel '${channel}' has no latest runtime`,
+        activeVersion: product.readActiveRuntime()
+      };
+    }
+    const entry = manifest.versions[latestVersion];
+    if (!entry) {
+      return {
+        checked: true,
+        updated: false,
+        reason: `manifest is missing version ${latestVersion}`,
+        activeVersion: product.readActiveRuntime(),
+        latestVersion
+      };
+    }
+    const activeVersion = product.readActiveRuntime();
+    const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
+    const activeInstalled = activeDir ? await isVerifiedInstall(activeDir) : false;
+    const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
+    if (!shouldInstall) {
+      return {
+        checked: true,
+        updated: false,
+        reason: "active runtime is current",
+        activeVersion,
+        latestVersion
+      };
+    }
+    const installed = await install({
+      version: latestVersion,
+      channel,
+      cdnOrigin,
+      setActive: false,
+      protectVersions: opts.protectVersions
+    });
+    return {
+      checked: true,
+      updated: true,
+      activeVersion: latestVersion,
+      latestVersion,
+      install: installed
+    };
+  }
+  async function checkUpToDate(opts = {}) {
+    const active = product.readActiveRuntime();
+    const pinned = resolvePin();
+    if (pinned) {
+      return { active, latest: pinned, pinned, outdated: active !== pinned };
+    }
+    try {
+      const manifest = await fetchManifest(
+        resolveCdnOrigin(opts.cdnOrigin),
+        UP_TO_DATE_CHECK_TIMEOUT_MS
+      );
+      const channel = resolveChannel(opts.channel);
+      const latest = manifest.channels[channel]?.latest ?? null;
+      const outdated = !!(latest && (!active || compareSemver(latest, active) > 0));
+      return { active, latest, pinned: null, outdated };
+    } catch {
+      return { active, latest: null, pinned: null, outdated: false };
+    }
+  }
+  function planLocalRetention(opts = {}) {
+    product.ensureHome();
+    const retainVersions = Math.max(
+      1,
+      Math.floor(opts.retainVersions ?? DEFAULT_LOCAL_RUNTIME_RETENTION_COUNT)
+    );
+    const installed = listInstalledRuntimes(product);
+    const installedSet = new Set(installed);
+    const activeVersion = product.readActiveRuntime();
+    const pinnedVersion = resolvePin();
+    const keep = /* @__PURE__ */ new Set();
+    for (const version of [
+      activeVersion,
+      pinnedVersion,
+      ...opts.protectVersions ?? []
+    ]) {
+      if (version && installedSet.has(version)) keep.add(version);
+    }
+    for (const version of [...installed].reverse()) {
+      if (keep.size >= retainVersions) break;
+      keep.add(version);
+    }
+    const cacheTemplateMarker = "__RUNTIME_VERSION__";
+    const cacheTemplate = runtimeTarballCacheName(product, cacheTemplateMarker);
+    const markerOffset = cacheTemplate.indexOf(cacheTemplateMarker);
+    const cachePrefix = cacheTemplate.slice(0, markerOffset);
+    const cacheSuffix = cacheTemplate.slice(markerOffset + cacheTemplateMarker.length);
+    let removeCacheFiles = [];
+    if (markerOffset >= 0) {
+      try {
+        removeCacheFiles = import_node_fs4.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
+          if (!entry.isFile()) return false;
+          const complete = entry.name.startsWith(cachePrefix) && entry.name.endsWith(cacheSuffix);
+          const partial = entry.name.startsWith(cachePrefix) && entry.name.endsWith(`${cacheSuffix}.partial`);
+          return complete || partial;
+        }).map((entry) => import_node_path3.default.join(product.cacheDir(), entry.name)).sort();
+      } catch {
+      }
+    }
+    return {
+      activeVersion,
+      pinnedVersion,
+      keepVersions: installed.filter((version) => keep.has(version)),
+      removeVersions: installed.filter((version) => !keep.has(version)),
+      removeCacheFiles
+    };
+  }
+  function pruneLocalRetention(opts = {}) {
+    const plan = planLocalRetention(opts);
+    for (const version of plan.removeVersions) {
+      import_node_fs4.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
+    }
+    for (const cacheFile of plan.removeCacheFiles) {
+      import_node_fs4.default.rmSync(cacheFile, { force: true });
+    }
+    return plan;
+  }
+  return {
+    product,
+    resolveCdnOrigin,
+    resolveChannel,
+    resolvePin,
+    manifestUrl,
+    tarballUrl,
+    fetchManifest,
+    resolveVersion,
+    install,
+    updateToLatest,
+    checkUpToDate,
+    planLocalRetention,
+    pruneLocalRetention,
+    listInstalled: () => listInstalledRuntimes(product)
+  };
+}
+async function installVerifiedTarball(tarball) {
+  const { destDir, installedMarker, signal } = tarball;
+  import_node_fs4.default.mkdirSync(import_node_path3.default.dirname(destDir), { recursive: true });
+  const presentAtStart = import_node_fs4.default.existsSync(import_node_path3.default.join(destDir, installedMarker));
+  const lock = `${destDir}.lock`;
+  for (; ; ) {
+    signal?.throwIfAborted();
+    try {
+      import_node_fs4.default.writeFileSync(lock, String(process.pid), { flag: "wx" });
+      break;
+    } catch (err) {
+      if (!isErrnoCode(err, "EEXIST")) throw err;
+      if (lockOwnerGone(lock)) import_node_fs4.default.rmSync(lock, { force: true });
+      else await new Promise((resolve3) => setTimeout(resolve3, 250));
+    }
+  }
+  try {
+    if (!presentAtStart && import_node_fs4.default.existsSync(import_node_path3.default.join(destDir, installedMarker))) {
+      await tarball.verify?.(destDir);
+      return;
+    }
+    await installVerifiedTarballLocked(tarball, presentAtStart);
+  } finally {
+    import_node_fs4.default.rmSync(lock, { force: true });
+  }
+}
+function lockOwnerGone(lock) {
+  try {
+    process.kill(Number(import_node_fs4.default.readFileSync(lock, "utf8")), 0);
+    return false;
+  } catch (err) {
+    return !isErrnoCode(err, "EPERM", "ENOENT");
+  }
+}
+async function installVerifiedTarballLocked(tarball, presentAtStart) {
+  const { url, digest, destDir, installedMarker, label, signal } = tarball;
+  signal?.throwIfAborted();
+  const downloadDir = import_node_fs4.default.mkdtempSync(import_node_path3.default.join(import_node_os3.default.tmpdir(), "runtime-delivery-download-"));
+  const archivePath = import_node_path3.default.join(downloadDir, "archive");
+  const tmpDir = import_node_fs4.default.mkdtempSync(
+    import_node_path3.default.join(import_node_path3.default.dirname(destDir), `.installing-${import_node_path3.default.basename(destDir)}-`)
+  );
+  try {
+    await downloadToFile(url, archivePath, signal);
+    const actual = await digestFile(
+      archivePath,
+      digest.algorithm,
+      digest.encoding,
+      signal
+    );
+    if (actual !== digest.value) {
+      throw new Error(
+        `${digest.algorithm} mismatch for ${label}: expected ${digest.value}, actual ${actual}`
+      );
+    }
+    const { pathname } = new URL(url);
+    if (pathname.endsWith(".zip")) await extractZip(archivePath, tmpDir, signal);
+    else
+      await extractTarball(
+        archivePath,
+        pathname.endsWith(".tar.zst"),
+        tmpDir,
+        tarball.stripComponents ?? 0,
+        signal
+      );
+    signal?.throwIfAborted();
+    if (!import_node_fs4.default.existsSync(import_node_path3.default.join(tmpDir, installedMarker))) {
+      throw new Error(`extracted tarball for ${label} is missing ${installedMarker}`);
+    }
+    await tarball.verify?.(tmpDir);
+    signal?.throwIfAborted();
+    try {
+      import_node_fs4.default.renameSync(tmpDir, destDir);
+    } catch (err) {
+      if (!isErrnoCode(err, "ENOTEMPTY", "EEXIST")) throw err;
+      if (!presentAtStart && import_node_fs4.default.existsSync(import_node_path3.default.join(destDir, installedMarker))) {
+        await tarball.verify?.(destDir);
+        return;
+      }
+      const aside = `${tmpDir}-replaced`;
+      try {
+        import_node_fs4.default.renameSync(destDir, aside);
+      } catch (moveErr) {
+        if (!isErrnoCode(moveErr, "ENOENT")) throw moveErr;
+      }
+      try {
+        import_node_fs4.default.renameSync(tmpDir, destDir);
+      } catch (landErr) {
+        if (!isErrnoCode(landErr, "ENOTEMPTY", "EEXIST") || !import_node_fs4.default.existsSync(import_node_path3.default.join(destDir, installedMarker))) {
+          throw landErr;
+        }
+        await tarball.verify?.(destDir);
+      } finally {
+        import_node_fs4.default.rmSync(aside, { recursive: true, force: true });
+      }
+    }
+  } finally {
+    import_node_fs4.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs4.default.rmSync(downloadDir, { recursive: true, force: true });
+  }
+}
+function isErrnoCode(err, ...codes) {
+  return err instanceof Error && "code" in err && codes.includes(String(err.code));
+}
+async function downloadToFile(url, destPath, signal) {
+  const res = await fetch(url, { signal });
+  if (!res.ok || !res.body) {
+    throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
+  }
+  import_node_fs4.default.mkdirSync(import_node_path3.default.dirname(destPath), { recursive: true });
+  const tmp = `${destPath}.partial`;
+  try {
+    await (0, import_promises2.pipeline)(
+      import_node_stream2.Readable.fromWeb(res.body),
+      import_node_fs4.default.createWriteStream(tmp),
+      { signal }
+    );
+    signal?.throwIfAborted();
+    import_node_fs4.default.renameSync(tmp, destPath);
+  } catch (err) {
+    try {
+      import_node_fs4.default.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function digestFile(filePath, algorithm, encoding, signal) {
+  const hash = import_node_crypto.default.createHash(algorithm);
+  await (0, import_promises2.pipeline)(import_node_fs4.default.createReadStream(filePath), hash, { signal });
+  return hash.digest(encoding);
+}
+function extractZip(zipPath, destDir, signal) {
+  return runExtractor("ditto", ["-x", "-k", zipPath, destDir], signal);
+}
+async function extractTarball(tarPath, zstd, destDir, stripComponents, signal) {
+  const args = [zstd ? "-xf" : "-xzf", "-"];
+  if (stripComponents > 0) args.push(`--strip-components=${stripComponents}`);
+  if (zstd) {
+    const decoder = import_node_zlib.default.createZstdDecompress({
+      params: { [import_node_zlib.default.constants.ZSTD_d_windowLogMax]: 30 }
+    });
+    await runExtractor("tar", args, signal, {
+      cwd: destDir,
+      stdin: (stdin) => (0, import_promises2.pipeline)(import_node_fs4.default.createReadStream(tarPath), decoder, stdin, { signal })
+    });
+    return;
+  }
+  const archive = import_node_fs4.default.openSync(tarPath, "r");
+  try {
+    await runExtractor("tar", args, signal, { cwd: destDir, stdin: archive });
+  } finally {
+    import_node_fs4.default.closeSync(archive);
+  }
+}
+async function runExtractor(command, args, signal, input) {
+  signal?.throwIfAborted();
+  const stdin = input?.stdin;
+  const stdio = [
+    typeof stdin === "function" ? "pipe" : stdin ?? "ignore",
+    "inherit",
+    "inherit"
+  ];
+  const child = (0, import_node_child_process3.spawn)(command, args, {
+    cwd: input?.cwd,
+    stdio,
+    detached: process.platform !== "win32"
+  });
+  const fed = typeof stdin === "function" && child.stdin ? stdin(child.stdin) : void 0;
+  void fed?.catch(() => {
+  });
+  let stopping;
+  const abort = () => {
+    stopping ??= terminateProcessGroup(child, "SIGKILL", 0);
+    void stopping.catch(() => {
+    });
+  };
+  try {
+    await new Promise((resolve3, reject) => {
+      let failure;
+      child.on("error", (error) => {
+        failure = error;
+      });
+      child.on("close", (code) => {
+        if (signal?.aborted) {
+          const reason = signal.reason;
+          reject(
+            reason instanceof Error ? reason : new Error("Extraction canceled", { cause: reason })
+          );
+        } else if (failure) reject(failure);
+        else if (code === 0) resolve3();
+        else reject(new Error(`${command} exited with code ${code}`));
+      });
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+    });
+    await fed;
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    await stopping;
+  }
+}
+
 // runtime-companion.json
-var runtime_companion_default = { abi: 1, sha256: "8d817e4a68a084ba50456a80439f20c8aa11c055d42c9cf1c7de017062bfd4a2", file: "node/cli-8d817e4a68a084ba50456a80439f20c8aa11c055d42c9cf1c7de017062bfd4a2.cjs" };
+var runtime_companion_default = { abi: 1, sha256: "1c15d055a3e1e68a17d3f735cd1c592fdc418c85e781e44abf4f4aa0b1215b52", file: "node/cli-1c15d055a3e1e68a17d3f735cd1c592fdc418c85e781e44abf4f4aa0b1215b52.cjs" };
 
 // src/answeredNativePackages.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -1429,50 +2396,72 @@ var import_url = require("url");
 
 // src/home-paths.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_os = require("node:os");
-var import_node_path = __toESM(require("node:path"), 1);
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_os4 = require("node:os");
+var import_node_path4 = __toESM(require("node:path"), 1);
 var PEACH_HOME_ENV = "PEACH_HOME";
 var ACTIVE_RUNTIME_FILE = "active";
 var DAEMON_LOCKFILE = "daemon.json";
+var CONFIG_FILE = "config.json";
 var DAEMON_HEARTBEAT_STALE_MS = 3e4;
 function ambientHomeDir() {
-  return import_node_path.default.join((0, import_node_os.homedir)(), ".peach");
+  return import_node_path4.default.join((0, import_node_os4.homedir)(), ".peach");
 }
 function rnxHomeDir() {
   const override = process.env[PEACH_HOME_ENV];
-  return override && override.length > 0 ? import_node_path.default.resolve(override) : ambientHomeDir();
+  return override && override.length > 0 ? import_node_path4.default.resolve(override) : ambientHomeDir();
 }
 function runtimesDir() {
-  return import_node_path.default.join(rnxHomeDir(), "runtimes");
+  return import_node_path4.default.join(rnxHomeDir(), "runtimes");
 }
 function runtimeDir(version) {
-  return import_node_path.default.join(runtimesDir(), version);
+  return import_node_path4.default.join(runtimesDir(), version);
 }
 function activeRuntimeFile() {
-  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+  return import_node_path4.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function electronDir() {
+  return import_node_path4.default.join(rnxHomeDir(), "electron");
+}
+function profilesDir() {
+  return import_node_path4.default.join(rnxHomeDir(), "profiles");
 }
 function cacheDir() {
-  return import_node_path.default.join(rnxHomeDir(), "cache");
+  return import_node_path4.default.join(rnxHomeDir(), "cache");
 }
 function daemonLockfilePath() {
-  return import_node_path.default.join(rnxHomeDir(), DAEMON_LOCKFILE);
+  return import_node_path4.default.join(rnxHomeDir(), DAEMON_LOCKFILE);
+}
+function configFilePath() {
+  return import_node_path4.default.join(rnxHomeDir(), CONFIG_FILE);
+}
+function ensureRnxHome() {
+  import_node_fs5.default.mkdirSync(rnxHomeDir(), { recursive: true });
+  import_node_fs5.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs5.default.mkdirSync(electronDir(), { recursive: true });
+  import_node_fs5.default.mkdirSync(profilesDir(), { recursive: true });
+  import_node_fs5.default.mkdirSync(cacheDir(), { recursive: true });
 }
 function readActiveRuntime() {
   try {
-    const value = import_node_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    const value = import_node_fs5.default.readFileSync(activeRuntimeFile(), "utf8").trim();
     return value.length > 0 ? value : null;
   } catch {
     return null;
   }
 }
+function writeActiveRuntime(version) {
+  import_node_fs5.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs5.default.writeFileSync(activeRuntimeFile(), `${version}
+`, "utf8");
+}
 var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
 function readDaemonLockfile() {
   try {
-    const fd = import_node_fs.default.openSync(daemonLockfilePath(), "r");
+    const fd = import_node_fs5.default.openSync(daemonLockfilePath(), "r");
     try {
       const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-      const bytesRead = import_node_fs.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const bytesRead = import_node_fs5.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
       const raw = buf.subarray(0, bytesRead).toString("utf8");
       const parsed = JSON.parse(raw);
       if (parsed && parsed.schema === 1 && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.cliVersion === void 0 || typeof parsed.cliVersion === "string") && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
@@ -1480,7 +2469,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs.default.closeSync(fd);
+      import_node_fs5.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -1560,7 +2549,6 @@ var ROOT_RUNTIME_PATHS = [
   "/fonts/",
   "/icons/",
   "/sounds/",
-  "/spike/",
   "/test-wallpaper.jpg",
   "/preview-sw.js",
   "/preview/guest-bridge-host.js",
@@ -1715,12 +2703,12 @@ function cliCompanionPath() {
   return `node/cli-${runtime_companion_default.sha256}.cjs`;
 }
 function verifyCliCompanion(root) {
-  verifyCompanionFile((0, import_node_path2.join)(root, cliCompanionPath()));
+  verifyCompanionFile((0, import_node_path5.join)(root, cliCompanionPath()));
 }
 function verifyCompanionFile(file) {
   let bytes;
   try {
-    bytes = (0, import_node_fs2.readFileSync)(file);
+    bytes = (0, import_node_fs6.readFileSync)(file);
   } catch (error) {
     if (error instanceof Error) {
       const missing2 = "code" in error && error.code === "ENOENT" ? `; run \`peach runtime install\`, which fetches the companion this CLI published${process.platform === "win32" ? ", and check Windows Security protection history if it repeats" : ""}` : "";
@@ -1728,20 +2716,41 @@ function verifyCompanionFile(file) {
     }
     throw error;
   }
-  const hash = (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+  const hash = (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex");
   if (hash !== runtime_companion_default.sha256) {
     throw new Error(
       "Peach runtime companion does not match this CLI; run `peach runtime install`"
     );
   }
 }
+async function ensureCliCompanion(root) {
+  const file = (0, import_node_path5.join)(root, cliCompanionPath());
+  try {
+    verifyCompanionFile(file);
+    return;
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+      throw error;
+  }
+  const staged = `${file}.${process.pid}`;
+  try {
+    await downloadToFile(
+      `https://r2.rnxsim.com/rnx-cli/companions/cli-${runtime_companion_default.sha256}.cjs`,
+      staged
+    );
+    verifyCompanionFile(staged);
+    (0, import_node_fs6.renameSync)(staged, file);
+  } finally {
+    (0, import_node_fs6.rmSync)(staged, { force: true });
+  }
+}
 var loaded;
 function getCliRuntime() {
   if (loaded) return loaded.runtime;
   const root = peachRuntimeRoot();
   verifyCliCompanion(root);
   const require2 = (0, import_node_module.createRequire)(__sootsim_import_meta_url);
-  const runtime = require2((0, import_node_path2.join)(root, cliCompanionPath()));
+  const runtime = require2((0, import_node_path5.join)(root, cliCompanionPath()));
   if (runtime.cliCompanionAbi !== CLI_COMPANION_ABI) {
     throw new Error(
       "Incompatible Peach runtime companion ABI; run `peach runtime install`"
@@ -1753,10 +2762,10 @@ function getCliRuntime() {
 
 // src/dev-server-open.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_child_process = require("node:child_process");
-var import_node_crypto2 = require("node:crypto");
-var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_child_process4 = require("node:child_process");
+var import_node_crypto3 = require("node:crypto");
+var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
 function resolveRnxDesktopAppName(open, projectRoot) {
   if (!open) return null;
   if (typeof open === "object") {
@@ -1764,8 +2773,8 @@ function resolveRnxDesktopAppName(open, projectRoot) {
     if (!appName) throw new Error("peach: open.appName must not be empty");
     return appName;
   }
-  const packageJsonPath = import_node_path3.default.join(projectRoot, "package.json");
-  const packageJson = JSON.parse(import_node_fs3.default.readFileSync(packageJsonPath, "utf8"));
+  const packageJsonPath = import_node_path6.default.join(projectRoot, "package.json");
+  const packageJson = JSON.parse(import_node_fs7.default.readFileSync(packageJsonPath, "utf8"));
   const packageName = packageJson && typeof packageJson === "object" ? Reflect.get(packageJson, "name") : void 0;
   if (typeof packageName !== "string" || !packageName.trim()) {
     throw new Error(`peach: ${packageJsonPath} must declare a package name`);
@@ -1779,7 +2788,7 @@ function tagRnxBundleForPlugin(bundleUrl, replacementOrigin, replacementToken, p
     url.searchParams.set("rnxAppName", appName);
     url.searchParams.set(
       "rnxProjectId",
-      (0, import_node_crypto2.createHash)("sha256").update(import_node_fs3.default.realpathSync(projectRoot)).digest("hex").slice(0, 32)
+      (0, import_node_crypto3.createHash)("sha256").update(import_node_fs7.default.realpathSync(projectRoot)).digest("hex").slice(0, 32)
     );
   }
   url.searchParams.set("rnxReplacementOrigin", replacementOrigin);
@@ -1815,7 +2824,7 @@ function observeRnxDesktopLaunch(child, appName) {
 }
 function launchRnxDesktop(bundleUrl, appName) {
   console.log(`[peach] opening ${appName} in the desktop simulator`);
-  const child = (0, import_node_child_process.spawn)("peach", buildRnxDesktopOpenArgs(bundleUrl), {
+  const child = (0, import_node_child_process4.spawn)("peach", buildRnxDesktopOpenArgs(bundleUrl), {
     stdio: ["ignore", "ignore", "pipe"],
     windowsHide: true
   });
@@ -1827,7 +2836,7 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 var import_http = __toESM(require("http"), 1);
 var import_https = __toESM(require("https"), 1);
 var import_node_http2 = require("node:http2");
-var import_promises4 = require("stream/promises");
+var import_promises6 = require("stream/promises");
 
 // src/backend-origin.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -1870,7 +2879,7 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/expo-autolinking.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_child_process2 = require("node:child_process");
+var import_node_child_process5 = require("node:child_process");
 var import_node_util = require("node:util");
 
 // src/forked-script-contract.ts
@@ -1878,7 +2887,7 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 var PEACH_FORKED_SCRIPT_ENV = "PEACH_RUNS_FORKED_SCRIPTS";
 
 // src/expo-autolinking.ts
-var run = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+var run = (0, import_node_util.promisify)(import_node_child_process5.execFile);
 
 // src/expo-native-prebuilt.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -1895,21 +2904,21 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/swift-objc-sdk-tree.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_fs4 = require("node:fs");
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_fs8 = require("node:fs");
+var import_node_path7 = __toESM(require("node:path"), 1);
 function readIosSdkTree(root) {
-  return (0, import_node_fs4.readdirSync)(root, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => {
-    const file = import_node_path4.default.join(entry.parentPath, entry.name);
+  return (0, import_node_fs8.readdirSync)(root, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => {
+    const file = import_node_path7.default.join(entry.parentPath, entry.name);
     return [
-      import_node_path4.default.relative(root, file).split(import_node_path4.default.sep).join("/"),
-      (0, import_node_fs4.readFileSync)(file, "utf8")
+      import_node_path7.default.relative(root, file).split(import_node_path7.default.sep).join("/"),
+      (0, import_node_fs8.readFileSync)(file, "utf8")
     ];
   }).sort(([a], [b]) => a < b ? -1 : 1);
 }
 
 // src/swift-standin-digest.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var STANDIN_SOURCE_DIGEST = true ? "30ee25efff915489853ffb5c34661d03b2ca480fc48fe80201fced1d4821577a" : standinSourceDigest();
+var STANDIN_SOURCE_DIGEST = true ? "f077081111b09ca27482cd53be422dae6cd1bd3a5fd2b2bdef48a83a9c0d6ca8" : standinSourceDigest();
 
 // src/expo-native-workspace.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -1984,17 +2993,17 @@ function visit(node, visitor) {
 visit.BREAK = BREAK;
 visit.SKIP = SKIP;
 visit.REMOVE = REMOVE;
-function visit_(key, node, visitor, path17) {
-  const ctrl = callVisitor(key, node, visitor, path17);
+function visit_(key, node, visitor, path20) {
+  const ctrl = callVisitor(key, node, visitor, path20);
   if (isNode(ctrl) || isPair(ctrl)) {
-    replaceNode(key, path17, ctrl);
-    return visit_(key, ctrl, visitor, path17);
+    replaceNode(key, path20, ctrl);
+    return visit_(key, ctrl, visitor, path20);
   }
   if (typeof ctrl !== "symbol") {
     if (isCollection(node)) {
-      path17 = Object.freeze(path17.concat(node));
+      path20 = Object.freeze(path20.concat(node));
       for (let i = 0; i < node.items.length; ++i) {
-        const ci = visit_(i, node.items[i], visitor, path17);
+        const ci = visit_(i, node.items[i], visitor, path20);
         if (typeof ci === "number")
           i = ci - 1;
         else if (ci === BREAK)
@@ -2005,13 +3014,13 @@ function visit_(key, node, visitor, path17) {
         }
       }
     } else if (isPair(node)) {
-      path17 = Object.freeze(path17.concat(node));
-      const ck = visit_("key", node.key, visitor, path17);
+      path20 = Object.freeze(path20.concat(node));
+      const ck = visit_("key", node.key, visitor, path20);
       if (ck === BREAK)
         return BREAK;
       else if (ck === REMOVE)
         node.key = null;
-      const cv = visit_("value", node.value, visitor, path17);
+      const cv = visit_("value", node.value, visitor, path20);
       if (cv === BREAK)
         return BREAK;
       else if (cv === REMOVE)
@@ -2032,17 +3041,17 @@ async function visitAsync(node, visitor) {
 visitAsync.BREAK = BREAK;
 visitAsync.SKIP = SKIP;
 visitAsync.REMOVE = REMOVE;
-async function visitAsync_(key, node, visitor, path17) {
-  const ctrl = await callVisitor(key, node, visitor, path17);
+async function visitAsync_(key, node, visitor, path20) {
+  const ctrl = await callVisitor(key, node, visitor, path20);
   if (isNode(ctrl) || isPair(ctrl)) {
-    replaceNode(key, path17, ctrl);
-    return visitAsync_(key, ctrl, visitor, path17);
+    replaceNode(key, path20, ctrl);
+    return visitAsync_(key, ctrl, visitor, path20);
   }
   if (typeof ctrl !== "symbol") {
     if (isCollection(node)) {
-      path17 = Object.freeze(path17.concat(node));
+      path20 = Object.freeze(path20.concat(node));
       for (let i = 0; i < node.items.length; ++i) {
-        const ci = await visitAsync_(i, node.items[i], visitor, path17);
+        const ci = await visitAsync_(i, node.items[i], visitor, path20);
         if (typeof ci === "number")
           i = ci - 1;
         else if (ci === BREAK)
@@ -2053,13 +3062,13 @@ async function visitAsync_(key, node, visitor, path17) {
         }
       }
     } else if (isPair(node)) {
-      path17 = Object.freeze(path17.concat(node));
-      const ck = await visitAsync_("key", node.key, visitor, path17);
+      path20 = Object.freeze(path20.concat(node));
+      const ck = await visitAsync_("key", node.key, visitor, path20);
       if (ck === BREAK)
         return BREAK;
       else if (ck === REMOVE)
         node.key = null;
-      const cv = await visitAsync_("value", node.value, visitor, path17);
+      const cv = await visitAsync_("value", node.value, visitor, path20);
       if (cv === BREAK)
         return BREAK;
       else if (cv === REMOVE)
@@ -2086,23 +3095,23 @@ function initVisitor(visitor) {
   }
   return visitor;
 }
-function callVisitor(key, node, visitor, path17) {
+function callVisitor(key, node, visitor, path20) {
   if (typeof visitor === "function")
-    return visitor(key, node, path17);
+    return visitor(key, node, path20);
   if (isMap(node))
-    return visitor.Map?.(key, node, path17);
+    return visitor.Map?.(key, node, path20);
   if (isSeq(node))
-    return visitor.Seq?.(key, node, path17);
+    return visitor.Seq?.(key, node, path20);
   if (isPair(node))
-    return visitor.Pair?.(key, node, path17);
+    return visitor.Pair?.(key, node, path20);
   if (isScalar(node))
-    return visitor.Scalar?.(key, node, path17);
+    return visitor.Scalar?.(key, node, path20);
   if (isAlias(node))
-    return visitor.Alias?.(key, node, path17);
+    return visitor.Alias?.(key, node, path20);
   return void 0;
 }
-function replaceNode(key, path17, node) {
-  const parent = path17[path17.length - 1];
+function replaceNode(key, path20, node) {
+  const parent = path20[path20.length - 1];
   if (isCollection(parent)) {
     parent.items[key] = node;
   } else if (isPair(parent)) {
@@ -2172,8 +3181,8 @@ var Directives = class _Directives {
       this.atNextDocument = false;
     }
     const parts = line.trim().split(/[ \t]+/);
-    const name = parts.shift();
-    switch (name) {
+    const name2 = parts.shift();
+    switch (name2) {
       case "%TAG": {
         if (parts.length !== 2) {
           onError(0, "%TAG directive should contain exactly two parts");
@@ -2201,7 +3210,7 @@ var Directives = class _Directives {
         }
       }
       default:
-        onError(0, `Unknown directive ${name}`, true);
+        onError(0, `Unknown directive ${name2}`, true);
         return false;
     }
   }
@@ -2601,10 +3610,10 @@ function createNode(value, tagName, ctx) {
 }
 
 // ../../node_modules/yaml/browser/dist/nodes/Collection.js
-function collectionFromPath(schema4, path17, value) {
+function collectionFromPath(schema4, path20, value) {
   let v6 = value;
-  for (let i = path17.length - 1; i >= 0; --i) {
-    const k = path17[i];
+  for (let i = path20.length - 1; i >= 0; --i) {
+    const k = path20[i];
     if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
       const a = [];
       a[k] = v6;
@@ -2623,7 +3632,7 @@ function collectionFromPath(schema4, path17, value) {
     sourceObjects: /* @__PURE__ */ new Map()
   });
 }
-var isEmptyPath = (path17) => path17 == null || typeof path17 === "object" && !!path17[Symbol.iterator]().next().done;
+var isEmptyPath = (path20) => path20 == null || typeof path20 === "object" && !!path20[Symbol.iterator]().next().done;
 var Collection = class extends NodeBase {
   constructor(type, schema4) {
     super(type);
@@ -2653,11 +3662,11 @@ var Collection = class extends NodeBase {
    * be a Pair instance or a `{ key, value }` object, which may not have a key
    * that already exists in the map.
    */
-  addIn(path17, value) {
-    if (isEmptyPath(path17))
+  addIn(path20, value) {
+    if (isEmptyPath(path20))
       this.add(value);
     else {
-      const [key, ...rest] = path17;
+      const [key, ...rest] = path20;
       const node = this.get(key, true);
       if (isCollection(node))
         node.addIn(rest, value);
@@ -2671,8 +3680,8 @@ var Collection = class extends NodeBase {
    * Removes a value from the collection.
    * @returns `true` if the item was found and removed.
    */
-  deleteIn(path17) {
-    const [key, ...rest] = path17;
+  deleteIn(path20) {
+    const [key, ...rest] = path20;
     if (rest.length === 0)
       return this.delete(key);
     const node = this.get(key, true);
@@ -2686,8 +3695,8 @@ var Collection = class extends NodeBase {
    * scalar values from their surrounding node; to disable set `keepScalar` to
    * `true` (collections are always returned intact).
    */
-  getIn(path17, keepScalar) {
-    const [key, ...rest] = path17;
+  getIn(path20, keepScalar) {
+    const [key, ...rest] = path20;
     const node = this.get(key, true);
     if (rest.length === 0)
       return !keepScalar && isScalar(node) ? node.value : node;
@@ -2705,8 +3714,8 @@ var Collection = class extends NodeBase {
   /**
    * Checks if the collection includes a value with the key `key`.
    */
-  hasIn(path17) {
-    const [key, ...rest] = path17;
+  hasIn(path20) {
+    const [key, ...rest] = path20;
     if (rest.length === 0)
       return this.has(key);
     const node = this.get(key, true);
@@ -2716,8 +3725,8 @@ var Collection = class extends NodeBase {
    * Sets a value in this collection. For `!!set`, `value` needs to be a
    * boolean to add/remove the item from the set.
    */
-  setIn(path17, value) {
-    const [key, ...rest] = path17;
+  setIn(path20, value) {
+    const [key, ...rest] = path20;
     if (rest.length === 0) {
       this.set(key, value);
     } else {
@@ -3222,8 +4231,8 @@ function getTagObject(tags, item) {
     tagObj = tags.find((t) => t.nodeClass && obj instanceof t.nodeClass);
   }
   if (!tagObj) {
-    const name = obj?.constructor?.name ?? (obj === null ? "null" : typeof obj);
-    throw new Error(`Tag not resolved for ${name} value`);
+    const name2 = obj?.constructor?.name ?? (obj === null ? "null" : typeof obj);
+    throw new Error(`Tag not resolved for ${name2} value`);
   }
   return tagObj;
 }
@@ -4306,9 +5315,9 @@ function visit2(cst, visitor) {
 visit2.BREAK = BREAK2;
 visit2.SKIP = SKIP2;
 visit2.REMOVE = REMOVE2;
-visit2.itemAtPath = (cst, path17) => {
+visit2.itemAtPath = (cst, path20) => {
   let item = cst;
-  for (const [field, index] of path17) {
+  for (const [field, index] of path20) {
     const tok = item?.[field];
     if (tok && "items" in tok) {
       item = tok.items[index];
@@ -4317,23 +5326,23 @@ visit2.itemAtPath = (cst, path17) => {
   }
   return item;
 };
-visit2.parentCollection = (cst, path17) => {
-  const parent = visit2.itemAtPath(cst, path17.slice(0, -1));
-  const field = path17[path17.length - 1][0];
+visit2.parentCollection = (cst, path20) => {
+  const parent = visit2.itemAtPath(cst, path20.slice(0, -1));
+  const field = path20[path20.length - 1][0];
   const coll = parent?.[field];
   if (coll && "items" in coll)
     return coll;
   throw new Error("Parent collection not found");
 };
-function _visit(path17, item, visitor) {
-  let ctrl = visitor(item, path17);
+function _visit(path20, item, visitor) {
+  let ctrl = visitor(item, path20);
   if (typeof ctrl === "symbol")
     return ctrl;
   for (const field of ["key", "value"]) {
     const token = item[field];
     if (token && "items" in token) {
       for (let i = 0; i < token.items.length; ++i) {
-        const ci = _visit(Object.freeze(path17.concat([[field, i]])), token.items[i], visitor);
+        const ci = _visit(Object.freeze(path20.concat([[field, i]])), token.items[i], visitor);
         if (typeof ci === "number")
           i = ci - 1;
         else if (ci === BREAK2)
@@ -4344,10 +5353,10 @@ function _visit(path17, item, visitor) {
         }
       }
       if (typeof ctrl === "function" && field === "key")
-        ctrl = ctrl(item, path17);
+        ctrl = ctrl(item, path20);
     }
   }
-  return typeof ctrl === "function" ? ctrl(item, path17) : ctrl;
+  return typeof ctrl === "function" ? ctrl(item, path20) : ctrl;
 }
 
 // ../../node_modules/yaml/browser/dist/parse/lexer.js
@@ -4469,7 +5478,7 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/swift-binary-modules.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
 
 // src/swift-package.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -4498,16 +5507,16 @@ var SWIFT_NATIVE_SOURCE_EXTENSIONS = [
 ];
 
 // src/swift-binary-modules.ts
-var cacheDir2 = import_node_path5.default.join(cacheDir(), "swift-binary-modules");
+var cacheDir2 = import_node_path8.default.join(cacheDir(), "swift-binary-modules");
 
 // src/swift-coverage/xcode-assets.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/swift-coverage/provenance.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_crypto3 = require("node:crypto");
-var import_node_fs5 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_crypto4 = require("node:crypto");
+var import_node_fs9 = require("node:fs");
+var import_node_path9 = require("node:path");
 var SWIFT_COVERAGE_DIGEST_SOURCES = [
   "swift-coverage/indexdump.ts",
   "swift-coverage/indexing.ts",
@@ -4537,11 +5546,11 @@ function swiftCoverageSourceDigests(srcDir) {
   return Object.fromEntries(
     SWIFT_COVERAGE_DIGEST_SOURCES.map((file) => [
       file,
-      (0, import_node_crypto3.createHash)("sha256").update((0, import_node_fs5.readFileSync)((0, import_node_path6.join)(srcDir, file))).digest("hex")
+      (0, import_node_crypto4.createHash)("sha256").update((0, import_node_fs9.readFileSync)((0, import_node_path9.join)(srcDir, file))).digest("hex")
     ])
   );
 }
-var swiftCoverageProvenance = typeof define_SWIFT_COVERAGE_SOURCE_DIGESTS_default === "object" ? define_SWIFT_COVERAGE_SOURCE_DIGESTS_default : swiftCoverageSourceDigests((0, import_node_path6.join)(__sootsim_import_meta_dirname, ".."));
+var swiftCoverageProvenance = typeof define_SWIFT_COVERAGE_SOURCE_DIGESTS_default === "object" ? define_SWIFT_COVERAGE_SOURCE_DIGESTS_default : swiftCoverageSourceDigests((0, import_node_path9.join)(__sootsim_import_meta_dirname, ".."));
 
 // src/swift-coverage/xcode-asset-symbols.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -4727,8 +5736,8 @@ var assetSymbolSettingKeys = [
 
 // src/swift-package-manifest.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_child_process4 = require("node:child_process");
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_child_process7 = require("node:child_process");
+var import_node_path12 = __toESM(require("node:path"), 1);
 var import_node_util3 = require("node:util");
 
 // src/swift-distribution.ts
@@ -4758,12 +5767,12 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/swift-toolchain.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
 function peachsimPackageRoot() {
   let dir = __sootsim_import_meta_dirname;
-  while (!import_node_fs6.default.existsSync(import_node_path7.default.join(dir, "package.json")) && dir !== import_node_path7.default.dirname(dir))
-    dir = import_node_path7.default.dirname(dir);
+  while (!import_node_fs10.default.existsSync(import_node_path10.default.join(dir, "package.json")) && dir !== import_node_path10.default.dirname(dir))
+    dir = import_node_path10.default.dirname(dir);
   return dir;
 }
 var SWIFT_HOST_COMPILER_RELEASE = "swift-6.4.0-RELEASE-custom-81b2c791c27276bf";
@@ -4992,17 +6001,17 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/swift-objc-standin.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 
 // src/swift-interface-bodies.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/swift-objc-sdk.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
 var IOS_SDK_TARGET = "arm64-apple-ios16.0-simulator";
 var OVERLAY_PATH = /^usr\/lib\/swift\/([^/]+)\.swiftmodule\/arm64-apple-ios-simulator\.swiftinterface$/;
-var tree = typeof __PEACH_BUNDLED_IOS_SDK__ === "undefined" ? readIosSdkTree(import_node_path8.default.join(peachsimPackageRoot(), "sdk", "ios")) : Object.entries(__PEACH_BUNDLED_IOS_SDK__).sort(([a], [b]) => a < b ? -1 : 1);
+var tree = typeof __PEACH_BUNDLED_IOS_SDK__ === "undefined" ? readIosSdkTree(import_node_path11.default.join(peachsimPackageRoot(), "sdk", "ios")) : Object.entries(__PEACH_BUNDLED_IOS_SDK__).sort(([a], [b]) => a < b ? -1 : 1);
 var IOS_SDK_HEADERS = {};
 var IOS_SDK_OVERLAYS = {};
 for (const [file, text] of tree) {
@@ -5029,7 +6038,7 @@ var WASI_EMULATION = [
   "_WASI_EMULATED_MMAN",
   "_WASI_EMULATED_PROCESS_CLOCKS"
 ];
-var WASI_EMULATION_FLAGS = WASI_EMULATION.map((name) => `-D${name}`);
+var WASI_EMULATION_FLAGS = WASI_EMULATION.map((name2) => `-D${name2}`);
 var NATIVE_GRAPH_INPUTS = {
   sdk: NATIVE_GRAPH_SDK_VERSION,
   settings: "e68503e5e534e9194af5efe8c636ca8b824e2d8237c5f38ec84aa4d155bc8418",
@@ -5037,7 +6046,7 @@ var NATIVE_GRAPH_INPUTS = {
   compiler: "Apple Swift version 6.4 (swiftlang-6.4.0.34.1 clang-2100.3.34.1)",
   target: IOS_SDK_TARGET
 };
-var NATIVE_GRAPH_ID = (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(NATIVE_GRAPH_INPUTS)).digest("hex");
+var NATIVE_GRAPH_ID = (0, import_node_crypto5.createHash)("sha256").update(JSON.stringify(NATIVE_GRAPH_INPUTS)).digest("hex");
 
 // src/swift-shared-sdk.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -5203,7 +6212,7 @@ var SWIFTUI_WRAPPER_HOST_PROTOCOLS = new Set(
     "ToolbarContent",
     "Commands",
     "DynamicProperty"
-  ].map((name) => `$s7SwiftUI${name.length}${name}Mp`)
+  ].map((name2) => `$s7SwiftUI${name2.length}${name2}Mp`)
 );
 
 // src/swift-guest-link.ts
@@ -5284,9 +6293,9 @@ var WASM_OPTIMIZE_IDENTITY = `wasm-opt ${import_wasm_opt.BINARYEN_VERSION} -Oz $
 
 // src/swift-icu.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_child_process3 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 var import_node_util2 = require("node:util");
-var import_node_zlib = require("node:zlib");
+var import_node_zlib2 = require("node:zlib");
 
 // ../sootsim-swift/src/icuData.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -5300,10 +6309,10 @@ var VERSION = 1;
 var SWIFT_ICU_PACKED = `picu${VERSION}`;
 
 // src/swift-icu.ts
-var run2 = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
-var deflate = (0, import_node_util2.promisify)(import_node_zlib.gzip);
-var compressBrotli = (0, import_node_util2.promisify)(import_node_zlib.brotliCompress);
-var inflateGzip = (0, import_node_util2.promisify)(import_node_zlib.gunzip);
+var run2 = (0, import_node_util2.promisify)(import_node_child_process6.execFile);
+var deflate = (0, import_node_util2.promisify)(import_node_zlib2.gzip);
+var compressBrotli = (0, import_node_util2.promisify)(import_node_zlib2.brotliCompress);
+var inflateGzip = (0, import_node_util2.promisify)(import_node_zlib2.gunzip);
 
 // src/swift-link-roots.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -5403,7 +6412,7 @@ var FOUNDATION_IMPLICIT_MODULES = [
 var FOUNDATION_IMPLICIT_FLAGS = FOUNDATION_IMPLICIT_MODULES.map(
   (module2) => `, "-Xfrontend", "-import-module", "-Xfrontend", "${module2}"`
 ).join("");
-var compilerSourceDigest = true ? "f113c3b74986e3d582dde643cb5771f750e5c836703fb20a79a1d67a53884748" : swiftCompilerSourceDigest2(__sootsim_import_meta_dirname);
+var compilerSourceDigest = true ? "4646bbe2e0cd2e48e498f51fd3d0d5ea29ecd5e6163fdf3afe8d64d4368022d7" : swiftCompilerSourceDigest2(__sootsim_import_meta_dirname);
 var CORE_FOUNDATION_HANDLE_IMPORTS = [
   "CFAllocator",
   "CFArray",
@@ -5418,11 +6427,24 @@ var CORE_FOUNDATION_HANDLE_IMPORTS = [
   "CFSet",
   "CFString",
   "CFURL"
-].map((name) => `import class CoreFoundation.${name}`).concat([
+].map((name2) => `import class CoreFoundation.${name2}`).concat([
   "import typealias CoreFoundation.CFPropertyList",
   "import typealias CoreFoundation.CFTypeRef",
   "import CoreGraphics"
 ]).join("; ");
+var emptyMacroEnvironment = {
+  defines: /* @__PURE__ */ new Map(),
+  predefines: /* @__PURE__ */ new Map(),
+  targetDefined: /* @__PURE__ */ new Set()
+};
+var wasmMacroEnvironment = {
+  ...emptyMacroEnvironment,
+  defines: /* @__PURE__ */ new Map([
+    ["__wasm__", "1"],
+    ["__wasm32__", "1"],
+    ["__wasi__", "1"]
+  ])
+};
 var ROOT_LOCKS = Symbol.for("peachsim.swiftCompile.rootLocks");
 var host = globalThis;
 var rootLocks = host[ROOT_LOCKS] ??= /* @__PURE__ */ new Map();
@@ -5438,8 +6460,8 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/swift-package-manifest.ts
-var cacheDir3 = import_node_path9.default.join(cacheDir(), "swift-manifests");
-var execFileAsync = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
+var cacheDir3 = import_node_path12.default.join(cacheDir(), "swift-manifests");
+var execFileAsync = (0, import_node_util3.promisify)(import_node_child_process7.execFile);
 
 // src/xcode-json-project.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -5459,36 +6481,36 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // src/nitro-dependencies.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_child_process6 = require("node:child_process");
+var import_node_child_process9 = require("node:child_process");
 var import_node_util5 = require("node:util");
 
 // src/kotlin-toolchain.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process8 = require("node:child_process");
 var import_node_util4 = require("node:util");
-var run3 = (0, import_node_util4.promisify)(import_node_child_process5.execFile);
+var run3 = (0, import_node_util4.promisify)(import_node_child_process8.execFile);
 
 // src/swift-source-file.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 function relativeInside(root, file) {
-  const relative2 = import_node_path10.default.relative(root, file);
-  return relative2 === ".." || relative2.startsWith(`..${import_node_path10.default.sep}`) || import_node_path10.default.isAbsolute(relative2) ? null : relative2;
+  const relative2 = import_node_path13.default.relative(root, file);
+  return relative2 === ".." || relative2.startsWith(`..${import_node_path13.default.sep}`) || import_node_path13.default.isAbsolute(relative2) ? null : relative2;
 }
 function packageInputPath(canonicalRoot, file) {
-  const canonicalFile = import_node_fs7.default.realpathSync(file);
+  const canonicalFile = import_node_fs11.default.realpathSync(file);
   if (relativeInside(canonicalRoot, canonicalFile) === null) {
     throw new Error(`swift input escapes the selected package: ${file}`);
   }
   return canonicalFile;
 }
 function readPackageFile(root, file, maxBytes) {
-  const canonicalFile = packageInputPath(import_node_fs7.default.realpathSync(root), file);
-  const expected = import_node_fs7.default.statSync(canonicalFile);
-  const fd = import_node_fs7.default.openSync(canonicalFile, import_node_fs7.default.constants.O_RDONLY | import_node_fs7.default.constants.O_NOFOLLOW);
+  const canonicalFile = packageInputPath(import_node_fs11.default.realpathSync(root), file);
+  const expected = import_node_fs11.default.statSync(canonicalFile);
+  const fd = import_node_fs11.default.openSync(canonicalFile, import_node_fs11.default.constants.O_RDONLY | import_node_fs11.default.constants.O_NOFOLLOW);
   try {
-    const stat = import_node_fs7.default.fstatSync(fd);
+    const stat = import_node_fs11.default.fstatSync(fd);
     if (stat.dev !== expected.dev || stat.ino !== expected.ino) {
       throw new Error(`swift input changed while opening: ${file}`);
     }
@@ -5498,16 +6520,16 @@ function readPackageFile(root, file, maxBytes) {
     const bytes = Buffer.alloc(stat.size + 1);
     let offset = 0;
     while (offset < bytes.length) {
-      const count = import_node_fs7.default.readSync(fd, bytes, offset, bytes.length - offset, null);
+      const count = import_node_fs11.default.readSync(fd, bytes, offset, bytes.length - offset, null);
       if (count === 0) break;
       offset += count;
     }
-    if (offset !== stat.size || import_node_fs7.default.fstatSync(fd).size !== stat.size) {
+    if (offset !== stat.size || import_node_fs11.default.fstatSync(fd).size !== stat.size) {
       throw new Error(`swift input changed while reading: ${file}`);
     }
     return bytes.subarray(0, offset);
   } finally {
-    import_node_fs7.default.closeSync(fd);
+    import_node_fs11.default.closeSync(fd);
   }
 }
 
@@ -5526,7 +6548,7 @@ var MAX_SWIFT_COMPILE_IMAGE_BYTES = 4 * 1024 * 1024;
 var MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES = 16 * 1024 * 1024;
 
 // src/nitro-dependencies.ts
-var run4 = (0, import_node_util5.promisify)(import_node_child_process6.execFile);
+var run4 = (0, import_node_util5.promisify)(import_node_child_process9.execFile);
 var DOUBLE_CONVERSION_WASM32_BACKPORT = {
   upstreamCommit: "8857767d5b2f5a035321e3712e8cd0008840ba6b",
   originalSha256: "b495b11f7b61693486894f747add5b454894b8b3ca41aa1610d370ba16407ab7",
@@ -5604,9 +6626,9 @@ var RN_FMT_12_DEPENDENCIES = [
 
 // src/react-native-autolinking.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_child_process7 = require("node:child_process");
+var import_node_child_process10 = require("node:child_process");
 var import_node_util6 = require("node:util");
-var run5 = (0, import_node_util6.promisify)(import_node_child_process7.execFile);
+var run5 = (0, import_node_util6.promisify)(import_node_child_process10.execFile);
 
 // src/workspace-root.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -8673,8 +9695,8 @@ var COMPAT_STUBS = {
 
 // src/installed-native-build-options.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 var RIVE_PACKAGE = "@rive-app/react-native";
 var RIVE_05 = [">=0.5.0 <0.6.0"];
 function missing(error) {
@@ -8682,10 +9704,10 @@ function missing(error) {
 }
 function answerSync(step) {
   try {
-    if (step.type === "realpath") return import_node_fs8.default.realpathSync(step.path);
-    if (step.type === "read") return import_node_fs8.default.readFileSync(step.path, "utf8");
-    if (step.type === "isDirectory") return import_node_fs8.default.statSync(step.path).isDirectory();
-    return import_node_fs8.default.readdirSync(step.path, { withFileTypes: true }).map((entry) => ({
+    if (step.type === "realpath") return import_node_fs12.default.realpathSync(step.path);
+    if (step.type === "read") return import_node_fs12.default.readFileSync(step.path, "utf8");
+    if (step.type === "isDirectory") return import_node_fs12.default.statSync(step.path).isDirectory();
+    return import_node_fs12.default.readdirSync(step.path, { withFileTypes: true }).map((entry) => ({
       name: entry.name,
       directory: entry.isDirectory(),
       symbolicLink: entry.isSymbolicLink()
@@ -8697,11 +9719,11 @@ function answerSync(step) {
 }
 async function answerAsync(step) {
   try {
-    if (step.type === "realpath") return await import_node_fs8.default.promises.realpath(step.path);
-    if (step.type === "read") return await import_node_fs8.default.promises.readFile(step.path, "utf8");
+    if (step.type === "realpath") return await import_node_fs12.default.promises.realpath(step.path);
+    if (step.type === "read") return await import_node_fs12.default.promises.readFile(step.path, "utf8");
     if (step.type === "isDirectory")
-      return (await import_node_fs8.default.promises.stat(step.path)).isDirectory();
-    return (await import_node_fs8.default.promises.readdir(step.path, { withFileTypes: true })).map(
+      return (await import_node_fs12.default.promises.stat(step.path)).isDirectory();
+    return (await import_node_fs12.default.promises.readdir(step.path, { withFileTypes: true })).map(
       (entry) => ({
         name: entry.name,
         directory: entry.isDirectory(),
@@ -8734,7 +9756,7 @@ function* rubyFiles(directory, seen, iosRoot = false) {
   const files = [];
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
     if (iosRoot && (entry.name === "Pods" || entry.name === "build")) continue;
-    const target = import_node_path11.default.join(directory, entry.name);
+    const target = import_node_path14.default.join(directory, entry.name);
     let isDirectory = entry.directory;
     if (entry.symbolicLink)
       isDirectory = (yield { type: "isDirectory", path: target }) === true;
@@ -8747,7 +9769,7 @@ function* nativeBuildOptionsWalk(projectRoot, versions, environment) {
   let sensorOptions = {};
   const sensors = versions["expo-sensors"];
   if (sensors && resolveCompatVersionRange([">=58.0.4 <59.0.0"], sensors).status === "matched") {
-    const file = import_node_path11.default.join(projectRoot, "ios", "Podfile.properties.json");
+    const file = import_node_path14.default.join(projectRoot, "ios", "Podfile.properties.json");
     const source = yield { type: "read", path: file };
     if (source !== null && typeof source !== "string")
       throw new Error(`cannot inspect ${file}`);
@@ -8763,8 +9785,8 @@ function* nativeBuildOptionsWalk(projectRoot, versions, environment) {
   if (!needsRiveOptions(versions)) return sensorOptions;
   if (environment.USE_RIVE_LEGACY === "1" || environment.USE_RIVE_LEGACY === "true")
     return { ...sensorOptions, [RIVE_PACKAGE]: { USE_RIVE_LEGACY: true } };
-  const ios = import_node_path11.default.join(projectRoot, "ios");
-  const podfile = import_node_path11.default.join(ios, "Podfile");
+  const ios = import_node_path14.default.join(projectRoot, "ios");
+  const podfile = import_node_path14.default.join(ios, "Podfile");
   const files = [podfile, ...yield* rubyFiles(ios, /* @__PURE__ */ new Set(), true)];
   let value = false;
   let assigned = false;
@@ -8883,7 +9905,7 @@ async function runAsync(walk, inputs) {
 function createInstalledPackageReader() {
   const hasModules = /* @__PURE__ */ new Map();
   const manifests = /* @__PURE__ */ new Map();
-  return function* readInstalledPackage(fromDir, name) {
+  return function* readInstalledPackage(fromDir, name2) {
     for (let dir = fromDir; ; ) {
       if (import_path2.default.basename(dir) !== "node_modules") {
         const modules = import_path2.default.join(dir, "node_modules");
@@ -8893,7 +9915,7 @@ function createInstalledPackageReader() {
           hasModules.set(dir, present);
         }
         if (present) {
-          const root = import_path2.default.join(modules, name);
+          const root = import_path2.default.join(modules, name2);
           let installed = manifests.get(root);
           if (installed === void 0) {
             const manifest = yield* readManifest(import_path2.default.join(root, "package.json"));
@@ -8912,11 +9934,11 @@ function createInstalledPackageReader() {
 function* installedVersionsWalk(projectRoot, names, selectedPackages) {
   const readInstalledPackage = createInstalledPackageReader();
   const versions = {};
-  for (const name of [...names].sort()) {
-    const installed = selectedPackages ? selectedPackages.get(name) : yield* readInstalledPackage(projectRoot, name);
+  for (const name2 of [...names].sort()) {
+    const installed = selectedPackages ? selectedPackages.get(name2) : yield* readInstalledPackage(projectRoot, name2);
     const version = installed && Reflect.get(installed.manifest, "version");
-    if (typeof version === "string" && version.length > 0) versions[name] = version;
-    if (name === "react-native-worklets" && installed) {
+    if (typeof version === "string" && version.length > 0) versions[name2] = version;
+    if (name2 === "react-native-worklets" && installed) {
       const defaults = yield* readManifest(
         import_path2.default.join(installed.root, "src/featureFlags/staticFlags.json")
       );
@@ -8938,8 +9960,8 @@ function* nativePackageVersionsWalk(projectRoot) {
     ...LAZY_STUB_PATTERNS,
     ...Object.values(COMPAT_STUBS).map((entry) => entry.specifier)
   ]) {
-    const name = extractPackageFromPath(`node_modules/${specifier}`);
-    if (name) nativeNames.add(name);
+    const name2 = extractPackageFromPath(`node_modules/${specifier}`);
+    if (name2) nativeNames.add(name2);
   }
   const manifest = yield* readManifest(import_path2.default.join(appRoot, "package.json"));
   if (!manifest) throw new Error("app package.json must contain an object");
@@ -8957,16 +9979,16 @@ function* nativePackageVersionsWalk(projectRoot) {
     for (const field of fields) {
       const dependencies = Reflect.get(next.manifest, field);
       if (typeof dependencies !== "object" || dependencies === null) continue;
-      for (const name of Object.keys(dependencies)) {
+      for (const name2 of Object.keys(dependencies)) {
         if (field === "peerDependencies" && typeof peers === "object" && peers !== null) {
-          const peer = Reflect.get(peers, name);
+          const peer = Reflect.get(peers, name2);
           if (typeof peer === "object" && peer !== null && Reflect.get(peer, "optional"))
             continue;
         }
-        const installed = yield* readInstalledPackage(root, name);
+        const installed = yield* readInstalledPackage(root, name2);
         if (!installed) continue;
-        if (nativeNames.has(name) && !needed.has(name))
-          needed.set(name, (yield* readInstalledPackage(appRoot, name)) ?? installed);
+        if (nativeNames.has(name2) && !needed.has(name2))
+          needed.set(name2, (yield* readInstalledPackage(appRoot, name2)) ?? installed);
         pending.push(installed);
       }
     }
@@ -9024,10 +10046,10 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 // scripts/dev-server-scanner.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 var import_child_process = require("child_process");
-var import_promises = require("fs/promises");
-var import_node_fs9 = require("node:fs");
-var import_node_os2 = require("node:os");
-var import_node_path12 = require("node:path");
+var import_promises3 = require("fs/promises");
+var import_node_fs13 = require("node:fs");
+var import_node_os5 = require("node:os");
+var import_node_path15 = require("node:path");
 
 // src/config.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -9177,11 +10199,11 @@ init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 
 // scripts/dev-server-scanner.ts
-var LISTENER_LOCK_PATH = (0, import_node_path12.join)((0, import_node_os2.tmpdir)(), "peach-listener-scan.lock");
-var LISTENER_RESULT_PATH = (0, import_node_path12.join)((0, import_node_os2.tmpdir)(), "peach-listener-scan.result");
+var LISTENER_LOCK_PATH = (0, import_node_path15.join)((0, import_node_os5.tmpdir)(), "peach-listener-scan.lock");
+var LISTENER_RESULT_PATH = (0, import_node_path15.join)((0, import_node_os5.tmpdir)(), "peach-listener-scan.result");
 var LISTENER_LOCK_STALE_MS = 25e3;
 var LISTENER_LOCK_WAIT_MS = 8e3;
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function pidIsAlive(pid) {
@@ -9196,8 +10218,8 @@ function pidIsAlive(pid) {
 }
 function readLockOwner() {
   try {
-    const raw = (0, import_node_fs9.readFileSync)(LISTENER_LOCK_PATH, "utf8");
-    const mtimeMs = (0, import_node_fs9.statSync)(LISTENER_LOCK_PATH).mtimeMs;
+    const raw = (0, import_node_fs13.readFileSync)(LISTENER_LOCK_PATH, "utf8");
+    const mtimeMs = (0, import_node_fs13.statSync)(LISTENER_LOCK_PATH).mtimeMs;
     const pid = Number(raw.split("-")[0]);
     return { raw, pid: Number.isInteger(pid) ? pid : -1, mtimeMs };
   } catch {
@@ -9210,15 +10232,15 @@ function lockIsAbandoned(owner) {
 }
 function clearLock(raw) {
   try {
-    if ((0, import_node_fs9.readFileSync)(LISTENER_LOCK_PATH, "utf8") !== raw) return;
-    (0, import_node_fs9.unlinkSync)(LISTENER_LOCK_PATH);
+    if ((0, import_node_fs13.readFileSync)(LISTENER_LOCK_PATH, "utf8") !== raw) return;
+    (0, import_node_fs13.unlinkSync)(LISTENER_LOCK_PATH);
   } catch {
   }
 }
 function readResult() {
   try {
     const parsed = JSON.parse(
-      (0, import_node_fs9.readFileSync)(LISTENER_RESULT_PATH, "utf8")
+      (0, import_node_fs13.readFileSync)(LISTENER_RESULT_PATH, "utf8")
     );
     if (!parsed || typeof parsed.token !== "string" || typeof parsed.key !== "string")
       return null;
@@ -9229,8 +10251,8 @@ function readResult() {
 }
 function publishResult(payload) {
   const tmp = `${LISTENER_RESULT_PATH}.${process.pid}.tmp`;
-  (0, import_node_fs9.writeFileSync)(tmp, JSON.stringify(payload));
-  (0, import_node_fs9.renameSync)(tmp, LISTENER_RESULT_PATH);
+  (0, import_node_fs13.writeFileSync)(tmp, JSON.stringify(payload));
+  (0, import_node_fs13.renameSync)(tmp, LISTENER_RESULT_PATH);
 }
 function throwPublished(payload) {
   throw Object.assign(new Error(payload.message || "listener scan failed"), {
@@ -9261,7 +10283,7 @@ async function waitForSharedResult(owner, key) {
       clearLock(latest.raw);
       return { kind: "retry" };
     }
-    await sleep(25);
+    await sleep2(25);
   }
   throw Object.assign(new Error("listener scan lock was held past the wait"), {
     killed: true
@@ -9273,7 +10295,7 @@ async function withListenerLock(key, body) {
   for (; ; ) {
     let fd = null;
     try {
-      fd = (0, import_node_fs9.openSync)(LISTENER_LOCK_PATH, "wx");
+      fd = (0, import_node_fs13.openSync)(LISTENER_LOCK_PATH, "wx");
     } catch (error) {
       const code = error instanceof Error && "code" in error ? error.code : "";
       if (code !== "EEXIST") throw error;
@@ -9282,7 +10304,7 @@ async function withListenerLock(key, body) {
         if (owner) clearLock(owner.raw);
         else {
           try {
-            (0, import_node_fs9.unlinkSync)(LISTENER_LOCK_PATH);
+            (0, import_node_fs13.unlinkSync)(LISTENER_LOCK_PATH);
           } catch {
           }
         }
@@ -9293,12 +10315,12 @@ async function withListenerLock(key, body) {
         if (shared.kind === "value") return shared.value;
         continue;
       }
-      await sleep(25);
+      await sleep2(25);
       continue;
     }
     if (fd === null) continue;
     try {
-      (0, import_node_fs9.writeSync)(fd, token);
+      (0, import_node_fs13.writeSync)(fd, token);
       try {
         const value = await body();
         publishResult({ token, key, ok: true, value });
@@ -9315,7 +10337,7 @@ async function withListenerLock(key, body) {
       }
     } finally {
       try {
-        (0, import_node_fs9.closeSync)(fd);
+        (0, import_node_fs13.closeSync)(fd);
       } catch {
       }
       clearLock(token);
@@ -9564,7 +10586,7 @@ async function flushCwdQueue() {
     const needLsof = [];
     for (const pid of pending) {
       try {
-        const cwd = await (0, import_promises.readlink)(`/proc/${pid}/cwd`);
+        const cwd = await (0, import_promises3.readlink)(`/proc/${pid}/cwd`);
         if (cwd) {
           cwdByPid.set(pid, cwd);
           continue;
@@ -9799,7 +10821,7 @@ function nodeRequestHeaderEntries(headers) {
 
 // src/host/hostname-resolver.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_promises2 = require("node:dns/promises");
+var import_promises4 = require("node:dns/promises");
 
 // src/dns-over-https.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -9841,7 +10863,7 @@ function parseIpv6(text) {
 
 // src/host/network-policy.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_path13 = require("node:path");
+var import_node_path16 = require("node:path");
 var import_node_url = require("node:url");
 var NETWORK_POLICY_TIMEOUT_MS = 1e4;
 var NetworkPolicyDeniedError = class extends Error {
@@ -9894,7 +10916,7 @@ function createNetworkAuthorizer(policy) {
   };
 }
 async function loadNetworkPolicy(file) {
-  if (!(0, import_node_path13.isAbsolute)(file)) {
+  if (!(0, import_node_path16.isAbsolute)(file)) {
     throw new Error(`PEACH_NETWORK_POLICY must be an absolute path: ${file}`);
   }
   const loaded2 = await import(
@@ -9930,7 +10952,7 @@ async function handleHostnameResolutionRequest(req, res) {
   }
   let addresses;
   try {
-    addresses = (await (0, import_promises2.lookup)(host2, { all: true })).map(({ address }) => {
+    addresses = (await (0, import_promises4.lookup)(host2, { all: true })).map(({ address }) => {
       const bytes = parseIpLiteral(address);
       if (!bytes) throw new Error("system resolver returned an invalid address");
       return bytes;
@@ -9982,12 +11004,12 @@ function projectLoopbackUrl(value) {
 // src/host/rolldown-bundle-forward.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 var import_stream = require("stream");
-var import_promises3 = require("stream/promises");
+var import_promises5 = require("stream/promises");
 var ROLLDOWN_INVENTORY_HEADER = "x-peach-rolldown-inventory";
 async function forwardRolldownBundleResponse(upstream, res) {
   res.setHeader(ROLLDOWN_INVENTORY_HEADER, "1");
   if (upstream.headers[ROLLDOWN_INVENTORY_HEADER] === "1") {
-    await (0, import_promises3.pipeline)(upstream, res);
+    await (0, import_promises5.pipeline)(upstream, res);
     return;
   }
   const contentType = typeof upstream.headers["content-type"] === "string" ? upstream.headers["content-type"] : "";
@@ -10029,7 +11051,7 @@ async function forwardRolldownBundleResponse(upstream, res) {
     }
     yield Buffer.from(annotated.slice(sent), "utf8");
   };
-  await (0, import_promises3.pipeline)(import_stream.Readable.from(annotate(), { objectMode: false }), res);
+  await (0, import_promises5.pipeline)(import_stream.Readable.from(annotate(), { objectMode: false }), res);
 }
 
 // src/host/fetch-proxy-handler.ts
@@ -10075,7 +11097,7 @@ function applyFetchProxyCors(req, res) {
     "access-control-expose-headers",
     [
       ...Object.keys(res.getHeaders()).filter(
-        (name) => !name.startsWith("access-control-")
+        (name2) => !name2.startsWith("access-control-")
       ),
       "x-sootsim-set-cookie"
     ].join(", ")
@@ -10101,7 +11123,7 @@ function buildAppApiProxyHeaders(reqHeaders, targetUrl) {
   if (typeof nativeCookie === "string" && nativeCookie)
     headers.cookie = decodeURIComponent(nativeCookie);
   headers.host = targetUrl.host;
-  if (!Object.keys(headers).some((name) => name.toLowerCase() === "mobile-origin")) {
+  if (!Object.keys(headers).some((name2) => name2.toLowerCase() === "mobile-origin")) {
     headers.origin = targetUrl.origin;
     headers.referer = `${targetUrl.origin}/`;
   }
@@ -10240,7 +11262,7 @@ function handleAppApiRequest(req, res) {
       res.setHeader("access-control-allow-credentials", "true");
       res.setHeader(
         "access-control-expose-headers",
-        Object.keys(res.getHeaders()).filter((name) => !name.startsWith("access-control-") && name !== "set-cookie").join(", ")
+        Object.keys(res.getHeaders()).filter((name2) => !name2.startsWith("access-control-") && name2 !== "set-cookie").join(", ")
       );
     }
   });
@@ -10360,7 +11382,7 @@ async function proxyUpstream(req, res, upstreamUrl, reportFailure, route) {
       await route.respond(proxyRes, hopCookies);
       if (isNativeCookieRedirect(hop)) res.removeHeader("location");
       res.statusCode = isNativeCookieRedirect(hop) ? 200 : status;
-      await (0, import_promises4.pipeline)(proxyRes, res);
+      await (0, import_promises6.pipeline)(proxyRes, res);
       return;
     }
     if (location && (status === 301 || status === 302 || status === 303 || status === 307 || status === 308)) {
@@ -10371,7 +11393,7 @@ async function proxyUpstream(req, res, upstreamUrl, reportFailure, route) {
       const switchToGet = (status === 301 || status === 302) && method === "POST" || status === 303 && method !== "GET" && method !== "HEAD";
       const redirectUrl = resolveRedirectUrl(location, targetUrl);
       proxyRes.resume();
-      await (0, import_promises4.finished)(proxyRes);
+      await (0, import_promises6.finished)(proxyRes);
       await proxy(
         redirectUrl,
         switchToGet ? "GET" : method,
@@ -10388,7 +11410,7 @@ async function proxyUpstream(req, res, upstreamUrl, reportFailure, route) {
       await forwardRolldownBundleResponse(proxyRes, res);
       return;
     }
-    await (0, import_promises4.pipeline)(proxyRes, res);
+    await (0, import_promises6.pipeline)(proxyRes, res);
   };
   let upstreamAnswered = false;
   let body;
@@ -10446,9 +11468,9 @@ async function proxyUpstream(req, res, upstreamUrl, reportFailure, route) {
 
 // src/host/replacement-module-handler.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_fs10 = require("node:fs");
-var import_promises5 = __toESM(require("node:fs/promises"), 1);
-var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_fs14 = require("node:fs");
+var import_promises7 = __toESM(require("node:fs/promises"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 
 // ../contrast-bundler/src/replacementModule.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
@@ -10489,7 +11511,7 @@ function normalize(p) {
   if (trailingSlash) joined += "/";
   return absolute ? "/" + joined : joined;
 }
-function join4(...parts) {
+function join5(...parts) {
   const present = parts.filter((part) => part.length > 0);
   if (present.length === 0) return ".";
   return normalize(present.join("/"));
@@ -10546,7 +11568,7 @@ var posix = {
   delimiter,
   isAbsolute: isAbsolute2,
   normalize,
-  join: join4,
+  join: join5,
   resolve: resolve2,
   dirname,
   basename,
@@ -10589,21 +11611,21 @@ function unsupportedSpecifier(specifier) {
     `replacement modules may only import react, react-native, peach-kit, the packages rnx stubs for this app, and other project files by relative path; '${specifier}' is none of those. vendor the code into a project file, or add the package to peach.config so the simulator bridges it.`
   );
 }
-function bridgeDeclaration(name, specifier) {
+function bridgeDeclaration(name2, specifier) {
   const notReady = (what) => JSON.stringify(`[peach] replacement ${what} bridge is not ready`);
   if (specifier === "react") {
-    return `const ${name} = ${REACT_BRIDGE}; if (!${name}) throw new Error(${notReady("React")});`;
+    return `const ${name2} = ${REACT_BRIDGE}; if (!${name2}) throw new Error(${notReady("React")});`;
   }
   if (specifier === "react-native") {
-    return `const ${name} = ${REACT_NATIVE_BRIDGE}; if (!${name}) throw new Error(${notReady("React Native")});`;
+    return `const ${name2} = ${REACT_NATIVE_BRIDGE}; if (!${name2}) throw new Error(${notReady("React Native")});`;
   }
   if (isPeachKitSpecifier(specifier)) {
-    return `const ${name} = (globalThis.__peach_kit_modules && globalThis.__peach_kit_modules[${JSON.stringify(specifier)}]) || (${PACKAGE_BRIDGES} || {})[${JSON.stringify(specifier)}]; if (!${name}) throw new Error(${JSON.stringify(`[peach] replacement package bridge ${specifier} is not ready`)});`;
+    return `const ${name2} = (globalThis.__peach_kit_modules && globalThis.__peach_kit_modules[${JSON.stringify(specifier)}]) || (${PACKAGE_BRIDGES} || {})[${JSON.stringify(specifier)}]; if (!${name2}) throw new Error(${JSON.stringify(`[peach] replacement package bridge ${specifier} is not ready`)});`;
   }
   if (JSX_RUNTIME_SPECIFIERS.has(specifier)) {
-    return `const ${name} = (() => { const react = ${REACT_BRIDGE}; if (!react) throw new Error(${notReady("React")}); const jsx = (type, props, key) => react.createElement(type, key === undefined ? props : { ...props, key }); return { Fragment: react.Fragment, jsx, jsxs: jsx, jsxDEV: jsx }; })();`;
+    return `const ${name2} = (() => { const react = ${REACT_BRIDGE}; if (!react) throw new Error(${notReady("React")}); const jsx = (type, props, key) => react.createElement(type, key === undefined ? props : { ...props, key }); return { Fragment: react.Fragment, jsx, jsxs: jsx, jsxDEV: jsx }; })();`;
   }
-  return `const ${name} = (${PACKAGE_BRIDGES} || {})[${JSON.stringify(specifier)}]; if (!${name}) throw new Error(${JSON.stringify(`[peach] replacement package bridge ${specifier} is not ready`)});`;
+  return `const ${name2} = (${PACKAGE_BRIDGES} || {})[${JSON.stringify(specifier)}]; if (!${name2}) throw new Error(${JSON.stringify(`[peach] replacement package bridge ${specifier} is not ready`)});`;
 }
 var DEFAULT_INTEROP = "__rnxReplacementDefault";
 var DEFAULT_INTEROP_DECLARATION = `const ${DEFAULT_INTEROP} = (bridge) => (bridge && bridge.__esModule ? bridge.default : bridge);`;
@@ -10635,10 +11657,10 @@ function compileReplacementModule(input) {
   const bridgeFor = (specifier) => {
     const existing = bridgeNames.get(specifier);
     if (existing) return existing;
-    const name = `__rnxReplacementBridge${bridgeNames.size}`;
-    bridgeNames.set(specifier, name);
-    declarations.push(bridgeDeclaration(name, specifier));
-    return name;
+    const name2 = `__rnxReplacementBridge${bridgeNames.size}`;
+    bridgeNames.set(specifier, name2);
+    declarations.push(bridgeDeclaration(name2, specifier));
+    return name2;
   };
   const edits = [];
   const pointAtLocalModule = (specifierToken, specifier) => {
@@ -10777,16 +11799,16 @@ function sendJavaScript(req, res, source) {
   res.end(req.method === "HEAD" ? void 0 : source);
 }
 function resolveReplacementModuleFile(fromFile, specifier) {
-  const base = import_node_path14.default.resolve(import_node_path14.default.dirname(fromFile), specifier);
+  const base = import_node_path17.default.resolve(import_node_path17.default.dirname(fromFile), specifier);
   const candidates = [
     ...REPLACEMENT_MODULE_EXTENSIONS.some(
-      (ext) => ext === import_node_path14.default.extname(base).toLowerCase()
+      (ext) => ext === import_node_path17.default.extname(base).toLowerCase()
     ) ? [base] : [],
     ...REPLACEMENT_MODULE_EXTENSIONS.map((ext) => base + ext),
-    ...REPLACEMENT_MODULE_EXTENSIONS.map((ext) => import_node_path14.default.join(base, `index${ext}`))
+    ...REPLACEMENT_MODULE_EXTENSIONS.map((ext) => import_node_path17.default.join(base, `index${ext}`))
   ];
   const found = candidates.find(
-    (candidate) => (0, import_node_fs10.statSync)(candidate, { throwIfNoEntry: false })?.isFile()
+    (candidate) => (0, import_node_fs14.statSync)(candidate, { throwIfNoEntry: false })?.isFile()
   );
   if (!found) {
     throw new Error(
@@ -10797,8 +11819,8 @@ function resolveReplacementModuleFile(fromFile, specifier) {
 }
 function isInsideAny(roots, file) {
   return roots.some((root) => {
-    const relative2 = import_node_path14.default.relative(root, file);
-    return !relative2.startsWith("..") && !import_node_path14.default.isAbsolute(relative2);
+    const relative2 = import_node_path17.default.relative(root, file);
+    return !relative2.startsWith("..") && !import_node_path17.default.isAbsolute(relative2);
   });
 }
 async function handleReplacementModuleRequest(req, res, options = {}) {
@@ -10838,19 +11860,19 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     res.end("missing path param");
     return true;
   }
-  const extension = import_node_path14.default.extname(targetPath).toLowerCase();
+  const extension = import_node_path17.default.extname(targetPath).toLowerCase();
   if (!REPLACEMENT_MODULE_EXTENSIONS.some((allowed) => allowed === extension)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end(`replacement files must be ${REPLACEMENT_MODULE_EXTENSIONS.join(", ")}`);
     return true;
   }
-  if (!import_node_path14.default.isAbsolute(targetPath)) {
+  if (!import_node_path17.default.isAbsolute(targetPath)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end("replacement file path must be absolute");
     return true;
   }
   const runtimePackages = new Set(url.searchParams.getAll("runtimePackage"));
-  const servedRoots = options.servedRoots?.map((root) => import_node_path14.default.resolve(root));
+  const servedRoots = options.servedRoots?.map((root) => import_node_path17.default.resolve(root));
   if (servedRoots && !isInsideAny(servedRoots, targetPath)) {
     res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
     res.end("replacement file must be inside a folder the bundler serves");
@@ -10858,7 +11880,7 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   }
   let resolvedTargetPath;
   try {
-    resolvedTargetPath = await import_promises5.default.realpath(targetPath);
+    resolvedTargetPath = await import_promises7.default.realpath(targetPath);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
@@ -10866,7 +11888,7 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     return true;
   }
   if (servedRoots) {
-    const realRoots = (await Promise.all(servedRoots.map((root) => import_promises5.default.realpath(root).catch(() => null)))).filter((root) => root !== null);
+    const realRoots = (await Promise.all(servedRoots.map((root) => import_promises7.default.realpath(root).catch(() => null)))).filter((root) => root !== null);
     if (!isInsideAny(realRoots, resolvedTargetPath)) {
       res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
       res.end("replacement file must be inside a folder the bundler serves");
@@ -10876,7 +11898,7 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   try {
     const compiled = compileReplacementModule({
       filePath: resolvedTargetPath,
-      source: await import_promises5.default.readFile(resolvedTargetPath, "utf8"),
+      source: await import_promises7.default.readFile(resolvedTargetPath, "utf8"),
       runtimePackages,
       // the imported file's url is this request's with only its path changed,
       // so the token, cache key and runtime packages carry over.
@@ -10905,7 +11927,7 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
 
 // src/one-native-app-catalog.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var ONE_NATIVE_APP_CATALOG_ROUTE = "/__peach/native-app-catalog";
 var HEX_COLOR = /^#[\da-f]{6}$/i;
 function parseAccent(value) {
@@ -10917,7 +11939,7 @@ function parseAccent(value) {
 function parseOneNativeAppCatalog(value) {
   if (!isRecord(value)) return null;
   const accentColor = parseAccent(value.accentColor);
-  const assetCatalog = typeof value.assetCatalog === "string" && import_node_path15.default.isAbsolute(value.assetCatalog) ? value.assetCatalog : null;
+  const assetCatalog = typeof value.assetCatalog === "string" && import_node_path18.default.isAbsolute(value.assetCatalog) ? value.assetCatalog : null;
   return accentColor || assetCatalog ? { accentColor, assetCatalog } : null;
 }
 function readOneNativeAppCatalog(entryConfig, root) {
@@ -10926,19 +11948,19 @@ function readOneNativeAppCatalog(entryConfig, root) {
   if (!isRecord(ios)) return null;
   return parseOneNativeAppCatalog({
     accentColor: ios.accentColor,
-    assetCatalog: typeof ios.assetCatalog === "string" ? import_node_path15.default.resolve(root, ios.assetCatalog) : null
+    assetCatalog: typeof ios.assetCatalog === "string" ? import_node_path18.default.resolve(root, ios.assetCatalog) : null
   });
 }
 
 // src/one-widget-metadata.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-var import_node_child_process8 = require("node:child_process");
-var import_node_crypto5 = require("node:crypto");
-var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_child_process11 = require("node:child_process");
+var import_node_crypto6 = require("node:crypto");
+var import_node_fs15 = __toESM(require("node:fs"), 1);
 var import_node_module2 = require("node:module");
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 var import_node_util7 = require("node:util");
-var run6 = (0, import_node_util7.promisify)(import_node_child_process8.execFile);
+var run6 = (0, import_node_util7.promisify)(import_node_child_process11.execFile);
 var configs = /* @__PURE__ */ new Map();
 var reads = /* @__PURE__ */ new Map();
 var CONFIG_CHILD = `
@@ -10958,8 +11980,8 @@ fs.writeFileSync(process.argv[2], JSON.stringify({
 function configStamp(files) {
   return JSON.stringify(
     files.map((file) => {
-      if (!import_node_fs11.default.existsSync(file)) return [file, null];
-      const stat = import_node_fs11.default.statSync(file);
+      if (!import_node_fs15.default.existsSync(file)) return [file, null];
+      const stat = import_node_fs15.default.statSync(file);
       return [file, stat.mtimeMs, stat.ctimeMs, stat.size];
     })
   );
@@ -10970,13 +11992,13 @@ async function readConfig(root) {
   const reading = reads.get(root);
   if (reading) return reading;
   const promise = (async () => {
-    (0, import_node_module2.createRequire)(import_node_path16.default.join(root, "package.json")).resolve("one/vite");
-    const cache = import_node_path16.default.join(root, "node_modules/.cache/peach-widget-config");
-    import_node_fs11.default.mkdirSync(cache, { recursive: true });
-    const directory = import_node_fs11.default.mkdtempSync(import_node_path16.default.join(cache, "read-"));
-    const script = import_node_path16.default.join(directory, "read.mjs");
-    const result = import_node_path16.default.join(directory, "result.json");
-    import_node_fs11.default.writeFileSync(script, CONFIG_CHILD);
+    (0, import_node_module2.createRequire)(import_node_path19.default.join(root, "package.json")).resolve("one/vite");
+    const cache = import_node_path19.default.join(root, "node_modules/.cache/peach-widget-config");
+    import_node_fs15.default.mkdirSync(cache, { recursive: true });
+    const directory = import_node_fs15.default.mkdtempSync(import_node_path19.default.join(cache, "read-"));
+    const script = import_node_path19.default.join(directory, "read.mjs");
+    const result = import_node_path19.default.join(directory, "result.json");
+    import_node_fs15.default.writeFileSync(script, CONFIG_CHILD);
     try {
       await run6(process.execPath, [script, result], {
         cwd: root,
@@ -10984,7 +12006,7 @@ async function readConfig(root) {
         timeout: 3e4,
         maxBuffer: 1024 * 1024
       });
-      const value = JSON.parse(import_node_fs11.default.readFileSync(result, "utf8"));
+      const value = JSON.parse(import_node_fs15.default.readFileSync(result, "utf8"));
       if (!isRecord(value) || !Array.isArray(value.watched) || !value.watched.every((file) => typeof file === "string"))
         throw new Error("One config loader returned invalid dependencies");
       if (!Array.isArray(value.urlSchemes) || !value.urlSchemes.every(
@@ -11007,8 +12029,8 @@ async function readConfig(root) {
       }
       const watched = [
         .../* @__PURE__ */ new Set([
-          import_node_path16.default.join(root, "package.json"),
-          ...value.watched.map((file) => import_node_path16.default.resolve(root, file))
+          import_node_path19.default.join(root, "package.json"),
+          ...value.watched.map((file) => import_node_path19.default.resolve(root, file))
         ])
       ];
       const loaded2 = {
@@ -11020,7 +12042,7 @@ async function readConfig(root) {
       configs.set(root, loaded2);
       return loaded2;
     } finally {
-      import_node_fs11.default.rmSync(directory, { recursive: true, force: true });
+      import_node_fs15.default.rmSync(directory, { recursive: true, force: true });
     }
   })();
   reads.set(root, promise);
@@ -11041,13 +12063,13 @@ function declaredFamilies(source) {
   return home;
 }
 async function readOneWidgetSources(appRoot) {
-  const root = import_node_fs11.default.realpathSync(appRoot);
+  const root = import_node_fs15.default.realpathSync(appRoot);
   const config = await readConfig(root);
   if (!config.widget) return null;
   const widget = config.widget;
   const sourceFiles = {
-    "OneWidget.swift": import_node_path16.default.join(root, "ios/OneWidgets/OneWidget.swift"),
-    "OneWidgetContract.swift": import_node_path16.default.join(
+    "OneWidget.swift": import_node_path19.default.join(root, "ios/OneWidgets/OneWidget.swift"),
+    "OneWidgetContract.swift": import_node_path19.default.join(
       root,
       "ios",
       widget.appName,
@@ -11056,15 +12078,15 @@ async function readOneWidgetSources(appRoot) {
   };
   const files = /* @__PURE__ */ new Map();
   const sources = {};
-  for (const [name, file] of Object.entries(sourceFiles)) {
-    if (!import_node_fs11.default.existsSync(file))
+  for (const [name2, file] of Object.entries(sourceFiles)) {
+    if (!import_node_fs15.default.existsSync(file))
       throw new Error(`missing One widget prebuild source ${file}; run one prebuild`);
     const bytes = readPackageFile(root, file, MAX_SWIFT_COMPILE_SOURCE_BYTES);
     const text = bytes.toString("utf8");
     if (!Buffer.from(text).equals(bytes))
       throw new Error(`One widget prebuild source is not UTF-8: ${file}`);
-    files.set(name, text);
-    sources[import_node_path16.default.relative(root, file).split(import_node_path16.default.sep).join("/")] = (0, import_node_crypto5.createHash)("sha256").update(bytes).digest("hex");
+    files.set(name2, text);
+    sources[import_node_path19.default.relative(root, file).split(import_node_path19.default.sep).join("/")] = (0, import_node_crypto6.createHash)("sha256").update(bytes).digest("hex");
   }
   const contract = files.get("OneWidgetContract.swift") ?? "";
   const source = files.get("OneWidget.swift") ?? "";
@@ -11088,13 +12110,217 @@ async function configuredOneWidget(appRoot, bundleUrl) {
   return {
     metadata: source.widget,
     projectRoot: source.root,
-    appIdentity: (0, import_node_crypto5.createHash)("sha256").update(JSON.stringify([source.root, source.widget.bundleId])).digest("hex"),
+    appIdentity: (0, import_node_crypto6.createHash)("sha256").update(JSON.stringify([source.root, source.widget.bundleId])).digest("hex"),
     bundleUrl,
     packageUrl: new URL(`${SWIFT_PACKAGE_PATH}OneWidgets`, bundleUrl).href,
     urlSchemes: source.urlSchemes
   };
 }
 
+// src/runtime-packs.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_fs16 = __toESM(require("node:fs"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_timers = require("node:timers");
+
+// src/runtime-delivery.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+
+// src/public-brand.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var name = "Peach";
+var peachPublicBrand = Object.freeze({
+  name,
+  packageName: "peachsim",
+  commandName: "peach",
+  domain: "peachsim.com",
+  origin: "https://peachsim.com",
+  boxOrigin: "https://rnx-box.contrast.dev"
+});
+
+// src/runtime-delivery.ts
+var DEFAULT_RUNTIME_CDN_ORIGIN = peachPublicBrand.origin;
+var RNX_CHANGELOG_URL = `${peachPublicBrand.origin}/changelog`;
+var RNX_CHANGELOG_API_URL = `${peachPublicBrand.origin}/api/changelog/sootsim`;
+var RNX_RUNTIME_PRODUCT = {
+  id: "peach",
+  defaultCdnOrigin: DEFAULT_RUNTIME_CDN_ORIGIN,
+  manifestPath: "/runtimes/manifest.json",
+  tarballPath: (version) => `/runtimes/sootsim-runtime-${version}.tar.zst`,
+  // the engine runtime is a static SPA: shell at the root, engine/ and
+  // engine-tenant/ beneath it. index.html is what the daemon and the
+  // vite/metro plugins serve, so its absence means the tarball is not one.
+  installedMarker: "index.html",
+  verifyInstall: ensureCliCompanion,
+  env: {
+    cdnOrigin: "PEACH_CDN_ORIGIN",
+    channel: "PEACH_RUNTIME_CHANNEL"
+  },
+  ensureHome: ensureRnxHome,
+  configFile: configFilePath,
+  runtimesDir,
+  runtimeDir,
+  cacheDir,
+  readActiveRuntime,
+  writeActiveRuntime
+};
+var rnxRuntime = createRuntimeDelivery(RNX_RUNTIME_PRODUCT);
+
+// src/runtime-packs.ts
+var inflight = /* @__PURE__ */ new Map();
+var packsByRoot = /* @__PURE__ */ new Map();
+var listedByRoot = /* @__PURE__ */ new Map();
+function listedFiles(runtimeRoot) {
+  let listed = listedByRoot.get(runtimeRoot);
+  if (listed) return listed;
+  listed = /* @__PURE__ */ new Map();
+  for (const [pack, entry] of Object.entries(readPacks(runtimeRoot) ?? {}))
+    for (const file of entry.files ?? []) {
+      const name2 = import_node_path20.default.posix.basename(file);
+      listed.set(name2, [...listed.get(name2) ?? [], { file, pack }]);
+    }
+  listedByRoot.set(runtimeRoot, listed);
+  return listed;
+}
+function readPacks(runtimeRoot) {
+  const cached = packsByRoot.get(runtimeRoot);
+  if (cached !== void 0) return cached;
+  const file = import_node_path20.default.join(runtimeRoot, RUNTIME_PACKS_FILE);
+  if (!import_node_fs16.default.existsSync(file)) {
+    packsByRoot.set(runtimeRoot, null);
+    return null;
+  }
+  const parsed = JSON.parse(import_node_fs16.default.readFileSync(file, "utf8"));
+  const packs = {};
+  if (typeof parsed !== "object" || parsed === null)
+    throw new Error(`${file} is not an object`);
+  for (const [prefix, entry] of Object.entries(parsed)) {
+    if (typeof entry?.file !== "string" || typeof entry?.sha256 !== "string")
+      throw new Error(`${file} entry ${prefix} lacks file and sha256`);
+    const files = entry.files;
+    if (files !== void 0 && !(Array.isArray(files) && files.every((f) => typeof f === "string")))
+      throw new Error(`${file} entry ${prefix} has files that are not paths`);
+    packs[prefix] = {
+      file: entry.file,
+      sha256: entry.sha256,
+      ...files ? { files } : {}
+    };
+  }
+  packsByRoot.set(runtimeRoot, packs);
+  return packs;
+}
+async function ensureRuntimePackFor(runtimeRoot, pathname) {
+  warmRuntimePacks(runtimeRoot);
+  const prefix = RUNTIME_PACK_PREFIXES.find(
+    (candidate) => pathname.includes(`/${candidate}`)
+  );
+  if (prefix) {
+    await installNamedPack(runtimeRoot, prefix);
+    return;
+  }
+  const listed = listedFiles(runtimeRoot).get(import_node_path20.default.posix.basename(pathname))?.find(({ file }) => pathname.endsWith(`/${file}`));
+  if (listed) {
+    if (!import_node_fs16.default.existsSync(import_node_path20.default.join(runtimeRoot, listed.file)))
+      await installNamedPack(runtimeRoot, listed.pack);
+    return;
+  }
+  const at = pathname.indexOf(`/${RUNTIME_MERGE_PACK_DIR}`);
+  if (at === -1) return;
+  const tenantDir = import_node_path20.default.join(runtimeRoot, RUNTIME_MERGE_PACK_DIR);
+  const rel = pathname.slice(at + RUNTIME_MERGE_PACK_DIR.length + 1);
+  if (!/\.m?js$/.test(rel) || import_node_fs16.default.existsSync(import_node_path20.default.join(tenantDir, rel))) return;
+  await installNamedPack(runtimeRoot, RUNTIME_MERGE_PACK_DIR);
+}
+function installNamedPack(runtimeRoot, name2) {
+  if (name2 === RUNTIME_MERGE_PACK_DIR) {
+    const tenantDir = import_node_path20.default.join(runtimeRoot, RUNTIME_MERGE_PACK_DIR);
+    return mergePack(
+      runtimeRoot,
+      name2,
+      import_node_path20.default.join(tenantDir, RUNTIME_MERGE_PACK_INSTALL),
+      tenantDir
+    );
+  }
+  if (readPacks(runtimeRoot)?.[name2]?.files)
+    return mergePack(
+      runtimeRoot,
+      name2,
+      import_node_path20.default.join(runtimeRoot, `.pack-${name2}`),
+      runtimeRoot
+    );
+  return installPack(runtimeRoot, name2, import_node_path20.default.join(runtimeRoot, name2.slice(0, -1)));
+}
+var WARM_DELAY_MS = 3e4;
+var warming = /* @__PURE__ */ new Set();
+function warmRuntimePacks(runtimeRoot) {
+  if (warming.has(runtimeRoot)) return;
+  warming.add(runtimeRoot);
+  const warm = async () => {
+    for (const name2 of Object.keys(readPacks(runtimeRoot) ?? {}))
+      if (!await installNamedPack(runtimeRoot, name2)) return;
+  };
+  const schedule = import_node_timers.setTimeout;
+  schedule(() => void warm(), WARM_DELAY_MS).unref();
+}
+async function mergePack(runtimeRoot, name2, installDir, targetDir) {
+  if (import_node_fs16.default.existsSync(import_node_path20.default.join(installDir, RUNTIME_MERGE_PACK_MERGED))) return true;
+  if (!await installPack(runtimeRoot, name2, installDir)) return false;
+  const link = (sub) => {
+    for (const entry of import_node_fs16.default.readdirSync(import_node_path20.default.join(installDir, sub), {
+      withFileTypes: true
+    })) {
+      const child = import_node_path20.default.join(sub, entry.name);
+      if (entry.isDirectory()) {
+        import_node_fs16.default.mkdirSync(import_node_path20.default.join(targetDir, child), { recursive: true });
+        link(child);
+      } else if (entry.name !== RUNTIME_PACK_MARKER) {
+        try {
+          import_node_fs16.default.linkSync(import_node_path20.default.join(installDir, child), import_node_path20.default.join(targetDir, child));
+        } catch (error) {
+          if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+            throw error;
+        }
+      }
+    }
+  };
+  try {
+    link("");
+    import_node_fs16.default.writeFileSync(import_node_path20.default.join(installDir, RUNTIME_MERGE_PACK_MERGED), "");
+    return true;
+  } catch (error) {
+    console.error(
+      `[peach] ${name2} pack merge failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}
+async function installPack(runtimeRoot, prefix, destDir) {
+  const marker = import_node_path20.default.join(destDir, RUNTIME_PACK_MARKER);
+  if (import_node_fs16.default.existsSync(marker)) return true;
+  const pack = readPacks(runtimeRoot)?.[prefix];
+  if (!pack) return true;
+  let install = inflight.get(destDir);
+  if (!install) {
+    const version = import_node_path20.default.basename(runtimeRoot);
+    const url = new URL(pack.file, rnxRuntime.tarballUrl(version));
+    url.searchParams.set("sha256", pack.sha256);
+    install = installVerifiedTarball({
+      url: url.toString(),
+      digest: { algorithm: "sha256", encoding: "hex", value: pack.sha256 },
+      destDir,
+      installedMarker: RUNTIME_PACK_MARKER,
+      label: `peach runtime ${version} pack ${prefix}`
+    }).catch((error) => {
+      console.error(
+        `[peach] ${prefix} pack download failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }).finally(() => inflight.delete(destDir));
+    inflight.set(destDir, install);
+  }
+  await install;
+  return import_node_fs16.default.existsSync(marker);
+}
+
 // src/swift-vite-lifetime.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 var LIFETIME = Symbol.for("peach.swift-vite-lifetime");
@@ -11132,11 +12358,11 @@ function requestAuthority(req) {
   const authority = req.headers[":authority"];
   return req.headers.host ?? (typeof authority === "string" ? authority : void 0);
 }
-function exposeHeader(res, name) {
+function exposeHeader(res, name2) {
   const exposed = res.getHeader("access-control-expose-headers");
   const names = typeof exposed === "string" && exposed ? exposed.split(/,\s*/) : [];
-  if (!names.includes(name))
-    res.setHeader("access-control-expose-headers", [...names, name].join(", "));
+  if (!names.includes(name2))
+    res.setHeader("access-control-expose-headers", [...names, name2].join(", "));
 }
 var BUNDLE_SOURCE_REQUEST_HEADER = "x-peach-bundle-source";
 var SWIFT_ROUTE_PREFIX = "/__peach/swift";
@@ -11232,7 +12458,7 @@ function peachPlugin(options = {}) {
             }
             res.setHeader(key, value);
           }
-          const forward = res.statusCode === 200 ? forwardRolldownBundleResponse(upstream, res) : (0, import_promises6.pipeline)(upstream, res);
+          const forward = res.statusCode === 200 ? forwardRolldownBundleResponse(upstream, res) : (0, import_promises8.pipeline)(upstream, res);
           forward.catch((error) => {
             console.error("[peach] bundle forward failed", error);
             const failure = error instanceof Error ? error : new Error(String(error));
@@ -11458,7 +12684,7 @@ function peachPlugin(options = {}) {
       });
       const bundleUrl = options.bundleUrl || "/node_modules/one/metro-entry.bundle?platform=ios&dev=true&minify=false";
       const appName = resolveRnxDesktopAppName(options.open, server.config.root);
-      const replacementToken = (0, import_node_crypto6.randomUUID)();
+      const replacementToken = (0, import_node_crypto7.randomUUID)();
       const bundleForOrigin = (origin) => {
         const fullBundleUrl = new URL(bundleUrl, `${origin}/`).toString();
         return tagRnxBundleForPlugin(
@@ -11546,7 +12772,7 @@ function peachPlugin(options = {}) {
           if (!handled) next();
         });
       });
-      server.middlewares.use((req, res, next) => {
+      server.middlewares.use(async (req, res, next) => {
         if (serveBrowserProxyRoute(req, res)) return;
         const url = req.url || "";
         const pathname = url.split("?")[0];
@@ -11560,6 +12786,7 @@ function peachPlugin(options = {}) {
           next();
           return;
         }
+        await ensureRuntimePackFor(runtimeRoot, pathname);
         if (isRootRuntimeAssetPath(pathname)) {
           const fullPath = resolveRuntimeFilePath(runtimeRoot, pathname);
           if (fullPath) {