peachsim 0.1.1469 → 0.1.1481

package/dist-lib/host/bridge-host.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1469 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1481 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;
@@ -35,6 +35,66 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../scripts/lib/chromium-admission.ts
+function readChromiumQueue(deps, verified3, own) {
+  const { fs: fs25, os: os10, path: path29, childProcess: childProcess2 } = deps;
+  const dir = path29.join(
+    process.platform === "win32" ? os10.tmpdir() : "/tmp",
+    "chromium-admission"
+  );
+  fs25.mkdirSync(dir, { recursive: true });
+  const limit = Math.max(2, Math.floor(os10.cpus().length / 3));
+  const live = (entry) => {
+    const match = /^(\d+)-(\d+)-/.exec(entry);
+    if (!match) return false;
+    const pid = Number(match[1]);
+    try {
+      process.kill(pid, 0);
+    } catch (err) {
+      if (!(err instanceof Error && "code" in err && err.code === "EPERM")) return false;
+    }
+    const known = verified3.get(entry);
+    if (known !== void 0) return known;
+    let same = pid === process.pid;
+    if (!same) {
+      try {
+        const started = childProcess2.execFileSync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8" }).trim();
+        same = Math.abs(Date.parse(started) / 1e3 - Number(match[2])) <= 2;
+      } catch {
+        same = false;
+      }
+    }
+    verified3.set(entry, same);
+    return same;
+  };
+  const tickets = [];
+  for (const entry of fs25.readdirSync(dir)) {
+    if (entry !== own && !live(entry)) {
+      try {
+        fs25.unlinkSync(path29.join(dir, entry));
+      } catch {
+      }
+      continue;
+    }
+    try {
+      tickets.push({
+        entry,
+        created: fs25.statSync(path29.join(dir, entry), { bigint: true }).ctimeNs
+      });
+    } catch {
+    }
+  }
+  tickets.sort(
+    (a, b) => a.created === b.created ? a.entry < b.entry ? -1 : 1 : a.created < b.created ? -1 : 1
+  );
+  return { dir, limit, tickets: tickets.map((t) => t.entry) };
+}
+var init_chromium_admission = __esm({
+  "../../scripts/lib/chromium-admission.ts"() {
+    "use strict";
+  }
+});
+
 // src/backend-origin.ts
 function normalizeHostname(hostname) {
   return hostname.replace(/^\[|\]$/g, "").toLowerCase();
@@ -89,6 +149,13 @@ var init_backend_origin = __esm({
   }
 });
 
+// src/bundleGlobalFooter.ts
+var init_bundleGlobalFooter = __esm({
+  "src/bundleGlobalFooter.ts"() {
+    "use strict";
+  }
+});
+
 // src/is-record.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -395,7 +462,7 @@ var init_optional_demo_registry = __esm({
 function rnxHomeDir() {
   const override = process.env[PEACH_HOME_ENV];
   if (override && override.length > 0) return import_node_path4.default.resolve(override);
-  return import_node_path4.default.join((0, import_node_os.homedir)(), ".peach");
+  return import_node_path4.default.join((0, import_node_os2.homedir)(), ".peach");
 }
 function isSootsimDevCheckout() {
   if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
@@ -736,13 +803,13 @@ function removeDevBridgeLockfile(owner) {
   } catch {
   }
 }
-var import_node_crypto, import_node_fs3, import_node_os, import_node_path4, PEACH_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, FETCH_TRANSPORT_DIR, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES, DAEMON_CLAIM_STALE_MS;
+var import_node_crypto, import_node_fs3, import_node_os2, import_node_path4, PEACH_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, FETCH_TRANSPORT_DIR, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES, DAEMON_CLAIM_STALE_MS;
 var init_home_paths = __esm({
   "src/home-paths.ts"() {
     "use strict";
     import_node_crypto = require("node:crypto");
     import_node_fs3 = __toESM(require("node:fs"), 1);
-    import_node_os = require("node:os");
+    import_node_os2 = require("node:os");
     import_node_path4 = __toESM(require("node:path"), 1);
     PEACH_HOME_ENV = "PEACH_HOME";
     ACTIVE_RUNTIME_FILE = "active";
@@ -3231,11 +3298,11 @@ async function serveKotlinRequest(pathname, res, app) {
   }
   return true;
 }
-var import_node_child_process13, import_node_crypto14, import_node_fs30, import_node_module2, import_node_path31, import_node_url4, import_node_util4, import_acorn, run4, KOTLIN_ARTIFACT_PREFIX, toolchainReady, SKIP_DIRS, BUILD_FORMAT, builds, expoTypeScans, argb, escapes, literal, CONTENT_TYPES, KOTLIN_PACKAGE_PATH;
+var import_node_child_process12, import_node_crypto14, import_node_fs30, import_node_module2, import_node_path31, import_node_url4, import_node_util4, import_acorn, run4, KOTLIN_ARTIFACT_PREFIX, toolchainReady, SKIP_DIRS, BUILD_FORMAT, builds, expoTypeScans, argb, escapes, literal, CONTENT_TYPES, KOTLIN_PACKAGE_PATH;
 var init_kotlin_host = __esm({
   "src/kotlin-host.ts"() {
     "use strict";
-    import_node_child_process13 = require("node:child_process");
+    import_node_child_process12 = require("node:child_process");
     import_node_crypto14 = require("node:crypto");
     import_node_fs30 = __toESM(require("node:fs"), 1);
     import_node_module2 = require("node:module");
@@ -3246,7 +3313,7 @@ var init_kotlin_host = __esm({
     init_home_paths();
     init_is_record();
     init_kotlin_view_models();
-    run4 = (0, import_node_util4.promisify)(import_node_child_process13.execFile);
+    run4 = (0, import_node_util4.promisify)(import_node_child_process12.execFile);
     KOTLIN_ARTIFACT_PREFIX = "/__peach/kotlin-artifact/";
     SKIP_DIRS = /* @__PURE__ */ new Set([
       "node_modules",
@@ -3432,11 +3499,11 @@ async function handleExpoKotlinRequest(req, res) {
   }
   return true;
 }
-var import_node_child_process14, import_node_fs31, import_node_module3, import_node_path32, import_node_util5, run5, scriptEnv2, EXPO_KOTLIN_ROUTE, MODULE_ROOT, compiling2;
+var import_node_child_process13, import_node_fs31, import_node_module3, import_node_path32, import_node_util5, run5, scriptEnv2, EXPO_KOTLIN_ROUTE, MODULE_ROOT, compiling2;
 var init_expo_kotlin_host = __esm({
   "src/expo-kotlin-host.ts"() {
     "use strict";
-    import_node_child_process14 = require("node:child_process");
+    import_node_child_process13 = require("node:child_process");
     import_node_fs31 = __toESM(require("node:fs"), 1);
     import_node_module3 = require("node:module");
     import_node_path32 = __toESM(require("node:path"), 1);
@@ -3444,7 +3511,7 @@ var init_expo_kotlin_host = __esm({
     init_internal_child();
     init_backend_origin();
     init_is_record();
-    run5 = (0, import_node_util5.promisify)(import_node_child_process14.execFile);
+    run5 = (0, import_node_util5.promisify)(import_node_child_process13.execFile);
     scriptEnv2 = { ...process.env, [RNX_FORKED_SCRIPT_ENV]: "1" };
     EXPO_KOTLIN_ROUTE = "/__peach/expo-kotlin";
     MODULE_ROOT = import_node_path32.default.resolve(__sootsim_import_meta_dirname, "../kotlin");
@@ -3738,6 +3805,7 @@ function rotateDevice(device, side) {
     frameCornerRadius: device.frameCornerRadius ? rotateCorners(device.frameCornerRadius, side) : void 0,
     cornerRadius: rotateCorners(device.cornerRadius, side),
     continuousCornerRadius: rotateCorners(device.continuousCornerRadius, side),
+    systemCornerRadius: device.systemCornerRadius ? rotateCorners(device.systemCornerRadius, side) : void 0,
     housing: device.housing ? {
       rail: rotateFrameInsets(device.housing.rail, side),
       // the rotated barrel is accounted for in frameInsets.
@@ -4552,6 +4620,7 @@ var RNX_METRO_MODULE_IDENTITY_VERSION;
 var init_metro_production_bundle = __esm({
   "src/metro-production-bundle.ts"() {
     "use strict";
+    init_bundleGlobalFooter();
     RNX_METRO_MODULE_IDENTITY_VERSION = 2;
   }
 });
@@ -4617,6 +4686,7 @@ function quotedEnd(text3, start, end) {
   return end;
 }
 function decodeSingleQuoted(contents) {
+  if (!contents.includes("\\")) return contents;
   let value = "";
   for (let cursor = 0; cursor < contents.length; cursor++) {
     const character = contents[cursor];
@@ -5029,13 +5099,21 @@ function metroAssetDataUri(type, bytes) {
   return `data:${metroAssetContentType(type)};base64,${base64FromBytes(bytes)}`;
 }
 async function sha256HexBytes(bytes) {
-  const buffer = bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes.buffer : bytes.slice().buffer;
-  const digest = await crypto.subtle.digest("SHA-256", buffer);
+  const digest = await crypto.subtle.digest("SHA-256", Uint8Array.from(bytes).buffer);
   let hex = "";
   for (const byte of new Uint8Array(digest)) hex += byte.toString(16).padStart(2, "0");
   return hex;
 }
 async function assertSelfContainedMetroArtifactAssets(bundle) {
+  return visitVerifiedMetroArtifactAssets(
+    bundle,
+    () => {
+    },
+    () => {
+    }
+  );
+}
+async function visitVerifiedMetroArtifactAssets(bundle, acceptVariant, acceptSite) {
   const seen = /* @__PURE__ */ new Set();
   const manifestLines = [];
   let descriptorsCount = 0;
@@ -5046,7 +5124,10 @@ async function assertSelfContainedMetroArtifactAssets(bundle) {
     for (const site of iterateAssetDescriptorSites(bundle)) {
       const descriptor = site.descriptor;
       const key2 = assetDescriptorKey(descriptor);
-      if (seen.has(key2)) continue;
+      if (seen.has(key2)) {
+        acceptSite(site);
+        continue;
+      }
       seen.add(key2);
       descriptorsCount++;
       const label = `${descriptor.httpServerLocation}/${descriptor.name}.${descriptor.type}`;
@@ -5081,11 +5162,13 @@ async function assertSelfContainedMetroArtifactAssets(bundle) {
             `peach ios --remote bundle is not self-contained: ${label} scale ${descriptor.scales[index]} bytes do not match their content hash`
           );
         }
+        acceptVariant(descriptor, index, decoded);
         variants++;
         bytes += decoded.byteLength;
         descriptorBytes += decoded.byteLength;
       }
       sizes.push({ asset: label, bytes: descriptorBytes });
+      acceptSite(site);
     }
   } catch (error) {
     if (error instanceof Error && error.message.startsWith("peach ios --remote bundle is not self-contained:")) {
@@ -5107,52 +5190,48 @@ async function assertSelfContainedMetroArtifactAssets(bundle) {
   };
 }
 async function separateMetroArtifactAssets(bundle) {
-  const assets2 = await assertSelfContainedMetroArtifactAssets(bundle);
-  const sites = scanAssetDescriptorSites(bundle);
   const resources = /* @__PURE__ */ new Map();
   const entries = /* @__PURE__ */ new Map();
-  for (const site of sites) {
-    const descriptor = site.descriptor;
-    const key2 = assetDescriptorKey(descriptor);
-    if (entries.has(key2)) continue;
-    const contentType = metroAssetContentType(descriptor.type);
-    const prefix = `data:${contentType};base64,`;
-    const fileUris = [];
-    const fileHashes = [];
-    for (let index = 0; index < descriptor.scales.length; index++) {
-      const dataUri = descriptor.fileUris?.[index];
+  const pieces = [];
+  let cursor = 0;
+  const assets2 = await visitVerifiedMetroArtifactAssets(
+    bundle,
+    (descriptor, index, bytes) => {
+      const key2 = assetDescriptorKey(descriptor);
+      let entry = entries.get(key2);
+      if (!entry) {
+        entry = { fileUris: [], fileHashes: [], scales: descriptor.scales };
+        entries.set(key2, entry);
+      }
       const sha256 = descriptor.fileHashes?.[index];
-      if (!dataUri || !sha256) throw new Error("verified Metro asset is incomplete");
       const scale = descriptor.scales[index];
-      if (scale === void 0) throw new Error("verified Metro asset scale is missing");
+      if (!sha256 || scale === void 0) {
+        throw new Error("verified Metro asset variant is incomplete");
+      }
       const filename = metroAssetScaleFilename(descriptor.name, descriptor.type, scale);
       const uri = `${PEACH_BUNDLE_ASSET_PREFIX}${sha256}/${encodeURIComponent(filename)}`;
       if (!resources.has(uri)) {
-        const bytes = decodeBase64ToBytes(dataUri.slice(prefix.length));
         resources.set(uri, {
           uri,
           sha256,
-          contentType,
+          contentType: metroAssetContentType(descriptor.type),
           bytes,
           byteLength: bytes.byteLength
         });
       }
-      fileUris.push(uri);
-      fileHashes.push(sha256);
+      entry.fileUris.push(uri);
+      entry.fileHashes.push(sha256);
+    },
+    (site) => {
+      const entry = entries.get(assetDescriptorKey(site.descriptor));
+      if (!entry) throw new Error("verified Metro asset descriptor is missing");
+      pieces.push(
+        bundle.slice(cursor, site.start),
+        rewriteDescriptorObject(bundle, site, entry)
+      );
+      cursor = site.end;
     }
-    entries.set(key2, { fileUris, fileHashes, scales: descriptor.scales });
-  }
-  const pieces = [];
-  let cursor = 0;
-  for (const site of sites) {
-    const entry = entries.get(assetDescriptorKey(site.descriptor));
-    if (!entry) throw new Error("verified Metro asset descriptor is missing");
-    pieces.push(
-      bundle.slice(cursor, site.start),
-      rewriteDescriptorObject(bundle, site, entry)
-    );
-    cursor = site.end;
-  }
+  );
   pieces.push(bundle.slice(cursor));
   return { code: pieces.join(""), assets: assets2, resources: [...resources.values()] };
 }
@@ -10492,11 +10571,13 @@ __export(bridge_host_exports, {
   injectSharedConfigIntoHtml: () => injectSharedConfigIntoHtml
 });
 module.exports = __toCommonJS(bridge_host_exports);
-var import_child_process3 = require("child_process");
+var import_child_process3 = __toESM(require("child_process"), 1);
 var import_fs2 = __toESM(require("fs"), 1);
 var import_http4 = require("http");
+var import_os = __toESM(require("os"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var import_ws = require("ws");
+init_chromium_admission();
 
 // scripts/dev-server-scanner.ts
 var import_child_process = require("child_process");
@@ -10504,162 +10585,8 @@ var import_promises2 = require("fs/promises");
 var import_http = __toESM(require("http"), 1);
 var import_net = __toESM(require("net"), 1);
 var import_node_fs2 = require("node:fs");
+var import_node_os = require("node:os");
 var import_node_path3 = require("node:path");
-
-// ../contrast/src/runtime/process-group.ts
-var import_node_child_process = require("node:child_process");
-
-// ../contrast/src/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
-}
-
-// ../contrast/src/runtime/process-group.ts
-var GRACEFUL_TIMEOUT_MS = 3e3;
-var FORCED_EXIT_TIMEOUT_MS = 1e3;
-function signalProcessGroup(child, signal) {
-  if (!child.pid) return;
-  try {
-    process.kill(-child.pid, signal);
-  } catch {
-    try {
-      process.kill(child.pid, signal);
-    } catch {
-    }
-  }
-}
-function runningPids(pids) {
-  return pids.filter((pid) => {
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch (error) {
-      return error instanceof Error && "code" in error && error.code === "EPERM";
-    }
-  });
-}
-function groupIsEmpty(pgid) {
-  try {
-    process.kill(-pgid, 0);
-  } catch (error) {
-    if (!(error instanceof Error && "code" in error && error.code === "EPERM"))
-      return true;
-  }
-  const result = (0, import_node_child_process.spawnSync)("ps", ["-A", "-o", "pgid=,stat="], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.error || result.status !== 0) return false;
-  return !result.stdout.split("\n").some((line) => {
-    const [group, state] = line.trim().split(/\s+/);
-    return Number(group) === pgid && state !== void 0 && !state.startsWith("Z");
-  });
-}
-async function waitForExit(pids, pgid, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  const gone = () => runningPids(pids).length === 0 && groupIsEmpty(pgid);
-  while (Date.now() < deadline) {
-    if (gone()) return true;
-    await sleep(50);
-  }
-  return gone();
-}
-async function terminateProcessGroup(child, signal = "SIGTERM", gracefulTimeoutMs = GRACEFUL_TIMEOUT_MS) {
-  if (!child.pid) {
-    try {
-      child.kill(signal);
-    } catch {
-    }
-    return;
-  }
-  signalProcessGroup(child, "SIGSTOP");
-  const descendants = /* @__PURE__ */ new Set();
-  let parents = [child.pid];
-  let inspectionError = null;
-  while (parents.length > 0) {
-    const result = (0, import_node_child_process.spawnSync)("pgrep", ["-P", parents.join(",")], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if (result.error || result.status !== 0 && result.status !== 1) {
-      inspectionError = new Error(
-        `could not inspect descendants of processes ${parents.join(",")}: ${result.error?.message || result.stderr.trim() || `pgrep exited ${result.status}`}`
-      );
-      break;
-    }
-    const next = [];
-    for (const line of result.stdout.split("\n")) {
-      const descendantPid = Number(line.trim());
-      if (Number.isInteger(descendantPid) && descendantPid > 1 && !descendants.has(descendantPid)) {
-        descendants.add(descendantPid);
-        next.push(descendantPid);
-        try {
-          process.kill(descendantPid, "SIGSTOP");
-        } catch {
-        }
-      }
-    }
-    parents = next;
-  }
-  const pids = [child.pid, ...descendants];
-  const gracefulDeadline = Date.now() + gracefulTimeoutMs;
-  try {
-    process.kill(child.pid, signal);
-  } catch {
-  }
-  signalProcessGroup(child, "SIGCONT");
-  for (const pid of descendants) {
-    try {
-      process.kill(pid, "SIGCONT");
-    } catch {
-    }
-  }
-  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");
-  await waitForExit(pids, child.pid, FORCED_EXIT_TIMEOUT_MS);
-  if (inspectionError) throw inspectionError;
-}
-
-// scripts/dev-server-scanner.ts
 init_backend_origin();
 
 // ../contrast-runtime-delivery/src/version.ts
@@ -10668,6 +10595,7 @@ function isValidRuntimeVersion(value) {
 }
 
 // src/config.ts
+init_bundleGlobalFooter();
 init_is_record();
 var PEACH_CONFIG_QUERY_PARAM = "peachConfig";
 function hasOwnKeys(value) {
@@ -11154,52 +11082,211 @@ function parseSwiftHostDiscovery(value) {
 
 // scripts/dev-server-scanner.ts
 init_optional_demo_registry();
-function execGuarded(command, timeout, extra = {}) {
-  const maxBuffer = extra.maxBuffer ?? 1024 * 1024;
-  return new Promise((resolve5, reject) => {
-    const child = (0, import_child_process.spawn)("/bin/sh", ["-c", command], {
-      detached: true,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    let stdout = "";
-    let settled = false;
-    let killing = false;
-    const settle = (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(deadline);
-      if (err) reject(err);
-      else resolve5({ stdout });
-    };
-    const killThenSettle = (err) => {
-      if (killing) return;
-      killing = true;
-      clearTimeout(deadline);
-      terminateProcessGroup(child, "SIGKILL", 0).finally(() => settle(err));
-    };
-    const deadline = setTimeout(() => {
-      killThenSettle(
-        Object.assign(new Error(`\`${command}\` did not exit within ${timeout}ms`), {
-          killed: true
-        })
-      );
-    }, timeout);
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-      if (stdout.length > maxBuffer) {
-        killThenSettle(new Error(`\`${command}\` exceeded maxBuffer ${maxBuffer}`));
-      }
-    });
-    child.on("error", (err) => {
-      if (!killing) settle(err);
-    });
-    child.on("close", (code) => {
-      if (killing) return;
-      settle(code === 0 ? null : new Error(`\`${command}\` exited with ${code}`));
-    });
+var LISTENER_LOCK_PATH = (0, import_node_path3.join)((0, import_node_os.tmpdir)(), "peach-listener-scan.lock");
+var LISTENER_RESULT_PATH = (0, import_node_path3.join)((0, import_node_os.tmpdir)(), "peach-listener-scan.result");
+var LISTENER_LOCK_STALE_MS = 25e3;
+var LISTENER_LOCK_WAIT_MS = 8e3;
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+function pidIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+    return code !== "ESRCH";
+  }
+}
+function readLockOwner() {
+  try {
+    const raw2 = (0, import_node_fs2.readFileSync)(LISTENER_LOCK_PATH, "utf8");
+    const mtimeMs = (0, import_node_fs2.statSync)(LISTENER_LOCK_PATH).mtimeMs;
+    const pid = Number(raw2.split("-")[0]);
+    return { raw: raw2, pid: Number.isInteger(pid) ? pid : -1, mtimeMs };
+  } catch {
+    return null;
+  }
+}
+function lockIsAbandoned(owner) {
+  if (owner.pid <= 0 || !pidIsAlive(owner.pid)) return true;
+  return Date.now() - owner.mtimeMs > LISTENER_LOCK_STALE_MS;
+}
+function clearLock(raw2) {
+  try {
+    if ((0, import_node_fs2.readFileSync)(LISTENER_LOCK_PATH, "utf8") !== raw2) return;
+    (0, import_node_fs2.unlinkSync)(LISTENER_LOCK_PATH);
+  } catch {
+  }
+}
+function readResult() {
+  try {
+    const parsed = JSON.parse(
+      (0, import_node_fs2.readFileSync)(LISTENER_RESULT_PATH, "utf8")
+    );
+    if (!parsed || typeof parsed.token !== "string" || typeof parsed.key !== "string")
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function publishResult(payload) {
+  const tmp = `${LISTENER_RESULT_PATH}.${process.pid}.tmp`;
+  (0, import_node_fs2.writeFileSync)(tmp, JSON.stringify(payload));
+  (0, import_node_fs2.renameSync)(tmp, LISTENER_RESULT_PATH);
+}
+function throwPublished(payload) {
+  throw Object.assign(new Error(payload.message || "listener scan failed"), {
+    killed: payload.killed === true
   });
 }
+async function waitForSharedResult(owner, key2) {
+  const cap = Date.now() + LISTING_TIMEOUT_MS;
+  let current = owner;
+  while (Date.now() < cap) {
+    const published = readResult();
+    if (published && published.token === current.raw) {
+      if (published.key !== key2) return { kind: "retry" };
+      if (!published.ok) throwPublished(published);
+      return { kind: "value", value: published.value };
+    }
+    const latest = readLockOwner();
+    if (!latest) {
+      const again = readResult();
+      if (again && again.token === current.raw && again.key === key2) {
+        if (!again.ok) throwPublished(again);
+        return { kind: "value", value: again.value };
+      }
+      return { kind: "retry" };
+    }
+    if (latest.raw !== current.raw) current = latest;
+    if (lockIsAbandoned(latest)) {
+      clearLock(latest.raw);
+      return { kind: "retry" };
+    }
+    await sleep(25);
+  }
+  throw Object.assign(new Error("listener scan lock was held past the wait"), {
+    killed: true
+  });
+}
+async function withListenerLock(key2, body) {
+  const token = `${process.pid}-${Date.now()}-${Math.random()}`;
+  const deadline = Date.now() + LISTENER_LOCK_WAIT_MS;
+  for (; ; ) {
+    let fd = null;
+    try {
+      fd = (0, import_node_fs2.openSync)(LISTENER_LOCK_PATH, "wx");
+    } catch (error) {
+      const code = error instanceof Error && "code" in error ? error.code : "";
+      if (code !== "EEXIST") throw error;
+      const owner = readLockOwner();
+      if (!owner || lockIsAbandoned(owner)) {
+        if (owner) clearLock(owner.raw);
+        else {
+          try {
+            (0, import_node_fs2.unlinkSync)(LISTENER_LOCK_PATH);
+          } catch {
+          }
+        }
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        const shared = await waitForSharedResult(owner, key2);
+        if (shared.kind === "value") return shared.value;
+        continue;
+      }
+      await sleep(25);
+      continue;
+    }
+    if (fd === null) continue;
+    try {
+      (0, import_node_fs2.writeSync)(fd, token);
+      try {
+        const value = await body();
+        publishResult({ token, key: key2, ok: true, value });
+        return value;
+      } catch (error) {
+        publishResult({
+          token,
+          key: key2,
+          ok: false,
+          message: error instanceof Error ? error.message : String(error),
+          killed: !!(error && typeof error === "object" && error.killed)
+        });
+        throw error;
+      }
+    } finally {
+      try {
+        (0, import_node_fs2.closeSync)(fd);
+      } catch {
+      }
+      clearLock(token);
+    }
+  }
+}
+function spawnReaped(file, args, timeoutMs, maxBuffer = 1024 * 1024) {
+  return withListenerLock(
+    `${file}\0${args.join("\0")}`,
+    () => new Promise((resolvePromise, reject) => {
+      const child = (0, import_child_process.spawn)(file, args, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let settled = false;
+      let timedOut = false;
+      let overflow = false;
+      let spawnError = null;
+      const timeoutError = () => Object.assign(new Error(`\`${file}\` did not exit within ${timeoutMs}ms`), {
+        killed: true
+      });
+      const finish = (err, code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(deadline);
+        clearTimeout(backup);
+        if (err) reject(err);
+        else resolvePromise({ stdout, code });
+      };
+      const killChild = () => {
+        if (child.exitCode !== null || child.signalCode !== null) return;
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      };
+      let backup;
+      const deadline = setTimeout(() => {
+        timedOut = true;
+        killChild();
+        backup = setTimeout(() => finish(timeoutError(), null), 1e3);
+      }, timeoutMs);
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.on("data", () => {
+      });
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+        if (stdout.length > maxBuffer) {
+          overflow = true;
+          killChild();
+        }
+      });
+      child.on("error", (err) => {
+        spawnError = err;
+        killChild();
+      });
+      child.on("close", (code) => {
+        if (timedOut) finish(timeoutError(), code);
+        else if (overflow)
+          finish(new Error(`\`${file}\` exceeded maxBuffer ${maxBuffer}`), code);
+        else if (spawnError && !stdout) finish(spawnError, code);
+        else finish(null, code);
+      });
+    })
+  );
+}
 var TIMEOUT_MS = 250;
 var MANIFEST_TIMEOUT_MS = 1500;
 var TCP_GATE_MS = 120;
@@ -11315,118 +11402,221 @@ async function scanListeningProcesses(excludePorts = []) {
     processes: listing.processes.filter((p) => acceptPort(p.port, excluded))
   };
 }
+var LISTENER_CACHE_MS = 2e3;
+var listenerCache = null;
 var inflightListing = null;
+var listenerHolds = 0;
+function cachedPidsAlive(scan) {
+  if (scan.state !== "looked") return true;
+  return scan.processes.every((entry) => entry.pid <= 0 || pidIsAlive(entry.pid));
+}
+async function cachedPortsStillHeld(scan) {
+  if (scan.state !== "looked") return true;
+  const owned = scan.processes.filter((entry) => entry.pid > 0);
+  if (owned.length === 0) return true;
+  const pids = [...new Set(owned.map((entry) => entry.pid))];
+  try {
+    const { stdout, code } = await spawnReaped(
+      "lsof",
+      ["-nP", "-b", "-w", "-a", "-p", pids.join(","), "-iTCP", "-sTCP:LISTEN", "-Fpcn"],
+      8e3,
+      16 * 1024 * 1024
+    );
+    if (code !== 0 && code !== 1) return false;
+    const live = new Set(
+      parseLsofListeners(stdout).map((entry) => `${entry.port}:${entry.pid}`)
+    );
+    return owned.every((entry) => live.has(`${entry.port}:${entry.pid}`));
+  } catch {
+    return false;
+  }
+}
 function listListenersShared() {
-  inflightListing ??= listListeners().finally(() => {
+  inflightListing ??= loadListeners().finally(() => {
     inflightListing = null;
   });
   return inflightListing;
 }
+async function loadListeners() {
+  const cached3 = listenerCache;
+  if (cached3 && (listenerHolds > 0 || Date.now() - cached3.at < LISTENER_CACHE_MS) && cachedPidsAlive(cached3.scan) && await cachedPortsStillHeld(cached3.scan)) {
+    return cached3.scan;
+  }
+  listenerCache = null;
+  const scan = await listListeners();
+  listenerCache = { at: Date.now(), scan };
+  return scan;
+}
+function isSpawnMissing(err) {
+  return !!(err && typeof err === "object" && err.code === "ENOENT");
+}
+function parseLsofListeners(stdout) {
+  const seen = /* @__PURE__ */ new Map();
+  let pid = 0;
+  let command = "";
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("p")) {
+      pid = Number(line.slice(1));
+      command = "";
+      continue;
+    }
+    if (line.startsWith("c")) {
+      command = line.slice(1);
+      continue;
+    }
+    if (!line.startsWith("n") || pid <= 0) continue;
+    if (!/^(node|bun|peach|vite)/.test(command)) continue;
+    const match = line.match(/:(\d+)$/);
+    if (!match) continue;
+    const port = Number(match[1]);
+    if (!seen.has(port)) seen.set(port, pid);
+  }
+  return [...seen.entries()].map(([port, owner]) => ({ port, pid: owner }));
+}
+function parseSsListeners(stdout) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const line of stdout.split("\n")) {
+    if (!/"(node|bun|peach|vite)/.test(line)) continue;
+    const portMatch = line.match(/:(\d+)\s/);
+    const pidMatch = line.match(/pid=(\d+)/);
+    if (!portMatch) continue;
+    const port = Number(portMatch[1]);
+    const pid = pidMatch ? Number(pidMatch[1]) : 0;
+    if (!seen.has(port)) seen.set(port, pid);
+  }
+  return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
+}
 async function listListeners() {
   let timedOut = false;
   try {
-    const { stdout } = await execGuarded(
-      `lsof -a -c node -c bun -c peach -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun|peach)'`,
-      LISTING_TIMEOUT_MS
+    const { stdout, code } = await spawnReaped(
+      "lsof",
+      [
+        "-nP",
+        "-a",
+        "-c",
+        "node",
+        "-c",
+        "bun",
+        "-c",
+        "peach",
+        "-c",
+        "vite",
+        "-iTCP",
+        "-sTCP:LISTEN",
+        "-Fpcn"
+      ],
+      LISTING_TIMEOUT_MS,
+      16 * 1024 * 1024
     );
-    const seen = /* @__PURE__ */ new Map();
-    for (const line of stdout.trim() ? stdout.trim().split("\n") : []) {
-      const parts = line.trim().split(/\s+/);
-      if (parts.length < 9) continue;
-      const pid = Number(parts[1]);
-      const m = parts[8].match(/:(\d+)$/);
-      if (!m) continue;
-      const port = Number(m[1]);
-      if (!seen.has(port)) seen.set(port, pid);
+    if (code === 0 || code === 1) {
+      return { state: "looked", processes: parseLsofListeners(stdout) };
     }
-    return {
-      state: "looked",
-      processes: [...seen.entries()].map(([port, pid]) => ({ port, pid }))
-    };
   } catch (err) {
     if (wasKilledByTimeout(err)) timedOut = true;
+    else if (!isSpawnMissing(err)) return { state: "could-not-look" };
   }
-  try {
-    const { stdout } = await execGuarded(
-      `ss -tlnp 2>/dev/null | grep -E '"(node|bun|peach)"'`,
-      LISTING_TIMEOUT_MS
-    );
-    const seen = /* @__PURE__ */ new Map();
-    for (const line of stdout.trim() ? stdout.trim().split("\n") : []) {
-      const portMatch = line.match(/:(\d+)\s/);
-      const pidMatch = line.match(/pid=(\d+)/);
-      if (!portMatch) continue;
-      const port = Number(portMatch[1]);
-      const pid = pidMatch ? Number(pidMatch[1]) : 0;
-      if (!seen.has(port)) seen.set(port, pid);
+  if (!timedOut) {
+    try {
+      const { stdout, code } = await spawnReaped(
+        "ss",
+        ["-H", "-ltnp"],
+        LISTING_TIMEOUT_MS,
+        16 * 1024 * 1024
+      );
+      if (code === 0 || code === 1) {
+        return { state: "looked", processes: parseSsListeners(stdout) };
+      }
+    } catch (err) {
+      if (wasKilledByTimeout(err)) timedOut = true;
+      else if (!isSpawnMissing(err)) return { state: "could-not-look" };
     }
-    return {
-      state: "looked",
-      processes: [...seen.entries()].map(([port, pid]) => ({ port, pid }))
-    };
-  } catch (err) {
-    if (wasKilledByTimeout(err)) timedOut = true;
   }
   if (timedOut) return { state: "could-not-look" };
   return { state: "looked", processes: FALLBACK_PORTS };
 }
 async function resolveListeningPid(port) {
   if (!Number.isInteger(port) || port <= 0) return null;
-  if (process.platform === "darwin") {
-    try {
-      const { stdout } = await execGuarded(
-        `lsof -nP -a -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null`,
-        8e3
-      );
-      const pids = [...new Set(stdout.trim().split(/\s+/).map(Number))];
-      return pids.length === 1 && Number.isInteger(pids[0]) && pids[0] > 0 ? pids[0] : null;
-    } catch {
-      return null;
-    }
-  }
-  try {
-    const { stdout } = await execGuarded(`ss -tlnp 2>/dev/null`, 8e3, {
-      maxBuffer: 16 * 1024 * 1024
-    });
-    for (const line of stdout.split("\n")) {
-      if (!new RegExp(`:${port}\\s`).test(line)) continue;
-      const pid = Number(line.match(/pid=(\d+)/)?.[1]);
-      if (pid > 0) return pid;
-    }
-  } catch {
-  }
-  return null;
+  const scan = await listListenersShared();
+  if (scan.state !== "looked") return null;
+  const pids = [
+    ...new Set(
+      scan.processes.filter((entry) => entry.port === port && entry.pid > 0).map((entry) => entry.pid)
+    )
+  ];
+  return pids.length === 1 && pids[0] !== void 0 ? pids[0] : null;
 }
 var cwdByPid = /* @__PURE__ */ new Map();
-async function resolveProcessCwd(pid) {
-  if (pid <= 0) return null;
-  const cached3 = cwdByPid.get(pid);
-  if (cached3) return cached3;
-  try {
-    const cwd = await (0, import_promises2.readlink)(`/proc/${pid}/cwd`);
-    if (cwd) {
-      cwdByPid.set(pid, cwd);
-      return cwd;
-    }
-  } catch {
-  }
-  try {
-    const { stdout } = await execGuarded(
-      `lsof -b -w -p ${pid} -a -d cwd -Fn 2>/dev/null`,
-      8e3
+var cwdQueue = [];
+var cwdFlushing = false;
+function kickCwdFlush() {
+  if (cwdFlushing || cwdQueue.length === 0) return;
+  cwdFlushing = true;
+  void flushCwdQueue().finally(() => {
+    cwdFlushing = false;
+    kickCwdFlush();
+  });
+}
+async function flushCwdQueue() {
+  await Promise.resolve();
+  while (cwdQueue.length > 0) {
+    const batch = cwdQueue.splice(0, cwdQueue.length);
+    const pending = [...new Set(batch.map((waiter) => waiter.pid))].filter(
+      (pid) => !cwdByPid.has(pid)
     );
-    for (const line of stdout.split("\n")) {
-      if (line.startsWith("n") && line.length > 1) {
-        const cwd = line.slice(1).trim();
+    const needLsof = [];
+    for (const pid of pending) {
+      try {
+        const cwd = await (0, import_promises2.readlink)(`/proc/${pid}/cwd`);
         if (cwd) {
           cwdByPid.set(pid, cwd);
-          return cwd;
+          continue;
         }
+      } catch {
       }
+      needLsof.push(pid);
     }
-  } catch {
+    if (needLsof.length > 0) {
+      let looked = false;
+      try {
+        const { stdout, code } = await spawnReaped(
+          "lsof",
+          ["-b", "-w", "-nP", "-a", "-d", "cwd", "-p", needLsof.join(","), "-Fn"],
+          8e3,
+          4 * 1024 * 1024
+        );
+        if (code === 0 || code === 1) {
+          looked = true;
+          let current = 0;
+          for (const line of stdout.split("\n")) {
+            if (line.startsWith("p")) {
+              current = Number(line.slice(1));
+              continue;
+            }
+            if (!line.startsWith("n") || line.length <= 1 || !needLsof.includes(current))
+              continue;
+            const cwd = line.slice(1).trim();
+            if (cwd) cwdByPid.set(current, cwd);
+          }
+        }
+      } catch {
+      }
+      if (looked) {
+        for (const pid of needLsof) {
+          if (!cwdByPid.has(pid)) cwdByPid.set(pid, null);
+        }
+      }
+    }
+    for (const waiter of batch) waiter.resolve(cwdByPid.get(waiter.pid) ?? null);
   }
-  return null;
+}
+function resolveProcessCwd(pid) {
+  if (pid <= 0) return Promise.resolve(null);
+  if (cwdByPid.has(pid)) return Promise.resolve(cwdByPid.get(pid) ?? null);
+  return new Promise((resolveCwd) => {
+    cwdQueue.push({ pid, resolve: resolveCwd });
+    kickCwdFlush();
+  });
 }
 function makeResult(hostname, port, framework, owner) {
   return {
@@ -11841,6 +12031,7 @@ async function scanDevServers(opts = {}) {
   const scan = await scanListeningProcesses(opts.excludePorts);
   if (scan.state === "could-not-look") throw new DevServerScanUnavailableError();
   const processes = scan.processes;
+  await Promise.all(processes.map((entry) => resolveProcessCwd(entry.pid)));
   const currentPorts = new Set(processes.map((p) => p.port));
   for (const p of [...portCache.keys()]) {
     if (!currentPorts.has(p)) portCache.delete(p);
@@ -11975,15 +12166,15 @@ function getCliVersion() {
 }
 
 // src/desktop-host-delivery.ts
-var import_node_child_process3 = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 var import_node_fs8 = __toESM(require("node:fs"), 1);
 var import_node_path8 = __toESM(require("node:path"), 1);
 
 // ../contrast-runtime-delivery/src/index.ts
-var import_node_child_process2 = require("node:child_process");
+var import_node_child_process = require("node:child_process");
 var import_node_crypto2 = __toESM(require("node:crypto"), 1);
 var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
 var import_node_path7 = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
 var import_promises3 = require("node:stream/promises");
@@ -12326,7 +12517,7 @@ function createRuntimeDelivery(product) {
 }
 async function installVerifiedTarball(tarball) {
   const { url, digest, destDir, installedMarker, label } = tarball;
-  const downloadDir = import_node_fs7.default.mkdtempSync(import_node_path7.default.join(import_node_os2.default.tmpdir(), "runtime-delivery-download-"));
+  const downloadDir = import_node_fs7.default.mkdtempSync(import_node_path7.default.join(import_node_os3.default.tmpdir(), "runtime-delivery-download-"));
   const archivePath = import_node_path7.default.join(downloadDir, "archive");
   import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(destDir), { recursive: true });
   const tmpDir = import_node_fs7.default.mkdtempSync(
@@ -12414,7 +12605,7 @@ function extractTarball(tarPath, destDir, stripComponents) {
 }
 function runExtractor(command, args) {
   return new Promise((resolve5, reject) => {
-    const child = (0, import_node_child_process2.spawn)(command, args, {
+    const child = (0, import_node_child_process.spawn)(command, args, {
       stdio: ["ignore", "inherit", "inherit"]
     });
     child.on("error", reject);
@@ -12438,7 +12629,7 @@ function desktopHostExecutable() {
 var MAC_HOST_APP = "/Applications/Peach.app";
 var HOST_BUNDLE_ID = "dev.contrast.peach-desktop";
 function bundleValue(app, key2) {
-  const read = (0, import_node_child_process3.spawnSync)(
+  const read = (0, import_node_child_process2.spawnSync)(
     "plutil",
     ["-extract", key2, "raw", "-o", "-", import_node_path8.default.join(app, "Contents/Info.plist")],
     { encoding: "utf8" }
@@ -12464,24 +12655,29 @@ function activeDesktopHostApp() {
 }
 
 // src/expo-swift-host.ts
-var import_node_child_process10 = require("node:child_process");
+var import_node_child_process9 = require("node:child_process");
 var import_node_crypto9 = require("node:crypto");
 var import_node_fs21 = __toESM(require("node:fs"), 1);
 var import_node_module = require("node:module");
-var import_node_os9 = __toESM(require("node:os"), 1);
+var import_node_os10 = __toESM(require("node:os"), 1);
 var import_node_path22 = __toESM(require("node:path"), 1);
 var import_node_util3 = require("node:util");
 init_internal_child();
 init_backend_origin();
 
 // src/swift-compile.ts
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process4 = require("node:child_process");
 var import_node_crypto4 = require("node:crypto");
 var import_node_fs10 = require("node:fs");
-var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_os4 = __toESM(require("node:os"), 1);
 var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_util2 = require("node:util");
 
+// src/admitted-mac-build.ts
+function admittedMacBuilderSlot(env = process.env) {
+  return env.CONTRAST_REMOTE_BUILD === "mac" && env.REMOTE_MAC_SLOT_HELD === "1" && env.CONTRAST_HEAVY_ADMITTED === "1";
+}
+
 // src/swift-distribution-contract.ts
 init_is_record();
 var SWIFT_DISTRIBUTION_MANIFEST = "distribution.json";
@@ -12549,13 +12745,13 @@ function swiftDistributionKey(id, host2) {
 }
 
 // src/swift-icu.ts
-var import_node_child_process4 = require("node:child_process");
+var import_node_child_process3 = require("node:child_process");
 var import_node_crypto3 = require("node:crypto");
 var import_node_fs9 = require("node:fs");
 var import_node_path9 = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
 var import_node_zlib = require("node:zlib");
-var run = (0, import_node_util.promisify)(import_node_child_process4.execFile);
+var run = (0, import_node_util.promisify)(import_node_child_process3.execFile);
 var deflate = (0, import_node_util.promisify)(import_node_zlib.gzip);
 var ARCHIVE = "wasi/lib_FoundationICU.a";
 var MEMBER = "icu_packaged_data.cpp.obj";
@@ -12897,9 +13093,9 @@ function isSwiftMetalLibrarySources(value) {
 }
 
 // src/swift-compile.ts
-var run2 = (0, import_node_util2.promisify)(import_node_child_process5.execFile);
+var run2 = (0, import_node_util2.promisify)(import_node_child_process4.execFile);
 var WASM_TRIPLE = "wasm32-unknown-wasip1";
-var cores = import_node_os3.default.availableParallelism();
+var cores = import_node_os4.default.availableParallelism();
 var BUILD_ENV = {
   ...process.env,
   BINARYEN_CORES: String(Math.min(4, cores))
@@ -13160,7 +13356,7 @@ function swiftSdkPaths(moduleRoot, toolchainBin) {
   const key2 = `${toolchainBin}\0${sdk}`;
   const cached3 = sdkPaths.get(key2);
   if (cached3) return cached3;
-  const configuration = (0, import_node_child_process5.execFileSync)(
+  const configuration = (0, import_node_child_process4.execFileSync)(
     import_node_path10.default.join(toolchainBin, "swift"),
     ["sdk", "configure", "--show-configuration", sdk, "wasm32-unknown-wasip1"],
     { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
@@ -14787,7 +14983,7 @@ function compileSwiftProjectUnit(input, options) {
   };
   const hash = swiftArtifactHash(input, options.release, moduleRoot);
   return serialize(root, async () => {
-    if (process.platform === "darwin" && process.env.TM_SESSION && !process.env.CONTRAST_REMOTE_BUILD && process.env.CI !== "true" && moduleRoot === import_node_path10.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift") && !swiftDistributionAt(moduleRoot)) {
+    if (process.platform === "darwin" && process.env.TM_SESSION && !admittedMacBuilderSlot() && process.env.CI !== "true" && moduleRoot === import_node_path10.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift") && !swiftDistributionAt(moduleRoot)) {
       const requestRoot = (0, import_node_fs10.mkdtempSync)(import_node_path10.default.join(root, ".builder-request-"));
       const output = import_node_path10.default.join(requestRoot, "output");
       const request = import_node_path10.default.join(requestRoot, "request.json");
@@ -15049,16 +15245,16 @@ var swift_distribution_lock_default = {
 };
 
 // src/swift-toolchain.ts
-var import_node_child_process6 = require("node:child_process");
+var import_node_child_process5 = require("node:child_process");
 var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_os5 = __toESM(require("node:os"), 1);
 var import_node_path11 = __toESM(require("node:path"), 1);
 function swiftCompilerRelease(release) {
   return release.replace(/^swift-(\d+\.\d+)\.0-RELEASE$/, "swift-$1-RELEASE");
 }
 function swiftToolchainBin(release) {
   if (process.platform === "darwin") {
-    const dirs = [import_node_os4.default.homedir(), "/"].map(
+    const dirs = [import_node_os5.default.homedir(), "/"].map(
       (base) => import_node_path11.default.join(base, `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`)
     );
     return dirs.find((dir) => import_node_fs11.default.existsSync(import_node_path11.default.join(dir, "swift"))) ?? dirs[0];
@@ -15076,7 +15272,7 @@ function swiftToolchain(release, sdk) {
   if (cached3) return cached3;
   const bin = swiftToolchainBin(release);
   const swift = import_node_path11.default.join(bin, "swift");
-  const version = import_node_fs11.default.existsSync(swift) ? (0, import_node_child_process6.execFileSync)(swift, ["--version"], {
+  const version = import_node_fs11.default.existsSync(swift) ? (0, import_node_child_process5.execFileSync)(swift, ["--version"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   }) : "";
@@ -15087,7 +15283,7 @@ function swiftToolchain(release, sdk) {
 ${swiftInstallSteps(release, sdk)}`
     );
   }
-  const sdks = (0, import_node_child_process6.execFileSync)(swift, ["sdk", "list"], {
+  const sdks = (0, import_node_child_process5.execFileSync)(swift, ["sdk", "list"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -15195,7 +15391,7 @@ function swiftModuleToolchain(root) {
 // src/swift-host.ts
 var import_node_crypto8 = require("node:crypto");
 var import_node_fs20 = __toESM(require("node:fs"), 1);
-var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_os9 = __toESM(require("node:os"), 1);
 var import_node_path21 = __toESM(require("node:path"), 1);
 
 // ../sootsim-swift/src/bundleAssets.ts
@@ -15798,9 +15994,9 @@ var ios_sdk_frameworks_default = {
 // src/swift-binary-modules.ts
 var import_node_crypto5 = require("node:crypto");
 var import_node_fs14 = __toESM(require("node:fs"), 1);
-var import_node_os5 = __toESM(require("node:os"), 1);
+var import_node_os6 = __toESM(require("node:os"), 1);
 var import_node_path14 = __toESM(require("node:path"), 1);
-var cacheDir2 = import_node_path14.default.join(import_node_os5.default.tmpdir(), "peach-swift-binary-modules");
+var cacheDir2 = import_node_path14.default.join(import_node_os6.default.tmpdir(), "peach-swift-binary-modules");
 function frameworkModules(paths) {
   const modules = /* @__PURE__ */ new Set();
   for (const file of paths) {
@@ -15878,10 +16074,10 @@ async function swiftBinaryModules(binary2) {
 }
 
 // src/swift-package-manifest.ts
-var import_node_child_process7 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 var import_node_crypto6 = require("node:crypto");
 var import_node_fs15 = __toESM(require("node:fs"), 1);
-var import_node_os6 = __toESM(require("node:os"), 1);
+var import_node_os7 = __toESM(require("node:os"), 1);
 var import_node_path15 = __toESM(require("node:path"), 1);
 var TARGET_TYPES = [
   "regular",
@@ -15899,7 +16095,7 @@ var string = (value) => typeof value === "string" ? value : void 0;
 function swiftCommand() {
   return process.platform === "darwin" ? { file: "xcrun", args: ["swift"] } : { file: import_node_path15.default.join(swiftToolchainBin(swift_distribution_lock_default.release), "swift"), args: [] };
 }
-var cacheDir3 = import_node_path15.default.join(import_node_os6.default.tmpdir(), "peach-swift-manifests");
+var cacheDir3 = import_node_path15.default.join(import_node_os7.default.tmpdir(), "peach-swift-manifests");
 var evaluated = /* @__PURE__ */ new Map();
 function dump(dir) {
   const manifests = import_node_fs15.default.readdirSync(dir).filter((name2) => /^Package(@swift-[\d.]+)?\.swift$/.test(name2)).sort();
@@ -15912,7 +16108,7 @@ function dump(dir) {
     return { key: key2, raw: record(JSON.parse(import_node_fs15.default.readFileSync(cached3, "utf8"))) };
   let output;
   try {
-    output = (0, import_node_child_process7.execFileSync)(
+    output = (0, import_node_child_process6.execFileSync)(
       command.file,
       [
         ...command.args,
@@ -16102,7 +16298,7 @@ function swiftTargetFiles(manifest, target) {
 }
 
 // src/swift-packages.ts
-var import_node_child_process8 = require("node:child_process");
+var import_node_child_process7 = require("node:child_process");
 var import_node_fs16 = __toESM(require("node:fs"), 1);
 var import_node_path16 = __toESM(require("node:path"), 1);
 var REMOTE_CHECKOUTS = import_node_path16.default.join(".build", "peach", "checkouts");
@@ -16129,7 +16325,7 @@ function checkout(checkouts, identity, pin) {
   const dir = import_node_path16.default.join(checkouts, identity);
   const key2 = `${dir}\0${pin.revision}`;
   if (verified2.has(key2)) return dir;
-  const git = (...args) => (0, import_node_child_process8.execFileSync)("git", ["-C", dir, ...args], {
+  const git = (...args) => (0, import_node_child_process7.execFileSync)("git", ["-C", dir, ...args], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   }).trim();
@@ -16368,10 +16564,10 @@ function readPackageFile(root, file, maxBytes) {
 }
 
 // src/swift-standins.ts
-var import_node_child_process9 = require("node:child_process");
+var import_node_child_process8 = require("node:child_process");
 var import_node_crypto7 = require("node:crypto");
 var import_node_fs18 = __toESM(require("node:fs"), 1);
-var import_node_os7 = __toESM(require("node:os"), 1);
+var import_node_os8 = __toESM(require("node:os"), 1);
 var import_node_path18 = __toESM(require("node:path"), 1);
 
 // src/swift-standin-emit.ts
@@ -17088,9 +17284,9 @@ function stripDefaults(decl) {
 
 // src/swift-standins.ts
 var TRIPLE = "wasm32-unknown-wasip1";
-var cacheDir4 = import_node_path18.default.join(import_node_os7.default.tmpdir(), "peach-swift-standins");
+var cacheDir4 = import_node_path18.default.join(import_node_os8.default.tmpdir(), "peach-swift-standins");
 function exec(file, args, cwd) {
-  return (0, import_node_child_process9.execFileSync)(file, args, {
+  return (0, import_node_child_process8.execFileSync)(file, args, {
     cwd,
     encoding: "utf8",
     maxBuffer: 256 * 1024 * 1024,
@@ -17350,7 +17546,7 @@ function swiftStandin(surface, binary2, toolchain, work) {
       plain
     });
     import_node_fs18.default.writeFileSync(file, source);
-    const check = (0, import_node_child_process9.spawnSync)(
+    const check = (0, import_node_child_process8.spawnSync)(
       import_node_path18.default.join(toolchain.toolchainBin, "swiftc"),
       [
         "-typecheck",
@@ -17679,7 +17875,7 @@ function standinLibrary(binary2, searchRoot) {
   if (!library) return null;
   const manifest = crateFor(searchRoot, library.slice("lib".length, -".a".length));
   if (!manifest) return null;
-  const result = (0, import_node_child_process9.spawnSync)(
+  const result = (0, import_node_child_process8.spawnSync)(
     "cargo",
     [
       "build",
@@ -17724,7 +17920,7 @@ function standinLibrary(binary2, searchRoot) {
 }
 function sourceBinaryStandins(binary2, toolchain, provided) {
   const repo = import_node_path18.default.resolve(toolchain.moduleRoot, "../..");
-  const work = import_node_fs18.default.mkdtempSync(import_node_path18.default.join(import_node_os7.default.tmpdir(), "peach-standin-request-"));
+  const work = import_node_fs18.default.mkdtempSync(import_node_path18.default.join(import_node_os8.default.tmpdir(), "peach-standin-request-"));
   try {
     const artifact = xcframework(binary2);
     const local = { ...binary2, dir: artifact.dir, url: null, checksum: null };
@@ -17741,7 +17937,7 @@ function sourceBinaryStandins(binary2, toolchain, provided) {
         callerToolchainBin: toolchain.toolchainBin
       })
     );
-    (0, import_node_child_process9.execFileSync)(
+    (0, import_node_child_process8.execFileSync)(
       "bash",
       [
         import_node_path18.default.join(repo, "scripts/build/remote.sh"),
@@ -17857,7 +18053,7 @@ function binaryStandins(binary2, toolchain, provided) {
     built.set(id, value);
     return value;
   }
-  const work = import_node_fs18.default.mkdtempSync(import_node_path18.default.join(import_node_os7.default.tmpdir(), "peach-standin-"));
+  const work = import_node_fs18.default.mkdtempSync(import_node_path18.default.join(import_node_os8.default.tmpdir(), "peach-standin-"));
   let result;
   try {
     result = process.platform === "darwin" && process.env.TM_SESSION && process.env.CI !== "true" && toolchain.moduleRoot === import_node_path18.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift") && !swiftDistributionAt(toolchain.moduleRoot) ? sourceBinaryStandins(binary2, toolchain, provided) : found.map((surface) => {
@@ -19861,7 +20057,7 @@ async function compile(packagePath, stamp, moduleRootOverride, hosted, snapshot)
     // each app and module checkout gets its own root, which keeps the same
     // app's incremental build across restarts.
     buildRoot: process.env.CONTRAST_SWIFT_BUILD_ROOT ?? import_node_path21.default.join(
-      import_node_os8.default.tmpdir(),
+      import_node_os9.default.tmpdir(),
       "contrast-swift-build",
       (0, import_node_crypto8.createHash)("sha256").update(`${moduleRoot}\0${import_node_path21.default.resolve(packagePath)}`).digest("hex").slice(0, 16)
     ),
@@ -20142,7 +20338,7 @@ function serveSwiftPackageAsset(pathname, res) {
 }
 
 // src/expo-swift-host.ts
-var run3 = (0, import_node_util3.promisify)(import_node_child_process10.execFile);
+var run3 = (0, import_node_util3.promisify)(import_node_child_process9.execFile);
 var scriptEnv = { ...process.env, [RNX_FORKED_SCRIPT_ENV]: "1" };
 var EXPO_SWIFT_ROUTE = "/__peach/expo-swift";
 var EXPO_SWIFT_ENTRY = "Sources/PeachExpoApp/PeachExpoEntry.swift";
@@ -20317,7 +20513,20 @@ ${[...new Set(units.map((unit) => unit.namespace))].map((namespace) => `import $
 `;
 }
 var compiling = /* @__PURE__ */ new Map();
-var failedCompilations = /* @__PURE__ */ new Map();
+function failureRecordPath(packagePath) {
+  return `${packagePath}.failed.json`;
+}
+function readFailedCompilation(packagePath) {
+  let record2;
+  try {
+    record2 = JSON.parse(import_node_fs21.default.readFileSync(failureRecordPath(packagePath), "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof record2 !== "object" || record2 === null || !("stamp" in record2) || !("diagnostic" in record2) || typeof record2.stamp !== "string" || typeof record2.diagnostic !== "string")
+    return null;
+  return { stamp: record2.stamp, diagnostic: record2.diagnostic };
+}
 async function compileExpoSwiftModules(root, base, publishArtifact) {
   const units = await collectExpoSwiftSources(root);
   if (!units) return null;
@@ -20342,7 +20551,7 @@ async function compileExpoSwiftModules(root, base, publishArtifact) {
   const candidates = [];
   const stamps = /* @__PURE__ */ new Map();
   for (const unit of units) {
-    const packagePath = import_node_path22.default.join(import_node_os9.default.tmpdir(), "peach-expo-swift", key2, unit.moduleId);
+    const packagePath = import_node_path22.default.join(import_node_os10.default.tmpdir(), "peach-expo-swift", key2, unit.moduleId);
     syncSwiftTree(
       packagePath,
       new Map(
@@ -20353,12 +20562,12 @@ async function compileExpoSwiftModules(root, base, publishArtifact) {
       )
     );
     const stamp = sourceStamp(packagePath, module2.root);
-    const failed = failedCompilations.get(packagePath);
+    const failed = readFailedCompilation(packagePath);
     if (failed?.stamp === stamp) {
       failures.set(unit.moduleId, failed.diagnostic);
       continue;
     }
-    failedCompilations.delete(packagePath);
+    import_node_fs21.default.rmSync(failureRecordPath(packagePath), { force: true });
     stamps.set(unit, stamp);
     candidates.push(unit);
   }
@@ -20380,7 +20589,7 @@ async function compileExpoSwiftModules(root, base, publishArtifact) {
 import PackageDescription
 let package = Package(name: "PeachExpo", targets: [${targets.map((name2) => `.target(name: ${JSON.stringify(name2)}, path: ${JSON.stringify(`Sources/${name2}`)})`).join(", ")}, .executableTarget(name: "PeachExpoApp", path: "Sources/PeachExpoApp")])
 `;
-    const packagePath = import_node_path22.default.join(import_node_os9.default.tmpdir(), "peach-expo-swift", key2, "linked-app");
+    const packagePath = import_node_path22.default.join(import_node_os10.default.tmpdir(), "peach-expo-swift", key2, "linked-app");
     syncSwiftTree(
       packagePath,
       new Map(
@@ -20400,7 +20609,7 @@ let package = Package(name: "PeachExpo", targets: [${targets.map((name2) => `.ta
     } catch (linkError) {
       linked = [];
       for (const unit of candidates) {
-        const packagePath = import_node_path22.default.join(import_node_os9.default.tmpdir(), "peach-expo-swift", key2, unit.moduleId);
+        const packagePath = import_node_path22.default.join(import_node_os10.default.tmpdir(), "peach-expo-swift", key2, unit.moduleId);
         try {
           await artifactFor(projectFor(packagePath), EXPO_SWIFT_ENTRY, module2.root);
           linked.push(unit);
@@ -20422,10 +20631,13 @@ let package = Package(name: "PeachExpo", targets: [${targets.map((name2) => `.ta
             throw error;
           const missing = error instanceof SwiftMissingModulesError;
           if ((sourceErrors.length && sourceErrors.length === errors.length || missing) && sourceStamp(packagePath, module2.root) === stamps.get(unit)) {
-            failedCompilations.set(packagePath, {
-              stamp: stamps.get(unit),
-              diagnostic: missing ? diagnostic : sourceErrors.join("\n")
-            });
+            import_node_fs21.default.writeFileSync(
+              failureRecordPath(packagePath),
+              JSON.stringify({
+                stamp: stamps.get(unit),
+                diagnostic: missing ? diagnostic : sourceErrors.join("\n")
+              })
+            );
           }
           failures.set(
             unit.moduleId,
@@ -20647,7 +20859,7 @@ var import_node_fs25 = __toESM(require("node:fs"), 1);
 var import_node_path26 = __toESM(require("node:path"), 1);
 
 // src/agent-sessions.ts
-var import_node_child_process11 = require("node:child_process");
+var import_node_child_process10 = require("node:child_process");
 var import_node_crypto11 = require("node:crypto");
 var import_node_fs24 = __toESM(require("node:fs"), 1);
 var import_node_path25 = __toESM(require("node:path"), 1);
@@ -21021,7 +21233,7 @@ function eventsFifoPath(sessionId) {
 function transcriptPath(sessionId) {
   return import_node_path25.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
-function pidIsAlive(pid, sessionId) {
+function pidIsAlive2(pid, sessionId) {
   if (!pid) return false;
   try {
     process.kill(pid, 0);
@@ -21201,7 +21413,7 @@ function mkfifoSync(p) {
       import_node_fs24.default.unlinkSync(p);
     }
   }
-  const result = (0, import_node_child_process11.spawnSync)("mkfifo", ["-m", "600", p]);
+  const result = (0, import_node_child_process10.spawnSync)("mkfifo", ["-m", "600", p]);
   if (result.status !== 0) {
     throw new Error(
       `mkfifo(${p}) failed: ${result.stderr?.toString().trim() || "unknown error"}`
@@ -21223,7 +21435,7 @@ async function startSession(opts) {
   const provider = opts.provider || project.preferredProvider || "codex";
   return withStartLock(project.id, provider, async () => {
     const existingLive = listSessions(project.id).find(
-      (s) => s.provider === provider && s.status !== "ended" && pidIsAlive(s.wrapperPid, s.id)
+      (s) => s.provider === provider && s.status !== "ended" && pidIsAlive2(s.wrapperPid, s.id)
     );
     if (existingLive) {
       throw new AgentSessionError(
@@ -21276,7 +21488,7 @@ async function startSession(opts) {
     if (claudeSessionUuid) {
       wrapperArgs.push("--claude-session-uuid", claudeSessionUuid);
     }
-    const child = (0, import_node_child_process11.spawn)(executable, wrapperArgs, {
+    const child = (0, import_node_child_process10.spawn)(executable, wrapperArgs, {
       detached: true,
       stdio: "ignore",
       env: {
@@ -21319,7 +21531,7 @@ async function sendPrompt(sessionId, prompt) {
   if (!session) {
     throw new AgentSessionError("NO_SESSION", `no session with id=${sessionId}`);
   }
-  if (!pidIsAlive(session.wrapperPid, sessionId)) {
+  if (!pidIsAlive2(session.wrapperPid, sessionId)) {
     updateSessionStatus(sessionId, { status: "ended" });
     throw new AgentSessionError(
       "NOT_ALIVE",
@@ -21350,7 +21562,7 @@ async function endSession(sessionId) {
   if (!session) {
     throw new AgentSessionError("NO_SESSION", `no session with id=${sessionId}`);
   }
-  if (pidIsAlive(session.wrapperPid, sessionId)) {
+  if (pidIsAlive2(session.wrapperPid, sessionId)) {
     try {
       process.kill(session.wrapperPid, "SIGTERM");
     } catch {
@@ -22688,7 +22900,7 @@ async function dispatchPlaneCommand(plane, type, msg, mutationOptions) {
 }
 
 // cli/commands/box/checkout-plane.ts
-var import_node_child_process12 = require("node:child_process");
+var import_node_child_process11 = require("node:child_process");
 var import_node_fs27 = __toESM(require("node:fs"), 1);
 var import_node_path28 = __toESM(require("node:path"), 1);
 var CheckoutRequiresGitError = class extends Error {
@@ -22730,7 +22942,7 @@ var CheckoutFilePlane = class {
   }
   listFiles() {
     const args = this.trackedOnly ? ["ls-files", "-z"] : ["ls-files", "-co", "--exclude-standard", "-z"];
-    const stdout = (0, import_node_child_process12.execFileSync)("git", args, {
+    const stdout = (0, import_node_child_process11.execFileSync)("git", args, {
       cwd: this.root,
       encoding: "utf8",
       maxBuffer: 64 * 1024 * 1024,
@@ -23021,7 +23233,7 @@ function normalize(p) {
   if (trailingSlash) joined += "/";
   return absolute ? "/" + joined : joined;
 }
-function join6(...parts) {
+function join7(...parts) {
   const present = parts.filter((part) => part.length > 0);
   if (present.length === 0) return ".";
   return normalize(present.join("/"));
@@ -23078,7 +23290,7 @@ var posix = {
   delimiter,
   isAbsolute,
   normalize,
-  join: join6,
+  join: join7,
   resolve: resolve3,
   dirname: dirname4,
   basename: basename4,
@@ -25140,6 +25352,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   reapIdleSims(now = Date.now()) {
     const attachedSimIds = new Set(this.cliSimBySocket.values());
+    let reclaimable = null;
     for (const sim of this.sims.values()) {
       if (attachedSimIds.has(sim.id)) continue;
       const automation = this.isAutomationSim(sim);
@@ -25148,9 +25361,27 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
         continue;
       }
       const idleMs = now - Math.max(sim.lastActiveAt, sim.connectedAt);
-      const ttl = automation ? AUTOMATION_SIM_IDLE_REAP_TTL_MS : _SootSimBridgeHost.SIM_IDLE_REAP_TTL_MS;
-      if (idleMs >= ttl) this.closeSimSocketFromHost(sim.ws);
+      if (automation) {
+        if (idleMs >= AUTOMATION_SIM_IDLE_REAP_TTL_MS && idleMs > (reclaimable?.idleMs ?? 0))
+          reclaimable = { ws: sim.ws, idleMs };
+        continue;
+      }
+      if (idleMs >= _SootSimBridgeHost.SIM_IDLE_REAP_TTL_MS)
+        this.closeSimSocketFromHost(sim.ws);
     }
+    if (reclaimable && this.chromiumLaunchWaiting())
+      this.closeSimSocketFromHost(reclaimable.ws);
+  }
+  chromiumQueueVerified = /* @__PURE__ */ new Map();
+  chromiumLaunchWaiting() {
+    const queue = readChromiumQueue(
+      { fs: import_fs2.default, os: import_os.default, path: import_path2.default, childProcess: import_child_process3.default },
+      this.chromiumQueueVerified
+    );
+    const live = new Set(queue.tickets);
+    for (const entry of this.chromiumQueueVerified.keys())
+      if (!live.has(entry)) this.chromiumQueueVerified.delete(entry);
+    return queue.tickets.length > queue.limit;
   }
   // ping every connected ws; if the previous round's ping went unanswered,
   // terminate the socket so 'close' fires and the sim cleanup path