peachsim 0.1.664 → 0.1.666

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

@@ -1,4 +1,4 @@
-/*! rnx v0.1.664 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.666 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;
@@ -49,10 +49,27 @@ function buildBrowserAssetProxyUrl(targetUrl) {
   const proxyPath = isLoopbackHost(new URL(targetUrl).hostname) ? "/__bundle-proxy" : "/__fetch-proxy";
   return `${proxyPath}?url=${encodeURIComponent(targetUrl)}`;
 }
-var LOOPBACK_PROBE_HOSTNAMES;
+function isContrastBackendHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return isLoopbackHost(normalized) || normalized === "contrast.dev" || normalized.endsWith(".contrast.dev");
+}
+function resolveContrastBackendOrigin(currentOrigin) {
+  const origin = currentOrigin?.trim();
+  if (!origin) return DEFAULT_CONTRAST_BACKEND_ORIGIN;
+  try {
+    const parsed = new URL(origin);
+    if (isLoopbackHost(parsed.hostname) || isContrastBackendHost(parsed.hostname)) {
+      return parsed.origin;
+    }
+  } catch {
+  }
+  return DEFAULT_CONTRAST_BACKEND_ORIGIN;
+}
+var DEFAULT_CONTRAST_BACKEND_ORIGIN, LOOPBACK_PROBE_HOSTNAMES;
 var init_backend_origin = __esm({
   "src/backend-origin.ts"() {
     "use strict";
+    DEFAULT_CONTRAST_BACKEND_ORIGIN = "https://contrast.dev";
     LOOPBACK_PROBE_HOSTNAMES = ["127.0.0.1", "::1"];
   }
 });
@@ -181,8 +198,8 @@ function configFilePath() {
 }
 function readSharedConfig() {
   try {
-    const raw = import_node_fs3.default.readFileSync(configFilePath(), "utf8");
-    const parsed = JSON.parse(raw);
+    const raw2 = import_node_fs3.default.readFileSync(configFilePath(), "utf8");
+    const parsed = JSON.parse(raw2);
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -250,8 +267,8 @@ function readDaemonLockfile() {
     try {
       const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
       const bytesRead = import_node_fs3.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
-      const raw = buf.subarray(0, bytesRead).toString("utf8");
-      const parsed = JSON.parse(raw);
+      const raw2 = buf.subarray(0, bytesRead).toString("utf8");
+      const parsed = JSON.parse(raw2);
       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.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
         return parsed;
       }
@@ -263,9 +280,9 @@ function readDaemonLockfile() {
     return null;
   }
 }
-function parseDevBridgeLockfile(raw) {
+function parseDevBridgeLockfile(raw2) {
   try {
-    const parsed = JSON.parse(raw);
+    const parsed = JSON.parse(raw2);
     if (parsed && parsed.schema === 1 && parsed.source === "vite-dev" && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.cwd === "string" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.shellPort === void 0 || typeof parsed.shellPort === "number") && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
       return parsed;
     }
@@ -346,9 +363,9 @@ function createDaemonLockfileExclusive(data) {
 function daemonClaimPath() {
   return `${daemonLockfilePath()}.claim`;
 }
-function parseDaemonClaim(raw) {
+function parseDaemonClaim(raw2) {
   try {
-    const value = JSON.parse(raw);
+    const value = JSON.parse(raw2);
     if (value !== null && typeof value === "object" && typeof Reflect.get(value, "pid") === "number" && typeof Reflect.get(value, "startedAt") === "number" && typeof Reflect.get(value, "createdAt") === "number") {
       return {
         pid: Reflect.get(value, "pid"),
@@ -502,14 +519,14 @@ function sharedDesktopAuthAccounts(user) {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path15.dirname)((0, import_node_path15.resolve)(explicit));
+    return (0, import_node_path6.dirname)((0, import_node_path6.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path15.resolve)(explicit);
-  return (0, import_node_path15.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path6.resolve)(explicit);
+  return (0, import_node_path6.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -559,26 +576,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs15.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs6.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs15.rmSync)(filepath, { force: true });
+      (0, import_node_fs6.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs15.rmSync)(filepath, { force: true });
+    (0, import_node_fs6.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs15, import_node_path15, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs6, import_node_path6, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs15 = require("node:fs");
-    import_node_path15 = require("node:path");
+    import_node_fs6 = require("node:fs");
+    import_node_path6 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -726,20 +743,20 @@ var init_auth = __esm({
 });
 
 // ../peach-engine/src/preview/storage-snapshot-contract.ts
-function isRecord3(value) {
+function isRecord4(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isStorageSnapshotEntry(value) {
-  return isRecord3(value) && typeof value.key === "string" && typeof value.value === "string";
+  return isRecord4(value) && typeof value.key === "string" && typeof value.value === "string";
 }
 function isSecureStoreSnapshotEntry(value) {
-  return isRecord3(value) && typeof value.key === "string" && typeof value.value === "string" && (value.keychainService == null || typeof value.keychainService === "string") && (value.accessGroup == null || typeof value.accessGroup === "string") && (value.requireAuthentication == null || typeof value.requireAuthentication === "boolean");
+  return isRecord4(value) && typeof value.key === "string" && typeof value.value === "string" && (value.keychainService == null || typeof value.keychainService === "string") && (value.accessGroup == null || typeof value.accessGroup === "string") && (value.requireAuthentication == null || typeof value.requireAuthentication === "boolean");
 }
 function isPreviewRouteSnapshot(value) {
-  return isRecord3(value) && typeof value.currentPath === "string" && (value.routeNames == null || Array.isArray(value.routeNames) && value.routeNames.every((routeName) => typeof routeName === "string"));
+  return isRecord4(value) && typeof value.currentPath === "string" && (value.routeNames == null || Array.isArray(value.routeNames) && value.routeNames.every((routeName) => typeof routeName === "string"));
 }
 function isSerializedIndexedDBValue(value) {
-  if (!isRecord3(value) || typeof value.type !== "string") return false;
+  if (!isRecord4(value) || typeof value.type !== "string") return false;
   switch (value.type) {
     case "array":
       return Array.isArray(value.value) && value.value.every(isSerializedIndexedDBValue);
@@ -749,7 +766,7 @@ function isSerializedIndexedDBValue(value) {
     case "null":
       return value.value === null;
     case "object":
-      return isRecord3(value.value) && Object.values(value.value).every(isSerializedIndexedDBValue);
+      return isRecord4(value.value) && Object.values(value.value).every(isSerializedIndexedDBValue);
     case "primitive":
       return typeof value.value === "boolean" || typeof value.value === "number" || typeof value.value === "string";
     default:
@@ -760,16 +777,16 @@ function isIndexedDBSnapshotKind(value) {
   return value === "bedrock-memfs" || value === "blob-util-fs" || value === "react-native-keychain" || value === "sootsim-system-permissions";
 }
 function isIndexedDBSnapshotEntry(value) {
-  return isRecord3(value) && typeof value.key === "string" && isSerializedIndexedDBValue(value.value);
+  return isRecord4(value) && typeof value.key === "string" && isSerializedIndexedDBValue(value.value);
 }
 function isIndexedDBStoreSnapshot(value) {
-  return isRecord3(value) && typeof value.name === "string" && Array.isArray(value.entries) && value.entries.every(isIndexedDBSnapshotEntry);
+  return isRecord4(value) && typeof value.name === "string" && Array.isArray(value.entries) && value.entries.every(isIndexedDBSnapshotEntry);
 }
 function isIndexedDBSnapshot(value) {
-  return isRecord3(value) && isIndexedDBSnapshotKind(value.kind) && Array.isArray(value.stores) && value.stores.every(isIndexedDBStoreSnapshot);
+  return isRecord4(value) && isIndexedDBSnapshotKind(value.kind) && Array.isArray(value.stores) && value.stores.every(isIndexedDBStoreSnapshot);
 }
 function isStorageSnapshot(value) {
-  return isRecord3(value) && Array.isArray(value.entries) && value.entries.every(isStorageSnapshotEntry) && (value.secureStore == null || Array.isArray(value.secureStore) && value.secureStore.every(isSecureStoreSnapshotEntry)) && (value.indexedDB == null || Array.isArray(value.indexedDB) && value.indexedDB.every(isIndexedDBSnapshot)) && (value.route == null || isPreviewRouteSnapshot(value.route));
+  return isRecord4(value) && Array.isArray(value.entries) && value.entries.every(isStorageSnapshotEntry) && (value.secureStore == null || Array.isArray(value.secureStore) && value.secureStore.every(isSecureStoreSnapshotEntry)) && (value.indexedDB == null || Array.isArray(value.indexedDB) && value.indexedDB.every(isIndexedDBSnapshot)) && (value.route == null || isPreviewRouteSnapshot(value.route));
 }
 var init_storage_snapshot_contract = __esm({
   "../peach-engine/src/preview/storage-snapshot-contract.ts"() {
@@ -2383,8 +2400,8 @@ function metroIosAssetDestRelatives(httpServerLocation, filename) {
   }
   const out = [];
   for (const dir of dirs) {
-    const path12 = `${dir}/${filename}`;
-    if (!out.includes(path12)) out.push(path12);
+    const path16 = `${dir}/${filename}`;
+    if (!out.includes(path16)) out.push(path16);
   }
   if (!out.includes(filename)) out.push(filename);
   return out;
@@ -2788,7 +2805,7 @@ async function buildRnxCloudArtifact(bundle, options = {}) {
       unresolved: composed.unresolved
     };
   }
-  const assets = await assertSelfContainedMetroArtifactAssets(code);
+  const assets2 = await assertSelfContainedMetroArtifactAssets(code);
   const sourceEncoded = encodedAssetBytes(bundle);
   const artifactEncoded = encodedAssetBytes(code);
   const sourceBytes = Buffer.byteLength((0, import_metro_production_bundle.detachRNXMetroSourceMapUrl)(bundle).source, "utf8");
@@ -2808,7 +2825,7 @@ async function buildRnxCloudArtifact(bundle, options = {}) {
         sourceBytes: sourceBytes - sourceEncoded,
         minifiedBytes: artifactBytes - artifactEncoded
       },
-      assets: { ...assets, encodedBytes: artifactEncoded },
+      assets: { ...assets2, encodedBytes: artifactEncoded },
       debug: sourceMap ? { sourceMap: { id: sourceMap.id, bytes: sourceMap.bytes } } : null,
       artifact: {
         sha256: await sha256HexBytes(new TextEncoder().encode(code)),
@@ -3334,13 +3351,13 @@ function readFactoryStringLiterals(factory) {
   return literals;
 }
 function normalizeFingerprintLiteral(literal) {
-  const path12 = literal.replaceAll("\\\\", "/").replaceAll("\\/", "/");
+  const path16 = literal.replaceAll("\\\\", "/").replaceAll("\\/", "/");
   const nodeModulesMarker = "/node_modules/";
-  const nodeModulesIndex = path12.lastIndexOf(nodeModulesMarker);
+  const nodeModulesIndex = path16.lastIndexOf(nodeModulesMarker);
   if (nodeModulesIndex >= 0) {
-    return `node_modules/${path12.slice(nodeModulesIndex + nodeModulesMarker.length)}`;
+    return `node_modules/${path16.slice(nodeModulesIndex + nodeModulesMarker.length)}`;
   }
-  if ((path12.startsWith("/") || /^[A-Za-z]:\//.test(path12) || path12.startsWith("file:/")) && /\.[cm]?[jt]sx?(?::\d+(?::\d+)?)?$/.test(path12)) {
+  if ((path16.startsWith("/") || /^[A-Za-z]:\//.test(path16) || path16.startsWith("file:/")) && /\.[cm]?[jt]sx?(?::\d+(?::\d+)?)?$/.test(path16)) {
     return null;
   }
   return literal;
@@ -3578,10 +3595,10 @@ function templateAssignment(template, embeddings) {
       if (existingNode !== void 0 && existingNode !== nodeIndex) return null;
       nodesByModuleId.set(moduleId, nodeIndex);
       const node = template.nodes[nodeIndex];
-      const path12 = node.landmarkPath ?? `node_modules/${template.packageName}/__rnx_inferred__/${moduleId}.js`;
+      const path16 = node.landmarkPath ?? `node_modules/${template.packageName}/__rnx_inferred__/${moduleId}.js`;
       const existingPath = pathsByModuleId.get(moduleId);
-      if (existingPath !== void 0 && existingPath !== path12) return null;
-      pathsByModuleId.set(moduleId, path12);
+      if (existingPath !== void 0 && existingPath !== path16) return null;
+      pathsByModuleId.set(moduleId, path16);
     }
   }
   return {
@@ -3743,14 +3760,14 @@ async function inferMetroModuleIdentity(args) {
     const packageClaims = claimsByPackage.values().next().value;
     if (!packageClaims) continue;
     const exactClaims = packageClaims.filter((assignment2) => {
-      const path12 = assignment2.pathsByModuleId.get(moduleId);
-      return path12 !== void 0 && !path12.includes("/__rnx_inferred__/");
+      const path16 = assignment2.pathsByModuleId.get(moduleId);
+      return path16 !== void 0 && !path16.includes("/__rnx_inferred__/");
     });
     const preferredClaims = exactClaims.length > 0 ? exactClaims : packageClaims;
     const routes = new Set(
       preferredClaims.flatMap((assignment2) => {
-        const path12 = assignment2.pathsByModuleId.get(moduleId);
-        return path12 ? [metroFingerprintModuleClaimRoute(assignment2.packageName, path12)] : [];
+        const path16 = assignment2.pathsByModuleId.get(moduleId);
+        return path16 ? [metroFingerprintModuleClaimRoute(assignment2.packageName, path16)] : [];
       })
     );
     if (routes.size !== 1) continue;
@@ -3949,8 +3966,8 @@ function detectFramework(deps) {
   return "unknown";
 }
 function detectProject(dir) {
-  const pkgPath = (0, import_node_path16.join)(dir, "package.json");
-  if (!(0, import_node_fs16.existsSync)(pkgPath)) return null;
+  const pkgPath = (0, import_node_path20.join)(dir, "package.json");
+  if (!(0, import_node_fs20.existsSync)(pkgPath)) return null;
   const pkg = readProjectManifest(dir);
   if (!pkg) return null;
   const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -3962,25 +3979,25 @@ function detectProject(dir) {
   if (framework === "unknown") return null;
   return {
     dir,
-    name: pkg.name || (0, import_node_path16.basename)(dir),
+    name: pkg.name || (0, import_node_path20.basename)(dir),
     framework,
     // a config file is a config file whatever module system it declares. real
     // apps write .cjs as often as .js, and missing one reads as "this project
     // has no bundler config" and sends the user to create a second one.
     hasViteConfig: CONFIG_EXTENSIONS.some(
-      (ext) => (0, import_node_fs16.existsSync)((0, import_node_path16.join)(dir, `vite.config.${ext}`))
+      (ext) => (0, import_node_fs20.existsSync)((0, import_node_path20.join)(dir, `vite.config.${ext}`))
     ),
     hasMetroConfig: CONFIG_EXTENSIONS.some(
-      (ext) => (0, import_node_fs16.existsSync)((0, import_node_path16.join)(dir, `metro.config.${ext}`))
+      (ext) => (0, import_node_fs20.existsSync)((0, import_node_path20.join)(dir, `metro.config.${ext}`))
     ),
     devCommand: typeof devCommand === "string" ? devCommand : null
   };
 }
-function readProjectMetadata(path12) {
+function readProjectMetadata(path16) {
   try {
-    const info = (0, import_node_fs16.lstatSync)(path12);
+    const info = (0, import_node_fs20.lstatSync)(path16);
     if (!info.isFile() || info.size > 4 * 1024 * 1024) return null;
-    return (0, import_node_fs16.readFileSync)(path12, "utf8");
+    return (0, import_node_fs20.readFileSync)(path16, "utf8");
   } catch {
     return null;
   }
@@ -3989,8 +4006,8 @@ function metadataValue(value, key) {
   if (!value || typeof value !== "object") return void 0;
   return Object.getOwnPropertyDescriptor(value, key)?.value;
 }
-function readProjectJson(path12) {
-  const text = readProjectMetadata(path12);
+function readProjectJson(path16) {
+  const text = readProjectMetadata(path16);
   if (text === null) return null;
   try {
     const value = JSON.parse(text);
@@ -4000,7 +4017,7 @@ function readProjectJson(path12) {
   }
 }
 function readProjectManifest(dir) {
-  const parsed = readProjectJson((0, import_node_path16.join)(dir, "package.json"));
+  const parsed = readProjectJson((0, import_node_path20.join)(dir, "package.json"));
   if (!parsed || typeof parsed !== "object") return null;
   const record = (value) => {
     if (!value || typeof value !== "object") return {};
@@ -4017,12 +4034,12 @@ function readProjectManifest(dir) {
     devDependencies: record(metadataValue(parsed, "devDependencies"))
   };
 }
-var import_node_fs16, import_node_path16, import_json5, import_yaml, CONFIG_EXTENSIONS;
+var import_node_fs20, import_node_path20, import_json5, import_yaml, CONFIG_EXTENSIONS;
 var init_detect = __esm({
   "cli/commands/detect.ts"() {
     "use strict";
-    import_node_fs16 = require("node:fs");
-    import_node_path16 = require("node:path");
+    import_node_fs20 = require("node:fs");
+    import_node_path20 = require("node:path");
     import_json5 = __toESM(require("json5"), 1);
     import_yaml = require("yaml");
     CONFIG_EXTENSIONS = ["ts", "js", "cjs", "mjs", "mts", "cts"];
@@ -4059,21 +4076,21 @@ function resolveCloudOrigin(value) {
   return normalizeCloudOrigin(source);
 }
 function readImmutableBundleSource(bundlePath) {
-  const filepath = (0, import_node_path17.resolve)(bundlePath);
-  if ((0, import_node_path17.extname)(filepath) !== ".js") {
+  const filepath = (0, import_node_path21.resolve)(bundlePath);
+  if ((0, import_node_path21.extname)(filepath) !== ".js") {
     throw new Error(`${REMOTE_COMMAND} requires one local Metro .js bundle`);
   }
-  const descriptor = (0, import_node_fs17.openSync)(filepath, "r");
+  const descriptor = (0, import_node_fs21.openSync)(filepath, "r");
   try {
-    const before = (0, import_node_fs17.fstatSync)(descriptor, { bigint: true });
+    const before = (0, import_node_fs21.fstatSync)(descriptor, { bigint: true });
     if (!before.isFile()) {
       throw new Error(`${REMOTE_COMMAND} bundle must be a regular local file`);
     }
     if (before.size <= 0n) {
       throw new Error(`${REMOTE_COMMAND} bundle is empty`);
     }
-    const bytes = (0, import_node_fs17.readFileSync)(descriptor);
-    const after = (0, import_node_fs17.fstatSync)(descriptor, { bigint: true });
+    const bytes = (0, import_node_fs21.readFileSync)(descriptor);
+    const after = (0, import_node_fs21.fstatSync)(descriptor, { bigint: true });
     if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeNs !== after.mtimeNs || bytes.length !== Number(before.size)) {
       throw new Error(`${REMOTE_COMMAND} bundle changed while it was being read`);
     }
@@ -4088,7 +4105,7 @@ function readImmutableBundleSource(bundlePath) {
     }
     return source;
   } finally {
-    (0, import_node_fs17.closeSync)(descriptor);
+    (0, import_node_fs21.closeSync)(descriptor);
   }
 }
 async function fetchBundleSource(bundleUrl) {
@@ -4135,15 +4152,15 @@ async function loadBundleSource(bundleInput) {
   return readImmutableBundleSource(bundleInput);
 }
 function listMetroAssetDest(assetsPath) {
-  const directory = (0, import_node_path17.resolve)(assetsPath);
-  if (!(0, import_node_fs17.existsSync)(directory)) return { directory, files: [], truncated: false };
-  const skipNested = (0, import_node_fs17.existsSync)((0, import_node_path17.join)(directory, "package.json"));
+  const directory = (0, import_node_path21.resolve)(assetsPath);
+  if (!(0, import_node_fs21.existsSync)(directory)) return { directory, files: [], truncated: false };
+  const skipNested = (0, import_node_fs21.existsSync)((0, import_node_path21.join)(directory, "package.json"));
   const files = [];
   let truncated = false;
   const walk = (dir, prefix) => {
     let entries;
     try {
-      entries = (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs21.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -4155,7 +4172,7 @@ function listMetroAssetDest(assetsPath) {
       if (entry.isDirectory()) {
         if (entry.name === ".git") continue;
         if (skipNested && PROJECT_ONLY_DIRECTORIES.has(entry.name)) continue;
-        walk((0, import_node_path17.join)(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
+        walk((0, import_node_path21.join)(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
       } else if (entry.isFile()) {
         files.push(prefix ? `${prefix}/${entry.name}` : entry.name);
       }
@@ -4165,7 +4182,7 @@ function listMetroAssetDest(assetsPath) {
   return { directory, files, truncated };
 }
 function metroDescriptorHash(scaleBytes) {
-  const hasher = (0, import_node_crypto6.createHash)("md5");
+  const hasher = (0, import_node_crypto10.createHash)("md5");
   for (const bytes of scaleBytes) hasher.update(bytes);
   return hasher.digest("hex");
 }
@@ -4190,11 +4207,11 @@ function distinctByContent(directory, options) {
   for (const relative2 of options) {
     let bytes;
     try {
-      bytes = (0, import_node_fs17.readFileSync)((0, import_node_path17.join)(directory, relative2));
+      bytes = (0, import_node_fs21.readFileSync)((0, import_node_path21.join)(directory, relative2));
     } catch {
       continue;
     }
-    const digest = (0, import_node_crypto6.createHash)("md5").update(bytes).digest("hex");
+    const digest = (0, import_node_crypto10.createHash)("md5").update(bytes).digest("hex");
     if (!byContent.has(digest)) byContent.set(digest, relative2);
   }
   return [...byContent.values()];
@@ -4222,13 +4239,13 @@ function placeMetroDescriptor(listing, descriptor) {
     let bytes;
     try {
       bytes = combination.map(
-        (relative2) => (0, import_node_fs17.readFileSync)((0, import_node_path17.join)(listing.directory, relative2))
+        (relative2) => (0, import_node_fs21.readFileSync)((0, import_node_path21.join)(listing.directory, relative2))
       );
     } catch {
       continue;
     }
     const identical = fileHashes ? bytes.every((file, index) => {
-      const digest = (0, import_node_crypto6.createHash)("md5").update(file).digest("hex");
+      const digest = (0, import_node_crypto10.createHash)("md5").update(file).digest("hex");
       return descriptor.scales.some(
         (scale, declared) => scale === scales[index] && fileHashes[declared] === digest
       );
@@ -4248,26 +4265,26 @@ function placeMetroDescriptor(listing, descriptor) {
 }
 function unverifiedFileKey(dest) {
   return dest.placements.filter((placement) => !placement.verified).flatMap(
-    (placement) => [...placement.files.values()].map((relative2) => (0, import_node_path17.join)(dest.directory, relative2))
+    (placement) => [...placement.files.values()].map((relative2) => (0, import_node_path21.join)(dest.directory, relative2))
   ).sort().join("\n");
 }
 function searchMetroAssetDest(bundlePath, descriptors) {
-  const bundleDirectory = (0, import_node_path17.dirname)((0, import_node_path17.resolve)(bundlePath));
+  const bundleDirectory = (0, import_node_path21.dirname)((0, import_node_path21.resolve)(bundlePath));
   const candidates = [
-    (0, import_node_path17.join)(bundleDirectory, "assets"),
+    (0, import_node_path21.join)(bundleDirectory, "assets"),
     bundleDirectory,
-    (0, import_node_path17.resolve)(bundleDirectory, "..", "assets")
+    (0, import_node_path21.resolve)(bundleDirectory, "..", "assets")
   ];
   const cwd = process.cwd();
   let projectDirectory = null;
   for (const start of [bundleDirectory, cwd]) {
-    let directory = (0, import_node_path17.resolve)(start);
+    let directory = (0, import_node_path21.resolve)(start);
     while (true) {
       if (detectProject(directory)?.hasMetroConfig) {
         projectDirectory = directory;
         break;
       }
-      const parent = (0, import_node_path17.dirname)(directory);
+      const parent = (0, import_node_path21.dirname)(directory);
       if (parent === directory) break;
       directory = parent;
     }
@@ -4275,11 +4292,11 @@ function searchMetroAssetDest(bundlePath, descriptors) {
   }
   if (projectDirectory) {
     candidates.push(
-      (0, import_node_path17.join)(projectDirectory, "assets"),
-      (0, import_node_path17.join)(projectDirectory, "dist"),
-      (0, import_node_path17.join)(projectDirectory, "dist", "assets"),
-      (0, import_node_path17.join)(projectDirectory, "build"),
-      (0, import_node_path17.join)(projectDirectory, "build", "assets")
+      (0, import_node_path21.join)(projectDirectory, "assets"),
+      (0, import_node_path21.join)(projectDirectory, "dist"),
+      (0, import_node_path21.join)(projectDirectory, "dist", "assets"),
+      (0, import_node_path21.join)(projectDirectory, "build"),
+      (0, import_node_path21.join)(projectDirectory, "build", "assets")
     );
   }
   const searched = [];
@@ -4287,7 +4304,7 @@ function searchMetroAssetDest(bundlePath, descriptors) {
   const stale = [];
   let truncated = false;
   for (const candidate of candidates) {
-    const directory = (0, import_node_path17.resolve)(candidate);
+    const directory = (0, import_node_path21.resolve)(candidate);
     if (searched.includes(directory)) continue;
     searched.push(directory);
     const listing = listMetroAssetDest(directory);
@@ -4393,7 +4410,7 @@ async function embedBundleAssets(bundlePath, command, assetPolicy) {
       );
     }
     const relative2 = placement?.files.get(variant.scale);
-    if (relative2 && dest) return (0, import_node_fs17.readFileSync)((0, import_node_path17.join)(dest.directory, relative2));
+    if (relative2 && dest) return (0, import_node_fs21.readFileSync)((0, import_node_path21.join)(dest.directory, relative2));
     if (placement && placement.files.size > 0) return null;
     if (placement && placement.ambiguous.length > 0 && dest) {
       throw new Error(
@@ -4422,7 +4439,7 @@ async function embedBundleAssets(bundlePath, command, assetPolicy) {
     );
     const classic = metroIosAssetDestRelatives(variant.descriptor.httpServerLocation, filename)[0] ?? filename;
     throw new Error(
-      `${command} could not read ${(0, import_node_path17.join)(dest?.directory ?? ".", classic)} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}, and has no stand-in for a .${variant.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`
+      `${command} could not read ${(0, import_node_path21.join)(dest?.directory ?? ".", classic)} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}, and has no stand-in for a .${variant.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`
     );
   });
   return {
@@ -4439,10 +4456,10 @@ async function produceArtifact(bundlePath, maxBytes, command, assetPolicy) {
     inferModuleIdentity: inferCloudModuleIdentity
   });
   const bytes = Buffer.from(artifact.code, "utf8");
-  const assets = artifact.receipt.assets;
+  const assets2 = artifact.receipt.assets;
   if (bytes.length > maxBytes) {
     throw new Error(
-      `${REMOTE_COMMAND} artifact is ${bytes.length} bytes and exceeds the ${maxBytes}-byte limit. Embedded assets weigh ${assets.bytes} bytes on disk, and base64 embedding costs about a third on top of that, so the practical asset budget is roughly ${Math.round(maxBytes * 0.75 / 1e6)} MB.${largestEmbeddedAssets(assets.sizes, 10)}`
+      `${REMOTE_COMMAND} artifact is ${bytes.length} bytes and exceeds the ${maxBytes}-byte limit. Embedded assets weigh ${assets2.bytes} bytes on disk, and base64 embedding costs about a third on top of that, so the practical asset budget is roughly ${Math.round(maxBytes * 0.75 / 1e6)} MB.${largestEmbeddedAssets(assets2.sizes, 10)}`
     );
   }
   const warnings = [];
@@ -4458,12 +4475,12 @@ async function produceArtifact(bundlePath, maxBytes, command, assetPolicy) {
   }
   if (bytes.length >= Math.floor(maxBytes * 0.8)) {
     warnings.push(
-      `${command} artifact is ${bytes.length} bytes, ${Math.round(bytes.length / maxBytes * 100)}% of the ${maxBytes}-byte limit.${largestEmbeddedAssets(assets.sizes, 5)}`
+      `${command} artifact is ${bytes.length} bytes, ${Math.round(bytes.length / maxBytes * 100)}% of the ${maxBytes}-byte limit.${largestEmbeddedAssets(assets2.sizes, 5)}`
     );
   }
   return {
     bytes,
-    sha256: (0, import_node_crypto6.createHash)("sha256").update(bytes).digest("hex"),
+    sha256: (0, import_node_crypto10.createHash)("sha256").update(bytes).digest("hex"),
     receipt: artifact.receipt,
     assetsDirectory: prepared.dest?.directory ?? null,
     warnings
@@ -4568,13 +4585,13 @@ async function createCloudBox(options) {
     warnings: artifact.warnings
   };
 }
-var import_node_crypto6, import_node_fs17, import_node_path17, DEFAULT_RNX_CLOUD_ORIGIN, MAX_RNX_CLOUD_BUNDLE_BYTES, REMOTE_COMMAND, MAX_ASSET_DEST_FILES, ACCOUNT_CHOICE_REFUSALS, PROJECT_ONLY_DIRECTORIES, MAX_PLACEMENT_COMBINATIONS;
+var import_node_crypto10, import_node_fs21, import_node_path21, DEFAULT_RNX_CLOUD_ORIGIN, MAX_RNX_CLOUD_BUNDLE_BYTES, REMOTE_COMMAND, MAX_ASSET_DEST_FILES, ACCOUNT_CHOICE_REFUSALS, PROJECT_ONLY_DIRECTORIES, MAX_PLACEMENT_COMBINATIONS;
 var init_cloud_client = __esm({
   "cli/cloud-client.ts"() {
     "use strict";
-    import_node_crypto6 = require("node:crypto");
-    import_node_fs17 = require("node:fs");
-    import_node_path17 = require("node:path");
+    import_node_crypto10 = require("node:crypto");
+    import_node_fs21 = require("node:fs");
+    import_node_path21 = require("node:path");
     init_metroAssetArtifact();
     init_metroCloudArtifact();
     init_metro_fingerprint_registry_client();
@@ -5018,9 +5035,9 @@ function safeChildPlistName(value) {
     name: file.toLowerCase().endsWith(".plist") ? file : `${file}.plist`
   };
 }
-async function readableSettingsBundle(path12) {
+async function readableSettingsBundle(path16) {
   try {
-    const root = await (0, import_promises.stat)((0, import_node_path.join)(path12, "Root.plist"));
+    const root = await (0, import_promises.stat)((0, import_node_path.join)(path16, "Root.plist"));
     return root.isFile() && root.size <= MAX_PLIST_BYTES;
   } catch {
     return false;
@@ -5065,26 +5082,26 @@ async function settingsBundleFingerprint(bundlePath) {
     return null;
   }
 }
-async function parsePlistRecord(path12) {
+async function parsePlistRecord(path16) {
   try {
-    const metadata = await (0, import_promises.stat)(path12);
+    const metadata = await (0, import_promises.stat)(path16);
     if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
-    const source = await (0, import_promises.readFile)(path12, "utf8");
+    const source = await (0, import_promises.readFile)(path16, "utf8");
     const parsed = parsePlistSource(source);
     return isRecord2(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
-function normalizeMultiValue(raw, key, title) {
-  if (!Array.isArray(raw.Values) || !Array.isArray(raw.Titles)) return null;
+function normalizeMultiValue(raw2, key, title) {
+  if (!Array.isArray(raw2.Values) || !Array.isArray(raw2.Titles)) return null;
   const values = [];
   const titles = [];
   let optionType;
-  const pairCount = Math.min(raw.Values.length, raw.Titles.length);
+  const pairCount = Math.min(raw2.Values.length, raw2.Titles.length);
   for (let index = 0; index < pairCount; index++) {
-    const value = preferenceValue(raw.Values[index]);
-    const optionTitle = optionalString(raw.Titles[index]);
+    const value = preferenceValue(raw2.Values[index]);
+    const optionTitle = optionalString(raw2.Titles[index]);
     if (value === null || optionTitle === void 0) continue;
     const valueType = typeof value === "string" ? "string" : typeof value === "number" ? "number" : "boolean";
     if (optionType !== void 0 && valueType !== optionType) continue;
@@ -5094,7 +5111,7 @@ function normalizeMultiValue(raw, key, title) {
   }
   const firstValue = values[0];
   if (firstValue === void 0) return null;
-  const declaredDefault = preferenceValue(raw.DefaultValue);
+  const declaredDefault = preferenceValue(raw2.DefaultValue);
   const defaultValue = declaredDefault !== null && values.includes(declaredDefault) ? declaredDefault : firstValue;
   return {
     type: "multi-value",
@@ -5106,37 +5123,37 @@ function normalizeMultiValue(raw, key, title) {
     titles
   };
 }
-async function normalizeSpecifier(raw, context) {
-  if (!isRecord2(raw)) return null;
+async function normalizeSpecifier(raw2, context) {
+  if (!isRecord2(raw2)) return null;
   if (context.budget.specifiers >= MAX_SPECIFIERS) return null;
-  const type = requiredString(raw.Type);
+  const type = requiredString(raw2.Type);
   if (!type) return null;
   context.budget.specifiers += 1;
   if (type === "PSGroupSpecifier") {
-    const title2 = optionalString(raw.Title);
-    const footer = optionalString(raw.FooterText);
+    const title2 = optionalString(raw2.Title);
+    const footer = optionalString(raw2.FooterText);
     return {
       type: "group",
       ...title2 !== void 0 ? { title: title2 } : null,
       ...footer !== void 0 ? { footer } : null
     };
   }
-  const key = requiredString(raw.Key);
+  const key = requiredString(raw2.Key);
   if (type === "PSSliderSpecifier") {
     if (!key) return null;
-    const minimumValue = finiteNumber(raw.MinimumValue);
-    const maximumValue = finiteNumber(raw.MaximumValue);
+    const minimumValue = finiteNumber(raw2.MinimumValue);
+    const maximumValue = finiteNumber(raw2.MaximumValue);
     if (minimumValue === null || maximumValue === null || maximumValue <= minimumValue) {
       return null;
     }
-    const declaredDefault = finiteNumber(raw.DefaultValue);
+    const declaredDefault = finiteNumber(raw2.DefaultValue);
     const defaultValue = Math.min(
       maximumValue,
       Math.max(minimumValue, declaredDefault ?? minimumValue)
     );
-    const title2 = optionalString(raw.Title);
-    const minimumValueImage = optionalString(raw.MinimumValueImage);
-    const maximumValueImage = optionalString(raw.MaximumValueImage);
+    const title2 = optionalString(raw2.Title);
+    const minimumValueImage = optionalString(raw2.MinimumValueImage);
+    const maximumValueImage = optionalString(raw2.MaximumValueImage);
     return {
       type: "slider",
       key,
@@ -5150,8 +5167,8 @@ async function normalizeSpecifier(raw, context) {
     };
   }
   if (type === "PSChildPaneSpecifier") {
-    const title2 = requiredString(raw.Title);
-    const child = safeChildPlistName(raw.File);
+    const title2 = requiredString(raw2.Title);
+    const child = safeChildPlistName(raw2.File);
     if (!title2 || !child || context.depth >= MAX_CHILD_DEPTH) return null;
     const childSpecifiers = await parseSpecifierFile(child.name, {
       ...context,
@@ -5166,9 +5183,9 @@ async function normalizeSpecifier(raw, context) {
     };
   }
   if (!key) return null;
-  const title = requiredString(raw.Title) ?? key;
+  const title = requiredString(raw2.Title) ?? key;
   if (type === "PSToggleSwitchSpecifier") {
-    const defaultValue = typeof raw.DefaultValue === "boolean" ? raw.DefaultValue : false;
+    const defaultValue = typeof raw2.DefaultValue === "boolean" ? raw2.DefaultValue : false;
     return {
       type: "toggle",
       key,
@@ -5178,11 +5195,11 @@ async function normalizeSpecifier(raw, context) {
     };
   }
   if (type === "PSTextFieldSpecifier") {
-    const defaultValue = optionalString(raw.DefaultValue) ?? "";
-    const placeholder = optionalString(raw.Placeholder);
-    const resolvedKeyboardType = keyboardType(raw.KeyboardType);
-    const resolvedAutocapitalization = autocapitalization(raw.AutocapitalizationType);
-    const resolvedAutocorrection = autocorrection(raw.AutocorrectionType);
+    const defaultValue = optionalString(raw2.DefaultValue) ?? "";
+    const placeholder = optionalString(raw2.Placeholder);
+    const resolvedKeyboardType = keyboardType(raw2.KeyboardType);
+    const resolvedAutocapitalization = autocapitalization(raw2.AutocapitalizationType);
+    const resolvedAutocorrection = autocorrection(raw2.AutocorrectionType);
     return {
       type: "text",
       key,
@@ -5190,17 +5207,17 @@ async function normalizeSpecifier(raw, context) {
       defaultValue,
       currentValue: defaultValue,
       ...placeholder !== void 0 ? { placeholder } : null,
-      ...typeof raw.IsSecure === "boolean" ? { secure: raw.IsSecure } : null,
+      ...typeof raw2.IsSecure === "boolean" ? { secure: raw2.IsSecure } : null,
       ...resolvedKeyboardType ? { keyboardType: resolvedKeyboardType } : null,
       ...resolvedAutocapitalization ? { autocapitalization: resolvedAutocapitalization } : null,
       ...resolvedAutocorrection !== void 0 ? { autocorrection: resolvedAutocorrection } : null
     };
   }
   if (type === "PSMultiValueSpecifier" || type === "PSRadioGroupSpecifier") {
-    return normalizeMultiValue(raw, key, title);
+    return normalizeMultiValue(raw2, key, title);
   }
   if (type === "PSTitleValueSpecifier") {
-    const defaultValue = preferenceValue(raw.DefaultValue) ?? "";
+    const defaultValue = preferenceValue(raw2.DefaultValue) ?? "";
     return {
       type: "title-value",
       key,
@@ -5226,9 +5243,9 @@ async function parseSpecifierFile(fileName, context) {
   const stack = new Set(context.stack);
   stack.add(fileName);
   const specifiers = [];
-  for (const raw of root.PreferenceSpecifiers) {
+  for (const raw2 of root.PreferenceSpecifiers) {
     if (context.budget.specifiers >= MAX_SPECIFIERS) break;
-    const specifier = await normalizeSpecifier(raw, { ...context, stack });
+    const specifier = await normalizeSpecifier(raw2, { ...context, stack });
     if (specifier) specifiers.push(specifier);
   }
   context.fileCache.set(fileName, specifiers);
@@ -5331,7 +5348,7 @@ async function tcpPing(port, timeout = TCP_GATE_MS) {
     return null;
   }
 }
-function httpGet(hostname, port, path12, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(hostname, port, path16, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve5) => {
     let settled = false;
     let killing = false;
@@ -5340,13 +5357,13 @@ function httpGet(hostname, port, path12, method = "GET", timeout = TIMEOUT_MS, h
       settled = true;
       resolve5(value);
     };
-    const req = import_http.default.request({ hostname, port, path: path12, method, headers }, (res) => {
+    const req = import_http.default.request({ hostname, port, path: path16, method, headers }, (res) => {
       let body = "";
       res.on("data", (c) => body += c.toString());
       const contentType = (() => {
-        const raw = res.headers["content-type"];
-        if (typeof raw === "string") return raw;
-        if (Array.isArray(raw)) return raw[0];
+        const raw2 = res.headers["content-type"];
+        if (typeof raw2 === "string") return raw2;
+        if (Array.isArray(raw2)) return raw2[0];
         return void 0;
       })();
       res.on(
@@ -6016,6 +6033,1833 @@ function getCliVersion() {
   return cached2;
 }
 
+// src/expo-swift-host.ts
+var import_node_child_process4 = require("node:child_process");
+var import_node_crypto5 = require("node:crypto");
+var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_module = require("node:module");
+var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_util3 = require("node:util");
+init_backend_origin();
+
+// src/swift-host.ts
+var import_node_crypto4 = require("node:crypto");
+var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
+
+// ../sootsim-swift/src/bundleAssets.ts
+var import_svgpath = __toESM(require("svgpath"), 1);
+var RASTER_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".bmp",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".webp"
+]);
+function extOf(file) {
+  const dot = file.lastIndexOf(".");
+  return dot < 0 ? "" : file.slice(dot).toLowerCase();
+}
+function baseOf(file) {
+  const slash = file.lastIndexOf("/");
+  return slash < 0 ? file : file.slice(slash + 1);
+}
+function pickImagesetFile(images) {
+  const rasters = images.filter(
+    (image) => typeof image.filename === "string" && RASTER_EXTENSIONS.has(extOf(image.filename))
+  );
+  if (rasters.length === 0) return null;
+  const rank = (scale) => scale === "2x" ? 0 : scale === "3x" ? 1 : scale === "1x" ? 2 : 3;
+  const pick = [...rasters].sort((a, b) => rank(a.scale) - rank(b.scale))[0];
+  return {
+    filename: pick.filename,
+    scale: pick.scale === "2x" ? 2 : pick.scale === "3x" ? 3 : 1
+  };
+}
+function flatScale(path16) {
+  const match = /@([23])x\.[^./]+$/.exec(path16);
+  return match ? Number(match[1]) : 1;
+}
+function providesNamespace(text) {
+  if (text === null) return false;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed?.properties?.["provides-namespace"] === true;
+  } catch {
+    return false;
+  }
+}
+function catalogEntryName(contentsPath, kind, readText) {
+  const parts = contentsPath.split("/");
+  const leaf = parts[parts.length - 2] ?? "";
+  if (!leaf.endsWith(kind)) return null;
+  const short = leaf.slice(0, -kind.length) || null;
+  if (short === null) return null;
+  const segments = [short];
+  for (let depth = parts.length - 3; depth >= 0; depth -= 1) {
+    const dir = parts[depth] ?? "";
+    if (dir.endsWith(".xcassets") || dir === "" || dir === "." || dir === "..") break;
+    const folderContents = [...parts.slice(0, depth + 1), "Contents.json"].join("/");
+    if (providesNamespace(readText(folderContents))) segments.unshift(dir);
+  }
+  return segments.join("/");
+}
+function isFlatResourceImage(path16) {
+  return path16.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path16));
+}
+function enumerateBundleImages(paths, readText) {
+  const table = [];
+  const seen = /* @__PURE__ */ new Set();
+  const catalogs = paths.filter((path16) => baseOf(path16) === "Contents.json");
+  for (const contentsPath of catalogs) {
+    const name2 = catalogEntryName(contentsPath, ".imageset", readText);
+    if (name2 === null || seen.has(name2)) continue;
+    let parsed;
+    try {
+      const text = readText(contentsPath);
+      if (text === null) continue;
+      parsed = JSON.parse(text);
+    } catch {
+      continue;
+    }
+    const images = parsed?.images;
+    if (!Array.isArray(images)) continue;
+    const dir = contentsPath.split("/").slice(0, -1).join("/");
+    const pick = pickImagesetFile(images);
+    if (pick === null || pick.filename.includes("/") || pick.filename.includes("\\"))
+      continue;
+    seen.add(name2);
+    table.push({ name: name2, file: `${dir}/${pick.filename}`, scale: pick.scale });
+  }
+  for (const path16 of paths) {
+    if (!isFlatResourceImage(path16)) continue;
+    const name2 = baseOf(path16).slice(0, -extOf(path16).length);
+    if (name2 === "" || seen.has(name2)) continue;
+    seen.add(name2);
+    table.push({ name: name2, file: path16, scale: flatScale(path16) });
+  }
+  return table;
+}
+function colorComponent(value) {
+  if (typeof value !== "string") return null;
+  const parsed = value.startsWith("0x") ? Number.parseInt(value.slice(2), 16) / 255 : value.includes(".") ? Number.parseFloat(value) : Number.parseInt(value, 10) / 255;
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function colorsetValue(color) {
+  if (typeof color !== "object" || color === null) return null;
+  const reference = Reflect.get(color, "reference");
+  if (typeof reference === "string") {
+    return { system: reference.replace(/Color$/, "") };
+  }
+  const space = Reflect.get(color, "color-space");
+  if (space !== "srgb" && space !== "extended-srgb") return null;
+  const components = Reflect.get(color, "components");
+  if (typeof components !== "object" || components === null) return null;
+  const [red, green, blue, alpha] = ["red", "green", "blue", "alpha"].map(
+    (key) => colorComponent(Reflect.get(components, key))
+  );
+  if (red === null || green === null || blue === null || alpha === null) return null;
+  if (![red, green, blue].every((value) => value >= 0 && value <= 1)) return null;
+  const byte = (value) => Math.round(value * 255);
+  return `rgba(${byte(red)}, ${byte(green)}, ${byte(blue)}, ${alpha})`;
+}
+function enumerateBundleColors(paths, readText) {
+  const table = {};
+  for (const contentsPath of paths.filter((path16) => baseOf(path16) === "Contents.json")) {
+    const name2 = catalogEntryName(contentsPath, ".colorset", readText);
+    if (name2 === null || name2 in table) continue;
+    let colors;
+    try {
+      const text = readText(contentsPath);
+      if (text === null) continue;
+      colors = Reflect.get(JSON.parse(text), "colors");
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(colors)) continue;
+    let light = null;
+    let dark = null;
+    for (const entry of colors) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const idiom = Reflect.get(entry, "idiom");
+      if (idiom !== "universal" && idiom !== "iphone") continue;
+      const appearances = Reflect.get(entry, "appearances");
+      const list = Array.isArray(appearances) ? appearances : [];
+      if (list.some((item) => Reflect.get(item, "appearance") === "contrast")) continue;
+      const isDark = list.some(
+        (item) => Reflect.get(item, "appearance") === "luminosity" && Reflect.get(item, "value") === "dark"
+      );
+      if (list.length > 0 && !isDark) continue;
+      const value = colorsetValue(Reflect.get(entry, "color"));
+      if (value === null) continue;
+      if (isDark) dark = value;
+      else light = value;
+    }
+    if (light === null) continue;
+    if (typeof light === "object") table[name2] = light;
+    else table[name2] = { light, dark: typeof dark === "string" ? dark : light };
+  }
+  return table;
+}
+var SYMBOL_CAP_HEIGHT_EM = 1443 / 2048;
+function axisExtremes(points) {
+  const [a = 0, b = 0, c = 0, d] = points;
+  const out = [a, d ?? c];
+  const within = (t) => t > 0 && t < 1;
+  if (d === void 0) {
+    const denom = a - 2 * b + c;
+    const t = denom === 0 ? -1 : (a - b) / denom;
+    if (within(t)) out.push((1 - t) ** 2 * a + 2 * (1 - t) * t * b + t ** 2 * c);
+    return out;
+  }
+  const qa = 3 * (-a + 3 * b - 3 * c + d);
+  const qb = 6 * (a - 2 * b + c);
+  const qc = 3 * (b - a);
+  const roots = Math.abs(qa) < 1e-12 ? qb === 0 ? [] : [-qc / qb] : (() => {
+    const disc = qb * qb - 4 * qa * qc;
+    if (disc < 0) return [];
+    const root = Math.sqrt(disc);
+    return [(-qb + root) / (2 * qa), (-qb - root) / (2 * qa)];
+  })();
+  for (const t of roots.filter(within))
+    out.push(
+      (1 - t) ** 3 * a + 3 * (1 - t) ** 2 * t * b + 3 * (1 - t) * t ** 2 * c + t ** 3 * d
+    );
+  return out;
+}
+function pathBounds(d) {
+  const xs = [];
+  const ys = [];
+  for (const path16 of d)
+    (0, import_svgpath.default)(path16).abs().unshort().unarc().iterate((segment, _index, x, y) => {
+      const [command, ...args] = segment;
+      if (command === "M" || command === "L") {
+        xs.push(Number(args[0]));
+        ys.push(Number(args[1]));
+      } else if (command === "H") xs.push(Number(args[0]));
+      else if (command === "V") ys.push(Number(args[0]));
+      else if (command === "Q" || command === "C") {
+        const n = args.map(Number);
+        xs.push(...axisExtremes([x, ...n.filter((_, i) => i % 2 === 0)]));
+        ys.push(...axisExtremes([y, ...n.filter((_, i) => i % 2 === 1)]));
+      }
+    });
+  return {
+    minX: Math.min(...xs),
+    maxX: Math.max(...xs),
+    minY: Math.min(...ys),
+    maxY: Math.max(...ys)
+  };
+}
+function guide(svg, id, axis) {
+  const line = new RegExp(`<line[^>]*id="${id}"[^>]*>`).exec(svg)?.[0];
+  const value = line === void 0 ? void 0 : new RegExp(`${axis}="([-0-9.]+)"`).exec(line)?.[1];
+  return value === void 0 ? null : Number(value);
+}
+function enumerateBundleSymbols(paths, readText) {
+  const table = {};
+  for (const contentsPath of paths.filter((path16) => baseOf(path16) === "Contents.json")) {
+    const name2 = catalogEntryName(contentsPath, ".symbolset", readText);
+    if (name2 === null || name2 in table) continue;
+    let symbols;
+    try {
+      symbols = Reflect.get(JSON.parse(readText(contentsPath) ?? "null") ?? {}, "symbols");
+    } catch {
+      continue;
+    }
+    const file = Array.isArray(symbols) ? symbols.map((entry) => Reflect.get(entry ?? {}, "filename")).find((f) => typeof f === "string") : void 0;
+    if (typeof file !== "string") continue;
+    if (file.includes("/") || file.includes("\\")) continue;
+    const svg = readText(`${contentsPath.split("/").slice(0, -1).join("/")}/${file}`);
+    if (svg === null) continue;
+    const group = /<g id="Regular-M"[^>]*>([\s\S]*?)<\/g>/.exec(svg)?.[1];
+    const baseline = guide(svg, "Baseline-M", "y1");
+    const capline = guide(svg, "Capline-M", "y1");
+    const left = guide(svg, "left-margin-Regular-M", "x1") ?? guide(svg, "left-margin", "x1");
+    const right = guide(svg, "right-margin-Regular-M", "x1") ?? guide(svg, "right-margin", "x1");
+    if (group === void 0 || baseline === null || capline === null || left === null || right === null)
+      continue;
+    const d = [...group.matchAll(/ d="([^"]+)"/g)].map((match) => match[1] ?? "");
+    if (d.length === 0 || baseline <= capline) continue;
+    const scale = 24 * SYMBOL_CAP_HEIGHT_EM / (baseline - capline);
+    const box = pathBounds(d);
+    const translateX = 12 - (box.minX + box.maxX) * scale / 2;
+    const translateY = 12 - (box.minY + box.maxY) * scale / 2;
+    const advance = Math.round((right - left) * scale * 1e3) / 1e3;
+    const tall = (box.maxY - box.minY) * scale + 0.175 * 24;
+    table[name2] = {
+      viewBox: "0 0 24 24",
+      advance,
+      box: [12 - advance / 2, 12 - tall / 2, advance, tall],
+      layers: d.map((path16) => ({
+        d: (0, import_svgpath.default)(path16).abs().scale(scale).translate(translateX, translateY).round(3).toString()
+      }))
+    };
+  }
+  return table;
+}
+function enumerateBundleJson(paths) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [...paths].filter(
+    (path16) => path16.split("/").includes("Resources") && path16.split("/").every((segment) => segment !== "" && segment !== "..") && (extOf(path16) === ".json" || extOf(path16) === ".xcstrings")
+  ).sort((a, b) => {
+    const aDepth = a.split("/").length;
+    const bDepth = b.split("/").length;
+    return aDepth - bDepth || (a < b ? -1 : a > b ? 1 : 0);
+  });
+  for (const file of ordered) {
+    const base = baseOf(file);
+    if (seen.has(base)) continue;
+    seen.add(base);
+    found.push({ base, file });
+  }
+  return found;
+}
+
+// src/swift-host.ts
+init_auth();
+init_backend_origin();
+
+// src/swift-compile.ts
+var import_node_child_process3 = require("node:child_process");
+var import_node_crypto3 = require("node:crypto");
+var import_node_fs8 = require("node:fs");
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_util2 = require("node:util");
+
+// src/swift-icu.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs7 = require("node:fs");
+var import_node_path7 = __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_process2.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";
+var raw = /* @__PURE__ */ new Map();
+var assets = /* @__PURE__ */ new Map();
+function memo(cache, key, load2) {
+  let pending = cache.get(key);
+  if (!pending) {
+    pending = load2();
+    pending.catch(() => cache.delete(key));
+    cache.set(key, pending);
+  }
+  return pending;
+}
+function swiftIcuData(toolchainBin, release) {
+  return memo(raw, `${toolchainBin}\0${release}`, () => load(toolchainBin, release));
+}
+function swiftIcuAsset(toolchainBin, release) {
+  return memo(assets, `${toolchainBin}\0${release}`, async () => {
+    const zipped = await deflate(await swiftIcuData(toolchainBin, release));
+    return { sha256: (0, import_node_crypto2.createHash)("sha256").update(zipped).digest("hex"), gzip: zipped };
+  });
+}
+async function load(toolchainBin, release) {
+  const { stdout } = await run(import_node_path7.default.join(toolchainBin, "swift"), [
+    "sdk",
+    "configure",
+    "--show-configuration",
+    `${release}_wasm`,
+    "wasm32-unknown-wasip1"
+  ]);
+  const resources = /^swiftStaticResourcesPath: (.+)$/m.exec(stdout)?.[1]?.trim();
+  if (!resources) throw new Error(`swift-icu: ${release}_wasm names no static resources`);
+  return Buffer.from(
+    icuSegment(archiveMember((0, import_node_fs7.readFileSync)(import_node_path7.default.join(resources, ARCHIVE)), MEMBER))
+  );
+}
+function archiveMember(archive, name2) {
+  if (archive.toString("latin1", 0, 8) !== "!<arch>\n")
+    throw new Error("swift-icu: not an ar archive");
+  let names = "";
+  for (let at = 8; at + 60 <= archive.length; ) {
+    const raw2 = archive.toString("latin1", at, at + 16).trimEnd();
+    const size = Number(archive.toString("latin1", at + 48, at + 58).trim());
+    const body = archive.subarray(at + 60, at + 60 + size);
+    if (raw2 === "//") names = body.toString("latin1");
+    const member = /^\/\d+$/.test(raw2) ? names.slice(Number(raw2.slice(1)), names.indexOf("/\n", Number(raw2.slice(1)))) : raw2.replace(/\/$/, "");
+    if (member === name2) return body;
+    at += 60 + size + size % 2;
+  }
+  throw new Error(`swift-icu: ${name2} is not in the sdk's icu archive`);
+}
+function icuSegment(object) {
+  let at = 8;
+  const leb = () => {
+    let result = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = object[at++];
+      result += (byte & 127) * 2 ** shift;
+      shift += 7;
+    } while (byte & 128);
+    return result;
+  };
+  const found = [];
+  while (at < object.length) {
+    const id = object[at++];
+    const size = leb();
+    const end = at + size;
+    if (id === 11) {
+      for (let count = leb(); count > 0; count--) {
+        if (leb() !== 0) throw new Error("swift-icu: unexpected data segment kind");
+        at++;
+        leb();
+        at++;
+        const length = leb();
+        const bytes = object.subarray(at, at + length);
+        if (bytes[2] === 218 && bytes[3] === 39) found.push(bytes);
+        at += length;
+      }
+    }
+    at = end;
+  }
+  if (found.length !== 1)
+    throw new Error(`swift-icu: expected one icu data segment, found ${found.length}`);
+  return found[0];
+}
+
+// src/swift-package.ts
+function swiftManifestTargets(manifest) {
+  const code = manifest.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+  const targets = [];
+  const pattern = /\.(executableTarget|target)\s*\(/g;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    const executable = match[1] === "executableTarget";
+    let depth = 1;
+    const start = pattern.lastIndex;
+    let i = start;
+    let inString = false;
+    let escaped = false;
+    let flat = "";
+    while (i < code.length && depth > 0) {
+      const ch = code[i];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        if (depth === 1) flat += ch;
+      } else if (ch === '"') {
+        inString = true;
+        if (depth === 1) flat += ch;
+      } else if (ch === "(") {
+        depth++;
+        if (depth === 1) flat += ch;
+      } else if (ch === ")") {
+        depth--;
+        if (depth >= 1) flat += ch;
+      } else if (depth === 1) {
+        flat += ch;
+      }
+      i++;
+    }
+    const name2 = /\bname\s*:\s*"([^"]+)"/.exec(flat)?.[1];
+    if (!name2) continue;
+    const rawPath = /\bpath\s*:\s*"([^"]*)"/.exec(flat)?.[1];
+    const targetPath = rawPath == null || rawPath === "" ? `Sources/${name2}` : rawPath.replace(/^\.\//, "").replace(/\/+$/, "");
+    const call = code.slice(start, i);
+    const languageMode = Number(
+      /\.swiftLanguageMode\(\s*\.v(\d+)\s*\)/.exec(call)?.[1] ?? "5"
+    );
+    const mainActorIsolation = /\.defaultIsolation\(\s*MainActor\.self\s*\)/.test(call);
+    const resources = /\bresources\s*:/.test(flat);
+    targets.push({
+      name: name2,
+      path: targetPath,
+      executable,
+      languageMode,
+      mainActorIsolation,
+      resources
+    });
+  }
+  return targets;
+}
+function swiftPackagePartition(manifest) {
+  const targets = swiftManifestTargets(manifest);
+  return targets.length === 1 && targets[0].executable && targets[0].path === "." ? [] : targets;
+}
+
+// src/swift-compile.ts
+var run2 = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
+var WASM_TRIPLE = "wasm32-unknown-wasip1";
+var cores = import_node_os2.default.availableParallelism();
+var BUILD_ENV = { ...process.env, BINARYEN_CORES: String(Math.min(4, cores)) };
+var BUILD_JOBS = String(Math.max(1, Math.floor(cores / 2)));
+function swiftModuleInputFiles(root) {
+  const files = [
+    "Package.swift",
+    "scripts/contrast-app-Package.swift",
+    "toolchain.json"
+  ];
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs8.readdirSync)(import_node_path8.default.join(root, dir), { withFileTypes: true })) {
+      const relative2 = `${dir}/${entry.name}`;
+      if (entry.isDirectory()) walk(relative2);
+      else if (/\.(swift|c|h)$/.test(entry.name)) files.push(relative2);
+    }
+  };
+  walk("Sources");
+  return files.sort();
+}
+async function ensureMacroPlugins(moduleRoot, toolchainBin) {
+  const dir = import_node_path8.default.join(moduleRoot, ".build/host/RnxPreviewMacros");
+  const ext = process.platform === "darwin" ? "dylib" : "so";
+  const plugins = [
+    {
+      library: import_node_path8.default.join(dir, `libRnxPreviewMacros.${ext}`),
+      source: import_node_path8.default.join(moduleRoot, "Sources/RnxPreviewMacros/PreviewMacro.swift")
+    },
+    {
+      library: import_node_path8.default.join(dir, `libFoundationMacros.${ext}`),
+      source: import_node_path8.default.join(moduleRoot, "Sources/FoundationMacros/PredicateMacro.swift")
+    }
+  ];
+  const stale = plugins.some(
+    ({ library, source }) => !(0, import_node_fs8.existsSync)(library) || (0, import_node_fs8.statSync)(source).mtimeMs > (0, import_node_fs8.statSync)(library).mtimeMs
+  );
+  if (stale) {
+    await run2("sh", [
+      import_node_path8.default.join(moduleRoot, "scripts/build-preview-plugin.sh"),
+      toolchainBin,
+      plugins[0].library
+    ]);
+  }
+  return plugins.map(({ library }) => library);
+}
+var linkedModuleDigests = /* @__PURE__ */ new Map();
+function linkedModuleDigest(root) {
+  const files = swiftModuleInputFiles(root);
+  const stampHash = (0, import_node_crypto3.createHash)("sha256");
+  for (const file of files) {
+    const stat2 = (0, import_node_fs8.statSync)(import_node_path8.default.join(root, file), { bigint: true });
+    stampHash.update(file);
+    stampHash.update(
+      `${stat2.dev}:${stat2.ino}:${stat2.size}:${stat2.mtimeNs}:${stat2.ctimeNs}
+`
+    );
+  }
+  const stamp = stampHash.digest("hex");
+  const cached3 = linkedModuleDigests.get(root);
+  if (cached3?.stamp === stamp) return cached3.digest;
+  const hash = (0, import_node_crypto3.createHash)("sha256");
+  for (const file of files) {
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(file).digest());
+    hash.update(
+      (0, import_node_crypto3.createHash)("sha256").update((0, import_node_fs8.readFileSync)(import_node_path8.default.join(root, file))).digest()
+    );
+  }
+  const digest = hash.digest();
+  linkedModuleDigests.set(root, { stamp, digest });
+  return digest;
+}
+function compileTargets(input) {
+  const manifest = input.files["Package.swift"];
+  return manifest === void 0 ? [] : swiftPackagePartition(manifest);
+}
+function withNativeSourceGlue(input, glue) {
+  const targets = compileTargets(input);
+  if (targets.length > 1) {
+    throw new Error("swift native modules need one SwiftPM target");
+  }
+  const targetPath = targets[0]?.path === "." ? "" : targets[0]?.path ?? "";
+  return {
+    ...input,
+    files: {
+      ...input.files,
+      [import_node_path8.default.posix.join(targetPath, "OneNativeSource.generated.swift")]: glue
+    },
+    oneModule: true
+  };
+}
+function swiftSiblingDependencies(files, targets) {
+  const names = new Set(targets.map((target) => target.name));
+  const siblings = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const prefix = `${target.path}/`;
+    const deps = /* @__PURE__ */ new Set();
+    for (const [file, contents] of Object.entries(files)) {
+      if (file === "Package.swift" || !file.startsWith(prefix)) continue;
+      for (const match of contents.matchAll(
+        /^\s*(?:@\w+(?:\([^)]*\))?\s+)*import\s+(?:(?:typealias|struct|class|enum|protocol|let|var|func)\s+)?([A-Za-z_][A-Za-z0-9_]*)/gm
+      )) {
+        if (names.has(match[1]) && match[1] !== target.name) deps.add(match[1]);
+      }
+    }
+    siblings.set(target.name, [...deps].sort());
+  }
+  return siblings;
+}
+var ONE_PRODUCT = '.product(name: "One", package: "sootsim-swift")';
+var OBJC_IMPLICIT_FLAGS = ', "-Xfrontend", "-import-module", "-Xfrontend", "PeachObjC"';
+var ONE_IMPLICIT_FLAGS = ', "-Xfrontend", "-import-module", "-Xfrontend", "One"';
+var MULTI_MANIFEST_VERSION = 6;
+function swiftArtifactHash(input, release, moduleRoot) {
+  const hash = (0, import_node_crypto3.createHash)("sha256");
+  hash.update(`swift-compile/v6
+${release}
+`);
+  if (input.oneModule) hash.update("one-module\n");
+  hash.update(linkedModuleDigest(moduleRoot));
+  for (const file of Object.keys(input.files).sort()) {
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(file).digest());
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(input.files[file]).digest());
+  }
+  for (const base of Object.keys(input.resources ?? {}).sort()) {
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(base).digest());
+    hash.update(
+      (0, import_node_crypto3.createHash)("sha256").update(input.resources?.[base] ?? "").digest()
+    );
+  }
+  for (const name2 of Object.keys(input.images ?? {}).sort()) {
+    const image = input.images?.[name2];
+    if (!image) continue;
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(name2).digest());
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(image.file).digest());
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(image.data).digest());
+  }
+  const targets = compileTargets(input);
+  if (targets.length > 0) {
+    hash.update(`swift-multi/v${MULTI_MANIFEST_VERSION}
+`);
+    hash.update(
+      JSON.stringify({
+        targets,
+        siblings: [...swiftSiblingDependencies(input.files, targets)].sort(
+          (a, b) => String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0
+        )
+      })
+    );
+  }
+  return hash.digest("hex");
+}
+function emitSwiftPackageManifest(args) {
+  const { targets, siblings, moduleRoot, oneModule } = args;
+  const executable = targets.find((target) => target.executable);
+  if (!executable) throw new Error("swift-compile: no executable target to emit");
+  const stanza = (target) => {
+    const isolation = target.mainActorIsolation ? " .defaultIsolation(MainActor.self)," : "";
+    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation} .unsafeFlags(["-Osize"${OBJC_IMPLICIT_FLAGS}${oneModule ? ONE_IMPLICIT_FLAGS : ""}])]`;
+    const deps = [
+      '.product(name: "SwiftUI", package: "sootsim-swift")',
+      ...oneModule ? [ONE_PRODUCT] : [],
+      ...(siblings.get(target.name) ?? []).map((sibling) => `"${sibling}"`)
+    ].join(", ");
+    const kind = target.executable ? ".executableTarget" : ".target";
+    const link = target.executable ? `,
+      linkerSettings: [
+        .unsafeFlags([
+          "-Xclang-linker", "-mexec-model=reactor",
+          "-Xlinker", "--export-if-defined=__main_argc_argv",
+        ]),
+        .unsafeFlags(["-Xlinker", "--strip-all"], .when(configuration: .release)),
+      ]` : "";
+    return [
+      `    ${kind}(`,
+      `      name: "${target.name}",`,
+      `      dependencies: [${deps}],`,
+      `      path: "${target.path}",`,
+      `      ${swiftSettings}${link}`,
+      `    ),`
+    ].join("\n");
+  };
+  return [
+    "// swift-tools-version: 6.2",
+    "import PackageDescription",
+    "",
+    "// generated by swift-compile from the project package partition.",
+    "let package = Package(",
+    '  name: "app",',
+    `  products: [.executable(name: "${executable.name}", targets: ["${executable.name}"])],`,
+    `  dependencies: [.package(path: "${moduleRoot}")],`,
+    "  targets: [",
+    ...targets.map(stanza),
+    "  ]",
+    ")",
+    ""
+  ].join("\n");
+}
+function syncSwiftTree(base, files) {
+  (0, import_node_fs8.mkdirSync)(base, { recursive: true });
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs8.readdirSync)(dir, { withFileTypes: true })) {
+      const full = import_node_path8.default.join(dir, entry.name);
+      if (dir === base && entry.name === ".build") continue;
+      if (entry.isDirectory()) walk(full);
+      else if (!files.has(full)) (0, import_node_fs8.rmSync)(full, { force: true });
+    }
+  };
+  walk(base);
+  for (const [full, contents] of files) {
+    if ((0, import_node_fs8.existsSync)(full) && (0, import_node_fs8.readFileSync)(full, "utf8") === contents) continue;
+    (0, import_node_fs8.mkdirSync)(import_node_path8.default.dirname(full), { recursive: true });
+    (0, import_node_fs8.writeFileSync)(full, contents, "utf8");
+  }
+}
+var DIRECTIVE = /^[ \t]*#(?:if|elseif)\b/;
+var OS_IOS = /\bos\(\s*iOS\s*\)/g;
+var OBJC_ATTRIBUTE = /^@(?:objcMembers\b|objc\b(?:(\s*)\(([^()]*)\))?|IBAction\b)/;
+var SELECTOR = /^#selector\b/;
+var DELEGATE_CLASS = /^class\s+[A-Za-z_]\w*\s*(?:<[^>{]*>)?\s*:[^{]*\b(?:UIApplicationDelegate|UISceneDelegate|UIWindowSceneDelegate)\b[^{]*\{/;
+function swiftSourceAsIOS(source) {
+  const { lineStarts, tokens } = swiftCodeScan(source);
+  let offset = 0;
+  const conditioned = source.split("\n").map((line) => {
+    const start = offset;
+    offset += line.length + 1;
+    if (!lineStarts.has(start) || !DIRECTIVE.test(line)) return line;
+    return line.replace(OS_IOS, (match) => "true".padEnd(match.length));
+  }).join("\n");
+  let out = "";
+  let copied = 0;
+  for (const at of tokens) {
+    const rest = conditioned.slice(at, at + 400);
+    if (rest.startsWith("class")) {
+      const modifiers = conditioned.slice(conditioned.lastIndexOf("\n", at - 1) + 1, at);
+      if (DELEGATE_CLASS.test(rest) && !/\b(?:final|open)\b/.test(modifiers)) {
+        out += `${conditioned.slice(copied, at)}final `;
+        copied = at;
+      }
+      continue;
+    }
+    const selector = SELECTOR.exec(rest);
+    const match = selector ?? OBJC_ATTRIBUTE.exec(rest);
+    if (!match) continue;
+    let replacement = "@ObjC";
+    if (selector) replacement = "#Selector";
+    else if (match[0] === "@objcMembers") replacement = "@ObjCMembers";
+    else if (match[0] === "@IBAction") replacement = "@ObjC".padEnd(match[0].length);
+    else if (match[2] !== void 0)
+      replacement = `@ObjC${match[1]}("${match[2].trim()}")`;
+    out += conditioned.slice(copied, at) + replacement;
+    copied = at + match[0].length;
+  }
+  return out + conditioned.slice(copied);
+}
+function swiftCodeScan(source) {
+  const starts = /* @__PURE__ */ new Set();
+  const tokens = [];
+  const stack = [{ kind: "code", parens: 0 }];
+  const hashesAt = (at) => {
+    let end = at;
+    while (source[end] === "#") end++;
+    return end - at;
+  };
+  const closes = (at, hashes) => source.startsWith("#".repeat(hashes), at);
+  let i = 0;
+  while (i < source.length) {
+    const top = stack[stack.length - 1];
+    if ((i === 0 || source[i - 1] === "\n") && top.kind === "code" && stack.length === 1)
+      starts.add(i);
+    const char = source[i];
+    if (top.kind === "block") {
+      if (source.startsWith("/*", i)) {
+        top.depth++;
+        i += 2;
+      } else if (source.startsWith("*/", i)) {
+        if (--top.depth === 0) stack.pop();
+        i += 2;
+      } else i++;
+      continue;
+    }
+    if (top.kind === "string") {
+      if (char === "\\" && closes(i + 1, top.hashes)) {
+        const after = i + 1 + top.hashes;
+        if (source[after] === "(") {
+          stack.push({ kind: "code", parens: 0 });
+          i = after + 1;
+        } else i = after + 1;
+        continue;
+      }
+      const quote = top.multiline ? '"""' : '"';
+      if (source.startsWith(quote, i) && closes(i + quote.length, top.hashes)) {
+        stack.pop();
+        i += quote.length + top.hashes;
+      } else i++;
+      continue;
+    }
+    if (top.kind === "regex") {
+      if (char === "/" && closes(i + 1, top.hashes)) {
+        stack.pop();
+        i += 1 + top.hashes;
+      } else i++;
+      continue;
+    }
+    if (source.startsWith("//", i)) {
+      const end = source.indexOf("\n", i);
+      i = end === -1 ? source.length : end;
+    } else if (source.startsWith("/*", i)) {
+      stack.push({ kind: "block", depth: 1 });
+      i += 2;
+    } else if (char === '"' || char === "#") {
+      const hashes = hashesAt(i);
+      const at = i + hashes;
+      if (source.startsWith('"""', at)) {
+        stack.push({ kind: "string", hashes, multiline: true });
+        i = at + 3;
+      } else if (source[at] === '"') {
+        stack.push({ kind: "string", hashes, multiline: false });
+        i = at + 1;
+      } else if (hashes > 0 && source[at] === "/") {
+        stack.push({ kind: "regex", hashes });
+        i = at + 1;
+      } else {
+        if (hashes > 0) tokens.push(at - 1);
+        i = Math.max(at, i + 1);
+      }
+    } else if (char === "(") {
+      top.parens++;
+      i++;
+    } else if (char === ")") {
+      if (top.parens === 0 && stack.length > 1) stack.pop();
+      else top.parens--;
+      i++;
+    } else if (source.startsWith("class", i) && !/[\w$]/.test(source[i - 1] ?? "") && !/[\w$]/.test(source[i + 5] ?? "")) {
+      tokens.push(i);
+      i += 5;
+    } else {
+      if (char === "@") tokens.push(i);
+      i++;
+    }
+  }
+  return { lineStarts: starts, tokens };
+}
+var compiledSource = (file, contents) => file.endsWith(".swift") ? swiftSourceAsIOS(contents) : contents;
+function writeSwiftProject(layout, input, moduleRoot) {
+  const targets = compileTargets(input);
+  const files = /* @__PURE__ */ new Map();
+  const moduleFiles = `
+// sootsim-swift files ${(0, import_node_crypto3.createHash)("sha256").update(swiftModuleInputFiles(moduleRoot).join("\n")).digest("hex").slice(0, 16)}
+`;
+  if (targets.length === 0) {
+    for (const [file, contents] of Object.entries(input.files)) {
+      if (file === "Package.swift") continue;
+      files.set(import_node_path8.default.join(layout.sources, file), compiledSource(file, contents));
+    }
+    let manifest = (0, import_node_fs8.readFileSync)(
+      import_node_path8.default.join(moduleRoot, "scripts/contrast-app-Package.swift"),
+      "utf8"
+    ).replaceAll("__SOOTSIM_SWIFT_PACKAGE__", moduleRoot);
+    if (input.oneModule) {
+      const product = '.product(name: "CoreLocation", package: "sootsim-swift"),';
+      const flags = `"-Osize"${OBJC_IMPLICIT_FLAGS}`;
+      if (!manifest.includes(product) || !manifest.includes(flags)) {
+        throw new Error(
+          "scripts/contrast-app-Package.swift lost the lines the One module links at"
+        );
+      }
+      manifest = manifest.replace(product, `${product}
+        ${ONE_PRODUCT},`).replace(flags, `${flags}${ONE_IMPLICIT_FLAGS}`);
+    }
+    files.set(import_node_path8.default.join(layout.root, "Package.swift"), manifest + moduleFiles);
+  } else {
+    for (const [file, contents] of Object.entries(input.files)) {
+      if (file === "Package.swift") continue;
+      files.set(import_node_path8.default.join(layout.root, file), compiledSource(file, contents));
+    }
+    for (const target of targets) {
+      if (!target.resources) continue;
+      files.set(
+        import_node_path8.default.join(layout.root, target.path, "ResourceBundleAccessor.generated.swift"),
+        [
+          "import Foundation",
+          "",
+          "extension Foundation.Bundle {",
+          "  static let module: Bundle = Bundle.main",
+          "}",
+          ""
+        ].join("\n")
+      );
+    }
+    files.set(
+      import_node_path8.default.join(layout.root, "Package.swift"),
+      emitSwiftPackageManifest({
+        targets,
+        siblings: swiftSiblingDependencies(input.files, targets),
+        moduleRoot,
+        oneModule: input.oneModule
+      }) + moduleFiles
+    );
+  }
+  syncSwiftTree(layout.root, files);
+}
+function streamText(value) {
+  if (typeof value === "string") return value.trim();
+  if (Buffer.isBuffer(value)) return value.toString("utf8").trim();
+  return "";
+}
+function outputOf(error) {
+  if (error && typeof error === "object") {
+    const streams = [
+      streamText(Reflect.get(error, "stdout")),
+      streamText(Reflect.get(error, "stderr"))
+    ].filter(Boolean);
+    if (streams.length > 0) return streams.join("\n");
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function builtArtifact(layout) {
+  const binDir = import_node_path8.default.join(layout.root, ".build", WASM_TRIPLE, "release");
+  const manifest = (0, import_node_fs8.readFileSync)(import_node_path8.default.join(layout.root, "Package.swift"), "utf8");
+  const executable = swiftManifestTargets(manifest).find((target) => target.executable);
+  if (executable === void 0) {
+    throw new Error("swift-compile: the written manifest names no executable target");
+  }
+  const file = import_node_path8.default.join(binDir, `${executable.name}.wasm`);
+  if (!(0, import_node_fs8.existsSync)(file)) {
+    const found = (0, import_node_fs8.existsSync)(binDir) ? (0, import_node_fs8.readdirSync)(binDir).filter((name2) => name2.endsWith(".wasm")).sort() : [];
+    throw new Error(
+      `swift-compile: the build produced no ${executable.name}.wasm (found: ${found.join(", ") || "none"})`
+    );
+  }
+  return file;
+}
+function projectDiagnostic(output, layout) {
+  const base = layout.multi ? layout.root : layout.sources;
+  const prefix = `${base}${import_node_path8.default.sep}`;
+  return output.split("\n").map((line) => line.startsWith(prefix) ? line.slice(prefix.length) : line).join("\n").trim();
+}
+var ROOT_LOCKS = Symbol.for("peachsim.swiftCompile.rootLocks");
+var host = globalThis;
+var rootLocks = host[ROOT_LOCKS] ??= /* @__PURE__ */ new Map();
+function serialize(root, work) {
+  const current = rootLocks.get(root) ?? Promise.resolve();
+  const next = current.then(work, work);
+  rootLocks.set(
+    root,
+    next.catch(() => {
+    })
+  );
+  return next;
+}
+function compileSwiftProjectUnit(input, options) {
+  (0, import_node_fs8.mkdirSync)(options.buildRoot, { recursive: true });
+  const root = (0, import_node_fs8.realpathSync)(options.buildRoot);
+  const moduleRoot = import_node_path8.default.resolve(options.moduleRoot);
+  const layout = {
+    root,
+    sources: import_node_path8.default.join(root, "Sources", "App"),
+    multi: compileTargets(input).length > 0
+  };
+  const hash = swiftArtifactHash(input, options.release, moduleRoot);
+  return serialize(root, async () => {
+    writeSwiftProject(layout, input, moduleRoot);
+    const swift = import_node_path8.default.join(options.toolchainBin, "swift");
+    if (!(0, import_node_fs8.existsSync)(swift)) {
+      throw new Error(
+        `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`
+      );
+    }
+    const macroPlugins = await ensureMacroPlugins(moduleRoot, options.toolchainBin);
+    const icu = swiftIcuAsset(options.toolchainBin, options.release);
+    try {
+      await run2(
+        swift,
+        [
+          "build",
+          "-j",
+          BUILD_JOBS,
+          "--package-path",
+          root,
+          "--swift-sdk",
+          `${options.release}_wasm`,
+          "-c",
+          "release",
+          "-Xswiftc",
+          "-Osize",
+          ...macroPlugins.flatMap((plugin) => [
+            "-Xswiftc",
+            "-load-plugin-library",
+            "-Xswiftc",
+            plugin
+          ])
+        ],
+        { env: BUILD_ENV, maxBuffer: 64 * 1024 * 1024, timeout: options.timeoutMs }
+      );
+    } catch (error) {
+      throw new Error(projectDiagnostic(outputOf(error), layout), { cause: error });
+    }
+    return {
+      hash,
+      bytes: (0, import_node_fs8.readFileSync)(builtArtifact(layout)),
+      icu: await icu
+    };
+  });
+}
+
+// src/swift-submit.ts
+var SWIFT_COMPILE_PATH = "/api/swift-compile";
+var MAX_SWIFT_COMPILE_FILES = 256;
+var MAX_SWIFT_COMPILE_SOURCE_BYTES = 2 * 1024 * 1024;
+var MAX_SWIFT_COMPILE_RESOURCES = 128;
+var MAX_SWIFT_COMPILE_RESOURCE_BYTES = 2 * 1024 * 1024;
+var MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES = 8 * 1024 * 1024;
+var MAX_SWIFT_COMPILE_IMAGES = 128;
+var MAX_SWIFT_COMPILE_IMAGE_BYTES = 4 * 1024 * 1024;
+var MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES = 16 * 1024 * 1024;
+var SWIFT_HOST_ABI = 3;
+var POLL_INTERVAL_MS = 1500;
+function httpSwiftCompileSubmit(context) {
+  const { assetReadToken, authorization, endpoint } = context;
+  if (!assetReadToken && !authorization) return void 0;
+  const url = endpoint ? `${endpoint.replace(/\/+$/, "")}${SWIFT_COMPILE_PATH}` : SWIFT_COMPILE_PATH;
+  return async (work) => {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        signal: context.signal,
+        headers: {
+          "content-type": "application/json",
+          ...authorization ? { authorization } : {}
+        },
+        body: JSON.stringify({
+          ...work,
+          hostAbi: SWIFT_HOST_ABI,
+          ...assetReadToken ? { token: assetReadToken } : {}
+        })
+      });
+    } catch (error) {
+      throw new Error(
+        `contrast-bundler: fetch failed for ${url} while compiling ${work.entry}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+    if (!response.ok) {
+      const detail = (await response.text()).trim();
+      throw new Error(
+        `contrast-bundler: the swift compile for ${work.entry} answered ${response.status}${detail ? `: ${detail}` : ""}`
+      );
+    }
+    const outcome = await response.json();
+    if (!isSwiftCompileOutcome(outcome)) {
+      throw new Error("swift compile: the service returned invalid artifact metadata");
+    }
+    return outcome;
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSwiftNativeModules(value) {
+  return isRecord3(value) && typeof value.packageId === "string" && typeof value.hash === "string" && isRecord3(value.files) && isRecord3(value.modules) && [...Object.values(value.files), ...Object.values(value.modules)].every(
+    (names) => Array.isArray(names) && names.every((name2) => typeof name2 === "string")
+  ) && Array.isArray(value.defaultViewFiles) && value.defaultViewFiles.every((file) => typeof file === "string");
+}
+function isSwiftCompileOutcome(value) {
+  if (!isRecord3(value)) return false;
+  switch (value.status) {
+    case "published":
+      return typeof value.artifactUrl === "string" && typeof value.icuUrl === "string" && typeof value.hash === "string" && /^[a-f0-9]{64}$/.test(value.hash) && (value.imageUrls === void 0 || isRecord3(value.imageUrls) && Object.values(value.imageUrls).every((url) => typeof url === "string")) && (value.native === void 0 || isSwiftNativeModules(value.native));
+    case "compiling":
+      return typeof value.hash === "string" && /^[a-f0-9]{64}$/.test(value.hash);
+    case "refused":
+    case "failed":
+      return typeof value.detail === "string";
+    default:
+      return false;
+  }
+}
+function compileAssetUrl(value, origin) {
+  const url = new URL(value, origin);
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.origin !== new URL(origin).origin) {
+    throw new Error("swift compile: artifact address escapes the compile origin");
+  }
+  return url.href;
+}
+function resolveImageUrls(urls, origin) {
+  const resolved = {};
+  for (const [name2, url] of Object.entries(urls)) {
+    resolved[name2] = compileAssetUrl(url, origin);
+  }
+  return resolved;
+}
+async function compileSwiftProject(submit, work, origin, signal) {
+  while (true) {
+    signal?.throwIfAborted();
+    const outcome = await submit(work);
+    switch (outcome.status) {
+      case "published":
+        return {
+          url: compileAssetUrl(outcome.artifactUrl, origin),
+          hash: outcome.hash,
+          icuUrl: compileAssetUrl(outcome.icuUrl, origin),
+          ...outcome.imageUrls === void 0 ? {} : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) },
+          ...outcome.native === void 0 ? {} : { native: outcome.native }
+        };
+      case "compiling":
+        await new Promise((resolve5, reject) => {
+          const finish = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve5();
+          };
+          const timer = setTimeout(finish, POLL_INTERVAL_MS);
+          const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            const reason = signal?.reason;
+            reject(reason instanceof Error ? reason : new Error(String(reason)));
+          };
+          signal?.addEventListener("abort", abort, { once: true });
+          if (signal?.aborted) abort();
+        });
+        continue;
+      case "refused":
+      case "failed":
+        throw new Error(
+          `contrast-bundler: the swift sources for ${work.entry} cannot be compiled: ${outcome.detail}`
+        );
+    }
+  }
+}
+
+// src/swift-host.ts
+var ARTIFACT_PATH = "/__peach/swift/";
+var RESOURCE_PATH = "/__peach/swift-res/";
+var ICU_PATH = "/__peach/swift-icu/";
+var SKIP_SOURCE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "ios",
+  "android",
+  "dist",
+  "types",
+  "build"
+]);
+var NATIVE_DESCRIPTOR = ".one-native-source.json";
+var NATIVE_GLUE = ".one-native-source.swift.txt";
+function swiftPackageId(packagePath) {
+  return import_node_path9.default.basename(packagePath).replace(/[^A-Za-z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+}
+function nativeSourceDescriptor(packagePath) {
+  packagePath = import_node_fs9.default.realpathSync(packagePath);
+  const file = import_node_path9.default.join(packagePath, NATIVE_DESCRIPTOR);
+  if (!import_node_fs9.default.existsSync(file)) return null;
+  const value = JSON.parse(
+    readPackageFile(packagePath, file, MAX_SWIFT_COMPILE_SOURCE_BYTES).toString("utf8")
+  );
+  const invalid = () => new Error(`${file}: invalid One native source descriptor; run one typegen`);
+  if (!value || typeof value !== "object" || Reflect.get(value, "generatedBy") !== "one typegen" || !import_node_fs9.default.existsSync(import_node_path9.default.join(packagePath, NATIVE_GLUE))) {
+    throw invalid();
+  }
+  if (!isSwiftNativeModules(value) || value.packageId !== swiftPackageId(packagePath)) {
+    throw invalid();
+  }
+  return value;
+}
+var projects = /* @__PURE__ */ new Map();
+function projectFor(packagePath, hosted) {
+  packagePath = import_node_fs9.default.realpathSync(packagePath);
+  const existing = projects.get(packagePath);
+  if (existing) {
+    if (hosted && !existing.hosted) {
+      throw new Error("a Swift package cannot share local and hosted compile ownership");
+    }
+    return existing;
+  }
+  const created = {
+    packagePath,
+    artifact: null,
+    building: null,
+    resourceFiles: /* @__PURE__ */ new Map(),
+    resourcesPrevious: /* @__PURE__ */ new Map(),
+    artifacts: [],
+    hosted
+  };
+  projects.set(packagePath, created);
+  return created;
+}
+function packageFiles(root) {
+  const canonicalRoot = import_node_fs9.default.realpathSync(root);
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs9.default.readdirSync(dir, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
+      if (entry.name.startsWith(".") && entry.name !== NATIVE_DESCRIPTOR && entry.name !== NATIVE_GLUE || SKIP_SOURCE_DIRS.has(entry.name))
+        continue;
+      const full = import_node_path9.default.join(dir, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`swift input is a symlink: ${full}`);
+      const real = import_node_fs9.default.realpathSync(full);
+      const relative2 = import_node_path9.default.relative(canonicalRoot, real);
+      if (relative2.startsWith(`..${import_node_path9.default.sep}`) || relative2 === ".." || import_node_path9.default.isAbsolute(relative2)) {
+        throw new Error(`swift input escapes the selected package: ${full}`);
+      }
+      if (entry.isDirectory()) {
+        if (import_node_fs9.default.existsSync(import_node_path9.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else if (entry.isFile()) {
+        found.push(full);
+        if (found.length > 4096) throw new Error("swift package exceeds 4096 input files");
+      }
+    }
+  };
+  walk(canonicalRoot);
+  return found;
+}
+function readPackageFile(root, file, maxBytes) {
+  const canonicalRoot = import_node_fs9.default.realpathSync(root);
+  const relative2 = import_node_path9.default.relative(canonicalRoot, import_node_fs9.default.realpathSync(file));
+  if (relative2 === ".." || relative2.startsWith(`..${import_node_path9.default.sep}`) || import_node_path9.default.isAbsolute(relative2)) {
+    throw new Error(`swift input escapes the selected package: ${file}`);
+  }
+  let ancestor = import_node_path9.default.resolve(file);
+  while (ancestor !== canonicalRoot) {
+    if (import_node_fs9.default.lstatSync(ancestor).isSymbolicLink()) {
+      throw new Error(`swift input is a symlink: ${ancestor}`);
+    }
+    const parent = import_node_path9.default.dirname(ancestor);
+    if (parent === ancestor)
+      throw new Error(`swift input escapes the selected package: ${file}`);
+    ancestor = parent;
+  }
+  const expected = import_node_fs9.default.statSync(file);
+  const fd = import_node_fs9.default.openSync(file, import_node_fs9.default.constants.O_RDONLY | import_node_fs9.default.constants.O_NOFOLLOW);
+  try {
+    const stat2 = import_node_fs9.default.fstatSync(fd);
+    if (stat2.dev !== expected.dev || stat2.ino !== expected.ino) {
+      throw new Error(`swift input changed while opening: ${file}`);
+    }
+    if (!stat2.isFile() || stat2.size > maxBytes) {
+      throw new Error(`swift input exceeds ${maxBytes} bytes: ${file}`);
+    }
+    const bytes = Buffer.alloc(stat2.size + 1);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const count = import_node_fs9.default.readSync(fd, bytes, offset, bytes.length - offset, null);
+      if (count === 0) break;
+      offset += count;
+    }
+    if (offset !== stat2.size || import_node_fs9.default.fstatSync(fd).size !== stat2.size) {
+      throw new Error(`swift input changed while reading: ${file}`);
+    }
+    return bytes.subarray(0, offset);
+  } finally {
+    import_node_fs9.default.closeSync(fd);
+  }
+}
+function sourceFiles(root) {
+  const files = packageFiles(root).filter((file) => file.endsWith(".swift"));
+  if (files.length > MAX_SWIFT_COMPILE_FILES || files.reduce((total, file) => total + import_node_fs9.default.statSync(file).size, 0) > MAX_SWIFT_COMPILE_SOURCE_BYTES) {
+    throw new Error("swift sources exceed the compile service caps");
+  }
+  return files;
+}
+function resourceCandidateFiles(root) {
+  return packageFiles(root).filter((file) => !file.endsWith(".swift"));
+}
+var RESOURCE_CONTENT_TYPES = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp"
+};
+function buildSwiftResourceTable(project, baseUrl) {
+  const absolute = resourceCandidateFiles(project.packagePath);
+  const relative2 = absolute.map(
+    (file) => import_node_path9.default.relative(project.packagePath, file).split(import_node_path9.default.sep).join(import_node_path9.default.posix.sep)
+  );
+  const byRelative = new Map(absolute.map((file, index) => [relative2[index], file]));
+  const readContents = (candidate) => {
+    const file = byRelative.get(candidate);
+    if (!file || !/(^|\/)Contents\.json$|\.symbolset\/[^/]+\.svg$/.test(candidate))
+      return null;
+    return readPackageFile(
+      project.packagePath,
+      file,
+      MAX_SWIFT_COMPILE_RESOURCE_BYTES
+    ).toString("utf8");
+  };
+  const found = enumerateBundleImages(relative2, readContents);
+  const colors = enumerateBundleColors(relative2, readContents);
+  const symbols = enumerateBundleSymbols(relative2, readContents);
+  const table = {};
+  const images = {};
+  const watched = [];
+  const registered = /* @__PURE__ */ new Map();
+  let imageBytes = 0;
+  for (const { name: name2, file, scale } of found) {
+    const disk = byRelative.get(file);
+    if (!disk) continue;
+    if (Object.keys(images).length >= MAX_SWIFT_COMPILE_IMAGES || imageBytes + import_node_fs9.default.statSync(disk).size > MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES) {
+      throw new Error("swift image pack exceeds the compile service caps");
+    }
+    const bytes = readPackageFile(
+      project.packagePath,
+      disk,
+      MAX_SWIFT_COMPILE_IMAGE_BYTES
+    );
+    imageBytes += bytes.length;
+    const hash = (0, import_node_crypto4.createHash)("sha256").update(bytes).digest("hex").slice(0, 16);
+    const ext = import_node_path9.default.posix.extname(file).toLowerCase();
+    table[name2] = { uri: `${baseUrl}${RESOURCE_PATH}${hash}${ext}`, scale };
+    images[name2] = {
+      file: import_node_path9.default.posix.basename(file),
+      data: bytes.toString("base64")
+    };
+    watched.push(file);
+    const contents = file.replace(/\/[^/]+$/, "/Contents.json");
+    if (byRelative.has(contents)) watched.push(contents);
+    registered.set(`${hash}${ext}`, {
+      bytes,
+      contentType: RESOURCE_CONTENT_TYPES[ext] ?? "application/octet-stream"
+    });
+  }
+  for (const file of relative2) {
+    if (file.endsWith(".colorset/Contents.json") || file.includes(".symbolset/"))
+      watched.push(file);
+  }
+  if (registered.size !== project.resourceFiles.size || [...registered].some(
+    ([key, value]) => !project.resourceFiles.get(key)?.bytes.equals(value.bytes)
+  )) {
+    project.resourcesPrevious = project.resourceFiles;
+    project.resourceFiles = registered;
+  }
+  return { table, images, colors, symbols, watched };
+}
+var BUNDLE_MAX_FILES = MAX_SWIFT_COMPILE_RESOURCES;
+var BUNDLE_MAX_FILE_BYTES = MAX_SWIFT_COMPILE_RESOURCE_BYTES;
+var BUNDLE_MAX_TOTAL_BYTES = MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES;
+function buildSwiftBundleFiles(packagePath) {
+  packagePath = import_node_fs9.default.realpathSync(packagePath);
+  const relative2 = resourceCandidateFiles(packagePath).map(
+    (file) => import_node_path9.default.relative(packagePath, file).split(import_node_path9.default.sep).join(import_node_path9.default.posix.sep)
+  );
+  const files = {};
+  const watched = [];
+  let total = 0;
+  for (const { base, file } of enumerateBundleJson(relative2)) {
+    watched.push(file);
+    const disk = import_node_path9.default.join(packagePath, ...file.split("/"));
+    if (Object.keys(files).length >= BUNDLE_MAX_FILES || total + import_node_fs9.default.statSync(disk).size > BUNDLE_MAX_TOTAL_BYTES) {
+      throw new Error(
+        `swift bundle pack exceeds ${BUNDLE_MAX_FILES} files / ${BUNDLE_MAX_TOTAL_BYTES} bytes`
+      );
+    }
+    const bytes = readPackageFile(packagePath, disk, BUNDLE_MAX_FILE_BYTES);
+    files[base] = bytes.toString("base64");
+    total += bytes.length;
+  }
+  return { files, watched };
+}
+function serveSwiftResource(project, key) {
+  return project.resourceFiles.get(key) ?? project.resourcesPrevious.get(key) ?? null;
+}
+function linkedModuleRoots(packagePath) {
+  packagePath = import_node_fs9.default.realpathSync(packagePath);
+  let manifest;
+  try {
+    manifest = readPackageFile(
+      packagePath,
+      import_node_path9.default.join(packagePath, "Package.swift"),
+      MAX_SWIFT_COMPILE_SOURCE_BYTES
+    ).toString("utf8");
+  } catch {
+    return [];
+  }
+  const roots = /* @__PURE__ */ new Set();
+  const dependency = /\.package\(\s*path:\s*"([^"]+)"\s*\)/g;
+  for (const match of manifest.replace(/^\s*\/\/.*$/gm, "").matchAll(dependency)) {
+    const root = import_node_path9.default.resolve(packagePath, match[1]);
+    if (import_node_fs9.default.existsSync(import_node_path9.default.join(root, "Package.swift"))) roots.add(root);
+  }
+  return [...roots].sort();
+}
+function sourceStamp(packagePath, moduleRootOverride, hosted = false) {
+  const hash = (0, import_node_crypto4.createHash)("sha256");
+  hash.update(packagePath);
+  const projectInputs = new Set(packageFiles(packagePath));
+  for (const file of [...projectInputs].sort()) {
+    hash.update(import_node_path9.default.relative(packagePath, file));
+    const stat2 = import_node_fs9.default.statSync(file);
+    hash.update(`${stat2.mtimeMs}/${stat2.ctimeMs}/${stat2.size}`);
+  }
+  const moduleRoot = hosted ? void 0 : moduleRootOverride ?? linkedModuleRoots(packagePath).find(
+    (root) => import_node_fs9.default.existsSync(import_node_path9.default.join(root, "toolchain.json"))
+  );
+  if (moduleRoot) {
+    hash.update(moduleRoot);
+    for (const relative2 of swiftModuleInputFiles(moduleRoot)) {
+      hash.update(relative2);
+      hash.update(String(import_node_fs9.default.statSync(import_node_path9.default.join(moduleRoot, relative2)).mtimeMs));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function icuUrl(origin, artifact) {
+  return "url" in artifact.icu ? artifact.icu.url : `${origin}${ICU_PATH}${artifact.icu.sha256}`;
+}
+function packageSources(packagePath) {
+  const sources = sourceFiles(packagePath);
+  if (sources.length > MAX_SWIFT_COMPILE_FILES)
+    throw new Error("swift source file cap exceeded");
+  let total = 0;
+  for (const file of sources) total += import_node_fs9.default.statSync(file).size;
+  if (total > MAX_SWIFT_COMPILE_SOURCE_BYTES)
+    throw new Error("swift source byte cap exceeded");
+  const files = {};
+  for (const file of sources) {
+    const relative2 = import_node_path9.default.relative(packagePath, file).split(import_node_path9.default.sep).join(import_node_path9.default.posix.sep);
+    files[relative2] = readPackageFile(
+      packagePath,
+      file,
+      MAX_SWIFT_COMPILE_SOURCE_BYTES
+    ).toString("utf8");
+  }
+  return files;
+}
+function packageSnapshot(project) {
+  const files = packageSources(project.packagePath);
+  const native = nativeSourceDescriptor(project.packagePath);
+  return {
+    files,
+    resources: buildSwiftResourceTable(project, ""),
+    bundleFiles: buildSwiftBundleFiles(project.packagePath),
+    native,
+    ...native ? {
+      glue: readPackageFile(
+        project.packagePath,
+        import_node_path9.default.join(project.packagePath, NATIVE_GLUE),
+        MAX_SWIFT_COMPILE_SOURCE_BYTES
+      ).toString("utf8")
+    } : {}
+  };
+}
+function snapshotCompileInput(snapshot, entry) {
+  const input = {
+    files: snapshot.files,
+    resources: snapshot.bundleFiles.files,
+    images: snapshot.resources.images,
+    entry,
+    oneModule: true
+  };
+  return snapshot.glue ? withNativeSourceGlue(input, snapshot.glue) : input;
+}
+async function compile(packagePath, entry, stamp, moduleRootOverride, hosted, snapshot) {
+  const resources = {
+    table: snapshot.resources.table,
+    colors: snapshot.resources.colors,
+    symbols: snapshot.resources.symbols,
+    watched: snapshot.resources.watched
+  };
+  const content = {
+    resources,
+    bundleFiles: snapshot.bundleFiles,
+    native: snapshot.native
+  };
+  if (hosted)
+    return {
+      ...await compileRemote(packagePath, entry, snapshot, hosted),
+      stamp,
+      package: content
+    };
+  const moduleRoot = moduleRootOverride ?? linkedModuleRoots(packagePath).find(
+    (root) => import_node_fs9.default.existsSync(import_node_path9.default.join(root, "toolchain.json"))
+  );
+  if (!moduleRoot)
+    return {
+      ...await compileRemote(packagePath, entry, snapshot),
+      stamp,
+      package: content
+    };
+  const toolchain = JSON.parse(
+    import_node_fs9.default.readFileSync(import_node_path9.default.join(moduleRoot, "toolchain.json"), "utf8")
+  );
+  const release = toolchain && typeof toolchain === "object" ? Reflect.get(toolchain, "release") : void 0;
+  if (typeof release !== "string") {
+    throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`);
+  }
+  const artifact = await compileSwiftProjectUnit(snapshotCompileInput(snapshot, entry), {
+    // the compile rewrites Sources/App in its root before swiftpm builds, and
+    // its lock orders one process only: two vites on one root (a lane's dev
+    // server and a capture, or two checkouts) build each other's sources. so
+    // 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_path9.default.join(
+      import_node_os3.default.tmpdir(),
+      "contrast-swift-build",
+      (0, import_node_crypto4.createHash)("sha256").update(`${moduleRoot}\0${import_node_path9.default.resolve(packagePath)}`).digest("hex").slice(0, 16)
+    ),
+    moduleRoot,
+    release,
+    toolchainBin: import_node_path9.default.join(
+      import_node_os3.default.homedir(),
+      `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`
+    )
+  });
+  return { ...artifact, stamp, package: content };
+}
+async function compileRemote(packagePath, entry, snapshot, hosted) {
+  const auth = hosted ? null : resolveCliAuth();
+  if (!hosted && (!auth || auth.kind === "github")) {
+    throw new Error(
+      `compiling ${import_node_path9.default.basename(packagePath)} for Peach needs \`peach login\` or PEACH_API_KEY: this peachsim has no local SwiftUI module, so Contrast compiles it`
+    );
+  }
+  const origin = hosted?.origin ?? resolveContrastBackendOrigin(auth?.kind === "session" ? auth.origin : null);
+  const authorization = hosted?.authorization ?? (auth ? authHeaderValue(auth) : void 0);
+  const signal = AbortSignal.any([
+    ...hosted ? [hosted.signal] : [],
+    AbortSignal.timeout(5 * 6e4)
+  ]);
+  const submit = httpSwiftCompileSubmit({
+    endpoint: origin,
+    authorization,
+    signal
+  });
+  if (!submit) throw new Error("swift compile: no credential to submit with");
+  const descriptor = snapshot.native;
+  const address = await compileSwiftProject(
+    submit,
+    {
+      files: snapshot.files,
+      resources: snapshot.bundleFiles.files,
+      images: snapshot.resources.images,
+      entry,
+      packageId: descriptor?.packageId ?? swiftPackageId(packagePath)
+    },
+    origin,
+    signal
+  );
+  if (descriptor && address.native?.hash !== descriptor.hash) {
+    throw new Error(
+      `${import_node_path9.default.basename(packagePath)}: Contrast compiled native contract ${address.native?.hash ?? "none"} but one typegen wrote ${descriptor.hash}; the app's One and the compile host's differ, or the compile host is older than this peachsim`
+    );
+  }
+  const response = await fetch(address.url, { signal });
+  if (!response.ok) {
+    throw new Error(`swift compile: ${address.url} answered ${response.status}`);
+  }
+  const maxArtifactBytes = 64 * 1024 * 1024;
+  if (Number(response.headers.get("content-length")) > maxArtifactBytes || !response.body) {
+    throw new Error("swift compile: artifact exceeds 64 MiB or has no body");
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    signal.throwIfAborted();
+    const next = await reader.read();
+    if (next.done) break;
+    total += next.value.byteLength;
+    if (total > maxArtifactBytes) {
+      await reader.cancel();
+      throw new Error("swift compile: artifact exceeds 64 MiB");
+    }
+    chunks.push(next.value);
+  }
+  return {
+    hash: address.hash,
+    bytes: Buffer.concat(chunks),
+    icu: { url: address.icuUrl }
+  };
+}
+function artifactFor(project, entry, moduleRoot) {
+  const stamp = sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted));
+  if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact);
+  if (project.building) {
+    const running = project.building;
+    if (running.stamp === stamp) return running.promise;
+    const again = () => artifactFor(project, entry, moduleRoot);
+    return running.promise.then(again, again);
+  }
+  const snapshot = packageSnapshot(project);
+  if (sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) !== stamp) {
+    return artifactFor(project, entry, moduleRoot);
+  }
+  const promise = compile(
+    project.packagePath,
+    entry,
+    stamp,
+    moduleRoot,
+    project.hosted,
+    snapshot
+  ).then(
+    (artifact) => {
+      project.artifact = artifact;
+      project.artifacts = [
+        artifact,
+        ...project.artifacts.filter((old) => old.hash !== artifact.hash)
+      ].slice(0, 2);
+      project.building = null;
+      return artifact;
+    },
+    (error) => {
+      project.building = null;
+      throw error;
+    }
+  );
+  const fresh = promise.then(
+    (artifact) => sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) === artifact.stamp ? artifact : artifactFor(project, entry, moduleRoot)
+  );
+  project.building = { stamp, promise: fresh };
+  return fresh;
+}
+function serveSwiftPackageAsset(pathname, res) {
+  if (pathname.startsWith(RESOURCE_PATH)) {
+    for (const project of projects.values()) {
+      const served = serveSwiftResource(project, pathname.slice(RESOURCE_PATH.length));
+      if (!served) continue;
+      res.setHeader("access-control-allow-origin", "*");
+      res.setHeader("content-type", served.contentType);
+      res.end(served.bytes);
+      return true;
+    }
+    res.statusCode = 404;
+    res.end("swift resource is stale");
+    return true;
+  }
+  if (pathname.startsWith(ICU_PATH)) {
+    for (const project of projects.values()) {
+      const icu = project.artifacts.find(
+        (artifact) => "sha256" in artifact.icu && pathname === `${ICU_PATH}${artifact.icu.sha256}`
+      )?.icu;
+      if (!icu || "url" in icu || pathname !== `${ICU_PATH}${icu.sha256}`) continue;
+      res.setHeader("access-control-allow-origin", "*");
+      res.setHeader("content-type", "application/gzip");
+      res.setHeader("cache-control", "public, max-age=31536000, immutable");
+      res.end(icu.gzip);
+      return true;
+    }
+    res.statusCode = 404;
+    res.end("swift icu data is stale");
+    return true;
+  }
+  if (!pathname.startsWith(ARTIFACT_PATH)) return false;
+  for (const project of projects.values()) {
+    const artifact = project.artifacts.find(
+      (artifact2) => pathname === `${ARTIFACT_PATH}${artifact2.hash}.wasm`
+    );
+    if (!artifact || pathname !== `${ARTIFACT_PATH}${artifact.hash}.wasm`) continue;
+    res.setHeader("access-control-allow-origin", "*");
+    res.setHeader("content-type", "application/wasm");
+    res.end(artifact.bytes);
+    return true;
+  }
+  res.statusCode = 404;
+  res.end("swift artifact is stale");
+  return true;
+}
+
+// src/expo-swift-host.ts
+var import_meta2 = {};
+var run3 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
+var EXPO_SWIFT_ROUTE = "/__peach/expo-swift";
+var EXPO_SWIFT_ENTRY = "Sources/PeachExpoApp/PeachExpoEntry.swift";
+async function collectExpoSwiftSources(appRoot) {
+  appRoot = import_node_fs10.default.realpathSync(appRoot);
+  const appRequire = (0, import_node_module.createRequire)(import_node_path10.default.join(appRoot, "package.json"));
+  let autolinker;
+  try {
+    autolinker = appRequire.resolve("expo-modules-autolinking/package.json");
+  } catch (error) {
+    if (error && typeof error === "object" && Reflect.get(error, "code") === "MODULE_NOT_FOUND")
+      return null;
+    throw error;
+  }
+  const { stdout } = await run3(
+    process.execPath,
+    [
+      import_node_path10.default.join(import_node_path10.default.dirname(autolinker), "bin/expo-modules-autolinking.js"),
+      "search",
+      "--platform",
+      "apple",
+      "--project-root",
+      appRoot,
+      "--json"
+    ],
+    { timeout: 3e4, maxBuffer: 8 * 1024 * 1024 }
+  );
+  const search = JSON.parse(stdout);
+  if (!search || typeof search !== "object" || Array.isArray(search))
+    throw new Error("invalid Expo autolinking result");
+  const { stdout: resolvedText } = await run3(
+    process.execPath,
+    [
+      import_node_path10.default.join(import_node_path10.default.dirname(autolinker), "bin/expo-modules-autolinking.js"),
+      "resolve",
+      "--platform",
+      "apple",
+      "--project-root",
+      appRoot,
+      "--json"
+    ],
+    { timeout: 3e4, maxBuffer: 8 * 1024 * 1024 }
+  );
+  const resolved = JSON.parse(resolvedText);
+  const resolutions = resolved && typeof resolved === "object" ? Reflect.get(resolved, "modules") : null;
+  if (!Array.isArray(resolutions)) throw new Error("invalid Expo Apple resolution");
+  const files = {};
+  const targets = [];
+  const classes = [];
+  let bytes = 0;
+  for (const entry of Object.values(search)) {
+    if (!entry || typeof entry !== "object")
+      throw new Error("invalid Expo autolinking entry");
+    const sourceRoot = Reflect.get(entry, "path");
+    if (typeof sourceRoot !== "string")
+      throw new Error("Expo autolinking entry has no path");
+    const canonical = import_node_fs10.default.realpathSync(sourceRoot);
+    if (canonical.split(import_node_path10.default.sep).includes("node_modules")) continue;
+    const resolution = resolutions.find(
+      (candidate) => candidate && typeof candidate === "object" && Reflect.get(candidate, "packageName") === Reflect.get(entry, "name")
+    );
+    const namespaces = resolution && typeof resolution === "object" ? Reflect.get(resolution, "swiftModuleNames") : null;
+    const modules = resolution && typeof resolution === "object" ? Reflect.get(resolution, "modules") : null;
+    if (!Array.isArray(modules) || modules.length === 0) continue;
+    if (!Array.isArray(namespaces) || namespaces.length !== 1 || typeof namespaces[0] !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(namespaces[0]))
+      throw new Error(
+        `${sourceRoot}: local Expo Swift modules need one Apple Swift module`
+      );
+    const namespace = namespaces[0];
+    if (targets.includes(namespace))
+      throw new Error(`duplicate local Expo Swift module ${namespace}`);
+    targets.push(namespace);
+    for (const module2 of modules) {
+      const className = module2 && typeof module2 === "object" ? Reflect.get(module2, "class") : null;
+      const name2 = module2 && typeof module2 === "object" ? Reflect.get(module2, "name") : null;
+      if (typeof className !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(className) || name2 !== null && typeof name2 !== "string")
+        throw new Error(`${sourceRoot}: invalid Expo Apple module descriptor`);
+      classes.push(
+        `(${className.includes(".") ? className : `${namespace}.${className}`}.self, ${name2 === null ? "nil" : JSON.stringify(name2)})`
+      );
+    }
+    const ios = import_node_path10.default.join(canonical, "ios");
+    if (import_node_fs10.default.lstatSync(ios).isSymbolicLink())
+      throw new Error(`Expo Swift source directory is a symlink: ${ios}`);
+    const walk = (dir) => {
+      for (const child of import_node_fs10.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = import_node_path10.default.join(dir, child.name);
+        if (child.isSymbolicLink())
+          throw new Error(`Expo Swift source is a symlink: ${file}`);
+        if (child.isDirectory()) {
+          if (!child.name.startsWith(".") && child.name !== "build") walk(file);
+          continue;
+        }
+        if (!child.name.endsWith(".swift")) continue;
+        const size = import_node_fs10.default.statSync(file).size;
+        bytes += size;
+        if (Object.keys(files).length + 1 > MAX_SWIFT_COMPILE_FILES - 2 || bytes > MAX_SWIFT_COMPILE_SOURCE_BYTES)
+          throw new Error("Expo Swift sources exceed compile service caps");
+        files[`Sources/${namespace}/${import_node_path10.default.relative(ios, file).split(import_node_path10.default.sep).join("/")}`] = `#sourceLocation(file: ${JSON.stringify(file)}, line: 1)
+${import_node_fs10.default.readFileSync(file, "utf8")}`;
+      }
+    };
+    walk(ios);
+  }
+  if (classes.length === 0) return null;
+  files["Package.swift"] = `// swift-tools-version: 6.0
+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")])
+`;
+  files[EXPO_SWIFT_ENTRY] = `import SwiftUI
+import ExpoModulesCore
+${targets.map((name2) => `import ${name2}
+`).join("")}
+@main struct PeachExpoApp: RNXPackage {
+  init() { MainActor.assumeIsolated { PeachExpoRuntime.register([${classes.join(", ")}]) } }
+  func view(props: JSON) -> PeachExpoNativeView { PeachExpoNativeView(props: props) }
+}
+
+@_expose(wasm, "peach_expo_call")
+@_cdecl("peach_expo_call")
+@MainActor public func peachExpoCall(_ payload: UnsafePointer<UInt8>?, _ length: Int32) -> UnsafeMutablePointer<UInt8>? {
+  PeachExpoRuntime.dispatch(payload, length)
+}
+`;
+  return files;
+}
+var compiling = /* @__PURE__ */ new Map();
+async function handleExpoSwiftRequest(req, res) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  if (!url.pathname.startsWith("/__peach/swift") && url.pathname !== EXPO_SWIFT_ROUTE)
+    return false;
+  const remote = req.socket.remoteAddress?.replace(/^::ffff:/, "");
+  const origin = req.headers.origin;
+  if (!remote || !isLoopbackHost(remote) || origin && !isLoopbackHost(new URL(origin).hostname)) {
+    res.writeHead(403);
+    res.end("Expo Swift artifacts require a loopback client");
+    return true;
+  }
+  res.setHeader("Access-Control-Allow-Origin", origin ?? "*");
+  res.setHeader("Vary", "Origin");
+  res.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
+  if (serveSwiftPackageAsset(url.pathname, res)) return true;
+  if (url.pathname !== EXPO_SWIFT_ROUTE) return false;
+  if (req.method !== "GET") {
+    res.writeHead(405);
+    res.end("GET required");
+    return true;
+  }
+  const root = url.searchParams.get("root");
+  if (!root || !import_node_path10.default.isAbsolute(root)) {
+    res.writeHead(400);
+    res.end("missing absolute app root");
+    return true;
+  }
+  try {
+    let pending = compiling.get(root);
+    if (!pending) {
+      pending = (async () => {
+        const files = await collectExpoSwiftSources(root);
+        if (!files) return null;
+        const key = (0, import_node_crypto5.createHash)("sha256").update(import_node_fs10.default.realpathSync(root)).digest("hex");
+        const packagePath = import_node_path10.default.join(import_node_os4.default.tmpdir(), "peach-expo-swift", key);
+        const sources = import_node_path10.default.join(packagePath, "Sources");
+        import_node_fs10.default.rmSync(sources, { recursive: true, force: true });
+        import_node_fs10.default.mkdirSync(sources, { recursive: true });
+        for (const [name2, content] of Object.entries(files)) {
+          const target = import_node_path10.default.join(packagePath, name2);
+          import_node_fs10.default.mkdirSync(import_node_path10.default.dirname(target), { recursive: true });
+          import_node_fs10.default.writeFileSync(target, content);
+        }
+        const moduleRoot = import_node_path10.default.resolve(import_meta2.dirname, "../../sootsim-swift");
+        const local = import_node_fs10.default.existsSync(import_node_path10.default.join(moduleRoot, "toolchain.json"));
+        const artifact = await artifactFor(
+          projectFor(packagePath),
+          EXPO_SWIFT_ENTRY,
+          local ? moduleRoot : void 0
+        );
+        const host2 = req.headers.host;
+        if (!host2) throw new Error("Expo Swift request has no host");
+        const base = `http://${host2}`;
+        return {
+          url: `${base}/__peach/swift/${artifact.hash}.wasm`,
+          hash: artifact.hash,
+          icuUrl: icuUrl(base, artifact),
+          rootId: `${key}/Expo`
+        };
+      })();
+      compiling.set(root, pending);
+    }
+    const metadata = await pending;
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      "Cache-Control": "no-store"
+    });
+    res.end(JSON.stringify(metadata));
+  } catch (error) {
+    res.writeHead(500, { "Content-Type": "text/plain" });
+    res.end(error instanceof Error ? error.message : String(error));
+  } finally {
+    compiling.delete(root);
+  }
+  return true;
+}
+
 // src/host/bridge-host.ts
 init_home_paths();
 init_public_brand();
@@ -6026,29 +7870,29 @@ var import_path = __toESM(require("path"), 1);
 var import_url = require("url");
 
 // ../contrast-runtime-delivery/src/index.ts
-var import_node_child_process2 = 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_path7 = __toESM(require("node:path"), 1);
+var import_node_child_process5 = require("node:child_process");
+var import_node_crypto6 = __toESM(require("node:crypto"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_os5 = __toESM(require("node:os"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
 var import_promises3 = require("node:stream/promises");
 
 // ../contrast-runtime-delivery/src/product.ts
-var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
 function isValidRuntimeVersion(value) {
   return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);
 }
 function listInstalledRuntimes(product) {
   try {
-    return import_node_fs6.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+    return import_node_fs11.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_path6.default.posix.basename(product.tarballPath(version));
+  return import_node_path11.default.posix.basename(product.tarballPath(version));
 }
 function compareSemver(a, b) {
   const parse2 = (v) => {
@@ -6078,7 +7922,7 @@ function createRuntimeDelivery(product) {
   function readConfig() {
     try {
       const parsed = JSON.parse(
-        import_node_fs7.default.readFileSync(product.configFile(), "utf8")
+        import_node_fs12.default.readFileSync(product.configFile(), "utf8")
       );
       return parsed && typeof parsed === "object" ? parsed : {};
     } catch {
@@ -6151,7 +7995,7 @@ function createRuntimeDelivery(product) {
     const setActive = opts.setActive !== false;
     const protectVersions = [version, ...opts.protectVersions ?? []];
     pruneLocalRetention({ protectVersions });
-    if (!opts.force && import_node_fs7.default.existsSync(import_node_path7.default.join(destDir, product.installedMarker))) {
+    if (!opts.force && import_node_fs12.default.existsSync(import_node_path12.default.join(destDir, product.installedMarker))) {
       if (setActive) product.writeActiveRuntime(version);
       pruneLocalRetention({ protectVersions });
       return {
@@ -6194,8 +8038,8 @@ function createRuntimeDelivery(product) {
     const pin = resolvePin();
     if (pin) {
       const activeVersion2 = product.readActiveRuntime();
-      const pinInstalled = import_node_fs7.default.existsSync(
-        import_node_path7.default.join(product.runtimeDir(pin), product.installedMarker)
+      const pinInstalled = import_node_fs12.default.existsSync(
+        import_node_path12.default.join(product.runtimeDir(pin), product.installedMarker)
       );
       if (activeVersion2 === pin && pinInstalled) {
         return {
@@ -6244,7 +8088,7 @@ function createRuntimeDelivery(product) {
     }
     const activeVersion = product.readActiveRuntime();
     const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
-    const activeInstalled = activeDir ? import_node_fs7.default.existsSync(import_node_path7.default.join(activeDir, product.installedMarker)) : false;
+    const activeInstalled = activeDir ? import_node_fs12.default.existsSync(import_node_path12.default.join(activeDir, product.installedMarker)) : false;
     const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
     if (!shouldInstall) {
       return {
@@ -6319,12 +8163,12 @@ function createRuntimeDelivery(product) {
     let removeCacheFiles = [];
     if (markerOffset >= 0) {
       try {
-        removeCacheFiles = import_node_fs7.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
+        removeCacheFiles = import_node_fs12.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_path7.default.join(product.cacheDir(), entry.name)).sort();
+        }).map((entry) => import_node_path12.default.join(product.cacheDir(), entry.name)).sort();
       } catch {
       }
     }
@@ -6339,10 +8183,10 @@ function createRuntimeDelivery(product) {
   function pruneLocalRetention(opts = {}) {
     const plan = planLocalRetention(opts);
     for (const version of plan.removeVersions) {
-      import_node_fs7.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
+      import_node_fs12.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
     }
     for (const cacheFile of plan.removeCacheFiles) {
-      import_node_fs7.default.rmSync(cacheFile, { force: true });
+      import_node_fs12.default.rmSync(cacheFile, { force: true });
     }
     return plan;
   }
@@ -6365,11 +8209,11 @@ 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 archivePath = import_node_path7.default.join(downloadDir, "archive.tar.gz");
-  import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(destDir), { recursive: true });
-  const tmpDir = import_node_fs7.default.mkdtempSync(
-    import_node_path7.default.join(import_node_path7.default.dirname(destDir), `.installing-${import_node_path7.default.basename(destDir)}-`)
+  const downloadDir = import_node_fs12.default.mkdtempSync(import_node_path12.default.join(import_node_os5.default.tmpdir(), "runtime-delivery-download-"));
+  const archivePath = import_node_path12.default.join(downloadDir, "archive.tar.gz");
+  import_node_fs12.default.mkdirSync(import_node_path12.default.dirname(destDir), { recursive: true });
+  const tmpDir = import_node_fs12.default.mkdtempSync(
+    import_node_path12.default.join(import_node_path12.default.dirname(destDir), `.installing-${import_node_path12.default.basename(destDir)}-`)
   );
   try {
     await downloadToFile(url, archivePath);
@@ -6380,32 +8224,32 @@ async function installVerifiedTarball(tarball) {
       );
     }
     await extractTarball(archivePath, tmpDir, tarball.stripComponents ?? 0);
-    if (!import_node_fs7.default.existsSync(import_node_path7.default.join(tmpDir, installedMarker))) {
+    if (!import_node_fs12.default.existsSync(import_node_path12.default.join(tmpDir, installedMarker))) {
       throw new Error(`extracted tarball for ${label} is missing ${installedMarker}`);
     }
     try {
-      import_node_fs7.default.renameSync(tmpDir, destDir);
+      import_node_fs12.default.renameSync(tmpDir, destDir);
     } catch (err) {
       if (!isErrnoCode(err, "ENOTEMPTY", "EEXIST")) throw err;
       const aside = `${tmpDir}-replaced`;
       try {
-        import_node_fs7.default.renameSync(destDir, aside);
+        import_node_fs12.default.renameSync(destDir, aside);
       } catch (moveErr) {
         if (!isErrnoCode(moveErr, "ENOENT")) throw moveErr;
       }
       try {
-        import_node_fs7.default.renameSync(tmpDir, destDir);
+        import_node_fs12.default.renameSync(tmpDir, destDir);
       } catch (landErr) {
-        if (!isErrnoCode(landErr, "ENOTEMPTY", "EEXIST") || !import_node_fs7.default.existsSync(import_node_path7.default.join(destDir, installedMarker))) {
+        if (!isErrnoCode(landErr, "ENOTEMPTY", "EEXIST") || !import_node_fs12.default.existsSync(import_node_path12.default.join(destDir, installedMarker))) {
           throw landErr;
         }
       } finally {
-        import_node_fs7.default.rmSync(aside, { recursive: true, force: true });
+        import_node_fs12.default.rmSync(aside, { recursive: true, force: true });
       }
     }
   } finally {
-    import_node_fs7.default.rmSync(tmpDir, { recursive: true, force: true });
-    import_node_fs7.default.rmSync(downloadDir, { recursive: true, force: true });
+    import_node_fs12.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs12.default.rmSync(downloadDir, { recursive: true, force: true });
   }
 }
 function isErrnoCode(err, ...codes) {
@@ -6416,17 +8260,17 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(destPath), { recursive: true });
+  import_node_fs12.default.mkdirSync(import_node_path12.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises3.pipeline)(
       import_node_stream.Readable.fromWeb(res.body),
-      import_node_fs7.default.createWriteStream(tmp)
+      import_node_fs12.default.createWriteStream(tmp)
     );
-    import_node_fs7.default.renameSync(tmp, destPath);
+    import_node_fs12.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_node_fs7.default.unlinkSync(tmp);
+      import_node_fs12.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -6434,8 +8278,8 @@ async function downloadToFile(url, destPath) {
 }
 function digestFile(filePath, algorithm, encoding) {
   return new Promise((resolve5, reject) => {
-    const hash = import_node_crypto2.default.createHash(algorithm);
-    const stream = import_node_fs7.default.createReadStream(filePath);
+    const hash = import_node_crypto6.default.createHash(algorithm);
+    const stream = import_node_fs12.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve5(hash.digest(encoding)));
@@ -6445,7 +8289,7 @@ function extractTarball(tarPath, destDir, stripComponents) {
   return new Promise((resolve5, reject) => {
     const args = ["-xzf", tarPath, "-C", destDir];
     if (stripComponents > 0) args.push(`--strip-components=${stripComponents}`);
-    const child = (0, import_node_child_process2.spawn)("tar", args, {
+    const child = (0, import_node_child_process5.spawn)("tar", args, {
       stdio: ["ignore", "inherit", "inherit"]
     });
     child.on("error", reject);
@@ -6585,20 +8429,20 @@ var RNX_RUNTIME_PRODUCT = {
 var rnxRuntime = createRuntimeDelivery(RNX_RUNTIME_PRODUCT);
 
 // src/host/agent-host.ts
-var import_node_crypto5 = require("node:crypto");
-var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_crypto9 = require("node:crypto");
+var import_node_fs16 = __toESM(require("node:fs"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 
 // src/agent-sessions.ts
-var import_node_child_process3 = require("node:child_process");
-var import_node_crypto4 = require("node:crypto");
-var import_node_fs10 = __toESM(require("node:fs"), 1);
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_child_process6 = require("node:child_process");
+var import_node_crypto8 = require("node:crypto");
+var import_node_fs15 = __toESM(require("node:fs"), 1);
+var import_node_path15 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
 // cli/self-invocation.ts
-var import_node_fs8 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path13 = require("node:path");
 var import_node_url3 = require("node:url");
 init_public_brand();
 
@@ -6608,14 +8452,14 @@ var IS_STANDALONE = typeof __SOOTSIM_STANDALONE__ !== "undefined" && __SOOTSIM_S
 // cli/self-invocation.ts
 function sourceEntryPath() {
   try {
-    const candidate = (0, import_node_path8.join)((0, import_node_path8.dirname)((0, import_node_url3.fileURLToPath)(__sootsim_import_meta_url)), "bin.ts");
-    return (0, import_node_fs8.existsSync)(candidate) ? candidate : null;
+    const candidate = (0, import_node_path13.join)((0, import_node_path13.dirname)((0, import_node_url3.fileURLToPath)(__sootsim_import_meta_url)), "bin.ts");
+    return (0, import_node_fs13.existsSync)(candidate) ? candidate : null;
   } catch {
     return null;
   }
 }
-function isCliEntry(path12) {
-  const name2 = (0, import_node_path8.basename)(path12);
+function isCliEntry(path16) {
+  const name2 = (0, import_node_path13.basename)(path16);
   return name2 === "bin.ts" || name2 === "bin.js";
 }
 function rnxSelfInvocation() {
@@ -6674,9 +8518,9 @@ function encodeAgentPromptEnvelope(input) {
 }
 
 // src/attached-projects.ts
-var import_node_crypto3 = require("node:crypto");
-var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_crypto7 = require("node:crypto");
+var import_node_fs14 = __toESM(require("node:fs"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 init_home_paths();
 var overrideDir = null;
 function userDataDir() {
@@ -6689,7 +8533,7 @@ function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path9.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path14.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -6701,15 +8545,15 @@ function cloneEmpty() {
 }
 function loadStore() {
   const file = storeFile();
-  let raw;
+  let raw2;
   try {
-    raw = import_node_fs9.default.readFileSync(file, "utf8");
+    raw2 = import_node_fs14.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
   }
   try {
-    const parsed = JSON.parse(raw);
+    const parsed = JSON.parse(raw2);
     if (!parsed || typeof parsed !== "object") throw new Error("not an object");
     return {
       version: 1,
@@ -6720,7 +8564,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs9.default.renameSync(file, quarantine);
+      import_node_fs14.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -6731,16 +8575,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs9.default.mkdirSync(import_node_path9.default.dirname(file), { recursive: true });
+  import_node_fs14.default.mkdirSync(import_node_path14.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs9.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs14.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs9.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs9.default.fsyncSync(fd);
+    import_node_fs14.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs14.default.fsyncSync(fd);
   } finally {
-    import_node_fs9.default.closeSync(fd);
+    import_node_fs14.default.closeSync(fd);
   }
-  import_node_fs9.default.renameSync(tmp, file);
+  import_node_fs14.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -6749,13 +8593,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto3.createHash)("sha256").update(import_node_path9.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto7.createHash)("sha256").update(import_node_path14.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
-  return `s_${(0, import_node_crypto3.randomBytes)(10).toString("hex")}`;
+  return `s_${(0, import_node_crypto7.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path9.default.resolve(input.cwd);
+  const cwd = import_node_path14.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -6781,7 +8625,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path9.default.basename(cwd),
+      name: input.name ?? import_node_path14.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -6927,8 +8771,8 @@ async function seedFromDemoAppRegistry() {
   if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs9.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path9.default.resolve(app.dir);
+      if (!import_node_fs14.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path14.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -6953,16 +8797,16 @@ async function seedFromDemoAppRegistry() {
 // src/agent-sessions.ts
 init_public_brand();
 function sessionDir(sessionId) {
-  return import_node_path10.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path15.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path10.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path15.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path10.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path15.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path10.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path15.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -6972,7 +8816,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs10.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs15.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -6985,11 +8829,11 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path10.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path10.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path15.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path15.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs10.default.existsSync(c)) return { executable: c, prefixArgs: [] };
+        if (import_node_fs15.default.existsSync(c)) return { executable: c, prefixArgs: [] };
       }
     }
   }
@@ -7008,15 +8852,15 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `peach-${process.platform === "win32" ? "windows" : process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
-    const distBinary = import_node_path10.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs10.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
-    const distBin = import_node_path10.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs10.default.existsSync(distBin)) {
+    const distBinary = import_node_path15.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs15.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
+    const distBin = import_node_path15.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs15.default.existsSync(distBin)) {
       try {
-        const src = import_node_path10.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs10.default.existsSync(src)) {
-          const srcMtime = import_node_fs10.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs10.default.statSync(distBin).mtimeMs;
+        const src = import_node_path15.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs15.default.existsSync(src)) {
+          const srcMtime = import_node_fs15.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs15.default.statSync(distBin).mtimeMs;
           if (buildMtime < srcMtime) {
             console.warn(
               `[peach] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/peachsim build:cli\`.`
@@ -7035,22 +8879,22 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve(`${rnxPublicBrand.packageName}/package.json`);
-    return import_node_path10.default.dirname(resolved);
+    return import_node_path15.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path10.default.dirname(here);
+  let cur = import_node_path15.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path10.default.join(cur, "package.json");
+    const pkg = import_node_path15.default.join(cur, "package.json");
     try {
-      if (import_node_fs10.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs10.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs15.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs15.default.readFileSync(pkg, "utf8"));
         if (parsed.name === rnxPublicBrand.packageName) return cur;
       }
     } catch {
     }
-    const parent = import_node_path10.default.dirname(cur);
+    const parent = import_node_path15.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -7066,28 +8910,28 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path10.default.join(getUserDataDir(), "locks");
-  import_node_fs10.default.mkdirSync(lockDir, { recursive: true });
+  const lockDir = import_node_path15.default.join(getUserDataDir(), "locks");
+  import_node_fs15.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs10.default.chmodSync(lockDir, 448);
+    import_node_fs15.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path10.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path15.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs10.default.openSync(
+      fd = import_node_fs15.default.openSync(
         lockPath,
-        import_node_fs10.constants.O_WRONLY | import_node_fs10.constants.O_CREAT | import_node_fs10.constants.O_EXCL,
+        import_node_fs15.constants.O_WRONLY | import_node_fs15.constants.O_CREAT | import_node_fs15.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs10.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs15.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs10.default.unlinkSync(lockPath);
+          import_node_fs15.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -7101,15 +8945,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs10.default.writeFileSync(fd, String(process.pid));
+    import_node_fs15.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs10.default.closeSync(fd);
+      import_node_fs15.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs10.default.unlinkSync(lockPath);
+      import_node_fs15.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -7123,28 +8967,28 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path10.default.dirname(p);
-  import_node_fs10.default.mkdirSync(parent, { recursive: true });
+  const parent = import_node_path15.default.dirname(p);
+  import_node_fs15.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs10.default.chmodSync(parent, 448);
+    import_node_fs15.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs10.default.existsSync(p)) {
+  if (import_node_fs15.default.existsSync(p)) {
     try {
-      const stat2 = import_node_fs10.default.statSync(p);
+      const stat2 = import_node_fs15.default.statSync(p);
       if (stat2.isFIFO()) {
         try {
-          import_node_fs10.default.chmodSync(p, 384);
+          import_node_fs15.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs10.default.unlinkSync(p);
+      import_node_fs15.default.unlinkSync(p);
     } catch {
-      import_node_fs10.default.unlinkSync(p);
+      import_node_fs15.default.unlinkSync(p);
     }
   }
-  const result = (0, import_node_child_process3.spawnSync)("mkfifo", ["-m", "600", p]);
+  const result = (0, import_node_child_process6.spawnSync)("mkfifo", ["-m", "600", p]);
   if (result.status !== 0) {
     throw new Error(
       `mkfifo(${p}) failed: ${result.stderr?.toString().trim() || "unknown error"}`
@@ -7174,7 +9018,7 @@ async function startSession(opts) {
         `session already running for project=${project.id} provider=${provider} (session ${existingLive.id}, pid ${existingLive.wrapperPid}). end it first with \`peach agent end <sessionId>\`.`
       );
     }
-    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto4.randomUUID)() : void 0;
+    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto8.randomUUID)() : void 0;
     const session = upsertSession({
       projectId: project.id,
       provider,
@@ -7188,10 +9032,10 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path10.default.dirname(transcript);
-    import_node_fs10.default.mkdirSync(transcriptDir, { recursive: true });
+    const transcriptDir = import_node_path15.default.dirname(transcript);
+    import_node_fs15.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs10.default.chmodSync(transcriptDir, 448);
+      import_node_fs15.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { executable, prefixArgs } = resolveSootsimInvocation();
@@ -7219,7 +9063,7 @@ async function startSession(opts) {
     if (claudeSessionUuid) {
       wrapperArgs.push("--claude-session-uuid", claudeSessionUuid);
     }
-    const child = (0, import_node_child_process3.spawn)(executable, wrapperArgs, {
+    const child = (0, import_node_child_process6.spawn)(executable, wrapperArgs, {
       detached: true,
       stdio: "ignore",
       env: {
@@ -7242,7 +9086,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs10.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs15.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -7270,18 +9114,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs10.default.existsSync(fifo)) {
+  if (!import_node_fs15.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_WRONLY);
+  const fd = import_node_fs15.default.openSync(fifo, import_node_fs15.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs10.default.writeSync(fd, wireText + "\n");
+    import_node_fs15.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs10.default.closeSync(fd);
+    import_node_fs15.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -7303,7 +9147,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs10.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs15.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -7311,11 +9155,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs10.default.existsSync(fifo)) {
+  if (!import_node_fs15.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_RDWR);
-  const stream = import_node_fs10.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs15.default.openSync(fifo, import_node_fs15.constants.O_RDWR);
+  const stream = import_node_fs15.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -7326,7 +9170,7 @@ function subscribeEvents(sessionId, onEvent) {
     if (closed) return;
     closed = true;
     try {
-      import_node_fs10.default.writeSync(fd, "\n");
+      import_node_fs15.default.writeSync(fd, "\n");
     } catch {
     }
     try {
@@ -7340,7 +9184,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_RDWR | import_node_fs10.constants.O_NONBLOCK);
+  const fd = import_node_fs15.default.openSync(fifo, import_node_fs15.constants.O_RDWR | import_node_fs15.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -7348,7 +9192,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs10.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs15.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -7368,7 +9212,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs10.default.closeSync(fd);
+    import_node_fs15.default.closeSync(fd);
   }
 }
 
@@ -7576,7 +9420,7 @@ var AgentHost = class {
       throw new AgentSessionError("EMPTY_PROMPT", "inspect message cannot be empty");
     }
     const message = {
-      id: `inspect-${(0, import_node_crypto5.randomUUID)()}`,
+      id: `inspect-${(0, import_node_crypto9.randomUUID)()}`,
       simId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       prompt
@@ -7622,7 +9466,7 @@ var AgentHost = class {
     );
     const project = upsertProject({
       cwd: match.cwd,
-      name: match.projectName ?? import_node_path11.default.basename(match.cwd),
+      name: match.projectName ?? import_node_path16.default.basename(match.cwd),
       preferredProvider: input.provider ?? existing?.preferredProvider,
       sourceRoots: existing?.sourceRoots ?? [match.cwd],
       knownBundleUrls,
@@ -7633,18 +9477,18 @@ var AgentHost = class {
   }
   getTranscript(sessionId) {
     const p = transcriptPath(sessionId);
-    if (!import_node_fs11.default.existsSync(p)) {
+    if (!import_node_fs16.default.existsSync(p)) {
       return { error: "transcript not found", code: "NO_TRANSCRIPT" };
     }
-    return import_node_fs11.default.readFileSync(p, "utf8");
+    return import_node_fs16.default.readFileSync(p, "utf8");
   }
   getPaths() {
     const dir = getUserDataDir();
     return {
       userDataDir: dir,
-      storeFile: import_node_path11.default.join(dir, "attached-projects.json"),
-      sessionsDir: import_node_path11.default.join(dir, "sessions"),
-      transcriptsDir: import_node_path11.default.join(dir, "transcripts")
+      storeFile: import_node_path16.default.join(dir, "attached-projects.json"),
+      sessionsDir: import_node_path16.default.join(dir, "sessions"),
+      transcriptsDir: import_node_path16.default.join(dir, "transcripts")
     };
   }
   // --- subscription management ---
@@ -7960,9 +9804,9 @@ var HOST_HEADER_OVERRIDES = [
   }
 ];
 function headerOverridesFor(hostname) {
-  const host = hostname.toLowerCase();
+  const host2 = hostname.toLowerCase();
   for (const override of HOST_HEADER_OVERRIDES) {
-    if (host === override.hostSuffix || host.endsWith(`.${override.hostSuffix}`)) {
+    if (host2 === override.hostSuffix || host2.endsWith(`.${override.hostSuffix}`)) {
       return override;
     }
   }
@@ -7984,9 +9828,9 @@ var PUBLIC_RPC_BY_QUICKNODE_CHAIN = {
   "unichain-mainnet": "https://unichain-rpc.publicnode.com"
 };
 function resolveFetchProxyTargetUrl(requested) {
-  const host = requested.hostname.toLowerCase();
-  if (!host.endsWith(QUICKNODE_HOST_SUFFIX)) return requested;
-  const tenant = host.slice(0, -QUICKNODE_HOST_SUFFIX.length);
+  const host2 = requested.hostname.toLowerCase();
+  if (!host2.endsWith(QUICKNODE_HOST_SUFFIX)) return requested;
+  const tenant = host2.slice(0, -QUICKNODE_HOST_SUFFIX.length);
   if (tenant !== PUBLIC_RPC_TENANT && !tenant.startsWith(`${PUBLIC_RPC_TENANT}.`)) {
     return requested;
   }
@@ -8351,8 +10195,8 @@ async function openUrl(url, options = {}) {
 }
 
 // src/host/plane-host.ts
-var import_node_fs13 = __toESM(require("node:fs"), 1);
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_fs18 = __toESM(require("node:fs"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 
 // ../peach-box/src/planeProtocol.ts
 var PLANE_FLAG_READ_ONLY = 1;
@@ -8431,9 +10275,9 @@ async function dispatchPlaneCommand(plane, type, msg, mutationOptions) {
 }
 
 // cli/commands/box/checkout-plane.ts
-var import_node_child_process4 = require("node:child_process");
-var import_node_fs12 = __toESM(require("node:fs"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs17 = __toESM(require("node:fs"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 var CheckoutRequiresGitError = class extends Error {
 };
 var BINARY_SNIFF_BYTES = 8192;
@@ -8444,14 +10288,14 @@ function looksBinary(filePath, size) {
   if (size === 0) return false;
   let fd;
   try {
-    fd = import_node_fs12.default.openSync(filePath, "r");
+    fd = import_node_fs17.default.openSync(filePath, "r");
     const buffer = Buffer.alloc(Math.min(BINARY_SNIFF_BYTES, size));
-    const read = import_node_fs12.default.readSync(fd, buffer, 0, buffer.length, 0);
+    const read = import_node_fs17.default.readSync(fd, buffer, 0, buffer.length, 0);
     return buffer.subarray(0, read).includes(0);
   } catch {
     return false;
   } finally {
-    if (fd !== void 0) import_node_fs12.default.closeSync(fd);
+    if (fd !== void 0) import_node_fs17.default.closeSync(fd);
   }
 }
 var CheckoutFilePlane = class {
@@ -8464,7 +10308,7 @@ var CheckoutFilePlane = class {
   listTimeoutMs;
   trackedOnly;
   constructor(root, options = {}) {
-    this.root = import_node_path12.default.resolve(root);
+    this.root = import_node_path17.default.resolve(root);
     this.listTimeoutMs = options.listTimeoutMs ?? LIST_FILES_TIMEOUT_MS;
     this.trackedOnly = options.trackedOnly ?? false;
   }
@@ -8473,7 +10317,7 @@ var CheckoutFilePlane = class {
   }
   listFiles() {
     const args = this.trackedOnly ? ["ls-files", "-z"] : ["ls-files", "-co", "--exclude-standard", "-z"];
-    const stdout = (0, import_node_child_process4.execFileSync)("git", args, {
+    const stdout = (0, import_node_child_process7.execFileSync)("git", args, {
       cwd: this.root,
       encoding: "utf8",
       maxBuffer: 64 * 1024 * 1024,
@@ -8526,13 +10370,13 @@ var CheckoutFilePlane = class {
       if (!relative2) continue;
       let stat2;
       try {
-        stat2 = import_node_fs12.default.statSync(import_node_path12.default.join(this.root, relative2));
+        stat2 = import_node_fs17.default.statSync(import_node_path17.default.join(this.root, relative2));
       } catch {
         continue;
       }
       if (!stat2.isFile()) continue;
       const seen = this.sniffed.get(relative2);
-      const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path12.default.join(this.root, relative2), stat2.size);
+      const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path17.default.join(this.root, relative2), stat2.size);
       nextSniffed.set(relative2, { size: stat2.size, mtimeMs: stat2.mtimeMs, binary });
       next.set(relative2, {
         size: stat2.size,
@@ -8546,22 +10390,22 @@ var CheckoutFilePlane = class {
     this.sniffed = nextSniffed;
   }
   absolute(planePath) {
-    const resolved = import_node_path12.default.resolve(this.root, planePath);
-    if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path12.default.sep}`)) {
+    const resolved = import_node_path17.default.resolve(this.root, planePath);
+    if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path17.default.sep}`)) {
       throw new Error(`path escapes the project: ${planePath}`);
     }
     return resolved;
   }
   async read(planePath) {
-    return import_node_fs12.default.promises.readFile(this.absolute(planePath), "utf8");
+    return import_node_fs17.default.promises.readFile(this.absolute(planePath), "utf8");
   }
   async readBytes(planePath) {
-    return import_node_fs12.default.promises.readFile(this.absolute(planePath));
+    return import_node_fs17.default.promises.readFile(this.absolute(planePath));
   }
   async write(planePath, content) {
     const absolute = this.absolute(planePath);
-    await import_node_fs12.default.promises.mkdir(import_node_path12.default.dirname(absolute), { recursive: true });
-    await import_node_fs12.default.promises.writeFile(absolute, content);
+    await import_node_fs17.default.promises.mkdir(import_node_path17.default.dirname(absolute), { recursive: true });
+    await import_node_fs17.default.promises.writeFile(absolute, content);
     this.entries.set(planePath, {
       size: content.byteLength,
       readOnly: false,
@@ -8570,7 +10414,7 @@ var CheckoutFilePlane = class {
     });
   }
   async delete(planePath) {
-    await import_node_fs12.default.promises.rm(this.absolute(planePath), { force: true });
+    await import_node_fs17.default.promises.rm(this.absolute(planePath), { force: true });
     this.entries.delete(planePath);
   }
 };
@@ -8696,14 +10540,14 @@ var PlaneHost = class {
   // root and an opened one cannot disagree about the same directory.
   realRoot(root) {
     if (!root) throw new Error("root is required");
-    const resolved = import_node_path13.default.resolve(root);
+    const resolved = import_node_path18.default.resolve(root);
     let real;
     try {
-      real = import_node_fs13.default.realpathSync(resolved);
+      real = import_node_fs18.default.realpathSync(resolved);
     } catch {
       throw new Error(`no such directory: ${resolved}`);
     }
-    if (!import_node_fs13.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
+    if (!import_node_fs18.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
     return real;
   }
   respond(ws, id, result) {
@@ -8723,9 +10567,9 @@ var PlaneHost = class {
 };
 
 // src/host/replacement-module-handler.ts
-var import_node_fs14 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 var import_promises5 = __toESM(require("node:fs/promises"), 1);
-var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 
 // ../contrast-bundler/src/replacementModule.ts
 var import_dist = require("sucrase/dist/index.js");
@@ -8764,12 +10608,12 @@ function normalize(p) {
   if (trailingSlash) joined += "/";
   return absolute ? "/" + joined : joined;
 }
-function join5(...parts) {
+function join6(...parts) {
   const present = parts.filter((part) => part.length > 0);
   if (present.length === 0) return ".";
   return normalize(present.join("/"));
 }
-function resolve2(...parts) {
+function resolve3(...parts) {
   let resolved = "";
   let absolute = false;
   for (let i = parts.length - 1; i >= 0 && !absolute; i--) {
@@ -8785,7 +10629,7 @@ function resolve2(...parts) {
   const normalized = normalizeSegments(resolved.split("/"), false).join("/");
   return normalized.length > 0 ? "/" + normalized : "/";
 }
-function dirname3(p) {
+function dirname4(p) {
   const idx = p.lastIndexOf("/");
   if (idx < 0) return ".";
   if (idx === 0) return "/";
@@ -8821,9 +10665,9 @@ var posix = {
   delimiter,
   isAbsolute,
   normalize,
-  join: join5,
-  resolve: resolve2,
-  dirname: dirname3,
+  join: join6,
+  resolve: resolve3,
+  dirname: dirname4,
   basename: basename3,
   extname,
   relative
@@ -8856,12 +10700,12 @@ function transformsFor(filePath) {
 function isLocalSpecifier(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../");
 }
-function isContrastKitSpecifier(specifier) {
-  return specifier === "contrast-kit" || specifier.startsWith("contrast-kit/");
+function isPeachKitSpecifier(specifier) {
+  return specifier === "peach-kit" || specifier.startsWith("peach-kit/");
 }
 function unsupportedSpecifier(specifier) {
   return new Error(
-    `replacement modules may only import react, react-native, contrast-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.`
+    `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(name2, specifier) {
@@ -8872,8 +10716,8 @@ function bridgeDeclaration(name2, specifier) {
   if (specifier === "react-native") {
     return `const ${name2} = ${REACT_NATIVE_BRIDGE}; if (!${name2}) throw new Error(${notReady("React Native")});`;
   }
-  if (isContrastKitSpecifier(specifier)) {
-    return `const ${name2} = (globalThis.__contrast_kit_modules && globalThis.__contrast_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 (isPeachKitSpecifier(specifier)) {
+    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 ${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 }; })();`;
@@ -9001,7 +10845,7 @@ function compileReplacementModule(input) {
       pointAtLocalModule(specifierToken, specifier);
       continue;
     }
-    if (specifier !== "react" && specifier !== "react-native" && !JSX_RUNTIME_SPECIFIERS.has(specifier) && !isContrastKitSpecifier(specifier) && !input.runtimePackages.has(specifier)) {
+    if (specifier !== "react" && specifier !== "react-native" && !JSX_RUNTIME_SPECIFIERS.has(specifier) && !isPeachKitSpecifier(specifier) && !input.runtimePackages.has(specifier)) {
       throw unsupportedSpecifier(specifier);
     }
     const bridge = bindings.length > 0 ? bridgeFor(specifier) : null;
@@ -9050,16 +10894,16 @@ function sendJavaScript(req, res, source) {
   res.end(req.method === "HEAD" ? void 0 : source);
 }
 function resolveLocalImport(fromFile, specifier) {
-  const base = import_node_path14.default.resolve(import_node_path14.default.dirname(fromFile), specifier);
+  const base = import_node_path19.default.resolve(import_node_path19.default.dirname(fromFile), specifier);
   const candidates = [
     ...REPLACEMENT_MODULE_EXTENSIONS.some(
-      (ext) => ext === import_node_path14.default.extname(base).toLowerCase()
+      (ext) => ext === import_node_path19.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_path19.default.join(base, `index${ext}`))
   ];
   const found = candidates.find(
-    (candidate) => (0, import_node_fs14.statSync)(candidate, { throwIfNoEntry: false })?.isFile()
+    (candidate) => (0, import_node_fs19.statSync)(candidate, { throwIfNoEntry: false })?.isFile()
   );
   if (!found) {
     throw new Error(
@@ -9114,13 +10958,13 @@ 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_path19.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_path19.default.isAbsolute(targetPath)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end("replacement file path must be absolute");
     return true;
@@ -9128,10 +10972,10 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   const runtimePackages = new Set(url.searchParams.getAll("runtimePackage"));
   let resolvedProjectRoot;
   if (options.projectRoot) {
-    const lexicalProjectRoot = import_node_path14.default.resolve(options.projectRoot);
+    const lexicalProjectRoot = import_node_path19.default.resolve(options.projectRoot);
     resolvedProjectRoot = await import_promises5.default.realpath(options.projectRoot);
-    const lexicalTarget = import_node_path14.default.relative(lexicalProjectRoot, targetPath);
-    if (lexicalTarget.startsWith("..") || import_node_path14.default.isAbsolute(lexicalTarget)) {
+    const lexicalTarget = import_node_path19.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path19.default.isAbsolute(lexicalTarget)) {
       res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
       res.end("replacement file must be inside the project root");
       return true;
@@ -9147,8 +10991,8 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     return true;
   }
   if (resolvedProjectRoot) {
-    const relativeTarget = import_node_path14.default.relative(resolvedProjectRoot, resolvedTargetPath);
-    if (relativeTarget.startsWith("..") || import_node_path14.default.isAbsolute(relativeTarget)) {
+    const relativeTarget = import_node_path19.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path19.default.isAbsolute(relativeTarget)) {
       res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
       res.end("replacement file must be inside the project root");
       return true;
@@ -9261,10 +11105,10 @@ function validateUpgradeRequest(req) {
 }
 function isSameOriginUpgrade(req) {
   const origin = req.headers.origin;
-  const host = req.headers.host;
-  if (!origin || !host) return false;
+  const host2 = req.headers.host;
+  if (!origin || !host2) return false;
   try {
-    return new URL(origin).host === host;
+    return new URL(origin).host === host2;
   } catch {
     return false;
   }
@@ -10320,8 +12164,8 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     void this.runServerScan().then((results) => sendJson(results));
   }
   resolveRuntimeUpdateIntervalMs() {
-    const raw = Number(process.env[RUNTIME_UPDATE_INTERVAL_ENV]);
-    if (Number.isFinite(raw) && raw > 0) return Math.max(100, Math.round(raw));
+    const raw2 = Number(process.env[RUNTIME_UPDATE_INTERVAL_ENV]);
+    if (Number.isFinite(raw2) && raw2 > 0) return Math.max(100, Math.round(raw2));
     return DEFAULT_RUNTIME_UPDATE_INTERVAL_MS;
   }
   startRuntimeUpdater() {
@@ -10452,6 +12296,18 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     res.setHeader("Cross-Origin-Embedder-Policy", SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY);
     res.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
     res.setHeader("Document-Policy", "js-profiling");
+    if (req.url?.startsWith("/__peach/expo-swift") || req.url?.startsWith("/__peach/swift")) {
+      void handleExpoSwiftRequest(req, res).then((handled) => {
+        if (!handled) {
+          res.writeHead(404);
+          res.end("Swift artifact not found");
+        }
+      }).catch((error) => {
+        res.writeHead(500);
+        res.end(String(error));
+      });
+      return;
+    }
     if (isFetchProxyRequestUrl(req.url)) {
       void handleFetchProxyRequest(req, res);
       return;