peachsim 0.1.1620 → 0.1.1625

package/dist-lib/bundle-channel.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1620 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1625 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;
@@ -36,6 +36,51 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/process-group.ts
+function listProcessChildren(parents, timeoutMs = 3e3) {
+  if (parents.some((pid) => !Number.isInteger(pid) || pid <= 1))
+    throw new Error("process inspection requires valid parent pids");
+  if (parents.length === 0) return [];
+  const deadline = Date.now() + timeoutMs;
+  let children;
+  if (process.platform === "linux") {
+    const lists = [];
+    for (const parent of parents) {
+      try {
+        const tasks = `/proc/${parent}/task`;
+        for (const thread of (0, import_node_fs.readdirSync)(tasks)) {
+          if (Date.now() >= deadline)
+            throw new Error("process descendant inspection exceeded its deadline");
+          try {
+            lists.push((0, import_node_fs.readFileSync)(`${tasks}/${thread}/children`, "utf8"));
+          } catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+              throw error;
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+          throw error;
+      }
+    }
+    children = lists.join(" ");
+  } else {
+    const result = (0, import_node_child_process.spawnSync)("pgrep", ["-P", parents.join(",")], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: Math.max(1, timeoutMs),
+      killSignal: "SIGKILL"
+    });
+    if (result.error || result.status !== 0 && result.status !== 1) {
+      throw new Error(
+        `could not inspect descendants of processes ${parents.join(",")}: ${result.error?.message || result.stderr.trim() || `pgrep exited ${result.status}`}`
+      );
+    }
+    children = result.stdout;
+  }
+  return [...new Set(children.trim().split(/\s+/).map(Number))].filter(
+    (pid) => Number.isInteger(pid) && pid > 1 && !parents.includes(pid)
+  );
+}
 function signalProcessGroup(child, signal) {
   if (!child.pid) return;
   try {
@@ -123,36 +168,35 @@ pid ${rootPid}
     }
   };
 }
-function runningPids(pids) {
-  return pids.filter((pid) => {
+function processesHaveExited(pids, pgid) {
+  const mayExist = [-pgid, ...pids].some((target) => {
     try {
-      process.kill(pid, 0);
+      process.kill(target, 0);
       return true;
     } catch (error) {
-      return error instanceof Error && "code" in error && error.code === "EPERM";
+      return !(error instanceof Error && "code" in error && error.code === "ESRCH");
     }
   });
-}
-function groupIsEmpty(pgid) {
-  try {
-    process.kill(-pgid, 0);
-  } catch (error) {
-    if (!(error instanceof Error && "code" in error && error.code === "EPERM"))
-      return true;
-  }
-  const result = (0, import_node_child_process.spawnSync)("ps", ["-A", "-o", "pgid=,stat="], {
+  if (!mayExist) return true;
+  const result = (0, import_node_child_process.spawnSync)("ps", ["-A", "-o", "pid=,pgid=,stat="], {
     encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: FORCED_EXIT_TIMEOUT_MS,
+    killSignal: "SIGKILL"
   });
   if (result.error || result.status !== 0) return false;
+  const knownPids = new Set(pids);
   return !result.stdout.split("\n").some((line) => {
-    const [group, state] = line.trim().split(/\s+/);
-    return Number(group) === pgid && state !== void 0 && !state.startsWith("Z");
+    const [pid, group, state] = line.trim().split(/\s+/);
+    return (Number(group) === pgid || knownPids.has(Number(pid))) && state !== void 0 && !state.startsWith("Z");
   });
 }
+function groupIsEmpty(pgid) {
+  return processesHaveExited([], pgid);
+}
 async function waitForExit(pids, pgid, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
-  const gone = () => runningPids(pids).length === 0 && groupIsEmpty(pgid);
+  const gone = () => processesHaveExited(pids, pgid);
   while (Date.now() < deadline) {
     if (gone()) return true;
     await (0, import_promises.setTimeout)(50);
@@ -185,22 +229,16 @@ async function terminateProcessGroup(child, signal = "SIGTERM", gracefulTimeoutM
         inspectionError = new Error("process descendant inspection exceeded its deadline");
         break;
       }
-      const result = (0, import_node_child_process.spawnSync)("pgrep", ["-P", parents.join(",")], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "pipe"],
-        timeout: remaining,
-        killSignal: "SIGKILL"
-      });
-      if (result.error || result.status !== 0 && result.status !== 1) {
-        inspectionError = new Error(
-          `could not inspect descendants of processes ${parents.join(",")}: ${result.error?.message || result.stderr.trim() || `pgrep exited ${result.status}`}`
-        );
+      let children;
+      try {
+        children = listProcessChildren(parents, remaining);
+      } catch (error) {
+        inspectionError = new Error(`could not inspect descendants: ${String(error)}`);
         break;
       }
       const next = [];
-      for (const line of result.stdout.split("\n")) {
-        const descendantPid = Number(line.trim());
-        if (Number.isInteger(descendantPid) && descendantPid > 1 && !descendants.has(descendantPid)) {
+      for (const descendantPid of children) {
+        if (!descendants.has(descendantPid)) {
           freeze.record(descendantPid);
           descendants.add(descendantPid);
           next.push(descendantPid);
@@ -326,6 +364,61 @@ var init_backend_origin = __esm({
   }
 });
 
+// src/bundleGlobalFooter.ts
+function findBundleFooter(source, prefix) {
+  let end = source.length;
+  while (end > 0) {
+    const newline = source.lastIndexOf("\n", end - 1);
+    if (newline < 0) return -1;
+    const line = newline + 1;
+    if (source.startsWith(prefix, line)) return newline;
+    if (!isFooterBlockLine(source, line, end)) return -1;
+    end = newline;
+  }
+  return -1;
+}
+function isFooterBlockLine(source, line, end) {
+  return line === end || source.startsWith("globalThis.", line) || source.startsWith("//", line);
+}
+function readFooter(source, prefix, suffix, name2) {
+  const start = findBundleFooter(source, prefix);
+  if (start < 0) return null;
+  const end = source.indexOf("\n", start + 1);
+  const line = source.slice(start + 1, end < 0 ? void 0 : end);
+  if (!line.endsWith(suffix)) throw new Error(`${name2} footer is truncated`);
+  const value = JSON.parse(
+    line.slice(prefix.length, suffix ? -suffix.length : void 0)
+  );
+  if (value === null) throw new Error(`${name2} footer has no metadata`);
+  return value;
+}
+function detachFooter(source, prefix, suffix, name2) {
+  const start = findBundleFooter(source, prefix);
+  if (start < 0) return { source, value: null };
+  const value = readFooter(source, prefix, suffix, name2);
+  const end = source.indexOf("\n", start + 1);
+  return { source: source.slice(0, start) + (end < 0 ? "" : source.slice(end)), value };
+}
+function insertBundleGlobalFooter(source, name2, value) {
+  return insertFooter(source, `globalThis.${name2}=`, ";", name2, value);
+}
+function insertBundleMetadataFooter(source, name2, value) {
+  return insertFooter(source, `// peach.${name2}=`, "", name2, value);
+}
+function insertFooter(source, prefix, suffix, name2, value) {
+  source = detachFooter(source, prefix, suffix, name2).source;
+  const json = JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/<\//g, "<\\/");
+  const footer = `
+${prefix}${json}${suffix}`;
+  const identity = findBundleFooter(source, "globalThis.__sootsimModulePaths=");
+  return identity < 0 ? source + footer : source.slice(0, identity) + footer + source.slice(identity);
+}
+var init_bundleGlobalFooter = __esm({
+  "src/bundleGlobalFooter.ts"() {
+    "use strict";
+  }
+});
+
 // cli/internal-child.ts
 var RNX_FORKED_SCRIPT_ENV;
 var init_internal_child = __esm({
@@ -335,13 +428,146 @@ var init_internal_child = __esm({
   }
 });
 
+// src/swift-binary-modules.ts
+function frameworkModules(paths) {
+  const modules = /* @__PURE__ */ new Set();
+  for (const file of paths) {
+    const segment2 = file.split("/").find((part) => part.endsWith(".framework"));
+    if (segment2) modules.add(segment2.slice(0, -".framework".length));
+  }
+  return [...modules].sort();
+}
+async function range(url, spec) {
+  const response = await fetch(url, {
+    headers: { range: `bytes=${spec}`, "accept-encoding": "identity" },
+    signal: AbortSignal.timeout(2e4)
+  });
+  const match = /^bytes (\d+)-\d+\/(\d+)$/.exec(
+    response.headers.get("content-range") ?? ""
+  );
+  if (response.status !== 206 || !match)
+    throw new Error(`${url} answered ${response.status} to a range request`);
+  return {
+    bytes: Buffer.from(await response.arrayBuffer()),
+    start: Number(match[1]),
+    total: Number(match[2])
+  };
+}
+async function zipEntries(url) {
+  const { total } = await range(url, "0-0");
+  const tail = await range(url, `${Math.max(0, total - 65558)}-${total - 1}`);
+  let end = tail.bytes.length - 22;
+  for (; end >= 0; end--)
+    if (tail.bytes.readUInt32LE(end) === 101010256 && end + 22 + tail.bytes.readUInt16LE(end + 20) === tail.bytes.length)
+      break;
+  if (end < 0) throw new Error(`${url} has no zip end record`);
+  let size = tail.bytes.readUInt32LE(end + 12);
+  let offset = tail.bytes.readUInt32LE(end + 16);
+  if (offset === 4294967295 || size === 4294967295) {
+    const locator = end - 20;
+    if (locator < 0 || tail.bytes.readUInt32LE(locator) !== 117853008)
+      throw new Error(`${url} has no zip64 locator`);
+    const recordAt = Number(tail.bytes.readBigUInt64LE(locator + 8));
+    const record4 = recordAt >= tail.start ? tail.bytes.subarray(recordAt - tail.start) : (await range(url, `${recordAt}-${recordAt + 55}`)).bytes;
+    size = Number(record4.readBigUInt64LE(40));
+    offset = Number(record4.readBigUInt64LE(48));
+  }
+  const directory = offset >= tail.start ? tail.bytes.subarray(offset - tail.start, offset - tail.start + size) : (await range(url, `${offset}-${offset + size - 1}`)).bytes;
+  const names = [];
+  for (let at = 0; at + 46 <= directory.length; ) {
+    if (directory.readUInt32LE(at) !== 33639248) break;
+    const nameLength = directory.readUInt16LE(at + 28);
+    names.push(directory.toString("utf8", at + 46, at + 46 + nameLength));
+    at += 46 + nameLength + directory.readUInt16LE(at + 30) + directory.readUInt16LE(at + 32);
+  }
+  return names;
+}
+function localEntries(dir) {
+  if (!import_node_fs2.default.existsSync(dir)) return [];
+  return import_node_fs2.default.readdirSync(dir, { withFileTypes: true }).filter((slice) => slice.isDirectory()).flatMap(
+    (slice) => import_node_fs2.default.readdirSync(import_node_path2.default.join(dir, slice.name)).map((entry) => `${slice.name}/${entry}`)
+  );
+}
+async function swiftBinaryModules(binary) {
+  if (!binary.url) return frameworkModules(localEntries(binary.dir));
+  const cached2 = import_node_path2.default.join(
+    cacheDir,
+    `${(0, import_node_crypto.createHash)("sha256").update(`${binary.url}\0${binary.checksum ?? ""}`).digest("hex").slice(0, 32)}.json`
+  );
+  if (import_node_fs2.default.existsSync(cached2)) {
+    const value = JSON.parse(import_node_fs2.default.readFileSync(cached2, "utf8"));
+    if (Array.isArray(value) && value.every((name2) => typeof name2 === "string"))
+      return value;
+  }
+  const modules = frameworkModules(await zipEntries(binary.url));
+  import_node_fs2.default.mkdirSync(cacheDir, { recursive: true });
+  import_node_fs2.default.writeFileSync(cached2, JSON.stringify(modules));
+  return modules;
+}
+var import_node_crypto, import_node_fs2, import_node_os2, import_node_path2, cacheDir;
+var init_swift_binary_modules = __esm({
+  "src/swift-binary-modules.ts"() {
+    "use strict";
+    import_node_crypto = require("node:crypto");
+    import_node_fs2 = __toESM(require("node:fs"), 1);
+    import_node_os2 = __toESM(require("node:os"), 1);
+    import_node_path2 = __toESM(require("node:path"), 1);
+    cacheDir = import_node_path2.default.join(import_node_os2.default.tmpdir(), "peach-swift-binary-modules");
+  }
+});
+
 // src/admitted-mac-build.ts
+function windowAdmission() {
+  const result = (0, import_node_child_process2.spawnSync)("tm", ["window", "ancestor", "--json"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "inherit"]
+  });
+  if (result.error) throw result.error;
+  if (result.status === 1) return null;
+  if (result.status !== 0) throw new Error(`tm window ancestor exited ${result.status}`);
+  const entry = JSON.parse(result.stdout);
+  if (entry.kind === "external")
+    return { kind: "external", name: entry.name ?? "", cores: null };
+  if (entry.kind !== "heavy" && entry.kind !== "quiet")
+    throw new Error(`tm window ancestor returned kind ${entry.kind}`);
+  return {
+    kind: entry.kind,
+    cores: entry.cores && entry.cores > 0 ? entry.cores : null,
+    scopes: entry.scopes ?? []
+  };
+}
 function admittedMacBuilderSlot(env = process.env) {
-  return env.CONTRAST_REMOTE_BUILD === "mac" && env.REMOTE_MAC_SLOT_HELD === "1" && env.CONTRAST_HEAVY_ADMITTED === "1";
+  if (process.platform !== "darwin" || env.REMOTE_MAC_SLOT_HELD !== "1") return false;
+  return windowAdmission() !== null;
 }
+var import_node_child_process2;
 var init_admitted_mac_build = __esm({
   "src/admitted-mac-build.ts"() {
     "use strict";
+    import_node_child_process2 = require("node:child_process");
+  }
+});
+
+// src/home-paths.ts
+function rnxHomeDir() {
+  const override = process.env[PEACH_HOME_ENV];
+  if (override && override.length > 0) return import_node_path3.default.resolve(override);
+  return import_node_path3.default.join((0, import_node_os3.homedir)(), ".peach");
+}
+function electronDir() {
+  return import_node_path3.default.join(rnxHomeDir(), "electron");
+}
+function electronUserDataDir() {
+  return import_node_path3.default.join(electronDir(), "userData");
+}
+var import_node_os3, import_node_path3, PEACH_HOME_ENV, DAEMON_LOCKFILE_MAX_BYTES;
+var init_home_paths = __esm({
+  "src/home-paths.ts"() {
+    "use strict";
+    import_node_os3 = require("node:os");
+    import_node_path3 = __toESM(require("node:path"), 1);
+    PEACH_HOME_ENV = "PEACH_HOME";
+    DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
   }
 });
 
@@ -700,9 +926,9 @@ function originalColumn(line, column) {
 }
 function designTimeDiagnostic(output, files2) {
   const rewritten = /* @__PURE__ */ new Map();
-  const linesOf = (path20) => {
+  const linesOf = (path21) => {
     const file = Object.keys(files2).find(
-      (name2) => name2.endsWith(".swift") && (path20 === name2 || path20.endsWith(`/${name2}`))
+      (name2) => name2.endsWith(".swift") && (path21 === name2 || path21.endsWith(`/${name2}`))
     );
     if (file === void 0) return null;
     let lines = rewritten.get(file);
@@ -876,12 +1102,12 @@ function swiftIcuData(toolchainBin, sdk) {
 function swiftIcuAsset(toolchainBin, sdk) {
   return memo(assets, `${toolchainBin}\0${sdk}`, async () => {
     const zipped = await deflate(await swiftIcuData(toolchainBin, sdk));
-    return { sha256: (0, import_node_crypto.createHash)("sha256").update(zipped).digest("hex"), gzip: zipped };
+    return { sha256: (0, import_node_crypto2.createHash)("sha256").update(zipped).digest("hex"), gzip: zipped };
   });
 }
 async function load(toolchainBin, sdk) {
-  const swift = import_node_path2.default.join(toolchainBin, "swift");
-  if (!(0, import_node_fs2.existsSync)(swift))
+  const swift = import_node_path4.default.join(toolchainBin, "swift");
+  if (!(0, import_node_fs3.existsSync)(swift))
     throw new Error(`swift-icu: no swift at ${swift} for the ${sdk} SDK's icu data`);
   const { stdout: listed } = await run(swift, ["sdk", "list"]);
   if (!listed.split("\n").some((line) => line.trim() === sdk))
@@ -896,7 +1122,7 @@ async function load(toolchainBin, sdk) {
   const resources = /^swiftStaticResourcesPath: (.+)$/m.exec(stdout)?.[1]?.trim();
   if (!resources) throw new Error(`swift-icu: ${sdk} names no static resources`);
   return Buffer.from(
-    icuSegment(archiveMember((0, import_node_fs2.readFileSync)(import_node_path2.default.join(resources, ARCHIVE)), MEMBER))
+    icuSegment(archiveMember((0, import_node_fs3.readFileSync)(import_node_path4.default.join(resources, ARCHIVE)), MEMBER))
   );
 }
 function archiveMember(archive, name2) {
@@ -950,17 +1176,17 @@ function icuSegment(object) {
     throw new Error(`swift-icu: expected one icu data segment, found ${found.length}`);
   return found[0];
 }
-var import_node_child_process2, import_node_crypto, import_node_fs2, import_node_path2, import_node_util, import_node_zlib, run, deflate, ARCHIVE, MEMBER, raw, assets;
+var import_node_child_process3, import_node_crypto2, import_node_fs3, import_node_path4, import_node_util, import_node_zlib, run, deflate, ARCHIVE, MEMBER, raw, assets;
 var init_swift_icu = __esm({
   "src/swift-icu.ts"() {
     "use strict";
-    import_node_child_process2 = require("node:child_process");
-    import_node_crypto = require("node:crypto");
-    import_node_fs2 = require("node:fs");
-    import_node_path2 = __toESM(require("node:path"), 1);
+    import_node_child_process3 = require("node:child_process");
+    import_node_crypto2 = require("node:crypto");
+    import_node_fs3 = require("node:fs");
+    import_node_path4 = __toESM(require("node:path"), 1);
     import_node_util = require("node:util");
     import_node_zlib = require("node:zlib");
-    run = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+    run = (0, import_node_util.promisify)(import_node_child_process3.execFile);
     deflate = (0, import_node_util.promisify)(import_node_zlib.gzip);
     ARCHIVE = "wasi/lib_FoundationICU.a";
     MEMBER = "icu_packaged_data.cpp.obj";
@@ -1261,7 +1487,7 @@ var init_swiftContract = __esm({
 async function runCompiler(command, args, options, stream = false) {
   const { signal } = options;
   signal?.throwIfAborted();
-  const child = (0, import_node_child_process3.spawn)(command, args, {
+  const child = (0, import_node_child_process4.spawn)(command, args, {
     cwd: options.cwd,
     env: options.env,
     detached: true,
@@ -1325,12 +1551,12 @@ async function runCompiler(command, args, options, stream = false) {
   }
 }
 function swiftDistributionAt(root) {
-  const file = import_node_path3.default.join(root, SWIFT_DISTRIBUTION_MANIFEST);
-  if (!(0, import_node_fs3.existsSync)(file)) return null;
-  return parseSwiftDistributionManifest(JSON.parse((0, import_node_fs3.readFileSync)(file, "utf8")));
+  const file = import_node_path5.default.join(root, SWIFT_DISTRIBUTION_MANIFEST);
+  if (!(0, import_node_fs4.existsSync)(file)) return null;
+  return parseSwiftDistributionManifest(JSON.parse((0, import_node_fs4.readFileSync)(file, "utf8")));
 }
 function swiftModuleSdk(root) {
-  const pin = swiftDistributionAt(root) ?? JSON.parse((0, import_node_fs3.readFileSync)(import_node_path3.default.join(root, "toolchain.json"), "utf8"));
+  const pin = swiftDistributionAt(root) ?? JSON.parse((0, import_node_fs4.readFileSync)(import_node_path5.default.join(root, "toolchain.json"), "utf8"));
   if (!pin || typeof pin !== "object" || typeof Reflect.get(pin, "wasmSdkId") !== "string" || typeof Reflect.get(pin, "wasmSdkUrl") !== "string" || typeof Reflect.get(pin, "wasmSdkChecksum") !== "string")
     throw new Error(`${root} pins no wasm SDK id, url and checksum`);
   return {
@@ -1352,7 +1578,7 @@ function swiftModuleInputFiles(root) {
     "toolchain.json"
   ];
   const walk2 = (dir) => {
-    for (const entry of (0, import_node_fs3.readdirSync)(import_node_path3.default.join(root, dir), {
+    for (const entry of (0, import_node_fs4.readdirSync)(import_node_path5.default.join(root, dir), {
       withFileTypes: true
     })) {
       const relative = `${dir}/${entry.name}`;
@@ -1370,29 +1596,29 @@ function swiftMacroPlugins(moduleRoot) {
   const distribution = swiftDistributionAt(moduleRoot);
   if (distribution)
     return {
-      libraries: distribution.plugins.map((plugin) => import_node_path3.default.join(moduleRoot, plugin)),
+      libraries: distribution.plugins.map((plugin) => import_node_path5.default.join(moduleRoot, plugin)),
       stale: false
     };
-  const dir = import_node_path3.default.join(moduleRoot, ".build/host/RnxPreviewMacros");
+  const dir = import_node_path5.default.join(moduleRoot, ".build/host/RnxPreviewMacros");
   const release = JSON.parse(
-    (0, import_node_fs3.readFileSync)(import_node_path3.default.join(moduleRoot, "toolchain.json"), "utf8")
+    (0, import_node_fs4.readFileSync)(import_node_path5.default.join(moduleRoot, "toolchain.json"), "utf8")
   ).release;
-  const compilerStamp = import_node_path3.default.join(dir, "compiler-release");
+  const compilerStamp = import_node_path5.default.join(dir, "compiler-release");
   const ext = process.platform === "darwin" ? "dylib" : "so";
   const plugins = [
     {
-      library: import_node_path3.default.join(dir, `libRnxPreviewMacros.${ext}`),
-      source: import_node_path3.default.join(moduleRoot, "Sources/RnxPreviewMacros/PreviewMacro.swift")
+      library: import_node_path5.default.join(dir, `libRnxPreviewMacros.${ext}`),
+      source: import_node_path5.default.join(moduleRoot, "Sources/RnxPreviewMacros/PreviewMacro.swift")
     },
     {
-      library: import_node_path3.default.join(dir, `libFoundationMacros.${ext}`),
-      source: import_node_path3.default.join(moduleRoot, "Sources/FoundationMacros/PredicateMacro.swift")
+      library: import_node_path5.default.join(dir, `libFoundationMacros.${ext}`),
+      source: import_node_path5.default.join(moduleRoot, "Sources/FoundationMacros/PredicateMacro.swift")
     }
   ];
   return {
     libraries: plugins.map(({ library }) => library),
-    stale: !(0, import_node_fs3.existsSync)(compilerStamp) || (0, import_node_fs3.readFileSync)(compilerStamp, "utf8").trim() !== release || plugins.some(
-      ({ library, source }) => !(0, import_node_fs3.existsSync)(library) || (0, import_node_fs3.statSync)(source).mtimeMs > (0, import_node_fs3.statSync)(library).mtimeMs
+    stale: !(0, import_node_fs4.existsSync)(compilerStamp) || (0, import_node_fs4.readFileSync)(compilerStamp, "utf8").trim() !== release || plugins.some(
+      ({ library, source }) => !(0, import_node_fs4.existsSync)(library) || (0, import_node_fs4.statSync)(source).mtimeMs > (0, import_node_fs4.statSync)(library).mtimeMs
     )
   };
 }
@@ -1402,14 +1628,14 @@ async function ensureMacroPlugins(moduleRoot, toolchainBin, release, signal) {
     await runCompiler(
       "sh",
       [
-        import_node_path3.default.join(moduleRoot, "scripts/build-preview-plugin.sh"),
+        import_node_path5.default.join(moduleRoot, "scripts/build-preview-plugin.sh"),
         toolchainBin,
         libraries[0]
       ],
       { signal }
     );
-    (0, import_node_fs3.writeFileSync)(
-      import_node_path3.default.join(import_node_path3.default.dirname(libraries[0]), "compiler-release"),
+    (0, import_node_fs4.writeFileSync)(
+      import_node_path5.default.join(import_node_path5.default.dirname(libraries[0]), "compiler-release"),
       `${release}
 `
     );
@@ -1418,9 +1644,9 @@ async function ensureMacroPlugins(moduleRoot, toolchainBin, release, signal) {
 }
 function swiftModuleDigest(root) {
   const files2 = swiftModuleInputFiles(root);
-  const stampHash = (0, import_node_crypto2.createHash)("sha256");
+  const stampHash = (0, import_node_crypto3.createHash)("sha256");
   for (const file of files2) {
-    const stat = (0, import_node_fs3.statSync)(import_node_path3.default.join(root, file), { bigint: true });
+    const stat = (0, import_node_fs4.statSync)(import_node_path5.default.join(root, file), { bigint: true });
     stampHash.update(file);
     stampHash.update(
       `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}
@@ -1430,11 +1656,11 @@ function swiftModuleDigest(root) {
   const stamp = stampHash.digest("hex");
   const cached2 = linkedModuleDigests.get(root);
   if (cached2?.stamp === stamp) return cached2.digest;
-  const hash = (0, import_node_crypto2.createHash)("sha256");
+  const hash = (0, import_node_crypto3.createHash)("sha256");
   for (const file of files2) {
-    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(file).digest());
     hash.update(
-      (0, import_node_crypto2.createHash)("sha256").update((0, import_node_fs3.readFileSync)(import_node_path3.default.join(root, file))).digest()
+      (0, import_node_crypto3.createHash)("sha256").update((0, import_node_fs4.readFileSync)(import_node_path5.default.join(root, file))).digest()
     );
   }
   const digest2 = hash.digest();
@@ -1455,7 +1681,7 @@ function withNativeSourceGlue(input, glue) {
     ...input,
     files: {
       ...input.files,
-      [import_node_path3.default.posix.join(targetPath, "OneNativeSource.generated.swift")]: glue
+      [import_node_path5.default.posix.join(targetPath, "OneNativeSource.generated.swift")]: glue
     },
     oneModule: true
   };
@@ -1534,7 +1760,7 @@ function swiftImportNames(contents, available) {
 function swiftPeachModules(moduleRoot) {
   const distribution = swiftDistributionAt(moduleRoot);
   return distribution ? distribution.modules : [
-    ...(0, import_node_fs3.readFileSync)(import_node_path3.default.join(moduleRoot, "Package.swift"), "utf8").matchAll(
+    ...(0, import_node_fs4.readFileSync)(import_node_path5.default.join(moduleRoot, "Package.swift"), "utf8").matchAll(
       /\.(?:target|systemLibrary)\(\s*name:\s*"([^"]+)"/g
     )
   ].map((match) => match[1]);
@@ -1544,8 +1770,8 @@ function swiftSdkPaths(moduleRoot, toolchainBin) {
   const key2 = `${toolchainBin}\0${sdk}`;
   const cached2 = sdkPaths.get(key2);
   if (cached2) return cached2;
-  const configuration = (0, import_node_child_process3.execFileSync)(
-    import_node_path3.default.join(toolchainBin, "swift"),
+  const configuration = (0, import_node_child_process4.execFileSync)(
+    import_node_path5.default.join(toolchainBin, "swift"),
     ["sdk", "configure", "--show-configuration", sdk, "wasm32-unknown-wasip1"],
     { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
   );
@@ -1568,14 +1794,14 @@ function swiftAvailableModules(moduleRoot, toolchainBin) {
   if (cached2) return cached2;
   const modules = new Set(swiftPeachModules(moduleRoot));
   const { resources } = swiftSdkPaths(moduleRoot, toolchainBin);
-  for (const entry of (0, import_node_fs3.readdirSync)(import_node_path3.default.join(resources, "wasi"))) {
+  for (const entry of (0, import_node_fs4.readdirSync)(import_node_path5.default.join(resources, "wasi"))) {
     if (entry.endsWith(".swiftmodule"))
       modules.add(entry.slice(0, -".swiftmodule".length));
   }
-  for (const entry of (0, import_node_fs3.readdirSync)(resources)) {
-    const map = import_node_path3.default.join(resources, entry, "module.modulemap");
-    if (!(0, import_node_fs3.existsSync)(map)) continue;
-    for (const match of (0, import_node_fs3.readFileSync)(map, "utf8").matchAll(/^module\s+([A-Za-z_]\w*)/gm))
+  for (const entry of (0, import_node_fs4.readdirSync)(resources)) {
+    const map = import_node_path5.default.join(resources, entry, "module.modulemap");
+    if (!(0, import_node_fs4.existsSync)(map)) continue;
+    for (const match of (0, import_node_fs4.readFileSync)(map, "utf8").matchAll(/^module\s+([A-Za-z_]\w*)/gm))
       modules.add(match[1]);
   }
   availableModules.set(key2, modules);
@@ -1617,39 +1843,39 @@ function swiftTargetDependencies(files2, targets) {
   return siblings;
 }
 function swiftArtifactHash(input, release, moduleRoot) {
-  const hash = (0, import_node_crypto2.createHash)("sha256");
-  hash.update(`swift-compile/v47
+  const hash = (0, import_node_crypto3.createHash)("sha256");
+  hash.update(`swift-compile/v49
 ${release}
 `);
   if (input.oneModule) hash.update("one-module\n");
   hash.update(swiftModuleDigest(moduleRoot));
   for (const file of Object.keys(input.files).sort()) {
-    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
-    hash.update((0, import_node_crypto2.createHash)("sha256").update(input.files[file]).digest());
+    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 file of Object.keys(input.metalSources ?? {}).sort()) {
     hash.update("metal-source\n");
-    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(file).digest());
     hash.update(
-      (0, import_node_crypto2.createHash)("sha256").update(input.metalSources?.[file] ?? "").digest()
+      (0, import_node_crypto3.createHash)("sha256").update(input.metalSources?.[file] ?? "").digest()
     );
   }
   for (const base of Object.keys(input.resources ?? {}).sort()) {
-    hash.update((0, import_node_crypto2.createHash)("sha256").update(base).digest());
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(base).digest());
     hash.update(
-      (0, import_node_crypto2.createHash)("sha256").update(input.resources?.[base] ?? "").digest()
+      (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_crypto2.createHash)("sha256").update(name2).digest());
-    hash.update((0, import_node_crypto2.createHash)("sha256").update(image.file).digest());
-    hash.update((0, import_node_crypto2.createHash)("sha256").update(image.data).digest());
+    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());
   }
   for (const file of [...new Set(input.resourcePaths ?? [])].sort()) {
     hash.update("resource-path\n");
-    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
+    hash.update((0, import_node_crypto3.createHash)("sha256").update(file).digest());
   }
   hash.update(
     JSON.stringify(
@@ -1661,7 +1887,7 @@ ${release}
 ${target}
 `);
     hash.update(
-      (0, import_node_crypto2.createHash)("sha256").update(input.libraries?.[target] ?? "").digest()
+      (0, import_node_crypto3.createHash)("sha256").update(input.libraries?.[target] ?? "").digest()
     );
   }
   const targets = compileTargets(input);
@@ -1704,21 +1930,21 @@ function emitSwiftPackageManifest(args) {
     distributionLink.files.set(
       distributionLink.path,
       objects.map(
-        (object) => `"${import_node_path3.default.join(moduleRoot, object).replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`
+        (object) => `"${import_node_path5.default.join(moduleRoot, object).replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`
       ).join("\n") + "\n"
     );
   }
-  const overlayRoot = import_node_path3.default.join(
+  const overlayRoot = import_node_path5.default.join(
     moduleRoot,
     distribution ? "modules" : "cross-import-overlays"
   );
-  const overlayFlags = (0, import_node_fs3.readdirSync)(overlayRoot, { encoding: "utf8", recursive: true }).filter((file) => file.endsWith(".swiftoverlay")).sort((left, right) => left.localeCompare(right)).flatMap((file) => [
+  const overlayFlags = (0, import_node_fs4.readdirSync)(overlayRoot, { encoding: "utf8", recursive: true }).filter((file) => file.endsWith(".swiftoverlay")).sort((left, right) => left.localeCompare(right)).flatMap((file) => [
     "-Xfrontend",
     "-swift-module-cross-import",
     "-Xfrontend",
-    import_node_path3.default.basename(import_node_path3.default.dirname(file), ".swiftcrossimport"),
+    import_node_path5.default.basename(import_node_path5.default.dirname(file), ".swiftcrossimport"),
     "-Xfrontend",
-    import_node_path3.default.join(overlayRoot, file)
+    import_node_path5.default.join(overlayRoot, file)
   ]).map((flag) => `, ${JSON.stringify(flag)}`).join("");
   const executable = targets.find((target) => target.executable);
   if (!executable) throw new Error("swift-compile: no executable target to emit");
@@ -1726,14 +1952,14 @@ function emitSwiftPackageManifest(args) {
     const isolation = target.mainActorIsolation ? " .defaultIsolation(MainActor.self)," : "";
     const interoperability = target.cxxInterop ? " .interoperabilityMode(.Cxx)," : "";
     const defines = (target.defines ?? []).map((name2) => ` .define(${JSON.stringify(name2)}),`).join("");
-    const imports = distribution ? `, "-I", ${JSON.stringify(import_node_path3.default.join(moduleRoot, "modules"))}` : "";
+    const imports = distribution ? `, "-I", ${JSON.stringify(import_node_path5.default.join(moduleRoot, "modules"))}` : "";
     const native = args.native?.get(target.name);
     const nativeImports = (siblings.get(target.name) ?? []).filter((name2) => args.native?.has(name2)).map(
       (name2) => `, "-Xfrontend", "-import-module", "-Xfrontend", ${JSON.stringify(swiftTargetModuleName(name2))}`
     ).join("");
     const header = args.headerDirectory && [...args.native?.values() ?? []].some(
       (value) => value.late?.producers.includes(target.name)
-    ) ? `, "-emit-objc-header-path", ${JSON.stringify(import_node_path3.default.join(args.headerDirectory, `${target.name}-Swift.h`))}` : "";
+    ) ? `, "-emit-objc-header-path", ${JSON.stringify(import_node_path5.default.join(args.headerDirectory, `${target.name}-Swift.h`))}` : "";
     const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation}${interoperability}${defines} .unsafeFlags(["-Osize", "-Xfrontend", "-enable-cross-import-overlays"${overlayFlags}${FOUNDATION_IMPLICIT_FLAGS}${oneModule ? ONE_IMPLICIT_FLAGS : ""}${imports}${nativeImports}${header}])]`;
     const deps = [
       ...target.executable ? [...args.native?.values() ?? []].flatMap(
@@ -1798,21 +2024,21 @@ function emitSwiftPackageManifest(args) {
   ].join("\n");
 }
 function syncSwiftTree(base, files2) {
-  (0, import_node_fs3.mkdirSync)(base, { recursive: true });
+  (0, import_node_fs4.mkdirSync)(base, { recursive: true });
   const walk2 = (dir) => {
-    for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
-      const full = import_node_path3.default.join(dir, entry.name);
+    for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
+      const full = import_node_path5.default.join(dir, entry.name);
       if (dir === base && entry.name === ".build") continue;
       if (entry.isDirectory()) walk2(full);
-      else if (!files2.has(full)) (0, import_node_fs3.rmSync)(full, { force: true });
+      else if (!files2.has(full)) (0, import_node_fs4.rmSync)(full, { force: true });
     }
   };
   walk2(base);
   for (const [full, contents] of files2) {
-    if ((0, import_node_fs3.existsSync)(full) && (typeof contents === "string" ? (0, import_node_fs3.readFileSync)(full, "utf8") === contents : (0, import_node_fs3.readFileSync)(full).equals(contents)))
+    if ((0, import_node_fs4.existsSync)(full) && (typeof contents === "string" ? (0, import_node_fs4.readFileSync)(full, "utf8") === contents : (0, import_node_fs4.readFileSync)(full).equals(contents)))
       continue;
-    (0, import_node_fs3.mkdirSync)(import_node_path3.default.dirname(full), { recursive: true });
-    (0, import_node_fs3.writeFileSync)(full, contents);
+    (0, import_node_fs4.mkdirSync)(import_node_path5.default.dirname(full), { recursive: true });
+    (0, import_node_fs4.writeFileSync)(full, contents);
   }
 }
 function splitTopLevel(text4) {
@@ -2180,11 +2406,53 @@ function compiledSwiftSources(files2, targets) {
     const sources = lifted.map(([, contents]) => contents);
     const extensions = objcExtensionMemberIndex(sources);
     const objc = objcIndex(sources);
+    const rooted = objcRootedClasses(sources);
     for (const [file, contents] of lifted)
-      compiled.set(file, swiftSourceAsIOS(contents, extensions, objc));
+      compiled.set(
+        file,
+        hideObjCClassesFromCxx(swiftSourceAsIOS(contents, extensions, objc), rooted)
+      );
   }
   return compiled;
 }
+function objcRootedClasses(sources) {
+  const bases = /* @__PURE__ */ new Map();
+  for (const source of sources)
+    for (const match of swiftCodeMask(source).matchAll(
+      /\bclass\s+(?!(?:func|var|let|subscript)\b)([A-Za-z_]\w*)\s*(?:<[^>{]*>)?\s*:\s*(?:[A-Za-z_]\w*\.)*([A-Za-z_]\w*)/g
+    ))
+      bases.set(match[1], match[2]);
+  const rooted = /* @__PURE__ */ new Set();
+  for (const name2 of bases.keys()) {
+    const seen = /* @__PURE__ */ new Set([name2]);
+    let base = bases.get(name2);
+    while (bases.has(base) && !seen.has(base)) {
+      seen.add(base);
+      base = bases.get(base);
+    }
+    if (!bases.has(base) && APPLE_CLASS.test(base) && !APPLE_PROTOCOL.test(base) && !(base in SDK_OBJC_OPTIONAL))
+      rooted.add(name2);
+  }
+  return rooted;
+}
+function hideObjCClassesFromCxx(source, rooted) {
+  if (rooted.size === 0) return source;
+  const code = swiftCodeMask(source);
+  const starts = [];
+  let depth = 0;
+  for (const match of code.matchAll(
+    /[{}]|\bclass\s+(?!(?:func|var|let|subscript)\b)([A-Za-z_]\w*)/g
+  )) {
+    if (match[0] === "{") depth++;
+    else if (match[0] === "}") depth--;
+    else if (depth === 0 && rooted.has(match[1]))
+      starts.push(declarationStart(code, match.index, 0));
+  }
+  let out = source;
+  for (const at of starts.reverse())
+    out = `${out.slice(0, at)}@_expose(!Cxx) ${out.slice(at)}`;
+  return out;
+}
 function lowerAnyObjectDoubleValue(source) {
   const masked = swiftCodeMask(source);
   const names = /* @__PURE__ */ new Set();
@@ -2606,11 +2874,39 @@ function objcIndex(sources) {
         /\b(?:var|let)\s+([A-Za-z_]\w*)/g
       ))
         variables.add(declared[1]);
-  const parents = requirements.size ? inheritedTypes(sources) : /* @__PURE__ */ new Map();
+  const parents = inheritedTypes(sources);
   for (const [protocol, inherited] of sdkParents)
     parents.set(protocol, /* @__PURE__ */ new Set([...parents.get(protocol) ?? [], ...inherited]));
   const conformers = requirements.size ? conformingTypes(parents, new Set(requirements.keys())) : /* @__PURE__ */ new Map();
-  return { requirements, conformers, callable, variables, aliases, typeMethods };
+  const protocols = /* @__PURE__ */ new Set();
+  const initializers = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    if (!/\bprotocol\b/.test(source)) continue;
+    const code = swiftCodeMask(source);
+    const braces = [...code.matchAll(/[{}]/g)].map((match) => match.index);
+    for (const protocol of code.matchAll(/\bprotocol\s+([A-Za-z_]\w*)[^{}]*\{/g)) {
+      const name2 = protocol[1];
+      protocols.add(name2);
+      const open = protocol.index + protocol[0].length - 1;
+      if (/\binit\s*[?!]?\s*\(/.test(code.slice(open + 1, closingBrace(code, braces, open))))
+        initializers.add(name2);
+    }
+  }
+  const rooted = conformingTypes(parents, /* @__PURE__ */ new Set(["NSObject"]));
+  const initialized = conformingTypes(parents, initializers);
+  const nsObjectTypes = /* @__PURE__ */ new Set([
+    "NSObject",
+    ...[...protocols].filter((name2) => rooted.has(name2) && !initialized.has(name2))
+  ]);
+  return {
+    requirements,
+    conformers,
+    callable,
+    variables,
+    aliases,
+    typeMethods,
+    nsObjectTypes
+  };
 }
 function objcAliases(sources) {
   const declared = /* @__PURE__ */ new Map();
@@ -2857,7 +3153,7 @@ function lowerObjCOptionalRequirements(source, index) {
 }
 function lowerObjCRuntimeCalls(source, index) {
   const casts = source.includes("@convention(c)");
-  const classes = /\b(?:AnyClass|AnyObject)\b/.test(source);
+  const classes = /\b(?:AnyClass|AnyObject)\b|\.\s*init\s*\(/.test(source);
   if (!casts && !classes) return source;
   const code = swiftCodeMask(source);
   const edits = [];
@@ -2887,11 +3183,24 @@ function lowerObjCRuntimeCalls(source, index) {
   if (classes) {
     const declarations = /* @__PURE__ */ new Map();
     for (const declared of code.matchAll(
-      /(?:\b(?:let|var)\s+|[(,]\s*(?:[A-Za-z_]\w*\s+)?)([A-Za-z_]\w*)\s*:\s*(?:([A-Z]\w*(?:\.\w+)*)\s*([?!])?|[[(])|\b(?:let|var|for)\s+([A-Za-z_]\w*)\b(?!\s*:)|[{,]\s*([A-Za-z_]\w*)\s+in\b/g
+      /(?:\b(?:let|var)\s+|[(,]\s*(?:[A-Za-z_]\w*\s+)?)([A-Za-z_]\w*)\s*:\s*(?:(?:any\s+)?([A-Z]\w*(?:\.\w+)*)\s*([?!])?|[[(])|\b(?:let|var|for)\s+([A-Za-z_]\w*)\b(?!\s*:)|[{,]\s*([A-Za-z_]\w*)\s+in\b/g
     )) {
       const name2 = declared[1] ?? declared[4] ?? declared[5];
       const list2 = declarations.get(name2) ?? [];
-      list2.push({ at: declared.index, type: declared[3] ? "" : declared[2] ?? "" });
+      let type = declared[3] ? "" : declared[2] ?? "";
+      if (!type && declared[4]) {
+        const lookup = /^\s*=\s*NSClassFromString\s*\(/.exec(
+          code.slice(declared.index + declared[0].length)
+        );
+        if (lookup) {
+          const open = declared.index + declared[0].length + lookup[0].length - 1;
+          type = /^\s*as\?\s*([A-Za-z_]\w*(?:\.\w+)*\.Type)\b/.exec(
+            code.slice(closingParen(code, open) + 1)
+          )?.[1] ?? "";
+        }
+      }
+      const resolved = type.endsWith(".Type") ? `${resolveAliases(type.slice(0, -5), index.aliases)}.Type` : resolveAliases(type, index.aliases);
+      list2.push({ at: declared.index, type: resolved });
       declarations.set(name2, list2);
     }
     for (const pattern of code.matchAll(/\b(?:let|var|for)\s*(?=\(|\.\s*\w+\s*\()/g)) {
@@ -2905,7 +3214,7 @@ function lowerObjCRuntimeCalls(source, index) {
     }
     for (const list2 of declarations.values()) list2.sort((a, b) => a.at - b.at);
     const braces = [...code.matchAll(/[{}]/g)].map((match) => match.index);
-    const receives = (name2, at, type) => {
+    const receiverType = (name2, at) => {
       let innermost;
       for (const declared of declarations.get(name2) ?? []) {
         if (declared.at > at) break;
@@ -2913,17 +3222,31 @@ function lowerObjCRuntimeCalls(source, index) {
         if (at > from && at < to && (!innermost || from >= innermost.from))
           innermost = { from, type: declared.type };
       }
-      return innermost?.type === type;
+      return innermost?.type;
     };
     let reached = -1;
     for (const call of code.matchAll(
       /(?<![\w.])((?:type\s*\(\s*of\s*:\s*([A-Za-z_]\w*)\s*\))|[A-Za-z_]\w*)\s*\.\s*([A-Za-z_]\w*)\s*\(/g
     )) {
-      if (call.index < reached || !(call[2] ? receives(call[2], call.index, "AnyObject") : receives(call[1], call.index, "AnyClass")))
-        continue;
+      if (call.index < reached) continue;
+      const type = receiverType(call[2] ?? call[1], call.index);
+      const constructed = call[2] ? type : type?.replace(/\.Type$/, "");
+      const constructs = call[3] === "init" && constructed && (call[2] || type?.endsWith(".Type")) && index.nsObjectTypes.has(constructed.replace(/^Foundation\./, ""));
+      if (!constructs && type !== (call[2] ? "AnyObject" : "AnyClass")) continue;
       const open = call.index + call[0].length - 1;
       const shut = closingParen(code, open);
       const passed = callArguments(source, code, open, shut);
+      if (constructs && passed.length === 0) {
+        const result2 = constructed.replace(/^Foundation\./, "") === "NSObject" ? constructed : `any ${constructed}`;
+        edits.push([
+          call.index,
+          shut + 1 - call.index,
+          `_objcNSObjectDefaultInit(${call[1]}, returning: (${result2}).self)`
+        ]);
+        reached = shut + 1;
+        continue;
+      }
+      if (type !== (call[2] ? "AnyObject" : "AnyClass")) continue;
       const selector = objcSelectorName(
         call[3],
         passed.map(({ label }) => label),
@@ -3332,7 +3655,7 @@ function writeSwiftProject(layout, input, moduleRoot) {
   const targets = distribution && compileTargets(input).length === 0 ? [
     {
       name: "App",
-      path: import_node_path3.default.relative(layout.root, layout.sources),
+      path: import_node_path5.default.relative(layout.root, layout.sources),
       executable: true,
       languageMode: 5,
       mainActorIsolation: false,
@@ -3341,7 +3664,7 @@ function writeSwiftProject(layout, input, moduleRoot) {
   ] : compileTargets(input);
   const files2 = /* @__PURE__ */ new Map();
   const native = /* @__PURE__ */ new Map();
-  const headerDirectory = import_node_path3.default.join(layout.root, ".build", "peach-cxx-headers");
+  const headerDirectory = import_node_path5.default.join(layout.root, ".build", "peach-cxx-headers");
   for (const target of targets) {
     const prefix = target.path === "." ? "" : `${target.path}/`;
     const entries = Object.entries(input.files).filter(
@@ -3364,7 +3687,7 @@ function writeSwiftProject(layout, input, moduleRoot) {
         if (producer && targets.some((value) => value.name === producer))
           producers.add(producer);
         const local = [
-          import_node_path3.default.posix.join(import_node_path3.default.posix.dirname(file), include),
+          import_node_path5.default.posix.join(import_node_path5.default.posix.dirname(file), include),
           `${includes}${include}`
         ].find((candidate) => input.files[candidate] !== void 0);
         if (local) {
@@ -3386,7 +3709,7 @@ function writeSwiftProject(layout, input, moduleRoot) {
     const late = units.filter(([file]) => consumers.get(file).size > 0);
     native.set(target.name, {
       path: target.path,
-      includeDirectory: import_node_path3.default.join(layout.root, includes),
+      includeDirectory: import_node_path5.default.join(layout.root, includes),
       lateSources: late.map(([file]) => file.slice(prefix.length)),
       ...late.length > 0 ? {
         late: {
@@ -3403,7 +3726,7 @@ function writeSwiftProject(layout, input, moduleRoot) {
       ([file]) => file.startsWith(includes) && /\.(?:h|hpp|hh|hxx)$/.test(file) && consumers.get(file).size === 0
     );
     files2.set(
-      import_node_path3.default.join(layout.root, includes, "module.modulemap"),
+      import_node_path5.default.join(layout.root, includes, "module.modulemap"),
       [
         `module ${target.name} {`,
         ...roots.map(
@@ -3415,14 +3738,14 @@ function writeSwiftProject(layout, input, moduleRoot) {
       ].join("\n")
     );
   }
-  if (native.size > 0) (0, import_node_fs3.mkdirSync)(headerDirectory, { recursive: true });
-  const modulePlan = (0, import_node_crypto2.createHash)("sha256").update(
+  if (native.size > 0) (0, import_node_fs4.mkdirSync)(headerDirectory, { recursive: true });
+  const modulePlan = (0, import_node_crypto3.createHash)("sha256").update(
     swiftModuleInputFiles(moduleRoot).join("\n")
   );
   if (!distribution) {
-    modulePlan.update((0, import_node_fs3.readFileSync)(import_node_path3.default.join(moduleRoot, "Package.swift")));
+    modulePlan.update((0, import_node_fs4.readFileSync)(import_node_path5.default.join(moduleRoot, "Package.swift")));
   }
-  const resourcePlan = (0, import_node_crypto2.createHash)("sha256").update(
+  const resourcePlan = (0, import_node_crypto3.createHash)("sha256").update(
     JSON.stringify(
       resourceTargets.filter((target) => target.resources).map((target) => [
         target.name,
@@ -3447,10 +3770,10 @@ function writeSwiftProject(layout, input, moduleRoot) {
   if (targets.length === 0) {
     for (const [file, contents] of Object.entries(input.files)) {
       if (file === "Package.swift") continue;
-      files2.set(import_node_path3.default.join(layout.sources, file), compiled.get(file) ?? contents);
+      files2.set(import_node_path5.default.join(layout.sources, file), compiled.get(file) ?? contents);
     }
-    let manifest = (0, import_node_fs3.readFileSync)(
-      import_node_path3.default.join(moduleRoot, "scripts/contrast-app-Package.swift"),
+    let manifest = (0, import_node_fs4.readFileSync)(
+      import_node_path5.default.join(moduleRoot, "scripts/contrast-app-Package.swift"),
       "utf8"
     ).replaceAll("__SOOTSIM_SWIFT_PACKAGE__", moduleRoot);
     const reactor = `          ${REACTOR_FLAG}`;
@@ -3494,21 +3817,21 @@ function writeSwiftProject(layout, input, moduleRoot) {
       manifest = manifest.replace(anchor, `${anchor}
         ${SPRITEKIT_PRODUCT},`);
     }
-    files2.set(import_node_path3.default.join(layout.root, "Package.swift"), manifest + moduleFiles);
+    files2.set(import_node_path5.default.join(layout.root, "Package.swift"), manifest + moduleFiles);
   } else {
     const base = layout.multi ? layout.root : layout.sources;
     const libraries = /* @__PURE__ */ new Map();
     for (const [target, data] of Object.entries(input.libraries ?? {})) {
-      const file = import_node_path3.default.join(layout.root, ".peach-libraries", `lib${target}.a`);
+      const file = import_node_path5.default.join(layout.root, ".peach-libraries", `lib${target}.a`);
       files2.set(file, Buffer.from(data, "base64"));
       libraries.set(target, file);
     }
     for (const [file, contents] of Object.entries(input.files)) {
       if (file === "Package.swift") continue;
-      files2.set(import_node_path3.default.join(base, file), compiled.get(file) ?? contents);
+      files2.set(import_node_path5.default.join(base, file), compiled.get(file) ?? contents);
     }
     files2.set(
-      import_node_path3.default.join(layout.root, "Package.swift"),
+      import_node_path5.default.join(layout.root, "Package.swift"),
       emitSwiftPackageManifest({
         targets,
         native,
@@ -3525,7 +3848,7 @@ function writeSwiftProject(layout, input, moduleRoot) {
         spriteKit: importsSpriteKit(input.files),
         distribution: distribution ?? void 0,
         distributionLink: {
-          path: import_node_path3.default.join(layout.root, ".peach-distribution-objects.rsp"),
+          path: import_node_path5.default.join(layout.root, ".peach-distribution-objects.rsp"),
           files: files2
         },
         libraries
@@ -3541,9 +3864,9 @@ function writeSwiftProject(layout, input, moduleRoot) {
       throw new Error(
         `swift resource target ${target.name} has no matching bundle assignment`
       );
-    const directory = layout.multi ? import_node_path3.default.join(layout.root, target.path) : layout.sources;
+    const directory = layout.multi ? import_node_path5.default.join(layout.root, target.path) : layout.sources;
     files2.set(
-      import_node_path3.default.join(directory, "ResourceBundleAccessor.generated.swift"),
+      import_node_path5.default.join(directory, "ResourceBundleAccessor.generated.swift"),
       [
         "import Foundation",
         "",
@@ -3576,15 +3899,15 @@ function outputOf(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function builtArtifact(layout) {
-  const binDir = import_node_path3.default.join(layout.root, ".build", WASM_TRIPLE, "release");
-  const manifest = (0, import_node_fs3.readFileSync)(import_node_path3.default.join(layout.root, "Package.swift"), "utf8");
+  const binDir = import_node_path5.default.join(layout.root, ".build", WASM_TRIPLE, "release");
+  const manifest = (0, import_node_fs4.readFileSync)(import_node_path5.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_path3.default.join(binDir, `${executable.name}.wasm`);
-  if (!(0, import_node_fs3.existsSync)(file)) {
-    const found = (0, import_node_fs3.existsSync)(binDir) ? (0, import_node_fs3.readdirSync)(binDir).filter((name2) => name2.endsWith(".wasm")).sort() : [];
+  const file = import_node_path5.default.join(binDir, `${executable.name}.wasm`);
+  if (!(0, import_node_fs4.existsSync)(file)) {
+    const found = (0, import_node_fs4.existsSync)(binDir) ? (0, import_node_fs4.readdirSync)(binDir).filter((name2) => name2.endsWith(".wasm")).sort() : [];
     throw new Error(
       `swift-compile: the build produced no ${executable.name}.wasm (found: ${found.join(", ") || "none"})`
     );
@@ -3593,7 +3916,7 @@ function builtArtifact(layout) {
 }
 function projectDiagnostic(output, layout, files2) {
   const base = layout.multi ? layout.root : layout.sources;
-  const prefix = `${base}${import_node_path3.default.sep}`;
+  const prefix = `${base}${import_node_path5.default.sep}`;
   return designTimeDiagnostic(output, files2).split("\n").map((line) => line.startsWith(prefix) ? line.slice(prefix.length) : line).join("\n").trim();
 }
 function serialize(root, work, signal) {
@@ -3626,13 +3949,13 @@ function serialize(root, work, signal) {
 function readCompiledArtifact(directory, hash) {
   try {
     const receipt = JSON.parse(
-      (0, import_node_fs3.readFileSync)(import_node_path3.default.join(directory, "artifact.json"), "utf8")
+      (0, import_node_fs4.readFileSync)(import_node_path5.default.join(directory, "artifact.json"), "utf8")
     );
     if (!receipt || typeof receipt !== "object" || !("hash" in receipt) || receipt.hash !== hash || !("icu" in receipt) || typeof receipt.icu !== "string" || !("wasm" in receipt) || typeof receipt.wasm !== "string")
       return null;
-    const bytes = (0, import_node_fs3.readFileSync)(import_node_path3.default.join(directory, "app.wasm"));
-    const gzip2 = (0, import_node_fs3.readFileSync)(import_node_path3.default.join(directory, "icu.gz"));
-    if ((0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex") !== receipt.wasm || (0, import_node_crypto2.createHash)("sha256").update(gzip2).digest("hex") !== receipt.icu || bytes.length < 8 || bytes.readUInt32LE(0) !== 1836278016 || bytes.readUInt32LE(4) !== 1)
+    const bytes = (0, import_node_fs4.readFileSync)(import_node_path5.default.join(directory, "app.wasm"));
+    const gzip2 = (0, import_node_fs4.readFileSync)(import_node_path5.default.join(directory, "icu.gz"));
+    if ((0, import_node_crypto3.createHash)("sha256").update(bytes).digest("hex") !== receipt.wasm || (0, import_node_crypto3.createHash)("sha256").update(gzip2).digest("hex") !== receipt.icu || bytes.length < 8 || bytes.readUInt32LE(0) !== 1836278016 || bytes.readUInt32LE(4) !== 1)
       return null;
     return { hash, bytes, icu: { sha256: receipt.icu, gzip: gzip2 } };
   } catch (error) {
@@ -3642,25 +3965,25 @@ function readCompiledArtifact(directory, hash) {
   }
 }
 function saveCompiledArtifact(root, artifact) {
-  const directory = import_node_path3.default.join(root, "artifact");
-  (0, import_node_fs3.mkdirSync)(directory, { recursive: true });
-  const pending = (0, import_node_fs3.mkdtempSync)(import_node_path3.default.join(root, ".artifact-"));
+  const directory = import_node_path5.default.join(root, "artifact");
+  (0, import_node_fs4.mkdirSync)(directory, { recursive: true });
+  const pending = (0, import_node_fs4.mkdtempSync)(import_node_path5.default.join(root, ".artifact-"));
   try {
-    (0, import_node_fs3.writeFileSync)(import_node_path3.default.join(pending, "app.wasm"), artifact.bytes);
-    (0, import_node_fs3.writeFileSync)(import_node_path3.default.join(pending, "icu.gz"), artifact.icu.gzip);
-    (0, import_node_fs3.writeFileSync)(
-      import_node_path3.default.join(pending, "artifact.json"),
+    (0, import_node_fs4.writeFileSync)(import_node_path5.default.join(pending, "app.wasm"), artifact.bytes);
+    (0, import_node_fs4.writeFileSync)(import_node_path5.default.join(pending, "icu.gz"), artifact.icu.gzip);
+    (0, import_node_fs4.writeFileSync)(
+      import_node_path5.default.join(pending, "artifact.json"),
       JSON.stringify({
         hash: artifact.hash,
-        wasm: (0, import_node_crypto2.createHash)("sha256").update(artifact.bytes).digest("hex"),
+        wasm: (0, import_node_crypto3.createHash)("sha256").update(artifact.bytes).digest("hex"),
         icu: artifact.icu.sha256
       })
     );
     for (const file of ["app.wasm", "icu.gz", "artifact.json"]) {
-      (0, import_node_fs3.renameSync)(import_node_path3.default.join(pending, file), import_node_path3.default.join(directory, file));
+      (0, import_node_fs4.renameSync)(import_node_path5.default.join(pending, file), import_node_path5.default.join(directory, file));
     }
   } finally {
-    (0, import_node_fs3.rmSync)(pending, { recursive: true, force: true });
+    (0, import_node_fs4.rmSync)(pending, { recursive: true, force: true });
   }
 }
 function retain(root, artifact) {
@@ -3675,42 +3998,54 @@ function retain(root, artifact) {
 }
 function compileSwiftProjectUnit(input, options) {
   options.signal?.throwIfAborted();
-  (0, import_node_fs3.mkdirSync)(options.buildRoot, { recursive: true });
-  const root = (0, import_node_fs3.realpathSync)(options.buildRoot);
-  const moduleRoot = import_node_path3.default.resolve(options.moduleRoot);
+  (0, import_node_fs4.mkdirSync)(options.buildRoot, { recursive: true });
+  const root = (0, import_node_fs4.realpathSync)(options.buildRoot);
+  const moduleRoot = import_node_path5.default.resolve(options.moduleRoot);
   const layout = {
     root,
-    sources: import_node_path3.default.join(root, "Sources", "App"),
+    sources: import_node_path5.default.join(root, "Sources", "App"),
     multi: compileTargets(input).length > 0
   };
   const hash = swiftArtifactHash(input, options.release, moduleRoot);
+  const sharedRoot = import_node_path5.default.join(rnxHomeDir(), "cache", "swift-projects", hash);
+  const report = (message) => console.error(`[swift-project ${hash.slice(0, 16)}] ${message}`);
+  report("checking verified artifacts");
   return serialize(
     root,
     async () => {
       const retained = retainedArtifacts.get(root)?.find((old) => old.hash === hash);
-      if (retained) return retain(root, retained);
-      const cached2 = readCompiledArtifact(import_node_path3.default.join(root, "artifact"), hash);
-      if (cached2) return retain(root, cached2);
-      if (process.platform === "darwin" && process.env.TM_SESSION && !admittedMacBuilderSlot() && process.env.CI !== "true" && moduleRoot === import_node_path3.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift") && !swiftDistributionAt(moduleRoot)) {
-        const requestRoot = (0, import_node_fs3.mkdtempSync)(import_node_path3.default.join(root, ".builder-request-"));
-        const output = import_node_path3.default.join(requestRoot, "output");
-        const request = import_node_path3.default.join(requestRoot, "request.json");
-        (0, import_node_fs3.writeFileSync)(
+      if (retained) {
+        report("reusing memory artifact");
+        return retain(root, retained);
+      }
+      const cached2 = readCompiledArtifact(import_node_path5.default.join(sharedRoot, "artifact"), hash);
+      const previous = cached2 ?? readCompiledArtifact(import_node_path5.default.join(root, "artifact"), hash);
+      if (previous) {
+        if (!cached2) saveCompiledArtifact(sharedRoot, previous);
+        report("reusing verified disk artifact");
+        return retain(root, previous);
+      }
+      if (process.platform === "darwin" && process.env.TM_SESSION && !admittedMacBuilderSlot() && process.env.CI !== "true" && moduleRoot === import_node_path5.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift") && !swiftDistributionAt(moduleRoot)) {
+        const requestRoot = (0, import_node_fs4.mkdtempSync)(import_node_path5.default.join(root, ".builder-request-"));
+        const output = import_node_path5.default.join(requestRoot, "output");
+        const request = import_node_path5.default.join(requestRoot, "request.json");
+        (0, import_node_fs4.writeFileSync)(
           request,
           JSON.stringify({
             input,
             hash,
             release: options.release,
             timeoutMs: options.timeoutMs,
-            buildKey: (0, import_node_crypto2.createHash)("sha256").update(root).digest("hex").slice(0, 32)
+            buildKey: (0, import_node_crypto3.createHash)("sha256").update(root).digest("hex").slice(0, 32)
           })
         );
         try {
-          const repo = import_node_path3.default.resolve(moduleRoot, "../..");
+          const repo = import_node_path5.default.resolve(moduleRoot, "../..");
+          report("requesting builder admission or cached result");
           await runCompiler(
             "bun",
             [
-              import_node_path3.default.join(repo, "scripts/build/swift-project.ts"),
+              import_node_path5.default.join(repo, "scripts/build/swift-project.ts"),
               "--request",
               request,
               "--output",
@@ -3734,18 +4069,21 @@ function compileSwiftProjectUnit(input, options) {
             );
           }
           saveCompiledArtifact(root, artifact2);
+          saveCompiledArtifact(sharedRoot, artifact2);
+          report("builder artifact verified");
           return retain(root, artifact2);
         } finally {
-          (0, import_node_fs3.rmSync)(requestRoot, { recursive: true, force: true });
+          (0, import_node_fs4.rmSync)(requestRoot, { recursive: true, force: true });
         }
       }
       writeSwiftProject(layout, input, moduleRoot);
-      const swift = import_node_path3.default.join(options.toolchainBin, "swift");
-      if (!(0, import_node_fs3.existsSync)(swift)) {
+      const swift = import_node_path5.default.join(options.toolchainBin, "swift");
+      if (!(0, import_node_fs4.existsSync)(swift)) {
         throw new Error(
           `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`
         );
       }
+      report("preparing compiler plugins");
       const macroPlugins = await ensureMacroPlugins(
         moduleRoot,
         options.toolchainBin,
@@ -3785,8 +4123,8 @@ function compileSwiftProjectUnit(input, options) {
           // shipped host plugins resolve against the selected compiler's runtime.
           ...process.platform === "linux" ? {
             LD_LIBRARY_PATH: [
-              import_node_path3.default.resolve(options.toolchainBin, "../lib/swift/linux"),
-              import_node_path3.default.resolve(options.toolchainBin, "../lib/swift/host"),
+              import_node_path5.default.resolve(options.toolchainBin, "../lib/swift/linux"),
+              import_node_path5.default.resolve(options.toolchainBin, "../lib/swift/host"),
               process.env.LD_LIBRARY_PATH
             ].filter(Boolean).join(":")
           } : {}
@@ -3795,21 +4133,22 @@ function compileSwiftProjectUnit(input, options) {
         timeout: options.timeoutMs,
         signal: options.signal
       };
+      report("compiling and linking Swift modules");
       try {
-        await runCompiler(swift, buildArgs, buildOptions);
+        await runCompiler(swift, buildArgs, buildOptions, true);
       } catch (error) {
         const output = outputOf(error);
-        const moduleCache = import_node_path3.default.join(
+        const moduleCache = import_node_path5.default.join(
           root,
           ".build",
           WASM_TRIPLE,
           "release",
           "ModuleCache"
         );
-        if (output.includes("was compiled with module cache path") && (0, import_node_fs3.existsSync)(moduleCache)) {
-          (0, import_node_fs3.rmSync)(moduleCache, { recursive: true, force: true });
+        if (output.includes("was compiled with module cache path") && (0, import_node_fs4.existsSync)(moduleCache)) {
+          (0, import_node_fs4.rmSync)(moduleCache, { recursive: true, force: true });
           try {
-            await runCompiler(swift, buildArgs, buildOptions);
+            await runCompiler(swift, buildArgs, buildOptions, true);
           } catch (retryError) {
             throw new Error(
               projectDiagnostic(outputOf(retryError), layout, input.files),
@@ -3826,25 +4165,28 @@ function compileSwiftProjectUnit(input, options) {
       }
       const artifact = {
         hash,
-        bytes: (0, import_node_fs3.readFileSync)(builtArtifact(layout)),
+        bytes: (0, import_node_fs4.readFileSync)(builtArtifact(layout)),
         icu: await icu
       };
       saveCompiledArtifact(root, artifact);
+      saveCompiledArtifact(sharedRoot, artifact);
+      report("compiled artifact verified");
       return retain(root, artifact);
     },
     options.signal
   );
 }
-var import_node_child_process3, import_node_crypto2, import_node_fs3, import_node_os2, import_node_path3, WASM_TRIPLE, BUILD_JOBS, linkedModuleDigests, OPTIONAL_FRAMEWORK_DEPENDENCIES, OPTIONAL_FRAMEWORKS, SWIFT_IMPORT, sdkPaths, availableModules, ONE_PRODUCT, SPRITEKIT_PRODUCT, importsSpriteKit, FOUNDATION_IMPLICIT_MODULES, FOUNDATION_IMPLICIT_FLAGS, ONE_IMPLICIT_FLAGS, EXECUTABLE_LINK_FLAGS, REACTOR_FLAG, MULTI_MANIFEST_VERSION, DIRECTIVE, OS_IOS, OBJC_ATTRIBUTE, SELECTOR, PROTOCOL_NAME, KEY_PATH, TYPE_AFTER_ATTRIBUTE, DELEGATE_CLASS, REUSABLE_INIT, REUSABLE_VIEW_BASES, CLASS_BASE, FRAME_INIT, APPLE_CLASS, EXTENSION_DECL, CLASS_DECL, MODIFIERS, OVERRIDE_FUNC, OVERRIDE_VAR, OBJC_PROTOCOL, OBJC_PREPOSITIONS, DECLARATION_MODIFIERS, optionalResult, SDK_OBJC_OPTIONAL, IMP_CONVENTION, ROOT_LOCKS, host, rootLocks, retainedArtifacts;
+var import_node_child_process4, import_node_crypto3, import_node_fs4, import_node_os4, import_node_path5, WASM_TRIPLE, BUILD_JOBS, linkedModuleDigests, OPTIONAL_FRAMEWORK_DEPENDENCIES, OPTIONAL_FRAMEWORKS, SWIFT_IMPORT, sdkPaths, availableModules, ONE_PRODUCT, SPRITEKIT_PRODUCT, importsSpriteKit, FOUNDATION_IMPLICIT_MODULES, FOUNDATION_IMPLICIT_FLAGS, ONE_IMPLICIT_FLAGS, EXECUTABLE_LINK_FLAGS, REACTOR_FLAG, MULTI_MANIFEST_VERSION, DIRECTIVE, OS_IOS, OBJC_ATTRIBUTE, SELECTOR, PROTOCOL_NAME, KEY_PATH, TYPE_AFTER_ATTRIBUTE, DELEGATE_CLASS, REUSABLE_INIT, REUSABLE_VIEW_BASES, CLASS_BASE, FRAME_INIT, APPLE_CLASS, EXTENSION_DECL, CLASS_DECL, MODIFIERS, OVERRIDE_FUNC, OVERRIDE_VAR, APPLE_PROTOCOL, OBJC_PROTOCOL, OBJC_PREPOSITIONS, DECLARATION_MODIFIERS, optionalResult, SDK_OBJC_OPTIONAL, IMP_CONVENTION, ROOT_LOCKS, host, rootLocks, retainedArtifacts;
 var init_swift_compile = __esm({
   "src/swift-compile.ts"() {
     "use strict";
-    import_node_child_process3 = require("node:child_process");
-    import_node_crypto2 = require("node:crypto");
-    import_node_fs3 = require("node:fs");
-    import_node_os2 = __toESM(require("node:os"), 1);
-    import_node_path3 = __toESM(require("node:path"), 1);
+    import_node_child_process4 = require("node:child_process");
+    import_node_crypto3 = require("node:crypto");
+    import_node_fs4 = require("node:fs");
+    import_node_os4 = __toESM(require("node:os"), 1);
+    import_node_path5 = __toESM(require("node:path"), 1);
     init_admitted_mac_build();
+    init_home_paths();
     init_process_group();
     init_swift_design_time();
     init_swift_distribution_contract();
@@ -3853,7 +4195,7 @@ var init_swift_compile = __esm({
     init_swiftContract();
     WASM_TRIPLE = "wasm32-unknown-wasip1";
     BUILD_JOBS = String(
-      Math.min(4, Math.max(1, Math.floor(import_node_os2.default.availableParallelism() / 2)))
+      Math.min(4, Math.max(1, Math.floor(import_node_os4.default.availableParallelism() / 2)))
     );
     linkedModuleDigests = /* @__PURE__ */ new Map();
     OPTIONAL_FRAMEWORK_DEPENDENCIES = {
@@ -3946,6 +4288,7 @@ var init_swift_compile = __esm({
     MODIFIERS = /(?:^|\s)(public|open|internal|fileprivate|private|final|nonisolated|@MainActor)(?=\s)/g;
     OVERRIDE_FUNC = /^override((?:\s+(?:public|open|internal|fileprivate|private|final|nonisolated|dynamic|@\w+))*)\s+func\s+([A-Za-z_]\w*)\s*(<[^>{}]*>)?\s*\(/;
     OVERRIDE_VAR = /^override((?:\s+(?:public|open|internal|fileprivate|private|final|nonisolated|dynamic|@\w+))*)\s+var\s+([A-Za-z_]\w*)\s*:\s*([^{=]+?)\s*\{/;
+    APPLE_PROTOCOL = /^NS(?:Mutable)?Copying$|^NS(?:Secure)?Coding$|^NSLocking$|^NSFastEnumeration$|^NSObjectProtocol$|(?:Delegate|DataSource)$/;
     OBJC_PROTOCOL = /@objc\b(?:\s*\([^()]*\))?(?:\s+(?:@\w+(?:\([^()]*\))?|public|internal|fileprivate|private|package))*\s+protocol\s+([A-Za-z_]\w*)[^{]*\{/g;
     OBJC_PREPOSITIONS = /* @__PURE__ */ new Set([
       "above",
@@ -5413,156 +5756,188 @@ var init_product = __esm({
 
 // ../contrast-runtime-delivery/src/index.ts
 async function installVerifiedTarball(tarball) {
-  const { url, digest: digest2, destDir, installedMarker, label } = tarball;
-  const downloadDir = import_node_fs4.default.mkdtempSync(import_node_path4.default.join(import_node_os3.default.tmpdir(), "runtime-delivery-download-"));
-  const archivePath = import_node_path4.default.join(downloadDir, "archive");
-  import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(destDir), { recursive: true });
-  const tmpDir = import_node_fs4.default.mkdtempSync(
-    import_node_path4.default.join(import_node_path4.default.dirname(destDir), `.installing-${import_node_path4.default.basename(destDir)}-`)
+  const { url, digest: digest2, destDir, installedMarker, label, signal } = tarball;
+  signal?.throwIfAborted();
+  const downloadDir = import_node_fs5.default.mkdtempSync(import_node_path6.default.join(import_node_os5.default.tmpdir(), "runtime-delivery-download-"));
+  const archivePath = import_node_path6.default.join(downloadDir, "archive");
+  import_node_fs5.default.mkdirSync(import_node_path6.default.dirname(destDir), { recursive: true });
+  const tmpDir = import_node_fs5.default.mkdtempSync(
+    import_node_path6.default.join(import_node_path6.default.dirname(destDir), `.installing-${import_node_path6.default.basename(destDir)}-`)
   );
   try {
-    await downloadToFile(url, archivePath);
-    const actual = await digestFile(archivePath, digest2.algorithm, digest2.encoding);
+    await downloadToFile(url, archivePath, signal);
+    const actual = await digestFile(
+      archivePath,
+      digest2.algorithm,
+      digest2.encoding,
+      signal
+    );
     if (actual !== digest2.value) {
       throw new Error(
         `${digest2.algorithm} mismatch for ${label}: expected ${digest2.value}, actual ${actual}`
       );
     }
-    if (new URL(url).pathname.endsWith(".zip")) await extractZip(archivePath, tmpDir);
-    else await extractTarball(archivePath, tmpDir, tarball.stripComponents ?? 0);
-    if (!import_node_fs4.default.existsSync(import_node_path4.default.join(tmpDir, installedMarker))) {
+    if (new URL(url).pathname.endsWith(".zip"))
+      await extractZip(archivePath, tmpDir, signal);
+    else await extractTarball(archivePath, tmpDir, tarball.stripComponents ?? 0, signal);
+    signal?.throwIfAborted();
+    if (!import_node_fs5.default.existsSync(import_node_path6.default.join(tmpDir, installedMarker))) {
       throw new Error(`extracted tarball for ${label} is missing ${installedMarker}`);
     }
     tarball.verify?.(tmpDir);
+    signal?.throwIfAborted();
     try {
-      import_node_fs4.default.renameSync(tmpDir, destDir);
+      import_node_fs5.default.renameSync(tmpDir, destDir);
     } catch (err) {
       if (!isErrnoCode(err, "ENOTEMPTY", "EEXIST")) throw err;
       const aside = `${tmpDir}-replaced`;
       try {
-        import_node_fs4.default.renameSync(destDir, aside);
+        import_node_fs5.default.renameSync(destDir, aside);
       } catch (moveErr) {
         if (!isErrnoCode(moveErr, "ENOENT")) throw moveErr;
       }
       try {
-        import_node_fs4.default.renameSync(tmpDir, destDir);
+        import_node_fs5.default.renameSync(tmpDir, destDir);
       } catch (landErr) {
-        if (!isErrnoCode(landErr, "ENOTEMPTY", "EEXIST") || !import_node_fs4.default.existsSync(import_node_path4.default.join(destDir, installedMarker))) {
+        if (!isErrnoCode(landErr, "ENOTEMPTY", "EEXIST") || !import_node_fs5.default.existsSync(import_node_path6.default.join(destDir, installedMarker))) {
           throw landErr;
         }
       } finally {
-        import_node_fs4.default.rmSync(aside, { recursive: true, force: true });
+        import_node_fs5.default.rmSync(aside, { recursive: true, force: true });
       }
     }
   } finally {
-    import_node_fs4.default.rmSync(tmpDir, { recursive: true, force: true });
-    import_node_fs4.default.rmSync(downloadDir, { recursive: true, force: true });
+    import_node_fs5.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs5.default.rmSync(downloadDir, { recursive: true, force: true });
   }
 }
 function isErrnoCode(err, ...codes) {
   return err instanceof Error && "code" in err && codes.includes(String(err.code));
 }
-async function downloadToFile(url, destPath) {
-  const res = await fetch(url);
+async function downloadToFile(url, destPath, signal) {
+  const res = await fetch(url, { signal });
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(destPath), { recursive: true });
+  import_node_fs5.default.mkdirSync(import_node_path6.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises2.pipeline)(
       import_node_stream.Readable.fromWeb(res.body),
-      import_node_fs4.default.createWriteStream(tmp)
+      import_node_fs5.default.createWriteStream(tmp),
+      { signal }
     );
-    import_node_fs4.default.renameSync(tmp, destPath);
+    signal?.throwIfAborted();
+    import_node_fs5.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_node_fs4.default.unlinkSync(tmp);
+      import_node_fs5.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
   }
 }
-function digestFile(filePath, algorithm, encoding) {
-  return new Promise((resolve2, reject) => {
-    const hash = import_node_crypto3.default.createHash(algorithm);
-    const stream = import_node_fs4.default.createReadStream(filePath);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("error", reject);
-    stream.on("end", () => resolve2(hash.digest(encoding)));
-  });
+async function digestFile(filePath, algorithm, encoding, signal) {
+  const hash = import_node_crypto4.default.createHash(algorithm);
+  await (0, import_promises2.pipeline)(import_node_fs5.default.createReadStream(filePath), hash, { signal });
+  return hash.digest(encoding);
 }
-function extractZip(zipPath, destDir) {
-  return runExtractor("ditto", ["-x", "-k", zipPath, destDir]);
+function extractZip(zipPath, destDir, signal) {
+  return runExtractor("ditto", ["-x", "-k", zipPath, destDir], signal);
 }
-function extractTarball(tarPath, destDir, stripComponents) {
+function extractTarball(tarPath, destDir, stripComponents, signal) {
   const args = ["-xzf", tarPath, "-C", destDir];
   if (stripComponents > 0) args.push(`--strip-components=${stripComponents}`);
-  return runExtractor("tar", args);
+  return runExtractor("tar", args, signal);
 }
-function runExtractor(command, args) {
-  return new Promise((resolve2, reject) => {
-    const child = (0, import_node_child_process4.spawn)(command, args, {
-      stdio: ["ignore", "inherit", "inherit"]
+async function runExtractor(command, args, signal) {
+  signal?.throwIfAborted();
+  const child = (0, import_node_child_process5.spawn)(command, args, {
+    stdio: ["ignore", "inherit", "inherit"],
+    detached: process.platform !== "win32"
+  });
+  let stopping;
+  const abort = () => {
+    stopping ??= terminateProcessGroup(child, "SIGKILL", 0);
+    void stopping.catch(() => {
     });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code === 0) resolve2();
-      else reject(new Error(`${command} exited with code ${code}`));
+  };
+  try {
+    await new Promise((resolve2, reject) => {
+      let failure2;
+      child.on("error", (error) => {
+        failure2 = error;
+      });
+      child.on("close", (code) => {
+        if (signal?.aborted) {
+          const reason = signal.reason;
+          reject(
+            reason instanceof Error ? reason : new Error("Extraction canceled", { cause: reason })
+          );
+        } else if (failure2) reject(failure2);
+        else if (code === 0) resolve2();
+        else reject(new Error(`${command} exited with code ${code}`));
+      });
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
     });
-  });
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    await stopping;
+  }
 }
-var import_node_child_process4, import_node_crypto3, import_node_fs4, import_node_os3, import_node_path4, import_node_stream, import_promises2;
+var import_node_child_process5, import_node_crypto4, import_node_fs5, import_node_os5, import_node_path6, import_node_stream, import_promises2;
 var init_src = __esm({
   "../contrast-runtime-delivery/src/index.ts"() {
     "use strict";
-    import_node_child_process4 = require("node:child_process");
-    import_node_crypto3 = __toESM(require("node:crypto"), 1);
-    import_node_fs4 = __toESM(require("node:fs"), 1);
-    import_node_os3 = __toESM(require("node:os"), 1);
-    import_node_path4 = __toESM(require("node:path"), 1);
+    import_node_child_process5 = require("node:child_process");
+    import_node_crypto4 = __toESM(require("node:crypto"), 1);
+    import_node_fs5 = __toESM(require("node:fs"), 1);
+    import_node_os5 = __toESM(require("node:os"), 1);
+    import_node_path6 = __toESM(require("node:path"), 1);
     import_node_stream = require("node:stream");
     import_promises2 = require("node:stream/promises");
+    init_process_group();
     init_product();
     init_product();
   }
 });
 
-// src/home-paths.ts
-function rnxHomeDir() {
-  const override = process.env[PEACH_HOME_ENV];
-  if (override && override.length > 0) return import_node_path5.default.resolve(override);
-  return import_node_path5.default.join((0, import_node_os4.homedir)(), ".peach");
-}
-function electronDir() {
-  return import_node_path5.default.join(rnxHomeDir(), "electron");
-}
-function electronUserDataDir() {
-  return import_node_path5.default.join(electronDir(), "userData");
-}
-var import_node_os4, import_node_path5, PEACH_HOME_ENV, DAEMON_LOCKFILE_MAX_BYTES;
-var init_home_paths = __esm({
-  "src/home-paths.ts"() {
-    "use strict";
-    import_node_os4 = require("node:os");
-    import_node_path5 = __toESM(require("node:path"), 1);
-    PEACH_HOME_ENV = "PEACH_HOME";
-    DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
-  }
-});
-
 // src/swift-distribution.lock.json
 var swift_distribution_lock_default;
 var init_swift_distribution_lock = __esm({
   "src/swift-distribution.lock.json"() {
     swift_distribution_lock_default = {
-      id: "64fd4ea71bc39e4f",
+      id: "1fda1fb984f25758",
       release: "swift-6.4.0-RELEASE",
-      wasmSdkId: "swift-6.4.0-RELEASE_wasm-peach-dc9c8c67",
-      wasmSdkUrl: "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-dc9c8c67.artifactbundle.tar.gz",
-      wasmSdkChecksum: "5d38f795f516ccfef3d7ac869b447cdedcd82a35af9761a65b9f88924eb6a89a",
-      source: "77fbca997182e53ceb1944e27d8689f469f632c5",
+      wasmSdkId: "swift-6.4.0-RELEASE_wasm-peach-34b989c2",
+      wasmSdkUrl: "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-34b989c2.artifactbundle.tar.gz",
+      wasmSdkChecksum: "1598ac9d063e07b20aa6232acb03c7147c9a94abf989d51f1e55688eb4aba854",
+      source: "078b4f63d3734871dc1fbea898005e2ef95a73cb",
       targets: [
+        "System",
+        "_LocationEssentials",
+        "GeoToolbox",
+        "DataDetection",
+        "Accessibility",
+        "Contacts",
+        "CoreML",
+        "EventKit",
+        "CloudKit",
+        "IOSurface",
+        "OpenGLES",
+        "ContactsUI",
+        "CoreLocationUI",
+        "MediaPlayer",
+        "MusicKit",
+        "RealityKit",
+        "SecureElementCredential",
+        "Social",
+        "Speech",
+        "Vision",
+        "VisionKit",
+        "WorkoutKit",
+        "_PassKit_SwiftUI",
         "ExpoModulesCore",
         "_MapKit_SwiftUI",
         "PeachJSON",
@@ -5578,6 +5953,7 @@ var init_swift_distribution_lock = __esm({
         "PeachObjC",
         "UIKitCore",
         "PeachICU",
+        "PeachCMark",
         "CoreImage",
         "QuartzCore",
         "CoreGraphics",
@@ -5608,6 +5984,7 @@ var init_swift_distribution_lock = __esm({
         "ActivityKit",
         "SwiftData",
         "UIKit",
+        "React",
         "Combine",
         "PeachFoundationCombine",
         "AppIntents",
@@ -5689,6 +6066,7 @@ var init_swift_distribution_lock = __esm({
         systemVersion: ["string"],
         colorScheme: ["string:light", "string:dark"],
         semanticColors: ["object"],
+        imageAssets: ["object"],
         locale: ["string"],
         dynamicTypeSize: [
           "string:xSmall",
@@ -5710,16 +6088,16 @@ var init_swift_distribution_lock = __esm({
       },
       hosts: {
         "darwin-arm64": {
-          sha256: "6b60bae2bc91957af3baee5e9cad44200f15ff3840d8e70afa5ddc63413d880f",
-          size: 58565898
+          sha256: "6a3b956b13bcc76dbf0b55533088251e2ae29badcd5c8d66394a2459e0942a32",
+          size: 63180761
         },
         "linux-x64": {
-          sha256: "d97e287ca5d7ea0d00dfc9db60be746aec35a9b7412299461ce0d5e77f38b7a8",
-          size: 58569694
+          sha256: "37f26adff0a90c0647065b3c2e70bfdae05c84832b27add00915d441f2f79359",
+          size: 63183751
         },
         "linux-arm64": {
-          sha256: "495fe6adc7cf1c8ec9fc8de3410c976e65a7ff051ca50ee3f6d0d3fee8aa2c5d",
-          size: 58567328
+          sha256: "e329424d19ede87f4c9257de40f88220cdaff42bd82f1ab47616394ec7f32f35",
+          size: 63181548
         }
       }
     };
@@ -5732,24 +6110,24 @@ function swiftCompilerRelease(release) {
 }
 function swiftToolchainBin(release) {
   if (process.platform === "darwin") {
-    const dirs = [import_node_os5.default.homedir(), "/"].map(
-      (base) => import_node_path6.default.join(base, `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`)
+    const dirs = [import_node_os6.default.homedir(), "/"].map(
+      (base) => import_node_path7.default.join(base, `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`)
     );
-    return dirs.find((dir) => import_node_fs5.default.existsSync(import_node_path6.default.join(dir, "swift"))) ?? dirs[0];
+    return dirs.find((dir) => import_node_fs6.default.existsSync(import_node_path7.default.join(dir, "swift"))) ?? dirs[0];
   }
   if (process.env.CONTRAST_SWIFT_TOOLCHAINS) {
-    return import_node_path6.default.join(process.env.CONTRAST_SWIFT_TOOLCHAINS, release, "usr/bin");
+    return import_node_path7.default.join(process.env.CONTRAST_SWIFT_TOOLCHAINS, release, "usr/bin");
   }
-  const image = import_node_path6.default.join("/opt/swift", release, "usr/bin");
-  if (import_node_fs5.default.existsSync(import_node_path6.default.join(image, "swift"))) return image;
-  return (process.env.PATH ?? "").split(import_node_path6.default.delimiter).find((dir) => dir && import_node_fs5.default.existsSync(import_node_path6.default.join(dir, "swift"))) ?? image;
+  const image = import_node_path7.default.join("/opt/swift", release, "usr/bin");
+  if (import_node_fs6.default.existsSync(import_node_path7.default.join(image, "swift"))) return image;
+  return (process.env.PATH ?? "").split(import_node_path7.default.delimiter).find((dir) => dir && import_node_fs6.default.existsSync(import_node_path7.default.join(dir, "swift"))) ?? image;
 }
 function swiftToolchain(release, sdk) {
   const cached2 = verified.get(`${release}\0${sdk.wasmSdkId}`);
   if (cached2) return cached2;
   const bin = swiftToolchainBin(release);
-  const swift = import_node_path6.default.join(bin, "swift");
-  const version = import_node_fs5.default.existsSync(swift) ? (0, import_node_child_process5.execFileSync)(swift, ["--version"], {
+  const swift = import_node_path7.default.join(bin, "swift");
+  const version = import_node_fs6.default.existsSync(swift) ? (0, import_node_child_process6.execFileSync)(swift, ["--version"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   }) : "";
@@ -5760,7 +6138,7 @@ function swiftToolchain(release, sdk) {
 ${swiftInstallSteps(release, sdk)}`
     );
   }
-  const sdks = (0, import_node_child_process5.execFileSync)(swift, ["sdk", "list"], {
+  const sdks = (0, import_node_child_process6.execFileSync)(swift, ["sdk", "list"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -5795,22 +6173,23 @@ function swiftInstallSteps(release, wasmSdk) {
     `  ${sdk}`
   ].join("\n");
 }
-var import_node_child_process5, import_node_fs5, import_node_os5, import_node_path6, verified;
+var import_node_child_process6, import_node_fs6, import_node_os6, import_node_path7, verified;
 var init_swift_toolchain = __esm({
   "src/swift-toolchain.ts"() {
     "use strict";
-    import_node_child_process5 = require("node:child_process");
-    import_node_fs5 = __toESM(require("node:fs"), 1);
-    import_node_os5 = __toESM(require("node:os"), 1);
-    import_node_path6 = __toESM(require("node:path"), 1);
+    import_node_child_process6 = require("node:child_process");
+    import_node_fs6 = __toESM(require("node:fs"), 1);
+    import_node_os6 = __toESM(require("node:os"), 1);
+    import_node_path7 = __toESM(require("node:path"), 1);
     verified = /* @__PURE__ */ new Map();
   }
 });
 
 // src/swift-distribution.ts
-function swiftDistributionRoot() {
+async function swiftDistributionRoot(signal) {
+  signal?.throwIfAborted();
   const endpoint = process.env[SWIFT_ENDPOINT_ENV]?.trim().replace(/\/+$/, "");
-  if (!endpoint) return Promise.resolve(null);
+  if (!endpoint) return null;
   const lock = parseSwiftDistributionLock(swift_distribution_lock_default);
   const host2 = swiftDistributionHost(process.platform, process.arch);
   if (!host2) {
@@ -5819,16 +6198,19 @@ function swiftDistributionRoot() {
     );
   }
   swiftToolchain(lock.release, lock);
-  const dir = import_node_path7.default.join(rnxHomeDir(), "swift", `${lock.id}-${host2}`);
+  const dir = import_node_path8.default.join(rnxHomeDir(), "swift", `${lock.id}-${host2}`);
   let pending = installs.get(dir);
+  if (pending?.controller.signal.aborted) pending = void 0;
   if (!pending) {
-    pending = (async () => {
-      if (!import_node_fs6.default.existsSync(import_node_path7.default.join(dir, SWIFT_DISTRIBUTION_MANIFEST))) {
+    const controller = new AbortController();
+    const promise = (async () => {
+      if (!import_node_fs7.default.existsSync(import_node_path8.default.join(dir, SWIFT_DISTRIBUTION_MANIFEST))) {
         process.stderr.write(
           `peach: downloading Swift distribution ${lock.id} (${host2})\u2026
 `
         );
         await installVerifiedTarball({
+          signal: controller.signal,
           url: `${endpoint}/${swiftDistributionKey(lock.id, host2)}`,
           digest: {
             algorithm: "sha256",
@@ -5845,17 +6227,52 @@ function swiftDistributionRoot() {
         throw new Error(`${dir} does not hold Swift distribution ${lock.id} (${host2})`);
       }
       return dir;
-    })();
-    pending.catch(() => installs.delete(dir));
+    })().finally(() => {
+      if (installs.get(dir)?.controller === controller) installs.delete(dir);
+    });
+    pending = { promise, controller, clients: 0 };
     installs.set(dir, pending);
   }
-  return pending;
+  const current = pending;
+  current.clients++;
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    if (--current.clients === 0) current.controller.abort(signal?.reason);
+  };
+  let abort;
+  try {
+    const root = await new Promise((resolve2, reject) => {
+      abort = () => {
+        release();
+        const reason = signal?.reason;
+        const error = reason instanceof Error ? reason : new Error("Swift distribution installation canceled", { cause: reason });
+        if (current.clients > 0) reject(error);
+        else
+          current.promise.then(
+            () => reject(error),
+            () => reject(error)
+          );
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      current.promise.then(resolve2, reject);
+      if (signal?.aborted) abort();
+    });
+    signal?.throwIfAborted();
+    return root;
+  } finally {
+    if (abort) signal?.removeEventListener("abort", abort);
+    release();
+  }
 }
 async function resolveSwiftModule({
-  required = false
+  required = false,
+  signal
 } = {}) {
-  const checkout2 = import_node_path7.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift");
-  if (import_node_fs6.default.existsSync(import_node_path7.default.join(checkout2, "toolchain.json"))) {
+  signal?.throwIfAborted();
+  const checkout2 = import_node_path8.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift");
+  if (import_node_fs7.default.existsSync(import_node_path8.default.join(checkout2, "toolchain.json"))) {
     try {
       return { root: checkout2, ...swiftModuleToolchain(checkout2) };
     } catch (error) {
@@ -5863,22 +6280,22 @@ async function resolveSwiftModule({
       return null;
     }
   }
-  const root = await swiftDistributionRoot();
+  const root = await swiftDistributionRoot(signal);
   return root ? { root, ...swiftModuleToolchain(root) } : null;
 }
 function swiftModuleToolchain(root) {
-  const pin = swiftDistributionAt(root) ?? JSON.parse(import_node_fs6.default.readFileSync(import_node_path7.default.join(root, "toolchain.json"), "utf8"));
+  const pin = swiftDistributionAt(root) ?? JSON.parse(import_node_fs7.default.readFileSync(import_node_path8.default.join(root, "toolchain.json"), "utf8"));
   return {
     release: pin.release,
     toolchainBin: swiftToolchain(pin.release, swiftModuleSdk(root))
   };
 }
-var import_node_fs6, import_node_path7, SWIFT_ENDPOINT_ENV, installs;
+var import_node_fs7, import_node_path8, SWIFT_ENDPOINT_ENV, installs;
 var init_swift_distribution = __esm({
   "src/swift-distribution.ts"() {
     "use strict";
-    import_node_fs6 = __toESM(require("node:fs"), 1);
-    import_node_path7 = __toESM(require("node:path"), 1);
+    import_node_fs7 = __toESM(require("node:fs"), 1);
+    import_node_path8 = __toESM(require("node:path"), 1);
     init_src();
     init_home_paths();
     init_swift_compile();
@@ -5911,8 +6328,8 @@ function imagesetFiles(images) {
     ];
   }).sort((a, b) => a.scale - b.scale);
 }
-function flatScale(path20) {
-  const match = /@([23])x\.[^./]+$/.exec(path20);
+function flatScale(path21) {
+  const match = /@([23])x\.[^./]+$/.exec(path21);
   return match ? Number(match[1]) : 1;
 }
 function providesNamespace(text4) {
@@ -5939,8 +6356,8 @@ function catalogEntryName(contentsPath, kind, readText) {
   }
   return segments.join("/");
 }
-function isFlatResourceImage(path20) {
-  return path20.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path20));
+function isFlatResourceImage(path21) {
+  return path21.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path21));
 }
 function enumerateBundleImages(paths, readText, bundleForFile = () => ".") {
   const table = [];
@@ -5953,7 +6370,7 @@ function enumerateBundleImages(paths, readText, bundleForFile = () => ".") {
     seen.set(bundlePath, names);
     return { bundlePath, names };
   };
-  const catalogs = paths.filter((path20) => baseOf(path20) === "Contents.json");
+  const catalogs = paths.filter((path21) => baseOf(path21) === "Contents.json");
   for (const contentsPath of catalogs) {
     const name2 = catalogEntryName(contentsPath, ".imageset", readText);
     if (name2 === null) continue;
@@ -5981,13 +6398,13 @@ function enumerateBundleImages(paths, readText, bundleForFile = () => ".") {
         bundlePath
       });
   }
-  for (const path20 of paths) {
-    if (!isFlatResourceImage(path20)) continue;
-    const name2 = baseOf(path20).slice(0, -extOf(path20).length);
-    const { bundlePath, names } = namesFor(path20);
+  for (const path21 of paths) {
+    if (!isFlatResourceImage(path21)) continue;
+    const name2 = baseOf(path21).slice(0, -extOf(path21).length);
+    const { bundlePath, names } = namesFor(path21);
     if (name2 === "" || names.has(name2)) continue;
     names.add(name2);
-    table.push({ name: name2, file: path20, scale: flatScale(path20), bundlePath });
+    table.push({ name: name2, file: path21, scale: flatScale(path21), bundlePath });
   }
   return table;
 }
@@ -6016,7 +6433,7 @@ function colorsetValue(color) {
 }
 function enumerateBundleColors(paths, readText) {
   const table = {};
-  for (const contentsPath of paths.filter((path20) => baseOf(path20) === "Contents.json")) {
+  for (const contentsPath of paths.filter((path21) => baseOf(path21) === "Contents.json")) {
     const name2 = catalogEntryName(contentsPath, ".colorset", readText);
     if (name2 === null || name2 in table) continue;
     let colors;
@@ -6080,8 +6497,8 @@ function axisExtremes(points) {
 function pathBounds(d) {
   const xs = [];
   const ys = [];
-  for (const path20 of d)
-    (0, import_svgpath.default)(path20).abs().unshort().unarc().iterate((segment2, _index, x, y) => {
+  for (const path21 of d)
+    (0, import_svgpath.default)(path21).abs().unshort().unarc().iterate((segment2, _index, x, y) => {
       const [command, ...args] = segment2;
       if (command === "M" || command === "L") {
         xs.push(Number(args[0]));
@@ -6108,7 +6525,7 @@ function guide(svg, id, axis) {
 }
 function enumerateBundleSymbols(paths, readText, bundleForFile) {
   const table = {};
-  for (const contentsPath of paths.filter((path20) => baseOf(path20) === "Contents.json")) {
+  for (const contentsPath of paths.filter((path21) => baseOf(path21) === "Contents.json")) {
     const name2 = catalogEntryName(contentsPath, ".symbolset", readText);
     if (name2 === null) continue;
     const bundle = bundleForFile(contentsPath);
@@ -6144,24 +6561,24 @@ function enumerateBundleSymbols(paths, readText, bundleForFile) {
       viewBox: "0 0 24 24",
       advance,
       box: [12 - advance / 2, 12 - tall / 2, advance, tall],
-      layers: d.map((path20) => ({
-        d: (0, import_svgpath.default)(path20).abs().scale(scale).translate(translateX, translateY).round(3).toString()
+      layers: d.map((path21) => ({
+        d: (0, import_svgpath.default)(path21).abs().scale(scale).translate(translateX, translateY).round(3).toString()
       }))
     };
   }
   return table;
 }
-function isCopiedResource(path20) {
-  if (path20.split("/").some((segment2) => segment2.endsWith(".atlasc"))) return true;
-  const ext = extOf(path20);
+function isCopiedResource(path21) {
+  if (path21.split("/").some((segment2) => segment2.endsWith(".atlasc"))) return true;
+  const ext = extOf(path21);
   if (ext === ".json" || ext === ".xcstrings") return true;
-  return !RASTER_EXTENSIONS.has(ext) && !COMPILED_EXTENSIONS.has(ext) && !path20.split("/").some((segment2) => NESTED_BUNDLE_DIR.test(segment2));
+  return !RASTER_EXTENSIONS.has(ext) && !COMPILED_EXTENSIONS.has(ext) && !path21.split("/").some((segment2) => NESTED_BUNDLE_DIR.test(segment2));
 }
 function enumerateBundleResources(paths) {
   const found = [];
   const seen = /* @__PURE__ */ new Set();
   const ordered = [...paths].filter(
-    (path20) => path20.split("/").includes("Resources") && path20.split("/").every((segment2) => segment2 !== "" && segment2 !== "..") && isCopiedResource(path20)
+    (path21) => path21.split("/").includes("Resources") && path21.split("/").every((segment2) => segment2 !== "" && segment2 !== "..") && isCopiedResource(path21)
   ).sort((a, b) => {
     const aDepth = a.split("/").length;
     const bDepth = b.split("/").length;
@@ -6211,7 +6628,8 @@ var init_public_brand = __esm({
       packageName: "peachsim",
       commandName: "peach",
       domain: "peachsim.com",
-      origin: "https://peachsim.com"
+      origin: "https://peachsim.com",
+      boxOrigin: "https://rnx-box.contrast.dev"
     });
     rnxPublicBrand = peachPublicBrand;
   }
@@ -6227,14 +6645,14 @@ function sharedDesktopAuthAccounts(user) {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path8.dirname)((0, import_node_path8.resolve)(explicit));
+    return (0, import_node_path9.dirname)((0, import_node_path9.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path8.resolve)(explicit);
-  return (0, import_node_path8.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path9.resolve)(explicit);
+  return (0, import_node_path9.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -6284,26 +6702,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs7.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs8.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs7.rmSync)(filepath, { force: true });
+      (0, import_node_fs8.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs7.rmSync)(filepath, { force: true });
+    (0, import_node_fs8.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs7, import_node_path8, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs8, import_node_path9, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
-    import_node_path8 = require("node:path");
+    import_node_fs8 = require("node:fs");
+    import_node_path9 = require("node:path");
     init_home_paths();
     init_public_brand();
     SESSION_VERSION = 1;
@@ -6690,94 +7108,6 @@ var init_ios_sdk_frameworks = __esm({
   }
 });
 
-// src/swift-binary-modules.ts
-function frameworkModules(paths) {
-  const modules = /* @__PURE__ */ new Set();
-  for (const file of paths) {
-    const segment2 = file.split("/").find((part) => part.endsWith(".framework"));
-    if (segment2) modules.add(segment2.slice(0, -".framework".length));
-  }
-  return [...modules].sort();
-}
-async function range(url, spec) {
-  const response = await fetch(url, {
-    headers: { range: `bytes=${spec}`, "accept-encoding": "identity" },
-    signal: AbortSignal.timeout(2e4)
-  });
-  const match = /^bytes (\d+)-\d+\/(\d+)$/.exec(
-    response.headers.get("content-range") ?? ""
-  );
-  if (response.status !== 206 || !match)
-    throw new Error(`${url} answered ${response.status} to a range request`);
-  return {
-    bytes: Buffer.from(await response.arrayBuffer()),
-    start: Number(match[1]),
-    total: Number(match[2])
-  };
-}
-async function zipEntries(url) {
-  const { total } = await range(url, "0-0");
-  const tail = await range(url, `${Math.max(0, total - 65558)}-${total - 1}`);
-  let end = tail.bytes.length - 22;
-  for (; end >= 0; end--)
-    if (tail.bytes.readUInt32LE(end) === 101010256 && end + 22 + tail.bytes.readUInt16LE(end + 20) === tail.bytes.length)
-      break;
-  if (end < 0) throw new Error(`${url} has no zip end record`);
-  let size = tail.bytes.readUInt32LE(end + 12);
-  let offset = tail.bytes.readUInt32LE(end + 16);
-  if (offset === 4294967295 || size === 4294967295) {
-    const locator = end - 20;
-    if (locator < 0 || tail.bytes.readUInt32LE(locator) !== 117853008)
-      throw new Error(`${url} has no zip64 locator`);
-    const recordAt = Number(tail.bytes.readBigUInt64LE(locator + 8));
-    const record4 = recordAt >= tail.start ? tail.bytes.subarray(recordAt - tail.start) : (await range(url, `${recordAt}-${recordAt + 55}`)).bytes;
-    size = Number(record4.readBigUInt64LE(40));
-    offset = Number(record4.readBigUInt64LE(48));
-  }
-  const directory = offset >= tail.start ? tail.bytes.subarray(offset - tail.start, offset - tail.start + size) : (await range(url, `${offset}-${offset + size - 1}`)).bytes;
-  const names = [];
-  for (let at = 0; at + 46 <= directory.length; ) {
-    if (directory.readUInt32LE(at) !== 33639248) break;
-    const nameLength = directory.readUInt16LE(at + 28);
-    names.push(directory.toString("utf8", at + 46, at + 46 + nameLength));
-    at += 46 + nameLength + directory.readUInt16LE(at + 30) + directory.readUInt16LE(at + 32);
-  }
-  return names;
-}
-function localEntries(dir) {
-  if (!import_node_fs8.default.existsSync(dir)) return [];
-  return import_node_fs8.default.readdirSync(dir, { withFileTypes: true }).filter((slice) => slice.isDirectory()).flatMap(
-    (slice) => import_node_fs8.default.readdirSync(import_node_path9.default.join(dir, slice.name)).map((entry) => `${slice.name}/${entry}`)
-  );
-}
-async function swiftBinaryModules(binary) {
-  if (!binary.url) return frameworkModules(localEntries(binary.dir));
-  const cached2 = import_node_path9.default.join(
-    cacheDir,
-    `${(0, import_node_crypto4.createHash)("sha256").update(`${binary.url}\0${binary.checksum ?? ""}`).digest("hex").slice(0, 32)}.json`
-  );
-  if (import_node_fs8.default.existsSync(cached2)) {
-    const value = JSON.parse(import_node_fs8.default.readFileSync(cached2, "utf8"));
-    if (Array.isArray(value) && value.every((name2) => typeof name2 === "string"))
-      return value;
-  }
-  const modules = frameworkModules(await zipEntries(binary.url));
-  import_node_fs8.default.mkdirSync(cacheDir, { recursive: true });
-  import_node_fs8.default.writeFileSync(cached2, JSON.stringify(modules));
-  return modules;
-}
-var import_node_crypto4, import_node_fs8, import_node_os6, import_node_path9, cacheDir;
-var init_swift_binary_modules = __esm({
-  "src/swift-binary-modules.ts"() {
-    "use strict";
-    import_node_crypto4 = require("node:crypto");
-    import_node_fs8 = __toESM(require("node:fs"), 1);
-    import_node_os6 = __toESM(require("node:os"), 1);
-    import_node_path9 = __toESM(require("node:path"), 1);
-    cacheDir = import_node_path9.default.join(import_node_os6.default.tmpdir(), "peach-swift-binary-modules");
-  }
-});
-
 // src/swift-package-manifest.ts
 function swiftCommand() {
   return process.platform === "darwin" ? { file: "xcrun", args: ["swift"] } : { file: import_node_path10.default.join(swiftToolchainBin(swift_distribution_lock_default.release), "swift"), args: [] };
@@ -6793,7 +7123,7 @@ function dump(dir) {
     return { key: key2, raw: record3(JSON.parse(import_node_fs9.default.readFileSync(cached2, "utf8"))) };
   let output;
   try {
-    output = (0, import_node_child_process6.execFileSync)(
+    output = (0, import_node_child_process7.execFileSync)(
       command.file,
       [
         ...command.args,
@@ -6980,11 +7310,11 @@ function swiftTargetFiles(manifest, target) {
   ];
   return included.flatMap(walk).filter((file) => !within(file, excluded)).sort();
 }
-var import_node_child_process6, import_node_crypto5, import_node_fs9, import_node_os7, import_node_path10, TARGET_TYPES, isTargetType, record3, array, string, cacheDir2, evaluated, within;
+var import_node_child_process7, import_node_crypto5, import_node_fs9, import_node_os7, import_node_path10, TARGET_TYPES, isTargetType, record3, array, string, cacheDir2, evaluated, within;
 var init_swift_package_manifest = __esm({
   "src/swift-package-manifest.ts"() {
     "use strict";
-    import_node_child_process6 = require("node:child_process");
+    import_node_child_process7 = require("node:child_process");
     import_node_crypto5 = require("node:crypto");
     import_node_fs9 = __toESM(require("node:fs"), 1);
     import_node_os7 = __toESM(require("node:os"), 1);
@@ -7030,7 +7360,7 @@ function checkout(checkouts, identity, pin) {
   const dir = import_node_path11.default.join(checkouts, identity);
   const key2 = `${dir}\0${pin.revision}`;
   if (verified2.has(key2)) return dir;
-  const git = (...args) => (0, import_node_child_process7.execFileSync)("git", ["-C", dir, ...args], {
+  const git = (...args) => (0, import_node_child_process8.execFileSync)("git", ["-C", dir, ...args], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   }).trim();
@@ -7232,11 +7562,11 @@ function resolveSwiftPackages(options) {
   result.targets = [...targets.entries()].filter(([key2]) => reached.has(key2)).map(([, target]) => target);
   return result;
 }
-var import_node_child_process7, import_node_fs10, import_node_path11, REMOTE_CHECKOUTS, UNSUPPORTED_NATIVE, BINARY, blocker, verified2;
+var import_node_child_process8, import_node_fs10, import_node_path11, REMOTE_CHECKOUTS, UNSUPPORTED_NATIVE, BINARY, blocker, verified2;
 var init_swift_packages = __esm({
   "src/swift-packages.ts"() {
     "use strict";
-    import_node_child_process7 = require("node:child_process");
+    import_node_child_process8 = require("node:child_process");
     import_node_fs10 = __toESM(require("node:fs"), 1);
     import_node_path11 = __toESM(require("node:path"), 1);
     init_swift_package();
@@ -8422,6 +8752,17 @@ function objcView(surface, toolchainBin, stdlib, cacheDir4, work) {
     const slash = include2.indexOf("/");
     if (slash > 0 && /^[A-Z]/.test(include2)) {
       const name2 = include2.slice(0, slash);
+      const umbrella = `${name2}/${name2}.h`;
+      if (Object.hasOwn(
+        IOS_SDK_HEADERS,
+        `System/Library/Frameworks/${name2}.framework/Headers/${name2}.h`
+      )) {
+        const header2 = import_node_path13.default.join(stubIncludes, include2);
+        import_node_fs13.default.mkdirSync(import_node_path13.default.dirname(header2), { recursive: true });
+        import_node_fs13.default.writeFileSync(header2, `#import <${umbrella}>
+`);
+        return true;
+      }
       const root = import_node_path13.default.join(stubs, `${name2}.framework`);
       const header = import_node_path13.default.join(root, "Headers", include2.slice(slash + 1));
       import_node_fs13.default.mkdirSync(import_node_path13.default.dirname(header), { recursive: true });
@@ -8469,7 +8810,7 @@ function objcView(surface, toolchainBin, stdlib, cacheDir4, work) {
   for (let round = 0; ; round++) {
     import_node_fs13.default.rmSync(out, { recursive: true, force: true });
     import_node_fs13.default.mkdirSync(out, { recursive: true });
-    const run5 = (0, import_node_child_process8.spawnSync)(
+    const run5 = (0, import_node_child_process9.spawnSync)(
       import_node_path13.default.join(toolchainBin, "swift-symbolgraph-extract"),
       [
         "-module-name",
@@ -8576,7 +8917,7 @@ function enumValues(graphs, surface, framework, toolchainBin, search, work) {
     if (flag === "-sdk") flags.push("-isysroot", dir);
     else flags.push(flag, dir);
   }
-  const run5 = (0, import_node_child_process8.spawnSync)(
+  const run5 = (0, import_node_child_process9.spawnSync)(
     import_node_path13.default.join(toolchainBin, "clang"),
     [
       "-x",
@@ -8645,11 +8986,11 @@ function constantValue(node) {
   }
   return null;
 }
-var import_node_child_process8, import_node_crypto6, import_node_fs13, import_node_path13, ROUNDS, IOS_SDK_ID, headerFiles, MISSING_IMPORT;
+var import_node_child_process9, import_node_crypto6, import_node_fs13, import_node_path13, ROUNDS, IOS_SDK_ID, headerFiles, MISSING_IMPORT;
 var init_swift_objc_standin = __esm({
   "src/swift-objc-standin.ts"() {
     "use strict";
-    import_node_child_process8 = require("node:child_process");
+    import_node_child_process9 = require("node:child_process");
     import_node_crypto6 = require("node:crypto");
     import_node_fs13 = __toESM(require("node:fs"), 1);
     import_node_path13 = __toESM(require("node:path"), 1);
@@ -8809,10 +9150,10 @@ function emitSwiftStandin(graphs, options) {
     owners.push(...physical.map(() => current));
   };
   const scoped = (body) => (symbol, ...rest) => {
-    const path20 = pathOf(symbol);
-    if (omit.has(path20)) return void skipped.push({ path: path20, reason: omit.get(path20) });
+    const path21 = pathOf(symbol);
+    if (omit.has(path21)) return void skipped.push({ path: path21, reason: omit.get(path21) });
     const previous = current;
-    current = path20;
+    current = path21;
     try {
       body(symbol, ...rest);
     } finally {
@@ -8832,14 +9173,14 @@ function emitSwiftStandin(graphs, options) {
   const access = (symbol, openOwner) => symbol.accessLevel === "open" && openOwner ? "open" : "public";
   const emitMember = scoped(
     (member, indent, context) => {
-      const path20 = pathOf(member);
+      const path21 = pathOf(member);
       if (TYPE_KINDS.has(member.kind.identifier)) {
         emitType(member, indent);
         return;
       }
       if (member.kind.identifier === "swift.enum.case") return;
       if (!MEMBER_KINDS.has(member.kind.identifier)) {
-        skipped.push({ path: path20, reason: `unhandled ${member.kind.identifier}` });
+        skipped.push({ path: path21, reason: `unhandled ${member.kind.identifier}` });
         return;
       }
       const { 1: attrs, 2: rest } = LEADING_ATTRS.exec(text2(member));
@@ -8853,12 +9194,12 @@ function emitSwiftStandin(graphs, options) {
       const final = context.inClass && flags.has("final") ? "final " : "";
       const mutating = flags.has("mutating") ? "mutating " : flags.has("nonmutating") ? "nonmutating " : "";
       let core = `${flags.has("convenience") ? "convenience " : ""}${modifiers[2]}`;
-      const override = context.inClass && !options.plain?.has(path20) && (flags.has("override") || overrides.has(member.identifier.precise) || options.forcedOverride?.has(path20) || isObjC(member) && path20.endsWith(".init()")) ? "override " : "";
+      const override = context.inClass && !options.plain?.has(path21) && (flags.has("override") || overrides.has(member.identifier.precise) || options.forcedOverride?.has(path21) || isObjC(member) && path21.endsWith(".init()")) ? "override " : "";
       const head = `${indent}${attrs}${access(member, context.openOwner)} ${required ? "required " : ""}${final}${override}${mutating}`;
-      const measured = behavior.get(path20);
-      if (measured) used.add(path20);
+      const measured = behavior.get(path21);
+      if (measured) used.add(path21);
       const overloadBody = /\basync\b/.test(core) ? measured?.asyncBody : /\bResult</.test(core) ? measured?.resultBody : void 0;
-      const body = overloadBody ?? measured?.body ?? trap(path20);
+      const body = overloadBody ?? measured?.body ?? trap(path21);
       switch (member.kind.identifier) {
         case "swift.property":
         case "swift.type.property":
@@ -8879,7 +9220,7 @@ function emitSwiftStandin(graphs, options) {
             return;
           }
           emit(
-            `${head}${computed} { get${effects} { ${body} }${settable && !effects ? ` ${parsed.nonmutating ? "nonmutating " : ""}set { ${measured?.set ?? trap(path20)} }` : ""} }`
+            `${head}${computed} { get${effects} { ${body} }${settable && !effects ? ` ${parsed.nonmutating ? "nonmutating " : ""}set { ${measured?.set ?? trap(path21)} }` : ""} }`
           );
           return;
         }
@@ -8932,7 +9273,7 @@ function emitSwiftStandin(graphs, options) {
   };
   const emitType = scoped(
     (symbol, indent) => {
-      const path20 = pathOf(symbol);
+      const path21 = pathOf(symbol);
       const id = symbol.identifier.precise;
       const inner = `${indent}  `;
       switch (symbol.kind.identifier) {
@@ -8944,10 +9285,10 @@ function emitSwiftStandin(graphs, options) {
         case "swift.class": {
           const shape = header(symbol, "class", indent);
           if (!shape)
-            return void skipped.push({ path: path20, reason: `unparsed class ${text2(symbol)}` });
-          const parent = options.superclasses?.get(path20) ?? superclass.get(id);
+            return void skipped.push({ path: path21, reason: `unparsed class ${text2(symbol)}` });
+          const parent = options.superclasses?.get(path21) ?? superclass.get(id);
           const blocked = classBlocked(id);
-          if (blocked) return void skipped.push({ path: path20, reason: blocked });
+          if (blocked) return void skipped.push({ path: path21, reason: blocked });
           const ancestors = /* @__PURE__ */ new Set();
           for (let at = superId.get(id); at; at = superId.get(at))
             for (const name2 of conforms.get(at) ?? []) ancestors.add(name2);
@@ -8963,9 +9304,9 @@ function emitSwiftStandin(graphs, options) {
             `${indent}${shape.attrs}${open ? "open" : "public"} class ${shape.name}${shape.generics}${list2.length ? `: ${list2.join(", ")}` : ""}${selfConforming(shape.where)} {`
           );
           const members = membersOf(id);
-          const extra = options.behavior?.get(path20)?.members;
+          const extra = options.behavior?.get(path21)?.members;
           if (extra) {
-            used.add(path20);
+            used.add(path21);
             emit(`${inner}${extra}`);
           }
           for (const member of members)
@@ -9017,13 +9358,13 @@ function emitSwiftStandin(graphs, options) {
                 continue;
               have.add(witnessKey(member));
               have.add(sideLeaf(member));
-              emitWitness(member, inner, path20);
+              emitWitness(member, inner, path21);
             }
           }
           const coder = members.some((member) => leaf(member) === "init(coder:)");
           if (designated && !coder && externalRoot(id) !== "NSObject" && externalRoot(id) !== null)
             emit(
-              `${inner}public required init?(coder: NSCoder) { ${trap(`${path20}.init(coder:)`)} }`
+              `${inner}public required init?(coder: NSCoder) { ${trap(`${path21}.init(coder:)`)} }`
             );
           emit(`${indent}}`);
           return;
@@ -9031,7 +9372,7 @@ function emitSwiftStandin(graphs, options) {
         case "swift.struct": {
           const shape = header(symbol, "struct", indent);
           if (!shape)
-            return void skipped.push({ path: path20, reason: `unparsed struct ${text2(symbol)}` });
+            return void skipped.push({ path: path21, reason: `unparsed struct ${text2(symbol)}` });
           const members = membersOf(id);
           const raw2 = rawType(members);
           const list2 = inheritance(id);
@@ -9063,7 +9404,7 @@ function emitSwiftStandin(graphs, options) {
         case "swift.enum": {
           const shape = header(symbol, "enum", indent);
           if (!shape)
-            return void skipped.push({ path: path20, reason: `unparsed enum ${text2(symbol)}` });
+            return void skipped.push({ path: path21, reason: `unparsed enum ${text2(symbol)}` });
           const members = membersOf(id);
           const raw2 = rawType(members);
           const cases = members.filter(
@@ -9072,7 +9413,7 @@ function emitSwiftStandin(graphs, options) {
           const missing = raw2 ? cases.filter((member) => !values.has(member.identifier.precise)) : [];
           if (raw2 && isObjC(symbol) && missing.length > 0)
             return void skipped.push({
-              path: path20,
+              path: path21,
               reason: `no header value for ${missing.map(leaf).join(", ")}`
             });
           const list2 = inheritance(id, raw2 ?? void 0).filter(
@@ -9112,7 +9453,7 @@ function emitSwiftStandin(graphs, options) {
           const shape = header(symbol, "protocol", indent);
           if (!shape)
             return void skipped.push({
-              path: path20,
+              path: path21,
               reason: `unparsed protocol ${text2(symbol)}`
             });
           const list2 = [...isObjC(symbol) ? ["AnyObject"] : [], ...inheritance(id)];
@@ -9137,7 +9478,7 @@ function emitSwiftStandin(graphs, options) {
           }
           emit(`${indent}}`);
           if (defaults.length > 0) {
-            emit(`${indent}extension ${path20} {`);
+            emit(`${indent}extension ${path21} {`);
             for (const member of defaults) {
               const decl = text2(member);
               if (optional.has(member.identifier.precise) && member.kind.identifier === "swift.method" && !decl.replace(/\([^)]*\)/g, "").includes("->") && !/ async\b/.test(decl))
@@ -9183,7 +9524,7 @@ function emitSwiftStandin(graphs, options) {
     return init ? /rawValue:\s*([^)]+)\)/.exec(text2(init))?.[1]?.trim() ?? null : null;
   };
   const emitGlobal = scoped((symbol) => {
-    const path20 = pathOf(symbol);
+    const path21 = pathOf(symbol);
     const kind = symbol.kind.identifier;
     if (kind === "swift.func" || kind === "swift.func.op" || kind === "swift.method" || kind === "swift.type.method") {
       const { 1: attrs, 2: rest } = LEADING_ATTRS.exec(text2(symbol));
@@ -9194,22 +9535,22 @@ function emitSwiftStandin(graphs, options) {
         if (fix && !/^(?:prefix|infix|postfix)\b/.test(spelled))
           spelled = `${fix} ${spelled}`;
       }
-      const measured = behavior.get(path20);
-      if (measured) used.add(path20);
+      const measured = behavior.get(path21);
+      if (measured) used.add(path21);
       const overloadBody = /\basync\b/.test(spelled) ? measured?.asyncBody : /\bResult</.test(spelled) ? measured?.resultBody : void 0;
       emit(
-        `${attrs}public ${spelled} { ${overloadBody ?? measured?.body ?? trap(path20)} }`
+        `${attrs}public ${spelled} { ${overloadBody ?? measured?.body ?? trap(path21)} }`
       );
     } else if (kind === "swift.var") {
       const parsed = splitAccessors(text2(symbol).replace(/^let /, "var "));
-      const measured = behavior.get(path20);
-      if (measured) used.add(path20);
-      emit(`public ${parsed.decl} { ${measured?.body ?? trap(path20)} }`);
-    } else skipped.push({ path: path20, reason: `unhandled top-level ${kind}` });
+      const measured = behavior.get(path21);
+      if (measured) used.add(path21);
+      emit(`public ${parsed.decl} { ${measured?.body ?? trap(path21)} }`);
+    } else skipped.push({ path: path21, reason: `unhandled top-level ${kind}` });
   });
   const roots = [...byId.values()].filter((symbol) => !owner.has(symbol.identifier.precise) && !unavailable(symbol)).sort((a, b) => pathOf(a).localeCompare(pathOf(b)));
   for (const symbol of roots) {
-    const path20 = pathOf(symbol);
+    const path21 = pathOf(symbol);
     if (TYPE_KINDS.has(symbol.kind.identifier)) emitType(symbol, "");
     else emitGlobal(symbol);
   }
@@ -9250,9 +9591,9 @@ function emitSwiftStandin(graphs, options) {
     ...imports.map((name2) => `import ${name2}`),
     ""
   ];
-  for (const path20 of behavior.keys())
-    if (!used.has(path20))
-      skipped.push({ path: path20, reason: "behavior names no emitted declaration" });
+  for (const path21 of behavior.keys())
+    if (!used.has(path21))
+      skipped.push({ path: path21, reason: "behavior names no emitted declaration" });
   return {
     source: `${[...banner, ...lines].join("\n")}
 `,
@@ -9292,7 +9633,7 @@ var STANDIN_EMIT_VERSION, STANDIN_IMPORTS, TYPE_KINDS, MEMBER_KINDS, ACCESSOR_WO
 var init_swift_standin_emit = __esm({
   "src/swift-standin-emit.ts"() {
     "use strict";
-    STANDIN_EMIT_VERSION = "6";
+    STANDIN_EMIT_VERSION = "7";
     STANDIN_IMPORTS = ["Foundation", "UIKit"];
     TYPE_KINDS = /* @__PURE__ */ new Set([
       "swift.class",
@@ -9339,7 +9680,7 @@ var init_swift_standin_emit = __esm({
     sideLeaf = (symbol) => `${symbol.kind.identifier.startsWith("swift.type.") ? "type" : "instance"}|leaf|${leaf(symbol)}`;
     isObjC = (symbol) => symbol.identifier.precise.startsWith("c:");
     synthesizedEquality = (symbol, conforms) => conforms.includes("Hashable") ? ["==(_:_:)", "hash(into:)", "hashValue"].includes(leaf(symbol)) : conforms.includes("Equatable") && leaf(symbol) === "==(_:_:)";
-    trap = (path20) => `fatalError("${path20} is a binary framework peach cannot run")`;
+    trap = (path21) => `fatalError("${path21} is a binary framework peach cannot run")`;
     KEYWORDS = /* @__PURE__ */ new Set([
       "Type",
       "Protocol",
@@ -9381,7 +9722,7 @@ var init_swift_standin_emit = __esm({
 
 // src/swift-standins.ts
 function exec(file, args, cwd) {
-  return (0, import_node_child_process9.execFileSync)(file, args, {
+  return (0, import_node_child_process10.execFileSync)(file, args, {
     cwd,
     encoding: "utf8",
     maxBuffer: 256 * 1024 * 1024,
@@ -9697,7 +10038,7 @@ function graphStandin(module2, graphs, values, wasm, binary, toolchain, work, be
         );
     }
     import_node_fs14.default.writeFileSync(file, source);
-    const check = (0, import_node_child_process9.spawnSync)(
+    const check = (0, import_node_child_process10.spawnSync)(
       import_node_path14.default.join(toolchain.toolchainBin, "swiftc"),
       [
         "-typecheck",
@@ -10019,7 +10360,7 @@ function standinLibrary(binary, searchRoot) {
   if (!library) return null;
   const manifest = crateFor(searchRoot, library.slice("lib".length, -".a".length));
   if (!manifest) return null;
-  const result = (0, import_node_child_process9.spawnSync)(
+  const result = (0, import_node_child_process10.spawnSync)(
     "cargo",
     [
       "build",
@@ -10081,7 +10422,7 @@ function sourceBinaryStandins(binary, toolchain, provided, behavior) {
         release: toolchain.release
       })
     );
-    (0, import_node_child_process9.execFileSync)(
+    const build = (0, import_node_child_process10.spawnSync)(
       "bun",
       [
         import_node_path14.default.join(repo, "scripts/build/swift-standins-submit.ts"),
@@ -10092,11 +10433,20 @@ function sourceBinaryStandins(binary, toolchain, provided, behavior) {
         "--delivery-dir",
         delivery
       ],
-      { cwd: repo, stdio: "inherit" }
-    );
-    const receipt = JSON.parse(
-      import_node_fs14.default.readFileSync(import_node_path14.default.join(delivery, "standins.json"), "utf8")
+      { cwd: repo, encoding: "utf8", maxBuffer: 8 * 1024 * 1024 }
     );
+    if (build.stdout) process.stdout.write(build.stdout);
+    if (build.stderr) process.stderr.write(build.stderr);
+    if (build.error || build.status !== 0)
+      throw new Error(
+        `source stand-in build for ${binary.target} failed (${build.error?.message ?? build.signal ?? `exit ${build.status}`}): ${build.stderr?.trim().slice(-4e3) || build.stdout?.trim().slice(-4e3) || "builder returned no diagnostic"}`
+      );
+    const output = import_node_path14.default.join(delivery, "standins.json");
+    if (!import_node_fs14.default.existsSync(output))
+      throw new Error(
+        `source stand-in builder returned no standins.json for ${binary.target}`
+      );
+    const receipt = JSON.parse(import_node_fs14.default.readFileSync(output, "utf8"));
     if (!receipt || typeof receipt !== "object" || !("generation" in receipt) || receipt.generation !== generation || !("result" in receipt))
       throw new Error("Swift stand-in builder source differs from the caller");
     const result = receipt.result;
@@ -10209,7 +10559,7 @@ function binaryStandins(binary, toolchain, provided, behavior) {
   const work = import_node_fs14.default.mkdtempSync(import_node_path14.default.join(import_node_os8.default.tmpdir(), "peach-standin-"));
   let result;
   try {
-    result = process.platform === "darwin" && process.env.TM_SESSION && process.env.CI !== "true" && toolchain.moduleRoot === import_node_path14.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift") && !swiftDistributionAt(toolchain.moduleRoot) ? sourceBinaryStandins(binary, toolchain, provided, behavior) : found.map((surface) => {
+    result = process.platform === "darwin" && process.env.TM_EXEC_BUILD_PLATFORM !== "mac" && process.env.TM_SESSION && process.env.CI !== "true" && toolchain.moduleRoot === import_node_path14.default.resolve(__sootsim_import_meta_dirname, "../../sootsim-swift") && !swiftDistributionAt(toolchain.moduleRoot) ? sourceBinaryStandins(binary, toolchain, provided, behavior) : found.map((surface) => {
       const dir = import_node_path14.default.join(work, surface.module);
       try {
         if (surface.kind === "c" && configured.has(surface.module))
@@ -10262,11 +10612,11 @@ function swiftStandins(binaries, toolchain, provided = /* @__PURE__ */ new Set()
   }
   return { standins, gaps };
 }
-var import_node_child_process9, import_node_crypto7, import_node_fs14, import_node_os8, import_node_path14, TRIPLE, cacheDir3, key, digests, files, OBJC, identChar, RUST_TARGET, UNSEARCHED, built;
+var import_node_child_process10, import_node_crypto7, import_node_fs14, import_node_os8, import_node_path14, TRIPLE, cacheDir3, SWIFT_STANDINS_DIR, key, digests, files, OBJC, identChar, RUST_TARGET, UNSEARCHED, built;
 var init_swift_standins = __esm({
   "src/swift-standins.ts"() {
     "use strict";
-    import_node_child_process9 = require("node:child_process");
+    import_node_child_process10 = require("node:child_process");
     import_node_crypto7 = require("node:crypto");
     import_node_fs14 = __toESM(require("node:fs"), 1);
     import_node_os8 = __toESM(require("node:os"), 1);
@@ -10278,6 +10628,7 @@ var init_swift_standins = __esm({
     init_swift_standin_emit();
     TRIPLE = "wasm32-unknown-wasip1";
     cacheDir3 = import_node_path14.default.join(import_node_os8.default.homedir(), "builders/cache/peach-swift-standins");
+    SWIFT_STANDINS_DIR = "__standins__";
     key = (...parts) => (0, import_node_crypto7.createHash)("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
     digests = /* @__PURE__ */ new Map();
     files = (dir, test) => import_node_fs14.default.existsSync(dir) ? import_node_fs14.default.readdirSync(dir, { recursive: true, encoding: "utf8" }).filter((file) => test(import_node_path14.default.basename(file))).sort() : [];
@@ -12291,20 +12642,20 @@ function targetSettings(ref, configuration, builtins, options = {}) {
     ...level(str(project.project.buildConfigurationList)),
     ...level(str(target.buildConfigurationList))
   ];
-  const resolving = /* @__PURE__ */ new Set();
+  const resolving2 = /* @__PURE__ */ new Set();
   const valueAt = (key2, top) => {
     let at = top;
     while (at >= 0 && levels[at][key2] === void 0) at--;
     if (at < 0) return derived(key2);
     const marker = `${key2}@${at}`;
-    if (resolving.has(marker))
+    if (resolving2.has(marker))
       throw new Error(`${str(target.name)} has a cyclic build setting ${key2}`);
-    resolving.add(marker);
+    resolving2.add(marker);
     const value = expand(
       levels[at][key2],
       (name2) => name2 === "inherited" ? valueAt(key2, at - 1) : valueAt(name2, levels.length - 1)
     );
-    resolving.delete(marker);
+    resolving2.delete(marker);
     return value;
   };
   const derived = (key2) => {
@@ -12615,6 +12966,16 @@ function readXcodeAppTarget(input, targetName, configurationName, options = {})
     const value = settings(key2);
     info[key2.slice("INFOPLIST_KEY_".length)] = value === "YES" ? true : value === "NO" ? false : value;
   }
+  if (settings("GENERATE_INFOPLIST_FILE") === "YES") {
+    const versions = {
+      CFBundleShortVersionString: "MARKETING_VERSION",
+      CFBundleVersion: "CURRENT_PROJECT_VERSION"
+    };
+    for (const [key2, setting] of Object.entries(versions)) {
+      const value = settings(setting);
+      if (info[key2] === void 0 && value) info[key2] = value;
+    }
+  }
   if (settings("INFOPLIST_KEY_UIApplicationSceneManifest_Generation") === "YES" && info.UIApplicationSceneManifest === void 0) {
     info.UIApplicationSceneManifest = {
       UIApplicationSupportsMultipleScenes: true,
@@ -12920,7 +13281,7 @@ function xcodeLayout(root) {
   for (const standin of standins)
     targets.push({
       name: standin.module,
-      path: import_node_path17.default.posix.join(XCODE_STANDINS_DIR, standin.module),
+      path: import_node_path17.default.posix.join(SWIFT_STANDINS_DIR, standin.module),
       executable: false,
       resources: false,
       exclude: [],
@@ -13235,6 +13596,8 @@ function sourceStamp(packagePath, moduleRootOverride, hosted = false) {
   const hash = (0, import_node_crypto8.createHash)("sha256");
   hash.update(packagePath);
   hash.update(JSON.stringify(xcodeProjects.get(packagePath)?.behavior ?? {}));
+  const libraries = projects.get(packagePath)?.libraries;
+  if (libraries) hash.update(JSON.stringify(libraries));
   const projectInputs = new Set(packageFiles(packagePath));
   for (const file of [...projectInputs].sort()) {
     hash.update(import_node_path17.default.relative(packagePath, file));
@@ -13264,14 +13627,14 @@ function otherInputs(input) {
 function icuUrl(origin, artifact) {
   return "url" in artifact.icu ? artifact.icu.url : `${origin}${ICU_PATH}${artifact.icu.sha256}`;
 }
-function standinLibraries(layout) {
+function standinLibraries(binaries, standins, rootDir) {
   const linked = /* @__PURE__ */ new Map();
-  for (const binary of layout.binaries) {
-    const modules = layout.standins.filter(
+  for (const binary of binaries) {
+    const modules = standins.filter(
       (standin) => standin.target === binary.target && `${standin.module}.c` in standin.files
     );
     if (modules.length === 0) continue;
-    const library = standinLibrary(binary, layout.app.rootDir);
+    const library = standinLibrary(binary, rootDir);
     if (!library) continue;
     linked.set(library, modules);
   }
@@ -13298,14 +13661,14 @@ function packageSources(packagePath, linked = /* @__PURE__ */ new Set()) {
     files2["Package.swift"] = xcodeManifest(xcode);
     for (const standin of xcode.standins)
       for (const [file, text4] of Object.entries(standin.files))
-        files2[import_node_path17.default.posix.join(XCODE_STANDINS_DIR, standin.module, file)] = linked.has(standin) && file === `${standin.module}.c` ? `// ${standin.target}'s WebAssembly library defines ${standin.module}'s functions.
+        files2[import_node_path17.default.posix.join(SWIFT_STANDINS_DIR, standin.module, file)] = linked.has(standin) && file === `${standin.module}.c` ? `// ${standin.target}'s WebAssembly library defines ${standin.module}'s functions.
 ` : text4;
   }
   return files2;
 }
 function packageSnapshot(project, entry) {
   const layout = xcodeLayout(project.packagePath);
-  const linked = layout ? standinLibraries(layout) : /* @__PURE__ */ new Map();
+  const linked = layout ? standinLibraries(layout.binaries, layout.standins, layout.app.rootDir) : /* @__PURE__ */ new Map();
   const files2 = packageSources(project.packagePath, new Set([...linked.values()].flat()));
   const native = nativeSourceDescriptor(project.packagePath);
   return {
@@ -13324,13 +13687,16 @@ function packageSnapshot(project, entry) {
       files2
     ),
     native,
-    ...linked.size > 0 ? {
-      libraries: Object.fromEntries(
-        [...linked].map(([library, [first]]) => [
-          first.module,
-          import_node_fs16.default.readFileSync(library).toString("base64")
-        ])
-      )
+    ...linked.size > 0 || project.libraries ? {
+      libraries: {
+        ...project.libraries,
+        ...Object.fromEntries(
+          [...linked].map(([library, [first]]) => [
+            first.module,
+            import_node_fs16.default.readFileSync(library).toString("base64")
+          ])
+        )
+      }
     } : {},
     ...native ? {
       glue: readPackageFile(
@@ -13376,7 +13742,7 @@ async function compile(packagePath, stamp, moduleRootOverride, hosted, snapshot,
     };
   const moduleRoot = moduleRootOverride ?? linkedModuleRoots(packagePath).find(
     (root) => import_node_fs16.default.existsSync(import_node_path17.default.join(root, "toolchain.json"))
-  ) ?? await swiftDistributionRoot();
+  ) ?? await swiftDistributionRoot(signal);
   if (!moduleRoot)
     return {
       ...await compileRemote(packagePath, snapshot, void 0, signal),
@@ -13596,19 +13962,30 @@ async function compileRemote(packagePath, snapshot, hosted, ownerSignal) {
     icu: { url: address.icuUrl }
   };
 }
-function artifactFor(project, entry, moduleRoot) {
-  project.signal?.throwIfAborted();
+function artifactFor(project, entry, moduleRoot, signal = project.signal) {
+  if (project.signal && signal !== project.signal)
+    signal = signal ? AbortSignal.any([project.signal, signal]) : project.signal;
+  signal?.throwIfAborted();
   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);
+    if (running.stamp === stamp && running.signal === signal) return running.promise;
+    const again = () => artifactFor(project, entry, moduleRoot, signal);
+    const queued = running.promise.then(again, again);
+    if (!signal) return queued;
+    return new Promise((resolve2, reject) => {
+      const stop = () => reject(
+        signal.reason instanceof Error ? signal.reason : new Error("Swift compilation canceled", { cause: signal.reason })
+      );
+      signal.addEventListener("abort", stop, { once: true });
+      if (signal.aborted) stop();
+      queued.then(resolve2, reject).finally(() => signal.removeEventListener("abort", stop));
+    });
   }
   const snapshot = packageSnapshot(project, entry);
   if (sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) !== stamp) {
-    return artifactFor(project, entry, moduleRoot);
+    return artifactFor(project, entry, moduleRoot, signal);
   }
   const compiled = project.artifact?.compiled;
   if (project.artifact && compiled && compiled.module === moduleStamp(project.packagePath, moduleRoot, false)) {
@@ -13625,7 +14002,7 @@ function artifactFor(project, entry, moduleRoot) {
     moduleRoot,
     project.hosted,
     snapshot,
-    project.signal
+    signal
   ).then(
     (artifact) => {
       project.artifact = artifact;
@@ -13642,12 +14019,12 @@ function artifactFor(project, entry, moduleRoot) {
     }
   );
   const fresh = promise.then(
-    (artifact) => sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) === artifact.stamp ? artifact : artifactFor(project, entry, moduleRoot)
+    (artifact) => sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) === artifact.stamp ? artifact : artifactFor(project, entry, moduleRoot, signal)
   );
-  project.building = { stamp, promise: fresh };
+  project.building = { stamp, promise: fresh, signal };
   return fresh;
 }
-var import_node_crypto8, import_node_fs16, import_node_os9, import_node_path17, RESOURCE_PATH, ICU_PATH, SKIP_SOURCE_DIRS, NATIVE_DESCRIPTOR, NATIVE_GLUE, SwiftMissingModulesError, projects, xcodeProjects, XCODE_APP_DIR, XCODE_FRAMEWORKS_DIR, XCODE_PACKAGES_DIR, XCODE_STANDINS_DIR, CHECKOUTS_PREFIX, HOSTED_LIMITS, LOCAL_LIMITS, inputLimits, RESOURCE_CONTENT_TYPES, API_GAP_PATTERNS, IOS_SDK_FRAMEWORKS;
+var import_node_crypto8, import_node_fs16, import_node_os9, import_node_path17, RESOURCE_PATH, ICU_PATH, SKIP_SOURCE_DIRS, NATIVE_DESCRIPTOR, NATIVE_GLUE, SwiftMissingModulesError, projects, xcodeProjects, XCODE_APP_DIR, XCODE_FRAMEWORKS_DIR, XCODE_PACKAGES_DIR, CHECKOUTS_PREFIX, HOSTED_LIMITS, LOCAL_LIMITS, inputLimits, RESOURCE_CONTENT_TYPES, API_GAP_PATTERNS, IOS_SDK_FRAMEWORKS;
 var init_swift_host = __esm({
   "src/swift-host.ts"() {
     "use strict";
@@ -13690,7 +14067,6 @@ var init_swift_host = __esm({
     XCODE_APP_DIR = "__app__";
     XCODE_FRAMEWORKS_DIR = "__frameworks__";
     XCODE_PACKAGES_DIR = "__packages__";
-    XCODE_STANDINS_DIR = "__standins__";
     CHECKOUTS_PREFIX = `${REMOTE_CHECKOUTS.split(import_node_path17.default.sep).join(import_node_path17.default.posix.sep)}/`;
     HOSTED_LIMITS = {
       resources: MAX_SWIFT_COMPILE_RESOURCES,
@@ -13738,7 +14114,8 @@ var init_swift_host = __esm({
 });
 
 // src/expo-swift-host.ts
-async function collectExpoSwiftSources(appRoot) {
+async function collectExpoSwiftSources(appRoot, signal) {
+  signal?.throwIfAborted();
   appRoot = import_node_fs17.default.realpathSync(appRoot);
   const appRequire = (0, import_node_module.createRequire)(import_node_path18.default.join(appRoot, "package.json"));
   let autolinker;
@@ -13762,7 +14139,7 @@ async function collectExpoSwiftSources(appRoot) {
           appRoot,
           "--json"
         ],
-        { timeout: 3e4, maxBuffer: 8 * 1024 * 1024, env: scriptEnv }
+        { timeout: 3e4, maxBuffer: 8 * 1024 * 1024, env: scriptEnv, signal }
       )
     )
   );
@@ -13802,6 +14179,7 @@ async function collectExpoSwiftSources(appRoot) {
       throw new Error(`duplicate local Expo Swift module ${namespace}`);
     namespacesSeen.add(namespace);
     const files2 = {};
+    const frameworks = /* @__PURE__ */ new Set();
     const classes = [];
     for (const module2 of modules) {
       const className = typeof module2 === "string" ? module2 : module2 && typeof module2 === "object" ? Reflect.get(module2, "class") : null;
@@ -13814,19 +14192,41 @@ async function collectExpoSwiftSources(appRoot) {
       });
     }
     const ios = import_node_path18.default.join(canonical, "ios");
-    if (import_node_fs17.default.lstatSync(ios).isSymbolicLink())
-      throw new Error(`Expo Swift source directory is a symlink: ${ios}`);
-    const walk2 = (dir) => {
+    const directories = /* @__PURE__ */ new Set();
+    const sources = /* @__PURE__ */ new Set();
+    const resolveSource = (file) => {
+      let target;
+      try {
+        target = import_node_fs17.default.realpathSync(file);
+      } catch (cause) {
+        throw new Error(`Cannot resolve Expo Swift source: ${file}`, { cause });
+      }
+      const relative = import_node_path18.default.relative(canonical, target);
+      if (relative === ".." || relative.startsWith(`..${import_node_path18.default.sep}`) || import_node_path18.default.isAbsolute(relative))
+        throw new Error(`Expo Swift source escapes module root: ${file} -> ${target}`);
+      return target;
+    };
+    const walk2 = (dir, binary = false) => {
+      signal?.throwIfAborted();
+      const directory = resolveSource(dir);
+      if (directories.has(directory)) return;
+      directories.add(directory);
       for (const child of import_node_fs17.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
         const file = import_node_path18.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") walk2(file);
+        const linked = child.isSymbolicLink() ? resolveSource(file) : null;
+        const target = linked ? import_node_fs17.default.statSync(linked) : child;
+        if (target.isDirectory()) {
+          const framework = /\.(xcframework|framework)$/.test(child.name);
+          if (framework && !binary) frameworks.add(linked ?? resolveSource(file));
+          if (!child.name.startsWith(".") && child.name !== "build")
+            walk2(file, binary || framework);
           continue;
         }
-        if (!child.name.endsWith(".swift")) continue;
-        const size = import_node_fs17.default.statSync(file).size;
+        if (!target.isFile() || !child.name.endsWith(".swift")) continue;
+        const source = linked ?? resolveSource(file);
+        if (sources.has(source)) continue;
+        sources.add(source);
+        const size = import_node_fs17.default.statSync(source).size;
         bytes += size;
         fileCount++;
         if (fileCount > MAX_SWIFT_COMPILE_FILES - 2 || bytes > MAX_SWIFT_COMPILE_SOURCE_BYTES)
@@ -13835,7 +14235,7 @@ async function collectExpoSwiftSources(appRoot) {
         // through the underlying module; these source units have no clang pod.
         `import UIKit
 #sourceLocation(file: ${JSON.stringify(file)}, line: 1)
-${import_node_fs17.default.readFileSync(file, "utf8")}`;
+${import_node_fs17.default.readFileSync(source, "utf8")}`;
       }
     };
     walk2(ios);
@@ -13844,7 +14244,8 @@ ${import_node_fs17.default.readFileSync(file, "utf8")}`;
         namespace,
         moduleId: `${namespace}.${module2.name}`,
         classes: [module2.registration],
-        files: swiftSourceClosure(files2, [module2.name])
+        files: swiftSourceClosure(files2, [module2.name]),
+        frameworks: [...frameworks]
       };
       unit.files[EXPO_SWIFT_ENTRY] = expoEntry([unit]);
       units.push(unit);
@@ -13880,17 +14281,36 @@ ${import_node_fs17.default.readFileSync(file, "utf8")}`;
       if (namespace === unit.namespace) continue;
       const dependency = byNamespace.get(namespace);
       if (!dependency) throw new Error(`missing local Swift namespace ${namespace}`);
+      unit.frameworks = [
+        .../* @__PURE__ */ new Set([
+          ...unit.frameworks,
+          ...dependency.flatMap((item) => item.frameworks)
+        ])
+      ];
       for (const [name2, source] of Object.entries(allFiles)) {
         if (name2.startsWith(`Sources/${namespace}/`)) unit.files[name2] = source;
       }
     }
-    unit.files["Package.swift"] = `// swift-tools-version: 6.0
-import PackageDescription
-let package = Package(name: "PeachExpo", targets: [${[...included].map((name2) => `.target(name: ${JSON.stringify(name2)}, path: ${JSON.stringify(`Sources/${name2}`)})`).join(", ")}, .executableTarget(name: "PeachExpoApp", path: "Sources/PeachExpoApp")])
-`;
+    unit.files["Package.swift"] = expoManifest(unit.files);
   }
   return units;
 }
+function expoManifest(files2, generation = "") {
+  const targets = /* @__PURE__ */ new Map();
+  for (const file of Object.keys(files2)) {
+    const match = /^(Sources|__standins__)\/([^/]+)\//.exec(file);
+    if (!match || match[2] === "PeachExpoApp") continue;
+    const dir = `${match[1]}/${match[2]}`;
+    if (targets.has(match[2]) && targets.get(match[2]) !== dir)
+      throw new Error(`duplicate Expo Swift compile target ${match[2]}`);
+    targets.set(match[2], dir);
+  }
+  return `// swift-tools-version: 6.0
+import PackageDescription
+let package = Package(name: "PeachExpo", targets: [${[...targets].map(([name2, dir]) => `.target(name: ${JSON.stringify(name2)}, path: ${JSON.stringify(dir)}${dir.startsWith(`${SWIFT_STANDINS_DIR}/`) ? ", swiftSettings: [.swiftLanguageMode(.v5)]" : ""})`).join(", ")}, .executableTarget(name: "PeachExpoApp", path: "Sources/PeachExpoApp")])
+// stand-in inputs: ${generation}
+`;
+}
 function expoEntry(units) {
   return `import SwiftUI
 import ExpoModulesCore
@@ -13920,152 +14340,312 @@ function readFailedCompilation(packagePath) {
   }
   if (typeof record4 !== "object" || record4 === null || !("stamp" in record4) || !("diagnostic" in record4) || typeof record4.stamp !== "string" || typeof record4.diagnostic !== "string")
     return null;
+  if ("retryAt" in record4 && (typeof record4.retryAt !== "number" || !Number.isFinite(record4.retryAt) || record4.retryAt <= Date.now()))
+    return null;
   return { stamp: record4.stamp, diagnostic: record4.diagnostic };
 }
-async function compileExpoSwiftModules(root, base, publishArtifact) {
-  const units = await collectExpoSwiftSources(root);
-  if (!units) return null;
-  const module2 = await resolveSwiftModule();
-  if (!module2 && publishArtifact)
-    throw new Error("No local Swift toolchain or distribution is available");
-  const result = {
-    namespaces: units.map((unit) => unit.moduleId),
-    modules: [],
-    failures: []
-  };
-  if (!module2) {
-    for (const unit of units)
-      result.failures.push({
-        namespace: unit.moduleId,
-        diagnostic: "No local Swift toolchain or distribution is available"
-      });
-    return result;
-  }
-  const key2 = (0, import_node_crypto9.createHash)("sha256").update(import_node_fs17.default.realpathSync(root)).digest("hex");
-  const failures = /* @__PURE__ */ new Map();
-  const candidates = [];
-  const stamps = /* @__PURE__ */ new Map();
-  for (const unit of units) {
-    const packagePath = import_node_path18.default.join(import_node_os10.default.tmpdir(), "peach-expo-swift", key2, unit.moduleId);
-    syncSwiftTree(
-      packagePath,
-      new Map(
-        Object.entries(unit.files).map(([name2, source]) => [
-          import_node_path18.default.join(packagePath, name2),
-          source
-        ])
-      )
-    );
-    const stamp = sourceStamp(packagePath, module2.root);
-    const failed = readFailedCompilation(packagePath);
-    if (failed?.stamp === stamp) {
-      failures.set(unit.moduleId, failed.diagnostic);
-      continue;
-    }
-    import_node_fs17.default.rmSync(failureRecordPath(packagePath), { force: true });
-    stamps.set(unit, stamp);
-    candidates.push(unit);
-  }
-  const link = async (linked2) => {
-    const files2 = Object.assign(
-      {},
-      ...linked2.map((unit) => unit.files)
-    );
-    files2[EXPO_SWIFT_ENTRY] = expoEntry(linked2);
-    const targets = [
-      ...new Set(
-        Object.keys(files2).flatMap((name2) => {
-          const match = /^Sources\/([^/]+)\//.exec(name2);
-          return match && match[1] !== "PeachExpoApp" ? [match[1]] : [];
-        })
-      )
-    ];
-    files2["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")])
-`;
-    const packagePath = import_node_path18.default.join(import_node_os10.default.tmpdir(), "peach-expo-swift", key2, "linked-app");
-    syncSwiftTree(
-      packagePath,
-      new Map(
-        Object.entries(files2).map(([name2, source]) => [
-          import_node_path18.default.join(packagePath, name2),
-          source
-        ])
-      )
+async function compileExpoSwiftModules(root, base, publishArtifact, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 6e5;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647)
+    throw new Error("Expo Swift preparation timeout must be between 1 and 2147483647ms");
+  const controller = new AbortController();
+  const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+  const started = performance.now();
+  const report = (message) => console.error(`[expo-swift ${Math.round(performance.now() - started)}ms] ${message}`);
+  const timer = setTimeout(
+    () => controller.abort(new Error(`Expo Swift preparation exceeded ${timeoutMs}ms`)),
+    timeoutMs
+  );
+  try {
+    signal.throwIfAborted();
+    report(`discovering app-owned modules (budget ${timeoutMs}ms): ${root}`);
+    const units = await collectExpoSwiftSources(root, signal);
+    signal.throwIfAborted();
+    if (!units) return null;
+    report(
+      `preparing ${units.length} modules: ${units.map((unit) => unit.moduleId).join(", ")}`
     );
-    return artifactFor(projectFor(packagePath), EXPO_SWIFT_ENTRY, module2.root);
-  };
-  let linked = candidates;
-  let artifact;
-  if (linked.length) {
-    try {
-      artifact = await link(linked);
-    } catch (linkError) {
-      linked = [];
-      for (const unit of candidates) {
-        const packagePath = import_node_path18.default.join(import_node_os10.default.tmpdir(), "peach-expo-swift", key2, unit.moduleId);
-        try {
-          await artifactFor(projectFor(packagePath), EXPO_SWIFT_ENTRY, module2.root);
-          linked.push(unit);
-        } catch (error) {
-          const diagnostic = error instanceof Error ? error.message : String(error);
-          const appPaths = Object.values(unit.files).flatMap((source) => {
-            const match = /^#sourceLocation\(file: (".*"), line: 1\)$/m.exec(source);
-            if (!match) return [];
-            const file = JSON.parse(match[1]);
-            return typeof file === "string" ? [file] : [];
-          });
-          const errors = diagnostic.match(/^.+:\d+(?::\d+)?: error:.*$/gm) ?? [];
-          const sourceErrors = errors.filter(
-            (line) => appPaths.some((file) => line.startsWith(`${file}:`)) && !/external macro implementation type|failed to load library plugin/.test(
-              line
-            )
+    const module2 = await resolveSwiftModule({ signal });
+    signal.throwIfAborted();
+    if (!module2 && publishArtifact)
+      throw new Error("No local Swift toolchain or distribution is available");
+    const result = {
+      namespaces: units.map((unit) => unit.moduleId),
+      modules: [],
+      failures: []
+    };
+    if (!module2) {
+      for (const unit of units)
+        result.failures.push({
+          namespace: unit.moduleId,
+          diagnostic: "No local Swift toolchain or distribution is available"
+        });
+      return result;
+    }
+    const key2 = (0, import_node_crypto9.createHash)("sha256").update(import_node_fs17.default.realpathSync(root)).digest("hex");
+    const failures = /* @__PURE__ */ new Map();
+    const failureRecords = /* @__PURE__ */ new Map();
+    const candidates = [];
+    const stamps = /* @__PURE__ */ new Map();
+    const generations = /* @__PURE__ */ new Map();
+    const gaps = /* @__PURE__ */ new Map();
+    const libraries = /* @__PURE__ */ new Map();
+    for (const unit of units) {
+      signal.throwIfAborted();
+      if (unit.frameworks.length > 0) {
+        const provided = new Set(swiftPeachModules(module2.root));
+        const available = swiftAvailableModules(module2.root, module2.toolchainBin);
+        const binaries = await Promise.all(
+          unit.frameworks.map(async (dir) => {
+            const binary = {
+              target: import_node_path18.default.basename(dir).replace(/\.(xcframework|framework)$/, ""),
+              source: dir,
+              url: null,
+              checksum: null,
+              dir,
+              reached: true
+            };
+            return {
+              binary,
+              modules: dir.endsWith(".framework") ? [binary.target] : await swiftBinaryModules(binary)
+            };
+          })
+        );
+        const importedAvailable = /* @__PURE__ */ new Set([
+          ...available,
+          ...units.map((item) => item.namespace),
+          ...binaries.flatMap((item) => item.modules)
+        ]);
+        const imports = new Set(
+          Object.values(unit.files).flatMap(
+            (source) => swiftImportNames(source, importedAvailable)
+          )
+        );
+        const reached = binaries.filter((item) => item.modules.some((name2) => imports.has(name2))).map((item) => item.binary);
+        if (reached.length > 0) {
+          const toolchain = {
+            moduleRoot: module2.root,
+            release: module2.release,
+            toolchainBin: module2.toolchainBin
+          };
+          const generation = standinGenerationInputs(reached, toolchain);
+          const built2 = swiftStandins(reached, toolchain, provided);
+          const linkedLibraries = standinLibraries(reached, built2.standins, root);
+          const linkedStandins = new Set([...linkedLibraries.values()].flat());
+          for (const standin of built2.standins)
+            for (const [name2, source] of Object.entries(standin.files)) {
+              const file = `${SWIFT_STANDINS_DIR}/${standin.module}/${name2}`;
+              const text4 = linkedStandins.has(standin) && name2 === `${standin.module}.c` ? `// ${standin.target}'s WebAssembly library defines ${standin.module}'s functions.
+` : source;
+              if (file in unit.files && unit.files[file] !== text4)
+                throw new Error(`conflicting Expo Swift binary source ${file}`);
+              unit.files[file] = text4;
+            }
+          if (linkedLibraries.size > 0)
+            libraries.set(
+              unit,
+              Object.fromEntries(
+                [...linkedLibraries].map(([library, [first]]) => [
+                  first.module,
+                  import_node_fs17.default.readFileSync(library).toString("base64")
+                ])
+              )
+            );
+          generations.set(unit, generation);
+          gaps.set(
+            unit,
+            [...built2.gaps].map(([name2, reason]) => `${name2}: no stand-in: ${reason}`)
           );
-          if (publishArtifact && (sourceErrors.length === 0 || sourceErrors.length !== errors.length) && !(error instanceof SwiftMissingModulesError))
-            throw error;
-          const missing = error instanceof SwiftMissingModulesError;
-          if ((sourceErrors.length && sourceErrors.length === errors.length || missing) && sourceStamp(packagePath, module2.root) === stamps.get(unit)) {
-            import_node_fs17.default.writeFileSync(
-              failureRecordPath(packagePath),
-              JSON.stringify({
-                stamp: stamps.get(unit),
-                diagnostic: missing ? diagnostic : sourceErrors.join("\n")
-              })
+          unit.files["Package.swift"] = expoManifest(unit.files, generation);
+        }
+      }
+      const packagePath = import_node_path18.default.join(import_node_os10.default.tmpdir(), "peach-expo-swift", key2, unit.moduleId);
+      syncSwiftTree(
+        packagePath,
+        new Map(
+          Object.entries(unit.files).map(([name2, source]) => [
+            import_node_path18.default.join(packagePath, name2),
+            source
+          ])
+        )
+      );
+      projectFor(packagePath).libraries = libraries.get(unit);
+      const stamp = sourceStamp(packagePath, module2.root);
+      const failed = readFailedCompilation(packagePath);
+      if (failed?.stamp === stamp) {
+        failures.set(unit.moduleId, failed.diagnostic);
+        continue;
+      }
+      import_node_fs17.default.rmSync(failureRecordPath(packagePath), { force: true });
+      stamps.set(unit, stamp);
+      candidates.push(unit);
+    }
+    const link = async (linked2) => {
+      const files2 = {};
+      for (const unit of linked2)
+        for (const [name2, source] of Object.entries(unit.files)) {
+          if (name2.startsWith(`${SWIFT_STANDINS_DIR}/`) && name2 in files2 && files2[name2] !== source)
+            throw new Error(`conflicting Expo Swift binary source ${name2}`);
+          files2[name2] = source;
+        }
+      files2[EXPO_SWIFT_ENTRY] = expoEntry(linked2);
+      files2["Package.swift"] = expoManifest(
+        files2,
+        linked2.map((unit) => generations.get(unit) ?? "").join(",")
+      );
+      const packagePath = import_node_path18.default.join(import_node_os10.default.tmpdir(), "peach-expo-swift", key2, "linked-app");
+      syncSwiftTree(
+        packagePath,
+        new Map(
+          Object.entries(files2).map(([name2, source]) => [
+            import_node_path18.default.join(packagePath, name2),
+            source
+          ])
+        )
+      );
+      const linkedLibraries = /* @__PURE__ */ new Map();
+      for (const unit of linked2)
+        for (const [name2, library] of Object.entries(libraries.get(unit) ?? {})) {
+          if (linkedLibraries.has(name2) && linkedLibraries.get(name2) !== library)
+            throw new Error(`conflicting Expo Swift binary libraries for ${name2}`);
+          linkedLibraries.set(name2, library);
+        }
+      projectFor(packagePath).libraries = linkedLibraries.size > 0 ? Object.fromEntries(linkedLibraries) : void 0;
+      signal.throwIfAborted();
+      const stamp = sourceStamp(packagePath, module2.root);
+      const refused = readFailedCompilation(packagePath);
+      if (refused?.stamp === stamp) {
+        report("reusing recent link refusal");
+        throw new ExpoSwiftLinkRefusal(refused.diagnostic);
+      }
+      import_node_fs17.default.rmSync(failureRecordPath(packagePath), { force: true });
+      report(`linking ${linked2.map((unit) => unit.moduleId).join(", ")}`);
+      try {
+        return await artifactFor(
+          projectFor(packagePath),
+          EXPO_SWIFT_ENTRY,
+          module2.root,
+          signal
+        );
+      } catch (error) {
+        signal.throwIfAborted();
+        const diagnostic = error instanceof Error ? error.message : String(error);
+        if (error instanceof SwiftMissingModulesError || /^.+:\d+(?::\d+)?: error:|^(?:ld(?:\.lld)?|wasm-ld): error:/m.test(diagnostic))
+          throw error;
+        if (sourceStamp(packagePath, module2.root) === stamp)
+          failureRecords.set(packagePath, {
+            stamp,
+            diagnostic,
+            retryAt: Date.now() + 6e4
+          });
+        throw new ExpoSwiftLinkRefusal(diagnostic, { cause: error });
+      }
+    };
+    let linked = candidates;
+    let artifact;
+    if (linked.length) {
+      try {
+        artifact = await link(linked);
+      } catch (linkError) {
+        signal.throwIfAborted();
+        if (linkError instanceof ExpoSwiftLinkRefusal) {
+          if (publishArtifact) throw linkError;
+          for (const unit of candidates) failures.set(unit.moduleId, linkError.message);
+          linked = [];
+        } else {
+          report("linked build failed; isolating module diagnostics");
+          linked = [];
+          for (const unit of candidates) {
+            const packagePath = import_node_path18.default.join(
+              import_node_os10.default.tmpdir(),
+              "peach-expo-swift",
+              key2,
+              unit.moduleId
             );
+            try {
+              signal.throwIfAborted();
+              report(`checking ${unit.moduleId}`);
+              await artifactFor(
+                projectFor(packagePath),
+                EXPO_SWIFT_ENTRY,
+                module2.root,
+                signal
+              );
+              linked.push(unit);
+            } catch (error) {
+              signal.throwIfAborted();
+              const diagnostic = [
+                error instanceof Error ? error.message : String(error),
+                ...gaps.get(unit) ?? []
+              ].join("\n");
+              const appPaths = Object.values(unit.files).flatMap((source) => {
+                const match = /^#sourceLocation\(file: (".*"), line: 1\)$/m.exec(source);
+                if (!match) return [];
+                const file = JSON.parse(match[1]);
+                return typeof file === "string" ? [file] : [];
+              });
+              const errors = diagnostic.match(/^.+:\d+(?::\d+)?: error:.*$/gm) ?? [];
+              const sourceErrors = errors.filter(
+                (line) => appPaths.some((file) => line.startsWith(`${file}:`)) && !/external macro implementation type|failed to load library plugin/.test(
+                  line
+                )
+              );
+              if (publishArtifact && (sourceErrors.length === 0 || sourceErrors.length !== errors.length) && !(error instanceof SwiftMissingModulesError))
+                throw error;
+              const missing = error instanceof SwiftMissingModulesError;
+              if ((sourceErrors.length && sourceErrors.length === errors.length || missing) && sourceStamp(packagePath, module2.root) === stamps.get(unit)) {
+                failureRecords.set(packagePath, {
+                  stamp: stamps.get(unit),
+                  diagnostic: missing ? diagnostic : sourceErrors.join("\n")
+                });
+              }
+              failures.set(
+                unit.moduleId,
+                sourceErrors.length ? sourceErrors.join("\n") : diagnostic
+              );
+            }
           }
-          failures.set(
-            unit.moduleId,
-            sourceErrors.length ? sourceErrors.join("\n") : diagnostic
-          );
+          if (linked.length === candidates.length) throw linkError;
+          if (linked.length) artifact = await link(linked);
         }
       }
-      if (linked.length === candidates.length) throw linkError;
-      if (linked.length) artifact = await link(linked);
     }
+    for (const unit of units) {
+      const diagnostic = failures.get(unit.moduleId);
+      if (diagnostic !== void 0)
+        result.failures.push({ namespace: unit.moduleId, diagnostic });
+    }
+    if (artifact) {
+      signal.throwIfAborted();
+      await publishArtifact?.(artifact, signal);
+      result.modules.push({
+        namespaces: linked.map((unit) => unit.moduleId),
+        url: `${base}/__peach/swift/${artifact.hash}.wasm`,
+        hash: artifact.hash,
+        icuUrl: icuUrl(base, artifact),
+        rootId: `${key2}/Expo`
+      });
+    }
+    signal.throwIfAborted();
+    for (const [packagePath, record4] of failureRecords)
+      import_node_fs17.default.writeFileSync(failureRecordPath(packagePath), JSON.stringify(record4));
+    report(
+      `ready: ${result.modules.length} artifact, ${result.failures.length} unavailable modules`
+    );
+    return result;
+  } catch (error) {
+    const failure2 = signal.aborted ? signal.reason : error;
+    report(`failed: ${failure2 instanceof Error ? failure2.message : String(failure2)}`);
+    throw failure2;
+  } finally {
+    clearTimeout(timer);
   }
-  for (const unit of units) {
-    const diagnostic = failures.get(unit.moduleId);
-    if (diagnostic !== void 0)
-      result.failures.push({ namespace: unit.moduleId, diagnostic });
-  }
-  if (artifact) {
-    await publishArtifact?.(artifact);
-    result.modules.push({
-      namespaces: linked.map((unit) => unit.moduleId),
-      url: `${base}/__peach/swift/${artifact.hash}.wasm`,
-      hash: artifact.hash,
-      icuUrl: icuUrl(base, artifact),
-      rootId: `${key2}/Expo`
-    });
-  }
-  return result;
 }
-var import_node_child_process10, import_node_crypto9, import_node_fs17, import_node_module, import_node_os10, import_node_path18, import_node_util2, run2, scriptEnv, EXPO_SWIFT_ENTRY;
+var import_node_child_process11, import_node_crypto9, import_node_fs17, import_node_module, import_node_os10, import_node_path18, import_node_util2, run2, scriptEnv, EXPO_SWIFT_ENTRY, ExpoSwiftLinkRefusal;
 var init_expo_swift_host = __esm({
   "src/expo-swift-host.ts"() {
     "use strict";
-    import_node_child_process10 = require("node:child_process");
+    import_node_child_process11 = require("node:child_process");
     import_node_crypto9 = require("node:crypto");
     import_node_fs17 = __toESM(require("node:fs"), 1);
     import_node_module = require("node:module");
@@ -14074,13 +14654,17 @@ var init_expo_swift_host = __esm({
     import_node_util2 = require("node:util");
     init_internal_child();
     init_backend_origin();
+    init_swift_binary_modules();
     init_swift_compile();
     init_swift_distribution();
     init_swift_host();
+    init_swift_standins();
     init_swift_submit();
-    run2 = (0, import_node_util2.promisify)(import_node_child_process10.execFile);
+    run2 = (0, import_node_util2.promisify)(import_node_child_process11.execFile);
     scriptEnv = { ...process.env, [RNX_FORKED_SCRIPT_ENV]: "1" };
     EXPO_SWIFT_ENTRY = "Sources/PeachExpoApp/PeachExpoEntry.swift";
+    ExpoSwiftLinkRefusal = class extends Error {
+    };
   }
 });
 
@@ -14091,20 +14675,25 @@ __export(expo_swift_bundle_exports, {
 });
 async function buildExpoSwiftBundle(appRoot) {
   const assets2 = [];
-  const metadata = await compileExpoSwiftModules(appRoot, "", async (artifact) => {
-    assets2.push({
-      path: `__peach/swift/${artifact.hash}.wasm`,
-      bytes: artifact.bytes,
-      contentType: "application/wasm"
-    });
-    if ("gzip" in artifact.icu) {
+  const metadata = await compileExpoSwiftModules(
+    appRoot,
+    "",
+    async (artifact, signal) => {
+      signal.throwIfAborted();
       assets2.push({
-        path: `__peach/swift-icu/${artifact.icu.sha256}`,
-        bytes: artifact.icu.gzip,
-        contentType: "application/gzip"
+        path: `__peach/swift/${artifact.hash}.wasm`,
+        bytes: artifact.bytes,
+        contentType: "application/wasm"
       });
+      if ("gzip" in artifact.icu) {
+        assets2.push({
+          path: `__peach/swift-icu/${artifact.icu.sha256}`,
+          bytes: artifact.icu.gzip,
+          contentType: "application/gzip"
+        });
+      }
     }
-  });
+  );
   if (!metadata) return null;
   return { metadata, assets: assets2 };
 }
@@ -14115,6 +14704,78 @@ var init_expo_swift_bundle = __esm({
   }
 });
 
+// src/androidAutolinkingContract.ts
+var init_androidAutolinkingContract = __esm({
+  "src/androidAutolinkingContract.ts"() {
+    "use strict";
+    init_bundleGlobalFooter();
+  }
+});
+
+// src/android-autolinking.ts
+async function resolveExpoAndroidAutolinking(appRoot) {
+  const root = import_node_fs18.default.realpathSync(appRoot);
+  const existing = resolving.get(root);
+  if (existing) return existing;
+  const pending = resolveAndroidModules(root);
+  resolving.set(root, pending);
+  try {
+    return await pending;
+  } finally {
+    if (resolving.get(root) === pending) resolving.delete(root);
+  }
+}
+async function resolveAndroidModules(appRoot) {
+  let autolinker;
+  try {
+    autolinker = (0, import_node_module2.createRequire)(import_node_path19.default.join(appRoot, "package.json")).resolve(
+      "expo-modules-autolinking/package.json"
+    );
+  } catch (error) {
+    if (isRecord(error) && error.code === "MODULE_NOT_FOUND") return [];
+    throw error;
+  }
+  const { stdout } = await run3(
+    process.execPath,
+    [
+      import_node_path19.default.join(import_node_path19.default.dirname(autolinker), "bin/expo-modules-autolinking.js"),
+      "resolve",
+      "--platform",
+      "android",
+      "--project-root",
+      appRoot,
+      "--json"
+    ],
+    {
+      timeout: 3e4,
+      maxBuffer: 8 * 1024 * 1024,
+      env: { ...process.env, [RNX_FORKED_SCRIPT_ENV]: "1" }
+    }
+  );
+  const resolved = JSON.parse(stdout);
+  if (!isRecord(resolved) || !Array.isArray(resolved.modules))
+    throw new Error("invalid Expo Android autolinking result");
+  if (!resolved.modules.every(isRecord))
+    throw new Error("invalid Expo Android autolinking entry");
+  return resolved.modules;
+}
+var import_node_child_process12, import_node_fs18, import_node_module2, import_node_path19, import_node_util3, run3, resolving;
+var init_android_autolinking = __esm({
+  "src/android-autolinking.ts"() {
+    "use strict";
+    import_node_child_process12 = require("node:child_process");
+    import_node_fs18 = __toESM(require("node:fs"), 1);
+    import_node_module2 = require("node:module");
+    import_node_path19 = __toESM(require("node:path"), 1);
+    import_node_util3 = require("node:util");
+    init_internal_child();
+    init_androidAutolinkingContract();
+    init_is_record();
+    run3 = (0, import_node_util3.promisify)(import_node_child_process12.execFile);
+    resolving = /* @__PURE__ */ new Map();
+  }
+});
+
 // cli/standalone.ts
 var IS_STANDALONE;
 var init_standalone = __esm({
@@ -14127,45 +14788,45 @@ var init_standalone = __esm({
 // src/kotlin-module.ts
 function peachKotlinModuleRoot() {
   if (!IS_STANDALONE)
-    return import_node_path19.default.resolve(import_node_path19.default.dirname((0, import_node_url2.fileURLToPath)(__sootsim_import_meta_url)), "..", "kotlin");
+    return import_node_path20.default.resolve(import_node_path20.default.dirname((0, import_node_url2.fileURLToPath)(__sootsim_import_meta_url)), "..", "kotlin");
   if (installedRoot) return installedRoot;
   const files2 = __PEACH_BUNDLED_KOTLIN__;
   const digest2 = (0, import_node_crypto10.createHash)("sha256").update(JSON.stringify(files2)).digest("hex");
-  const parent = import_node_path19.default.join(rnxHomeDir(), "kotlin", "modules");
-  const root = import_node_path19.default.join(parent, digest2);
-  import_node_fs18.default.mkdirSync(parent, { recursive: true });
-  if (!import_node_fs18.default.existsSync(root)) {
-    const pending = import_node_fs18.default.mkdtempSync(import_node_path19.default.join(parent, ".install-"));
+  const parent = import_node_path20.default.join(rnxHomeDir(), "kotlin", "modules");
+  const root = import_node_path20.default.join(parent, digest2);
+  import_node_fs19.default.mkdirSync(parent, { recursive: true });
+  if (!import_node_fs19.default.existsSync(root)) {
+    const pending = import_node_fs19.default.mkdtempSync(import_node_path20.default.join(parent, ".install-"));
     try {
       for (const [name2, contents] of Object.entries(files2)) {
-        const file = import_node_path19.default.join(pending, name2);
-        import_node_fs18.default.mkdirSync(import_node_path19.default.dirname(file), { recursive: true });
-        import_node_fs18.default.writeFileSync(file, contents);
+        const file = import_node_path20.default.join(pending, name2);
+        import_node_fs19.default.mkdirSync(import_node_path20.default.dirname(file), { recursive: true });
+        import_node_fs19.default.writeFileSync(file, contents);
       }
       try {
-        import_node_fs18.default.renameSync(pending, root);
+        import_node_fs19.default.renameSync(pending, root);
       } catch (error) {
         if (!isRecord(error) || error.code !== "EEXIST" && error.code !== "ENOTEMPTY")
           throw error;
       }
     } finally {
-      import_node_fs18.default.rmSync(pending, { recursive: true, force: true });
+      import_node_fs19.default.rmSync(pending, { recursive: true, force: true });
     }
   }
   for (const [name2, contents] of Object.entries(files2)) {
-    if (import_node_fs18.default.readFileSync(import_node_path19.default.join(root, name2), "utf8") !== contents)
+    if (import_node_fs19.default.readFileSync(import_node_path20.default.join(root, name2), "utf8") !== contents)
       throw new Error(`packaged Kotlin module differs from this CLI: ${name2}`);
   }
   installedRoot = root;
   return root;
 }
-var import_node_crypto10, import_node_fs18, import_node_path19, import_node_url2, installedRoot;
+var import_node_crypto10, import_node_fs19, import_node_path20, import_node_url2, installedRoot;
 var init_kotlin_module = __esm({
   "src/kotlin-module.ts"() {
     "use strict";
     import_node_crypto10 = require("node:crypto");
-    import_node_fs18 = __toESM(require("node:fs"), 1);
-    import_node_path19 = __toESM(require("node:path"), 1);
+    import_node_fs19 = __toESM(require("node:fs"), 1);
+    import_node_path20 = __toESM(require("node:path"), 1);
     import_node_url2 = require("node:url");
     init_standalone();
     init_home_paths();
@@ -14270,7 +14931,7 @@ __export(kotlin_host_exports, {
 });
 function readToolchain(moduleRoot) {
   const parsed = JSON.parse(
-    import_node_fs19.default.readFileSync(import_node_path20.default.join(moduleRoot, "toolchain.json"), "utf8")
+    import_node_fs20.default.readFileSync(import_node_path21.default.join(moduleRoot, "toolchain.json"), "utf8")
   );
   const download = (value) => {
     if (!isRecord(value) || typeof value.url !== "string" || typeof value.sha256 !== "string")
@@ -14311,43 +14972,43 @@ function readToolchain(moduleRoot) {
   };
 }
 function kotlinHome() {
-  return import_node_path20.default.join(rnxHomeDir(), "kotlin");
+  return import_node_path21.default.join(rnxHomeDir(), "kotlin");
 }
 async function fetchVerified(download, target) {
-  if (import_node_fs19.default.existsSync(target)) return;
+  if (import_node_fs20.default.existsSync(target)) return;
   const response = await fetch(download.url);
   if (!response.ok) throw new Error(`${download.url} answered ${response.status}`);
   const bytes = Buffer.from(await response.arrayBuffer());
   const digest2 = (0, import_node_crypto11.createHash)("sha256").update(bytes).digest("hex");
   if (digest2 !== download.sha256)
     throw new Error(`${download.url} has sha256 ${digest2}, expected ${download.sha256}`);
-  import_node_fs19.default.mkdirSync(import_node_path20.default.dirname(target), { recursive: true });
+  import_node_fs20.default.mkdirSync(import_node_path21.default.dirname(target), { recursive: true });
   const partial = `${target}.${process.pid}.partial`;
-  import_node_fs19.default.writeFileSync(partial, bytes);
-  import_node_fs19.default.renameSync(partial, target);
+  import_node_fs20.default.writeFileSync(partial, bytes);
+  import_node_fs20.default.renameSync(partial, target);
 }
 function ensureToolchain(toolchain) {
   const key2 = JSON.stringify(toolchain);
   const pending = toolchains.get(key2);
   if (pending) return pending;
   const ready = (async () => {
-    const dir = import_node_path20.default.join(kotlinHome(), toolchain.compiler.version);
-    const kotlinc = import_node_path20.default.join(dir, "kotlinc", "bin", "kotlinc-wasm");
-    if (!import_node_fs19.default.existsSync(kotlinc)) {
-      const zip = import_node_path20.default.join(dir, "kotlin-compiler.zip");
+    const dir = import_node_path21.default.join(kotlinHome(), toolchain.compiler.version);
+    const kotlinc = import_node_path21.default.join(dir, "kotlinc", "bin", "kotlinc-wasm");
+    if (!import_node_fs20.default.existsSync(kotlinc)) {
+      const zip = import_node_path21.default.join(dir, "kotlin-compiler.zip");
       await fetchVerified(toolchain.compiler, zip);
-      await run3("unzip", ["-q", "-o", zip, "-d", dir]);
-      import_node_fs19.default.rmSync(zip);
+      await run4("unzip", ["-q", "-o", zip, "-d", dir]);
+      import_node_fs20.default.rmSync(zip);
     }
-    const java = process.env.JAVA_HOME ? import_node_path20.default.join(process.env.JAVA_HOME, "bin", "java") : "java";
-    await run3(java, ["-version"]).catch(() => {
+    const java = process.env.JAVA_HOME ? import_node_path21.default.join(process.env.JAVA_HOME, "bin", "java") : "java";
+    await run4(java, ["-version"]).catch(() => {
       throw new Error(
         `Kotlin in Peach compiles with kotlinc, which needs a Java runtime (17 or newer, as android builds use); ${process.env.JAVA_HOME ? `JAVA_HOME ${process.env.JAVA_HOME} has none` : "set JAVA_HOME or put java on PATH"}`
       );
     });
-    const libraries = [import_node_path20.default.join(dir, "kotlinc", "lib", "kotlin-stdlib-wasm-js.klib")];
+    const libraries = [import_node_path21.default.join(dir, "kotlinc", "lib", "kotlin-stdlib-wasm-js.klib")];
     for (const library of toolchain.libraries) {
-      const target = import_node_path20.default.join(dir, library.name);
+      const target = import_node_path21.default.join(dir, library.name);
       await fetchVerified(library, target);
       libraries.push(target);
     }
@@ -14360,11 +15021,11 @@ function ensureToolchain(toolchain) {
   return ready;
 }
 function appKotlinLanguage(root) {
-  const reactNative = import_node_path20.default.dirname(
-    (0, import_node_module2.createRequire)(import_node_path20.default.join(root, "package.json")).resolve("react-native/package.json")
+  const reactNative = import_node_path21.default.dirname(
+    (0, import_node_module3.createRequire)(import_node_path21.default.join(root, "package.json")).resolve("react-native/package.json")
   );
-  const versions = import_node_fs19.default.readFileSync(
-    import_node_path20.default.join(reactNative, "gradle", "libs.versions.toml"),
+  const versions = import_node_fs20.default.readFileSync(
+    import_node_path21.default.join(reactNative, "gradle", "libs.versions.toml"),
     "utf8"
   );
   const match = /^kotlin\s*=\s*"(\d+)\.(\d+)/m.exec(versions);
@@ -14375,9 +15036,9 @@ function appKotlinLanguage(root) {
 function kotlinSources(root, skip = SKIP_DIRS) {
   const sources = [];
   const walk2 = (dir) => {
-    for (const entry of import_node_fs19.default.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs20.default.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || skip.has(entry.name)) continue;
-      const full = import_node_path20.default.join(dir, entry.name);
+      const full = import_node_path21.default.join(dir, entry.name);
       if (entry.isDirectory()) walk2(full);
       else if (entry.isFile() && entry.name.endsWith(".kt")) sources.push(full);
     }
@@ -14387,51 +15048,51 @@ function kotlinSources(root, skip = SKIP_DIRS) {
 }
 function kotlinPlatformSources(moduleRoot, usesCompose) {
   return ["Sources", "JniPlatformSources", "JniSources"].flatMap(
-    (directory) => kotlinSources(import_node_path20.default.join(moduleRoot, directory), /* @__PURE__ */ new Set()).filter(
+    (directory) => kotlinSources(import_node_path21.default.join(moduleRoot, directory), /* @__PURE__ */ new Set()).filter(
       (file) => usesCompose ? !file.endsWith("/androidx/annotation/CallSuper.kt") : !file.endsWith("/OneNativeSourceViewDispatch.kt")
     )
   );
 }
 function ensureCompilerPlugin(kotlinc, plugin) {
-  const cache = import_node_path20.default.join(kotlinHome(), "compiler-plugins");
-  const out = import_node_path20.default.join(cache, plugin.hash);
-  if (import_node_fs19.default.existsSync(out)) return Promise.resolve(out);
+  const cache = import_node_path21.default.join(kotlinHome(), "compiler-plugins");
+  const out = import_node_path21.default.join(cache, plugin.hash);
+  if (import_node_fs20.default.existsSync(out)) return Promise.resolve(out);
   const pending = compilerPlugins.get(plugin.hash);
   if (pending) return pending;
   const build = (async () => {
-    import_node_fs19.default.mkdirSync(cache, { recursive: true });
-    const work = import_node_fs19.default.mkdtempSync(import_node_path20.default.join(cache, `${plugin.hash}-`));
-    const classes = import_node_path20.default.join(work, "classes");
+    import_node_fs20.default.mkdirSync(cache, { recursive: true });
+    const work = import_node_fs20.default.mkdtempSync(import_node_path21.default.join(cache, `${plugin.hash}-`));
+    const classes = import_node_path21.default.join(work, "classes");
     try {
       const sources = [];
       for (const { name: name2, bytes } of plugin.files) {
-        const target = import_node_path20.default.join(work, "sources", name2);
-        import_node_fs19.default.mkdirSync(import_node_path20.default.dirname(target), { recursive: true });
-        import_node_fs19.default.writeFileSync(target, bytes);
+        const target = import_node_path21.default.join(work, "sources", name2);
+        import_node_fs20.default.mkdirSync(import_node_path21.default.dirname(target), { recursive: true });
+        import_node_fs20.default.writeFileSync(target, bytes);
         if (name2.endsWith(".kt")) sources.push(target);
       }
-      await run3(
-        import_node_path20.default.join(import_node_path20.default.dirname(kotlinc), "kotlinc"),
+      await run4(
+        import_node_path21.default.join(import_node_path21.default.dirname(kotlinc), "kotlinc"),
         [
           "-cp",
-          import_node_path20.default.resolve(import_node_path20.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
+          import_node_path21.default.resolve(import_node_path21.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
           ...sources,
           "-d",
           classes
         ],
         { maxBuffer: 16 * 1024 * 1024 }
       );
-      const service = import_node_path20.default.join(classes, COMPILER_PLUGIN_SERVICE);
-      import_node_fs19.default.mkdirSync(import_node_path20.default.dirname(service), { recursive: true });
-      import_node_fs19.default.copyFileSync(import_node_path20.default.join(work, "sources", COMPILER_PLUGIN_SERVICE), service);
+      const service = import_node_path21.default.join(classes, COMPILER_PLUGIN_SERVICE);
+      import_node_fs20.default.mkdirSync(import_node_path21.default.dirname(service), { recursive: true });
+      import_node_fs20.default.copyFileSync(import_node_path21.default.join(work, "sources", COMPILER_PLUGIN_SERVICE), service);
       try {
-        import_node_fs19.default.renameSync(classes, out);
+        import_node_fs20.default.renameSync(classes, out);
       } catch (error) {
-        if (!import_node_fs19.default.existsSync(out)) throw error;
+        if (!import_node_fs20.default.existsSync(out)) throw error;
       }
       return out;
     } finally {
-      import_node_fs19.default.rmSync(work, { recursive: true, force: true });
+      import_node_fs20.default.rmSync(work, { recursive: true, force: true });
     }
   })().finally(() => compilerPlugins.delete(plugin.hash));
   compilerPlugins.set(plugin.hash, build);
@@ -14485,7 +15146,7 @@ function entrySource(ids) {
   ].join("\n");
 }
 function buildsDir() {
-  return import_node_path20.default.join(kotlinHome(), "builds");
+  return import_node_path21.default.join(kotlinHome(), "builds");
 }
 async function kotlinArtifact(root, moduleRoot, origin, target = "app") {
   const { kotlinSourceId, nativeSourceContract, renderKotlinSourceGlue } = await import("vxrn/native-source-contract");
@@ -14498,7 +15159,7 @@ async function kotlinArtifact(root, moduleRoot, origin, target = "app") {
   const viewIds = [];
   let usesCompose = false;
   for (const file of sources) {
-    const source = import_node_fs19.default.readFileSync(file, "utf8");
+    const source = import_node_fs20.default.readFileSync(file, "utf8");
     if (/\bandroidx\.compose\./.test(source)) usesCompose = true;
     const contract = nativeSourceContract(file, source);
     if (contract.modules.length === 0 && contract.views.length === 0) continue;
@@ -14511,9 +15172,9 @@ async function kotlinArtifact(root, moduleRoot, origin, target = "app") {
   if (viewIds.length > 0) generated["PeachViews.kt"] = viewsSource(viewIds);
   const shims = kotlinPlatformSources(moduleRoot, usesCompose);
   if (target === "jni")
-    shims.push(...kotlinSources(import_node_path20.default.join(moduleRoot, "JniTransportSources"), /* @__PURE__ */ new Set()));
+    shims.push(...kotlinSources(import_node_path21.default.join(moduleRoot, "JniTransportSources"), /* @__PURE__ */ new Set()));
   if (viewIds.length > 0)
-    shims.push(...kotlinSources(import_node_path20.default.join(moduleRoot, "ComposeSources")));
+    shims.push(...kotlinSources(import_node_path21.default.join(moduleRoot, "ComposeSources")));
   return compileKotlin(
     { root, moduleRoot, toolchain, language, sources, generated, shims, usesCompose },
     origin
@@ -14583,23 +15244,23 @@ function readExpoTypes(output) {
 function scanExpoTypes(toolchain, script, sources) {
   const candidates = sources.filter(
     (file) => /\bRecord\b|\benum\s+class\b|\bExpoComposeView\b|\bExpoView\b|\bComposeProps\b|:\s*(?:[A-Za-z0-9_.]+\.)?(?:View|FrameLayout|LinearLayout|ViewGroup)\b/.test(
-      import_node_fs19.default.readFileSync(file, "utf8")
+      import_node_fs20.default.readFileSync(file, "utf8")
     )
   );
   if (candidates.length === 0) return Promise.resolve([]);
   const digest2 = (0, import_node_crypto11.createHash)("sha256").update(JSON.stringify(toolchain.compiler));
   for (const file of [script, ...candidates])
-    digest2.update(`${file}\0${import_node_fs19.default.readFileSync(file, "utf8")}\0`);
+    digest2.update(`${file}\0${import_node_fs20.default.readFileSync(file, "utf8")}\0`);
   const key2 = digest2.digest("hex");
   let scan = expoTypeScans.get(key2);
   if (!scan) {
     scan = (async () => {
       const { kotlinc } = await ensureToolchain(toolchain);
-      const { stdout } = await run3(
-        import_node_path20.default.join(import_node_path20.default.dirname(kotlinc), "kotlinc"),
+      const { stdout } = await run4(
+        import_node_path21.default.join(import_node_path21.default.dirname(kotlinc), "kotlinc"),
         [
           "-cp",
-          import_node_path20.default.resolve(import_node_path20.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
+          import_node_path21.default.resolve(import_node_path21.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
           "-script",
           script,
           ...candidates
@@ -14676,7 +15337,7 @@ function expoTypeSources(files2) {
       )
     ];
     if (edits.length > 0 || views.length > 0) {
-      let text4 = import_node_fs19.default.readFileSync(file.file, "utf8").replaceAll("\r\n", "\n");
+      let text4 = import_node_fs20.default.readFileSync(file.file, "utf8").replaceAll("\r\n", "\n");
       for (const { range: range2, owner, field } of edits.sort((a, b) => b.range[0] - a.range[0]))
         text4 = `${text4.slice(0, range2[0])}dev.peach.expo.PeachExpoTypes.initial(${owner}::class, ${literal(field.key)}, ${field.required}) { ${text4.slice(range2[0], range2[1])} }${text4.slice(range2[1])}`;
       if (views.length > 0) {
@@ -14692,7 +15353,7 @@ function expoTypeSources(files2) {
           `${file.package ? `${file.package}.` : ""}peachExpoViews${index}()`
         );
       }
-      const name2 = `PeachExpoSource_${index}_${import_node_path20.default.basename(file.file)}`;
+      const name2 = `PeachExpoSource_${index}_${import_node_path21.default.basename(file.file)}`;
       generated[name2] = text4;
       origins[name2] = file.file;
     }
@@ -14715,19 +15376,19 @@ async function expoKotlinArtifact(root, moduleRoot, origin, modules) {
   const language = appKotlinLanguage(root);
   const scanned = await scanExpoTypes(
     toolchain,
-    import_node_path20.default.join(moduleRoot, "tools/expo-types.main.kts"),
+    import_node_path21.default.join(moduleRoot, "tools/expo-types.main.kts"),
     modules.sources
   );
   const usesCompose = scanned.some((file) => file.views.length > 0) || modules.sources.some(
-    (file) => /\bandroidx\.compose\./.test(import_node_fs19.default.readFileSync(file, "utf8"))
+    (file) => /\bandroidx\.compose\./.test(import_node_fs20.default.readFileSync(file, "utf8"))
   );
   const shims = [
     ...kotlinPlatformSources(moduleRoot, usesCompose),
-    ...kotlinSources(import_node_path20.default.join(moduleRoot, "ExpoSources"), /* @__PURE__ */ new Set()),
-    ...kotlinSources(import_node_path20.default.join(moduleRoot, "AndroidViewSources"), /* @__PURE__ */ new Set()),
+    ...kotlinSources(import_node_path21.default.join(moduleRoot, "ExpoSources"), /* @__PURE__ */ new Set()),
+    ...kotlinSources(import_node_path21.default.join(moduleRoot, "AndroidViewSources"), /* @__PURE__ */ new Set()),
     ...usesCompose ? [
-      ...kotlinSources(import_node_path20.default.join(moduleRoot, "ComposeSources")),
-      ...kotlinSources(import_node_path20.default.join(moduleRoot, "ExpoComposeSources"), /* @__PURE__ */ new Set())
+      ...kotlinSources(import_node_path21.default.join(moduleRoot, "ComposeSources")),
+      ...kotlinSources(import_node_path21.default.join(moduleRoot, "ExpoComposeSources"), /* @__PURE__ */ new Set())
     ] : []
   ];
   const types = expoTypeSources(scanned);
@@ -14871,9 +15532,9 @@ async function kotlinAppArtifact(app, moduleRoot, origin) {
   };
   const shims = [
     ...kotlinPlatformSources(moduleRoot, true),
-    ...kotlinSources(import_node_path20.default.join(moduleRoot, "ComposeSources")),
-    ...kotlinSources(import_node_path20.default.join(moduleRoot, "AppSources"), /* @__PURE__ */ new Set()),
-    ...kotlinSources(import_node_path20.default.join(moduleRoot, "AndroidViewSources"), /* @__PURE__ */ new Set())
+    ...kotlinSources(import_node_path21.default.join(moduleRoot, "ComposeSources")),
+    ...kotlinSources(import_node_path21.default.join(moduleRoot, "AppSources"), /* @__PURE__ */ new Set()),
+    ...kotlinSources(import_node_path21.default.join(moduleRoot, "AndroidViewSources"), /* @__PURE__ */ new Set())
   ];
   return compileKotlin(
     {
@@ -14888,7 +15549,7 @@ async function kotlinAppArtifact(app, moduleRoot, origin) {
       viewModels: {
         file: "PeachAppEntry.kt",
         render: appEntry,
-        script: import_node_path20.default.join(moduleRoot, "tools/abi-classes.main.kts")
+        script: import_node_path21.default.join(moduleRoot, "tools/abi-classes.main.kts")
       }
     },
     origin
@@ -14933,7 +15594,7 @@ function appResourceSources(app) {
       entries: app.drawables.map((drawable) => ({
         name: drawable.name,
         init: `listOf(
-${drawable.files.map((file) => drawableInit(file, import_node_path20.default.relative(app.moduleDir, file.file))).join(",\n")}
+${drawable.files.map((file) => drawableInit(file, import_node_path21.default.relative(app.moduleDir, file.file))).join(",\n")}
 )`
       }))
     },
@@ -14997,7 +15658,7 @@ function drawableInit(drawable, file) {
   if (drawable.kind === "xml") return `PeachDrawable.Xml(${where})`;
   if (drawable.kind === "bitmap")
     return `PeachDrawable.Bitmap(${where}, ${drawable.ninePatch}, ${literal(
-      import_node_fs19.default.readFileSync(drawable.file).toString("base64")
+      import_node_fs20.default.readFileSync(drawable.file).toString("base64")
     )})`;
   const vector = drawable.vector;
   const float = (value) => `${value}f`;
@@ -15058,15 +15719,15 @@ async function compileKotlin(input, origin) {
     usesCompose,
     viewModels
   } = input;
-  const compilerRoot = import_node_path20.default.join(moduleRoot, "CompilerSources");
+  const compilerRoot = import_node_path21.default.join(moduleRoot, "CompilerSources");
   const compilerFiles = [
     ...kotlinSources(compilerRoot, /* @__PURE__ */ new Set()).map(
-      (file) => import_node_path20.default.relative(compilerRoot, file)
+      (file) => import_node_path21.default.relative(compilerRoot, file)
     ),
     COMPILER_PLUGIN_SERVICE
   ].map((name2) => ({
     name: name2,
-    bytes: import_node_fs19.default.readFileSync(import_node_path20.default.join(compilerRoot, name2))
+    bytes: import_node_fs20.default.readFileSync(import_node_path21.default.join(compilerRoot, name2))
   }));
   const compilerDigest = (0, import_node_crypto11.createHash)("sha256").update(
     JSON.stringify({ format: 1, compiler: toolchain.compiler })
@@ -15076,15 +15737,15 @@ async function compileKotlin(input, origin) {
   const plugin = { hash: compilerDigest.digest("hex"), files: compilerFiles };
   const inputs = [...shims, ...sources].map((file) => ({
     file,
-    bytes: import_node_fs19.default.readFileSync(file)
+    bytes: import_node_fs20.default.readFileSync(file)
   }));
   const digest2 = (0, import_node_crypto11.createHash)("sha256");
   digest2.update(
     JSON.stringify({ format: BUILD_FORMAT, toolchain, language, plugin: plugin.hash })
   );
   for (const { file, bytes } of inputs)
-    digest2.update(import_node_path20.default.relative(root, file)).update("\0").update(bytes).update("\0");
-  if (viewModels) digest2.update(import_node_fs19.default.readFileSync(viewModels.script));
+    digest2.update(import_node_path21.default.relative(root, file)).update("\0").update(bytes).update("\0");
+  if (viewModels) digest2.update(import_node_fs20.default.readFileSync(viewModels.script));
   for (const [name2, text4] of Object.entries(generated))
     digest2.update(`${name2}\0${text4}\0`);
   const hash = digest2.digest("hex").slice(0, 24);
@@ -15092,8 +15753,8 @@ async function compileKotlin(input, origin) {
     url: `${origin}${KOTLIN_ARTIFACT_PREFIX}${hash}/app.mjs`,
     hash
   };
-  const out = import_node_path20.default.join(buildsDir(), hash);
-  if (import_node_fs19.default.existsSync(import_node_path20.default.join(out, "js", "app.wasm"))) return artifact;
+  const out = import_node_path21.default.join(buildsDir(), hash);
+  if (import_node_fs20.default.existsSync(import_node_path21.default.join(out, "js", "app.wasm"))) return artifact;
   const pending = builds.get(hash);
   if (pending) return pending;
   const build = (async () => {
@@ -15101,29 +15762,29 @@ async function compileKotlin(input, origin) {
     const { kotlinc } = ready;
     const compilerPlugin = await ensureCompilerPlugin(kotlinc, plugin);
     const libraries = [...ready.libraries];
-    const composeRuntime = import_node_path20.default.join(
+    const composeRuntime = import_node_path21.default.join(
       kotlinHome(),
       toolchain.compiler.version,
       toolchain.composeRuntime.name
     );
     if (usesCompose) {
       for (const library of toolchain.composeLibraries) {
-        const target = import_node_path20.default.join(kotlinHome(), toolchain.compiler.version, library.name);
+        const target = import_node_path21.default.join(kotlinHome(), toolchain.compiler.version, library.name);
         await fetchVerified(library, target);
         libraries.push(target);
       }
       await fetchVerified(toolchain.composeRuntime, composeRuntime);
     }
-    import_node_fs19.default.mkdirSync(buildsDir(), { recursive: true });
-    const work = import_node_fs19.default.mkdtempSync(import_node_path20.default.join(buildsDir(), `${hash}-`));
-    const generatedDir = import_node_path20.default.join(work, "generated");
-    import_node_fs19.default.mkdirSync(generatedDir);
+    import_node_fs20.default.mkdirSync(buildsDir(), { recursive: true });
+    const work = import_node_fs20.default.mkdtempSync(import_node_path21.default.join(buildsDir(), `${hash}-`));
+    const generatedDir = import_node_path21.default.join(work, "generated");
+    import_node_fs20.default.mkdirSync(generatedDir);
     for (const [name2, text4] of Object.entries(generated))
-      import_node_fs19.default.writeFileSync(import_node_path20.default.join(generatedDir, name2), text4);
+      import_node_fs20.default.writeFileSync(import_node_path21.default.join(generatedDir, name2), text4);
     const compiledSources = inputs.map(({ file, bytes }, index) => {
-      const target = import_node_path20.default.join(work, "sources", String(index), import_node_path20.default.basename(file));
-      import_node_fs19.default.mkdirSync(import_node_path20.default.dirname(target), { recursive: true });
-      import_node_fs19.default.writeFileSync(target, bytes);
+      const target = import_node_path21.default.join(work, "sources", String(index), import_node_path21.default.basename(file));
+      import_node_fs20.default.mkdirSync(import_node_path21.default.dirname(target), { recursive: true });
+      import_node_fs20.default.writeFileSync(target, bytes);
       return { file, target };
     });
     const common = [
@@ -15132,15 +15793,15 @@ async function compileKotlin(input, origin) {
       "-Xallow-kotlin-package",
       "-Xwasm-target=js",
       "-libraries",
-      libraries.join(import_node_path20.default.delimiter)
+      libraries.join(import_node_path21.default.delimiter)
     ];
-    const compileKlib = (outputDir) => run3(
+    const compileKlib = (outputDir) => run4(
       kotlinc,
       [
         ...common,
         `-Xplugin=${compilerPlugin}`,
         ...usesCompose ? [
-          `-Xplugin=${import_node_path20.default.resolve(import_node_path20.default.dirname(kotlinc), "../lib/compose-compiler-plugin.jar")}`
+          `-Xplugin=${import_node_path21.default.resolve(import_node_path21.default.dirname(kotlinc), "../lib/compose-compiler-plugin.jar")}`
         ] : [],
         "-language-version",
         language,
@@ -15153,7 +15814,7 @@ async function compileKotlin(input, origin) {
         "-ir-output-name",
         "app",
         ...compiledSources.map(({ target }) => target),
-        ...Object.keys(generated).map((name2) => import_node_path20.default.join(generatedDir, name2))
+        ...Object.keys(generated).map((name2) => import_node_path21.default.join(generatedDir, name2))
       ],
       { maxBuffer: 16 * 1024 * 1024 }
     );
@@ -15161,49 +15822,49 @@ async function compileKotlin(input, origin) {
       if (viewModels && inputs.some(
         ({ file, bytes }) => sources.includes(file) && bytes.includes("ViewModel")
       )) {
-        await compileKlib(import_node_path20.default.join(work, "abi"));
-        const { stdout } = await run3(
-          import_node_path20.default.join(import_node_path20.default.dirname(kotlinc), "kotlinc"),
+        await compileKlib(import_node_path21.default.join(work, "abi"));
+        const { stdout } = await run4(
+          import_node_path21.default.join(import_node_path21.default.dirname(kotlinc), "kotlinc"),
           [
             "-cp",
-            import_node_path20.default.resolve(import_node_path20.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
+            import_node_path21.default.resolve(import_node_path21.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
             "-script",
             viewModels.script,
-            import_node_path20.default.join(work, "abi")
+            import_node_path21.default.join(work, "abi")
           ],
           { maxBuffer: 64 * 1024 * 1024 }
         );
-        import_node_fs19.default.writeFileSync(
-          import_node_path20.default.join(generatedDir, viewModels.file),
+        import_node_fs20.default.writeFileSync(
+          import_node_path21.default.join(generatedDir, viewModels.file),
           viewModels.render(viewModelClasses(readAbiClasses(stdout)))
         );
       }
-      await compileKlib(import_node_path20.default.join(work, "klib"));
-      await run3(
+      await compileKlib(import_node_path21.default.join(work, "klib"));
+      await run4(
         kotlinc,
         [
           ...common,
           "-nowarn",
-          `-Xinclude=${import_node_path20.default.join(work, "klib")}`,
+          `-Xinclude=${import_node_path21.default.join(work, "klib")}`,
           "-Xir-produce-js",
           "-ir-output-dir",
-          import_node_path20.default.join(work, "js"),
+          import_node_path21.default.join(work, "js"),
           "-ir-output-name",
           "app"
         ],
         { maxBuffer: 16 * 1024 * 1024 }
       );
       if (usesCompose) {
-        await run3("unzip", [
+        await run4("unzip", [
           "-q",
           "-j",
           composeRuntime,
           "skiko.mjs",
           "-d",
-          import_node_path20.default.join(work, "js")
+          import_node_path21.default.join(work, "js")
         ]);
-        const skikoPath = import_node_path20.default.join(work, "js", "skiko.mjs");
-        const upstream = (0, import_acorn2.parse)(import_node_fs19.default.readFileSync(skikoPath, "utf8"), {
+        const skikoPath = import_node_path21.default.join(work, "js", "skiko.mjs");
+        const upstream = (0, import_acorn2.parse)(import_node_fs20.default.readFileSync(skikoPath, "utf8"), {
           ecmaVersion: "latest",
           sourceType: "module"
         });
@@ -15226,7 +15887,7 @@ async function compileKotlin(input, origin) {
           "GL",
           ...bindings
         ];
-        import_node_fs19.default.writeFileSync(
+        import_node_fs20.default.writeFileSync(
           skikoPath,
           [
             "const runtime = globalThis.__peachKotlinSkiko;",
@@ -15240,10 +15901,10 @@ async function compileKotlin(input, origin) {
       if (usesCompose) {
         for (const library of toolchain.composeJsLibraries) {
           let imported = false;
-          for (const file of import_node_fs19.default.readdirSync(import_node_path20.default.join(work, "js"))) {
+          for (const file of import_node_fs20.default.readdirSync(import_node_path21.default.join(work, "js"))) {
             if (!file.endsWith(".mjs")) continue;
-            const target = import_node_path20.default.join(work, "js", file);
-            const source = import_node_fs19.default.readFileSync(target, "utf8");
+            const target = import_node_path21.default.join(work, "js", file);
+            const source = import_node_fs20.default.readFileSync(target, "utf8");
             let next = source;
             for (const quote of ["'", '"'])
               next = next.replaceAll(
@@ -15251,29 +15912,29 @@ async function compileKotlin(input, origin) {
                 `from ${quote}./${library.file}${quote}`
               );
             if (next === source) continue;
-            import_node_fs19.default.writeFileSync(target, next);
+            import_node_fs20.default.writeFileSync(target, next);
             imported = true;
           }
           if (!imported) continue;
-          const archive = import_node_path20.default.join(
+          const archive = import_node_path21.default.join(
             kotlinHome(),
             toolchain.compiler.version,
             library.name
           );
           await fetchVerified(library, archive);
-          const { stdout } = await run3("tar", ["-xOf", archive, library.archiveEntry], {
+          const { stdout } = await run4("tar", ["-xOf", archive, library.archiveEntry], {
             maxBuffer: 16 * 1024 * 1024
           });
-          import_node_fs19.default.writeFileSync(import_node_path20.default.join(work, "js", library.file), stdout);
+          import_node_fs20.default.writeFileSync(import_node_path21.default.join(work, "js", library.file), stdout);
         }
       }
     } catch (error) {
-      import_node_fs19.default.rmSync(work, { recursive: true, force: true });
+      import_node_fs20.default.rmSync(work, { recursive: true, force: true });
       let output = isRecord(error) ? `${String(error.stderr ?? "")}${String(error.stdout ?? "")}` : "";
       for (const [name2, source] of Object.entries(origins))
-        output = output.replaceAll(import_node_path20.default.join(generatedDir, name2), source);
+        output = output.replaceAll(import_node_path21.default.join(generatedDir, name2), source);
       for (const { file, target } of compiledSources)
-        output = output.replaceAll(target, file).replaceAll(import_node_path20.default.relative(process.cwd(), target), file);
+        output = output.replaceAll(target, file).replaceAll(import_node_path21.default.relative(process.cwd(), target), file);
       throw new Error(
         `kotlin compile failed:
 ${output.trim() || (error instanceof Error ? error.message : String(error))}`
@@ -15282,9 +15943,9 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
     const seams = [
       ["process.release.name", "process.release?.name"]
     ];
-    const js = import_node_fs19.default.readdirSync(import_node_path20.default.join(work, "js")).filter((file) => file.endsWith(".mjs"));
+    const js = import_node_fs20.default.readdirSync(import_node_path21.default.join(work, "js")).filter((file) => file.endsWith(".mjs"));
     if (js.some(
-      (file) => import_node_fs19.default.readFileSync(import_node_path20.default.join(work, "js", file), "utf8").includes("'kotlinx.coroutines.")
+      (file) => import_node_fs20.default.readFileSync(import_node_path21.default.join(work, "js", file), "utf8").includes("'kotlinx.coroutines.")
     ))
       seams.push([
         "(typeof(window) !== 'undefined' && window != null && typeof(window.addEventListener) === 'function') ? window : null",
@@ -15293,12 +15954,12 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
     for (const [from, to] of seams) {
       let patched = 0;
       for (const file of js) {
-        const target = import_node_path20.default.join(work, "js", file);
-        const text4 = import_node_fs19.default.readFileSync(target, "utf8");
+        const target = import_node_path21.default.join(work, "js", file);
+        const text4 = import_node_fs20.default.readFileSync(target, "utf8");
         const next = text4.replaceAll(from, to);
         if (next !== text4) {
           patched++;
-          import_node_fs19.default.writeFileSync(target, next);
+          import_node_fs20.default.writeFileSync(target, next);
         }
       }
       if (patched === 0)
@@ -15307,10 +15968,10 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
         );
     }
     try {
-      import_node_fs19.default.renameSync(work, out);
+      import_node_fs20.default.renameSync(work, out);
     } catch (error) {
-      if (!import_node_fs19.default.existsSync(import_node_path20.default.join(out, "js", "app.wasm"))) throw error;
-      import_node_fs19.default.rmSync(work, { recursive: true, force: true });
+      if (!import_node_fs20.default.existsSync(import_node_path21.default.join(out, "js", "app.wasm"))) throw error;
+      import_node_fs20.default.rmSync(work, { recursive: true, force: true });
     }
     return artifact;
   })().finally(() => builds.delete(hash));
@@ -15318,24 +15979,24 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
   return build;
 }
 function kotlinArtifactFiles(hash) {
-  const dir = import_node_path20.default.join(buildsDir(), hash, "js");
-  return import_node_fs19.default.readdirSync(dir).sort().map((name2) => {
-    const contentType = CONTENT_TYPES[import_node_path20.default.extname(name2)];
+  const dir = import_node_path21.default.join(buildsDir(), hash, "js");
+  return import_node_fs20.default.readdirSync(dir).sort().map((name2) => {
+    const contentType = CONTENT_TYPES[import_node_path21.default.extname(name2)];
     if (!contentType) throw new Error(`unexpected kotlin artifact file ${name2}`);
-    return { name: name2, bytes: import_node_fs19.default.readFileSync(import_node_path20.default.join(dir, name2)), contentType };
+    return { name: name2, bytes: import_node_fs20.default.readFileSync(import_node_path21.default.join(dir, name2)), contentType };
   });
 }
 function serveKotlinArtifact(pathname, res) {
   if (!pathname.startsWith(KOTLIN_ARTIFACT_PREFIX)) return false;
   const [hash, file, ...rest] = pathname.slice(KOTLIN_ARTIFACT_PREFIX.length).split("/");
-  const type = file ? CONTENT_TYPES[import_node_path20.default.extname(file)] : void 0;
+  const type = file ? CONTENT_TYPES[import_node_path21.default.extname(file)] : void 0;
   if (!hash || !/^[0-9a-f]+$/.test(hash) || !file || rest.length > 0 || !type || file.includes("..")) {
     res.statusCode = 404;
     res.end("not a kotlin artifact");
     return true;
   }
-  const target = import_node_path20.default.join(buildsDir(), hash, "js", file);
-  if (!import_node_fs19.default.existsSync(target)) {
+  const target = import_node_path21.default.join(buildsDir(), hash, "js", file);
+  if (!import_node_fs20.default.existsSync(target)) {
     res.statusCode = 404;
     res.end(`kotlin artifact ${hash}/${file} was not built`);
     return true;
@@ -15343,7 +16004,7 @@ function serveKotlinArtifact(pathname, res) {
   res.setHeader("access-control-allow-origin", "*");
   res.setHeader("content-type", type);
   res.setHeader("cache-control", "public, max-age=31536000, immutable");
-  res.end(import_node_fs19.default.readFileSync(target));
+  res.end(import_node_fs20.default.readFileSync(target));
   return true;
 }
 async function serveKotlinRequest(pathname, res, app) {
@@ -15360,22 +16021,22 @@ async function serveKotlinRequest(pathname, res, app) {
   }
   return true;
 }
-var import_node_child_process11, import_node_crypto11, import_node_fs19, import_node_module2, import_node_path20, import_node_util3, import_acorn2, run3, KOTLIN_ARTIFACT_PREFIX, toolchains, SKIP_DIRS, compilerPlugins, COMPILER_PLUGIN_SERVICE, BUILD_FORMAT, builds, expoTypeScans, argb, escapes, literal, CONTENT_TYPES, KOTLIN_PACKAGE_PATH;
+var import_node_child_process13, import_node_crypto11, import_node_fs20, import_node_module3, import_node_path21, import_node_util4, import_acorn2, run4, KOTLIN_ARTIFACT_PREFIX, toolchains, SKIP_DIRS, compilerPlugins, COMPILER_PLUGIN_SERVICE, BUILD_FORMAT, builds, expoTypeScans, argb, escapes, literal, CONTENT_TYPES, KOTLIN_PACKAGE_PATH;
 var init_kotlin_host = __esm({
   "src/kotlin-host.ts"() {
     "use strict";
-    import_node_child_process11 = require("node:child_process");
+    import_node_child_process13 = require("node:child_process");
     import_node_crypto11 = require("node:crypto");
-    import_node_fs19 = __toESM(require("node:fs"), 1);
-    import_node_module2 = require("node:module");
-    import_node_path20 = __toESM(require("node:path"), 1);
-    import_node_util3 = require("node:util");
+    import_node_fs20 = __toESM(require("node:fs"), 1);
+    import_node_module3 = require("node:module");
+    import_node_path21 = __toESM(require("node:path"), 1);
+    import_node_util4 = require("node:util");
     import_acorn2 = require("acorn");
     init_home_paths();
     init_is_record();
     init_kotlin_view_models();
     init_kotlin_module();
-    run3 = (0, import_node_util3.promisify)(import_node_child_process11.execFile);
+    run4 = (0, import_node_util4.promisify)(import_node_child_process13.execFile);
     KOTLIN_ARTIFACT_PREFIX = "/__peach/kotlin-artifact/";
     toolchains = /* @__PURE__ */ new Map();
     SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -15417,41 +16078,17 @@ var init_kotlin_host = __esm({
 
 // src/expo-kotlin-host.ts
 async function collectExpoKotlinModules(appRoot) {
-  appRoot = import_node_fs20.default.realpathSync(appRoot);
-  let autolinker;
-  try {
-    autolinker = (0, import_node_module3.createRequire)(import_node_path21.default.join(appRoot, "package.json")).resolve(
-      "expo-modules-autolinking/package.json"
-    );
-  } catch (error) {
-    if (isRecord(error) && error.code === "MODULE_NOT_FOUND") return null;
-    throw error;
-  }
-  const { stdout } = await run4(
-    process.execPath,
-    [
-      import_node_path21.default.join(import_node_path21.default.dirname(autolinker), "bin/expo-modules-autolinking.js"),
-      "resolve",
-      "--platform",
-      "android",
-      "--project-root",
-      appRoot,
-      "--json"
-    ],
-    { timeout: 3e4, maxBuffer: 8 * 1024 * 1024, env: scriptEnv2 }
-  );
-  const resolved = JSON.parse(stdout);
-  if (!isRecord(resolved) || !Array.isArray(resolved.modules))
-    throw new Error("invalid Expo Android resolution");
+  const modules = await resolveExpoAndroidAutolinking(appRoot);
   const result = { modules: [], sources: [] };
-  for (const entry of resolved.modules) {
-    if (!isRecord(entry) || !Array.isArray(entry.projects))
+  for (const entry of modules) {
+    if (entry.projects === void 0) continue;
+    if (!Array.isArray(entry.projects))
       throw new Error("invalid Expo Android module entry");
     for (const project of entry.projects) {
       if (!isRecord(project) || typeof project.sourceDir !== "string" || !Array.isArray(project.modules))
         throw new Error("invalid Expo Android project");
-      const sourceDir = import_node_fs20.default.realpathSync(project.sourceDir);
-      if (sourceDir.split(import_node_path21.default.sep).includes("node_modules")) continue;
+      const sourceDir = import_node_fs21.default.realpathSync(project.sourceDir);
+      if (sourceDir.split(import_node_path22.default.sep).includes("node_modules")) continue;
       if (project.modules.length === 0) continue;
       for (const module2 of project.modules) {
         if (!isRecord(module2) || typeof module2.classifier !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)+$/.test(
@@ -15461,9 +16098,9 @@ async function collectExpoKotlinModules(appRoot) {
         result.modules.push({ classifier: module2.classifier, name: module2.name });
       }
       const walk2 = (dir) => {
-        if (!import_node_fs20.default.existsSync(dir)) return;
-        for (const child of import_node_fs20.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-          const file = import_node_path21.default.join(dir, child.name);
+        if (!import_node_fs21.default.existsSync(dir)) return;
+        for (const child of import_node_fs21.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+          const file = import_node_path22.default.join(dir, child.name);
           if (child.isSymbolicLink())
             throw new Error(`Expo Kotlin source is a symlink: ${file}`);
           if (child.isDirectory()) walk2(file);
@@ -15472,8 +16109,8 @@ async function collectExpoKotlinModules(appRoot) {
           else if (child.name.endsWith(".kt")) result.sources.push(file);
         }
       };
-      walk2(import_node_path21.default.join(sourceDir, "src", "main", "java"));
-      walk2(import_node_path21.default.join(sourceDir, "src", "main", "kotlin"));
+      walk2(import_node_path22.default.join(sourceDir, "src", "main", "java"));
+      walk2(import_node_path22.default.join(sourceDir, "src", "main", "kotlin"));
     }
   }
   return result.modules.length === 0 ? null : result;
@@ -15507,21 +16144,16 @@ async function compileExpoKotlinModules(root, origin) {
     };
   }
 }
-var import_node_child_process12, import_node_fs20, import_node_module3, import_node_path21, import_node_util4, run4, scriptEnv2;
+var import_node_fs21, import_node_path22;
 var init_expo_kotlin_host = __esm({
   "src/expo-kotlin-host.ts"() {
     "use strict";
-    import_node_child_process12 = require("node:child_process");
-    import_node_fs20 = __toESM(require("node:fs"), 1);
-    import_node_module3 = require("node:module");
-    import_node_path21 = __toESM(require("node:path"), 1);
-    import_node_util4 = require("node:util");
-    init_internal_child();
+    import_node_fs21 = __toESM(require("node:fs"), 1);
+    import_node_path22 = __toESM(require("node:path"), 1);
+    init_android_autolinking();
     init_backend_origin();
     init_is_record();
     init_kotlin_module();
-    run4 = (0, import_node_util4.promisify)(import_node_child_process12.execFile);
-    scriptEnv2 = { ...process.env, [RNX_FORKED_SCRIPT_ENV]: "1" };
   }
 });
 
@@ -15567,56 +16199,8 @@ var import_node_vm = require("node:vm");
 init_process_group();
 init_backend_origin();
 
-// src/bundleGlobalFooter.ts
-function findBundleFooter(source, prefix) {
-  let end = source.length;
-  while (end > 0) {
-    const newline = source.lastIndexOf("\n", end - 1);
-    if (newline < 0) return -1;
-    const line = newline + 1;
-    if (source.startsWith(prefix, line)) return newline;
-    if (line !== end && !source.startsWith("globalThis.", line) && !source.startsWith("//", line)) {
-      return -1;
-    }
-    end = newline;
-  }
-  return -1;
-}
-function readFooter(source, prefix, suffix, name2) {
-  const start = findBundleFooter(source, prefix);
-  if (start < 0) return null;
-  const end = source.indexOf("\n", start + 1);
-  const line = source.slice(start + 1, end < 0 ? void 0 : end);
-  if (!line.endsWith(suffix)) throw new Error(`${name2} footer is truncated`);
-  const value = JSON.parse(
-    line.slice(prefix.length, suffix ? -suffix.length : void 0)
-  );
-  if (value === null) throw new Error(`${name2} footer has no metadata`);
-  return value;
-}
-function detachFooter(source, prefix, suffix, name2) {
-  const start = findBundleFooter(source, prefix);
-  if (start < 0) return { source, value: null };
-  const value = readFooter(source, prefix, suffix, name2);
-  const end = source.indexOf("\n", start + 1);
-  return { source: source.slice(0, start) + (end < 0 ? "" : source.slice(end)), value };
-}
-function insertBundleGlobalFooter(source, name2, value) {
-  return insertFooter(source, `globalThis.${name2}=`, ";", name2, value);
-}
-function insertBundleMetadataFooter(source, name2, value) {
-  return insertFooter(source, `// peach.${name2}=`, "", name2, value);
-}
-function insertFooter(source, prefix, suffix, name2, value) {
-  source = detachFooter(source, prefix, suffix, name2).source;
-  const json = JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/<\//g, "<\\/");
-  const footer = `
-${prefix}${json}${suffix}`;
-  const identity = findBundleFooter(source, "globalThis.__sootsimModulePaths=");
-  return identity < 0 ? source + footer : source.slice(0, identity) + footer + source.slice(identity);
-}
-
 // src/expoKotlinContract.ts
+init_bundleGlobalFooter();
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -15654,6 +16238,7 @@ function insertExpoKotlinFooter(source, metadata) {
 }
 
 // src/expoSwiftContract.ts
+init_bundleGlobalFooter();
 function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -15687,6 +16272,7 @@ function insertExpoSwiftFooter(source, metadata) {
 }
 
 // src/nitroContract.ts
+init_bundleGlobalFooter();
 function readNitroMetadata(value) {
   if (value === null || value === void 0) return null;
   if (typeof value !== "object" || Array.isArray(value) || Reflect.get(value, "platform") !== "ios")
@@ -15806,17 +16392,17 @@ function prepareChannel({
     }
   }
   const identity = (0, import_node_crypto12.createHash)("sha256").update(bundle).update(icon);
-  for (const [path20, bytes] of [...files2].sort(
+  for (const [path21, bytes] of [...files2].sort(
     ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
   )) {
-    identity.update(JSON.stringify([path20, digest(bytes)]));
+    identity.update(JSON.stringify([path21, digest(bytes)]));
   }
   if (native) identity.update(JSON.stringify(native.metadata));
   if (nitro) identity.update(JSON.stringify(nitro.metadata));
   const releaseKey = `${prefix}/peach/releases/${identity.digest("hex")}`;
   const assetBaseUrl = `${origin.origin}/${releaseKey}/`;
   const directories = new Set(
-    [...files2.keys()].map((path20) => path20.slice(0, path20.lastIndexOf("/")))
+    [...files2.keys()].map((path21) => path21.slice(0, path21.lastIndexOf("/")))
   );
   let locations = 0;
   let source = new TextDecoder("utf-8", { fatal: true }).decode(bundle).replace(
@@ -15824,12 +16410,12 @@ function prepareChannel({
     /("?httpServerLocation"?\s*:\s*)(?:"((?:[^"\\]|\\.)*)"|`([^`\\$]*)`)/g,
     (match, property, quoted, template) => {
       const location = quoted === void 0 ? template : JSON.parse(`"${quoted}"`);
-      const path20 = packagedAssetDirectory(location);
-      if (!directories.has(path20)) {
+      const path21 = packagedAssetDirectory(location);
+      if (!directories.has(path21)) {
         throw new Error(`bundle asset location has no packaged files: ${location}`);
       }
       locations++;
-      return `${property}${JSON.stringify(new URL(path20, assetBaseUrl).href)}`;
+      return `${property}${JSON.stringify(new URL(path21, assetBaseUrl).href)}`;
     }
   );
   if (assets2.length && !locations)
@@ -15892,10 +16478,10 @@ function prepareChannel({
       contentType: "application/javascript"
     },
     { key: `${releaseKey}/icon.png`, bytes: icon, contentType: "image/png" },
-    ...[...files2].map(([path20, bytes]) => ({
-      key: `${releaseKey}/${path20}`,
+    ...[...files2].map(([path21, bytes]) => ({
+      key: `${releaseKey}/${path21}`,
       bytes,
-      contentType: nativeAssets.get(path20)?.contentType ?? {
+      contentType: nativeAssets.get(path21)?.contentType ?? {
         png: "image/png",
         jpg: "image/jpeg",
         jpeg: "image/jpeg",
@@ -15904,7 +16490,7 @@ function prepareChannel({
         ttf: "font/ttf",
         otf: "font/otf",
         wav: "audio/wav"
-      }[path20.split(".").pop()] ?? "application/octet-stream"
+      }[path21.split(".").pop()] ?? "application/octet-stream"
     }))
   ];
   return { platform, key: `${prefix}/${channelKey(platform)}`, metadata, objects };
@@ -15944,7 +16530,7 @@ async function publishBundleChannel(release, { put, fetchObject = fetch }) {
 }
 async function snapshotDevServerBundles(origin, projectRoot, { platforms = ["ios", "android"], assertRunning = () => {
 } } = {}) {
-  const { readFileSync: readFileSync5 } = await import("node:fs");
+  const { readFileSync: readFileSync6 } = await import("node:fs");
   const { basename: basename2 } = await import("node:path");
   const snapshots = [];
   for (const platform of platforms) {
@@ -15965,27 +16551,27 @@ async function snapshotDevServerBundles(origin, projectRoot, { platforms = ["ios
       const directory = packagedAssetDirectory(asset.httpServerLocation);
       if (asset.files) {
         for (const file of asset.files) {
-          const path20 = `${directory}/${basename2(file)}`;
-          if (!assets2.has(path20)) assets2.set(path20, readFileSync5(file));
+          const path21 = `${directory}/${basename2(file)}`;
+          if (!assets2.has(path21)) assets2.set(path21, readFileSync6(file));
         }
         continue;
       }
       for (const scale of asset.scales) {
         const file = `${asset.name}${scale === 1 ? "" : `@${scale}x`}.${asset.type}`;
-        const path20 = `${directory}/${file}`;
-        if (assets2.has(path20)) continue;
+        const path21 = `${directory}/${file}`;
+        if (assets2.has(path21)) continue;
         const response = await fetch(
           `${origin}${asset.httpServerLocation}/${file}?platform=${platform}&hash=${asset.hash}`
         );
         if (!response.ok)
-          throw new Error(`dev server asset ${path20} failed: ${response.status}`);
-        assets2.set(path20, Buffer.from(await response.arrayBuffer()));
+          throw new Error(`dev server asset ${path21} failed: ${response.status}`);
+        assets2.set(path21, Buffer.from(await response.arrayBuffer()));
       }
     }
     snapshots.push({
       platform,
       bundle,
-      assets: [...assets2].map(([path20, bytes]) => ({ path: path20, bytes })),
+      assets: [...assets2].map(([path21, bytes]) => ({ path: path21, bytes })),
       ...platform === "ios" ? {
         expoSwift: await (await Promise.resolve().then(() => (init_expo_swift_bundle(), expo_swift_bundle_exports))).buildExpoSwiftBundle(projectRoot)
       } : {
@@ -15997,7 +16583,7 @@ async function snapshotDevServerBundles(origin, projectRoot, { platforms = ["ios
 }
 async function snapshotOneDevBundle(projectRoot, env = {}) {
   const { spawn: spawn4 } = await import("node:child_process");
-  const { readFileSync: readFileSync5 } = await import("node:fs");
+  const { readFileSync: readFileSync6 } = await import("node:fs");
   const { createServer } = await import("node:net");
   const { dirname: dirname2, join: join3 } = await import("node:path");
   const { createRequire: createRequire4 } = await import("node:module");
@@ -16006,7 +16592,7 @@ async function snapshotOneDevBundle(projectRoot, env = {}) {
   );
   const oneBin = join3(
     dirname2(onePackage),
-    JSON.parse(readFileSync5(onePackage, "utf8")).bin.one
+    JSON.parse(readFileSync6(onePackage, "utf8")).bin.one
   );
   const port = await new Promise((resolve2, reject) => {
     const server = createServer().listen(0, "127.0.0.1", () => {