peachsim 0.1.2193 → 0.1.2195

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

@@ -1,4 +1,4 @@
-/*! peach v0.1.2193 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.2195 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = '', __sootsim_import_meta_filename = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; __sootsim_import_meta_filename = __filename; } catch {}
 "use strict";
 var __create = Object.create;
@@ -3119,17 +3119,17 @@ function visit(node, visitor) {
   } else
     visit_(null, node, visitor_, Object.freeze([]));
 }
-function visit_(key2, node, visitor, path109) {
-  const ctrl = callVisitor(key2, node, visitor, path109);
+function visit_(key2, node, visitor, path110) {
+  const ctrl = callVisitor(key2, node, visitor, path110);
   if (isNode(ctrl) || isPair(ctrl)) {
-    replaceNode(key2, path109, ctrl);
-    return visit_(key2, ctrl, visitor, path109);
+    replaceNode(key2, path110, ctrl);
+    return visit_(key2, ctrl, visitor, path110);
   }
   if (typeof ctrl !== "symbol") {
     if (isCollection(node)) {
-      path109 = Object.freeze(path109.concat(node));
+      path110 = Object.freeze(path110.concat(node));
       for (let i = 0; i < node.items.length; ++i) {
-        const ci = visit_(i, node.items[i], visitor, path109);
+        const ci = visit_(i, node.items[i], visitor, path110);
         if (typeof ci === "number")
           i = ci - 1;
         else if (ci === BREAK)
@@ -3140,13 +3140,13 @@ function visit_(key2, node, visitor, path109) {
         }
       }
     } else if (isPair(node)) {
-      path109 = Object.freeze(path109.concat(node));
-      const ck = visit_("key", node.key, visitor, path109);
+      path110 = Object.freeze(path110.concat(node));
+      const ck = visit_("key", node.key, visitor, path110);
       if (ck === BREAK)
         return BREAK;
       else if (ck === REMOVE)
         node.key = null;
-      const cv = visit_("value", node.value, visitor, path109);
+      const cv = visit_("value", node.value, visitor, path110);
       if (cv === BREAK)
         return BREAK;
       else if (cv === REMOVE)
@@ -3164,17 +3164,17 @@ async function visitAsync(node, visitor) {
   } else
     await visitAsync_(null, node, visitor_, Object.freeze([]));
 }
-async function visitAsync_(key2, node, visitor, path109) {
-  const ctrl = await callVisitor(key2, node, visitor, path109);
+async function visitAsync_(key2, node, visitor, path110) {
+  const ctrl = await callVisitor(key2, node, visitor, path110);
   if (isNode(ctrl) || isPair(ctrl)) {
-    replaceNode(key2, path109, ctrl);
-    return visitAsync_(key2, ctrl, visitor, path109);
+    replaceNode(key2, path110, ctrl);
+    return visitAsync_(key2, ctrl, visitor, path110);
   }
   if (typeof ctrl !== "symbol") {
     if (isCollection(node)) {
-      path109 = Object.freeze(path109.concat(node));
+      path110 = Object.freeze(path110.concat(node));
       for (let i = 0; i < node.items.length; ++i) {
-        const ci = await visitAsync_(i, node.items[i], visitor, path109);
+        const ci = await visitAsync_(i, node.items[i], visitor, path110);
         if (typeof ci === "number")
           i = ci - 1;
         else if (ci === BREAK)
@@ -3185,13 +3185,13 @@ async function visitAsync_(key2, node, visitor, path109) {
         }
       }
     } else if (isPair(node)) {
-      path109 = Object.freeze(path109.concat(node));
-      const ck = await visitAsync_("key", node.key, visitor, path109);
+      path110 = Object.freeze(path110.concat(node));
+      const ck = await visitAsync_("key", node.key, visitor, path110);
       if (ck === BREAK)
         return BREAK;
       else if (ck === REMOVE)
         node.key = null;
-      const cv = await visitAsync_("value", node.value, visitor, path109);
+      const cv = await visitAsync_("value", node.value, visitor, path110);
       if (cv === BREAK)
         return BREAK;
       else if (cv === REMOVE)
@@ -3218,23 +3218,23 @@ function initVisitor(visitor) {
   }
   return visitor;
 }
-function callVisitor(key2, node, visitor, path109) {
+function callVisitor(key2, node, visitor, path110) {
   if (typeof visitor === "function")
-    return visitor(key2, node, path109);
+    return visitor(key2, node, path110);
   if (isMap(node))
-    return visitor.Map?.(key2, node, path109);
+    return visitor.Map?.(key2, node, path110);
   if (isSeq(node))
-    return visitor.Seq?.(key2, node, path109);
+    return visitor.Seq?.(key2, node, path110);
   if (isPair(node))
-    return visitor.Pair?.(key2, node, path109);
+    return visitor.Pair?.(key2, node, path110);
   if (isScalar(node))
-    return visitor.Scalar?.(key2, node, path109);
+    return visitor.Scalar?.(key2, node, path110);
   if (isAlias(node))
-    return visitor.Alias?.(key2, node, path109);
+    return visitor.Alias?.(key2, node, path110);
   return void 0;
 }
-function replaceNode(key2, path109, node) {
-  const parent = path109[path109.length - 1];
+function replaceNode(key2, path110, node) {
+  const parent = path110[path110.length - 1];
   if (isCollection(parent)) {
     parent.items[key2] = node;
   } else if (isPair(parent)) {
@@ -3843,10 +3843,10 @@ var init_createNode = __esm({
 });
 
 // ../../node_modules/yaml/browser/dist/nodes/Collection.js
-function collectionFromPath(schema4, path109, value) {
+function collectionFromPath(schema4, path110, value) {
   let v6 = value;
-  for (let i = path109.length - 1; i >= 0; --i) {
-    const k = path109[i];
+  for (let i = path110.length - 1; i >= 0; --i) {
+    const k = path110[i];
     if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
       const a = [];
       a[k] = v6;
@@ -3872,7 +3872,7 @@ var init_Collection = __esm({
     init_createNode();
     init_identity();
     init_Node();
-    isEmptyPath = (path109) => path109 == null || typeof path109 === "object" && !!path109[Symbol.iterator]().next().done;
+    isEmptyPath = (path110) => path110 == null || typeof path110 === "object" && !!path110[Symbol.iterator]().next().done;
     Collection = class extends NodeBase {
       constructor(type, schema4) {
         super(type);
@@ -3902,11 +3902,11 @@ var init_Collection = __esm({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path109, value) {
-        if (isEmptyPath(path109))
+      addIn(path110, value) {
+        if (isEmptyPath(path110))
           this.add(value);
         else {
-          const [key2, ...rest] = path109;
+          const [key2, ...rest] = path110;
           const node = this.get(key2, true);
           if (isCollection(node))
             node.addIn(rest, value);
@@ -3920,8 +3920,8 @@ var init_Collection = __esm({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path109) {
-        const [key2, ...rest] = path109;
+      deleteIn(path110) {
+        const [key2, ...rest] = path110;
         if (rest.length === 0)
           return this.delete(key2);
         const node = this.get(key2, true);
@@ -3935,8 +3935,8 @@ var init_Collection = __esm({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path109, keepScalar) {
-        const [key2, ...rest] = path109;
+      getIn(path110, keepScalar) {
+        const [key2, ...rest] = path110;
         const node = this.get(key2, true);
         if (rest.length === 0)
           return !keepScalar && isScalar(node) ? node.value : node;
@@ -3954,8 +3954,8 @@ var init_Collection = __esm({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path109) {
-        const [key2, ...rest] = path109;
+      hasIn(path110) {
+        const [key2, ...rest] = path110;
         if (rest.length === 0)
           return this.has(key2);
         const node = this.get(key2, true);
@@ -3965,8 +3965,8 @@ var init_Collection = __esm({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path109, value) {
-        const [key2, ...rest] = path109;
+      setIn(path110, value) {
+        const [key2, ...rest] = path110;
         if (rest.length === 0) {
           this.set(key2, value);
         } else {
@@ -6435,9 +6435,9 @@ var init_Document = __esm({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path109, value) {
+      addIn(path110, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path109, value);
+          this.contents.addIn(path110, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -6512,14 +6512,14 @@ var init_Document = __esm({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path109) {
-        if (isEmptyPath(path109)) {
+      deleteIn(path110) {
+        if (isEmptyPath(path110)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path109) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path110) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -6534,10 +6534,10 @@ var init_Document = __esm({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path109, keepScalar) {
-        if (isEmptyPath(path109))
+      getIn(path110, keepScalar) {
+        if (isEmptyPath(path110))
           return !keepScalar && isScalar(this.contents) ? this.contents.value : this.contents;
-        return isCollection(this.contents) ? this.contents.getIn(path109, keepScalar) : void 0;
+        return isCollection(this.contents) ? this.contents.getIn(path110, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -6548,10 +6548,10 @@ var init_Document = __esm({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path109) {
-        if (isEmptyPath(path109))
+      hasIn(path110) {
+        if (isEmptyPath(path110))
           return this.contents !== void 0;
-        return isCollection(this.contents) ? this.contents.hasIn(path109) : false;
+        return isCollection(this.contents) ? this.contents.hasIn(path110) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -6568,13 +6568,13 @@ var init_Document = __esm({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path109, value) {
-        if (isEmptyPath(path109)) {
+      setIn(path110, value) {
+        if (isEmptyPath(path110)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = collectionFromPath(this.schema, Array.from(path109), value);
+          this.contents = collectionFromPath(this.schema, Array.from(path110), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path109, value);
+          this.contents.setIn(path110, value);
         }
       }
       /**
@@ -8498,15 +8498,15 @@ function visit2(cst, visitor) {
     cst = { start: cst.start, value: cst.value };
   _visit(Object.freeze([]), cst, visitor);
 }
-function _visit(path109, item, visitor) {
-  let ctrl = visitor(item, path109);
+function _visit(path110, item, visitor) {
+  let ctrl = visitor(item, path110);
   if (typeof ctrl === "symbol")
     return ctrl;
   for (const field of ["key", "value"]) {
     const token = item[field];
     if (token && "items" in token) {
       for (let i = 0; i < token.items.length; ++i) {
-        const ci = _visit(Object.freeze(path109.concat([[field, i]])), token.items[i], visitor);
+        const ci = _visit(Object.freeze(path110.concat([[field, i]])), token.items[i], visitor);
         if (typeof ci === "number")
           i = ci - 1;
         else if (ci === BREAK2)
@@ -8517,10 +8517,10 @@ function _visit(path109, item, visitor) {
         }
       }
       if (typeof ctrl === "function" && field === "key")
-        ctrl = ctrl(item, path109);
+        ctrl = ctrl(item, path110);
     }
   }
-  return typeof ctrl === "function" ? ctrl(item, path109) : ctrl;
+  return typeof ctrl === "function" ? ctrl(item, path110) : ctrl;
 }
 var BREAK2, SKIP2, REMOVE2;
 var init_cst_visit = __esm({
@@ -8532,9 +8532,9 @@ var init_cst_visit = __esm({
     visit2.BREAK = BREAK2;
     visit2.SKIP = SKIP2;
     visit2.REMOVE = REMOVE2;
-    visit2.itemAtPath = (cst, path109) => {
+    visit2.itemAtPath = (cst, path110) => {
       let item = cst;
-      for (const [field, index] of path109) {
+      for (const [field, index] of path110) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -8543,9 +8543,9 @@ var init_cst_visit = __esm({
       }
       return item;
     };
-    visit2.parentCollection = (cst, path109) => {
-      const parent = visit2.itemAtPath(cst, path109.slice(0, -1));
-      const field = path109[path109.length - 1][0];
+    visit2.parentCollection = (cst, path110) => {
+      const parent = visit2.itemAtPath(cst, path110.slice(0, -1));
+      const field = path110[path110.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
@@ -9852,14 +9852,14 @@ var init_parser = __esm({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs85 = this.flowScalar(this.type);
+              const fs86 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map2.items.push({ start, key: fs85, sep: [] });
+                map2.items.push({ start, key: fs86, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs85);
+                this.stack.push(fs86);
               } else {
-                Object.assign(it, { key: fs85, sep: [] });
+                Object.assign(it, { key: fs86, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -9987,13 +9987,13 @@ var init_parser = __esm({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs85 = this.flowScalar(this.type);
+              const fs86 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs85, sep: [] });
+                fc.items.push({ start: [], key: fs86, sep: [] });
               else if (it.sep)
-                this.stack.push(fs85);
+                this.stack.push(fs86);
               else
-                Object.assign(it, { key: fs85, sep: [] });
+                Object.assign(it, { key: fs86, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -10437,8 +10437,8 @@ function metadataValue(value, key2) {
   if (!value || typeof value !== "object") return void 0;
   return Object.getOwnPropertyDescriptor(value, key2)?.value;
 }
-function readProjectJson(path109, files2 = nodeRepoFileReader) {
-  const text6 = readProjectMetadata(path109, files2);
+function readProjectJson(path110, files2 = nodeRepoFileReader) {
+  const text6 = readProjectMetadata(path110, files2);
   if (text6 === null) return null;
   try {
     const value = JSON.parse(text6);
@@ -12208,7 +12208,7 @@ var init_swift_standin_digest = __esm({
     STANDIN_DIGEST_ENTRYPOINTS = ["swift-standins.ts", "swift-objc-compile.ts"];
     SPECIFIER = /from\s*['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
     standinSourceDigest = (srcDir = __sootsim_import_meta_dirname) => sourceClosureDigest(srcDir, STANDIN_DIGEST_ENTRYPOINTS);
-    STANDIN_SOURCE_DIGEST = true ? "d9690faaeece4d15e4d1c3fd98fcb05d93d520f33afa9a5f18fdd043578ad02f" : standinSourceDigest();
+    STANDIN_SOURCE_DIGEST = true ? "afff2f6ba145885813b507114e72f9218f9a815a257ab2e44f7da376b7bf5cd1" : standinSourceDigest();
   }
 });
 
@@ -12311,9 +12311,9 @@ async function packageTreeDigest(root) {
       (a, b) => a.name.localeCompare(b.name)
     )) {
       if (entry.name === "node_modules") continue;
-      const path109 = `${relative4}${entry.name}`;
-      if (entry.isDirectory()) walk3((0, import_node_path66.join)(directory2, entry.name), `${path109}/`);
-      else if (entry.isFile()) files2.push(path109);
+      const path110 = `${relative4}${entry.name}`;
+      if (entry.isDirectory()) walk3((0, import_node_path66.join)(directory2, entry.name), `${path110}/`);
+      else if (entry.isFile()) files2.push(path110);
     }
   };
   walk3(root, "");
@@ -12490,7 +12490,7 @@ var init_nitro_superset = __esm({
     init_nitroContract();
     init_swift_standin_digest();
     NITRO_SUPERSET_ENTRY_NAME = "superset";
-    NITRO_COMPILER_DIGEST = true ? "b921ffdabd74c27ca68557852e8aa9fbef685540e0bf588ba802520b59f12bce" : nitroCompilerSourceDigest(__sootsim_import_meta_dirname, STANDIN_SOURCE_DIGEST2);
+    NITRO_COMPILER_DIGEST = true ? "476dc80dfe13d046b6e1e4401add50aab58adb46496109e4a66c3681a8325ee8" : nitroCompilerSourceDigest(__sootsim_import_meta_dirname, STANDIN_SOURCE_DIGEST2);
     nitroSupersetLock = parseLock(nitro_superset_lock_default);
     nitroSupersetKey = (inputs) => nativeEntryKey({ ...inputs, compiler: NITRO_COMPILER_DIGEST });
     published2 = /* @__PURE__ */ new Map();
@@ -12878,6 +12878,37 @@ async function resolveAndroidModules(appRoot) {
     throw new Error("invalid Expo Android autolinking entry");
   return resolved.modules;
 }
+async function resolveReactNativeAndroidAutolinking(appRoot) {
+  const config = await reactNativeAutolinkingConfig(appRoot, "android");
+  if (!isRecord(config) || !isRecord(config.dependencies))
+    throw new Error(`${appRoot}: React Native autolinking config has no dependencies`);
+  const linked = [];
+  for (const [name3, dependency] of Object.entries(config.dependencies)) {
+    if (!isRecord(dependency) || !isRecord(dependency.platforms))
+      throw new Error(
+        `${appRoot}: React Native autolinking dependency ${name3} is malformed`
+      );
+    const android = dependency.platforms.android;
+    if (android == null) continue;
+    if (!isRecord(android) || typeof dependency.root !== "string")
+      throw new Error(
+        `${appRoot}: React Native autolinking dependency ${name3} has no Android project`
+      );
+    const string5 = (field) => {
+      const value = android[field];
+      if (value == null || typeof value === "string") return value ?? null;
+      throw new Error(`${appRoot}: Android dependency ${name3} has invalid ${field}`);
+    };
+    linked.push({
+      name: name3,
+      root: dependency.root,
+      sourceDir: string5("sourceDir"),
+      packageImportPath: string5("packageImportPath"),
+      packageInstance: string5("packageInstance")
+    });
+  }
+  return linked;
+}
 var import_node_child_process49, import_node_fs113, import_node_module18, import_node_path115, import_node_util18, run8, resolving;
 var init_android_autolinking = __esm({
   "src/android-autolinking.ts"() {
@@ -12897,6 +12928,199 @@ var init_android_autolinking = __esm({
   }
 });
 
+// src/android-gradle-sources.ts
+var android_gradle_sources_exports = {};
+__export(android_gradle_sources_exports, {
+  resolveAndroidGradleSources: () => resolveAndroidGradleSources
+});
+async function resolveAndroidGradleSources(request) {
+  let { root } = request;
+  const { projects: projectDirs, variant: variant2 } = request;
+  if (projectDirs.length === 0) return [];
+  if (!import_node_path116.default.isAbsolute(root) || projectDirs.some((dir) => !import_node_path116.default.isAbsolute(dir)))
+    throw new Error("Android Gradle source selection requires absolute project paths");
+  if (!variant2) throw new Error("Android Gradle source selection requires a variant");
+  root = import_node_fs114.default.realpathSync(root);
+  const projects2 = [...new Set(projectDirs.map((dir) => import_node_fs114.default.realpathSync(dir)))];
+  const parent = import_node_path116.default.join(kotlinHome(), "gradle-sources");
+  import_node_fs114.default.mkdirSync(parent, { recursive: true });
+  const work = import_node_fs114.default.mkdtempSync(import_node_path116.default.join(parent, ".query-"));
+  const task = `peachAndroidSources${(0, import_node_crypto59.randomBytes)(8).toString("hex")}`;
+  const script = import_node_path116.default.join(work, "sources.gradle");
+  const encoded = Buffer.from(
+    JSON.stringify({ root, projects: projects2, variant: variant2, output: work, task })
+  ).toString("base64");
+  import_node_fs114.default.writeFileSync(script, modelQuery.replace("__PEACH_REQUEST__", encoded));
+  try {
+    await run9(
+      "bash",
+      [
+        import_node_path116.default.join(root, "gradlew"),
+        "--init-script",
+        script,
+        `${task}All`,
+        "--no-daemon",
+        "--no-configuration-cache",
+        "--no-configure-on-demand",
+        "--max-workers=1",
+        "--console=plain"
+      ],
+      {
+        cwd: root,
+        timeout: 3e5,
+        maxBuffer: 8 * 1024 * 1024,
+        env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: "1" }
+      }
+    );
+    return projects2.map((projectDir, index) => {
+      const value = JSON.parse(
+        import_node_fs114.default.readFileSync(import_node_path116.default.join(work, `${index}.json`), "utf8")
+      );
+      if (!isRecord(value) || value.projectDir !== projectDir || value.variant !== variant2 || typeof value.projectPath !== "string" || value.applicationId !== null && typeof value.applicationId !== "string" || typeof value.namespace !== "string" || !value.namespace || value.targetSdk !== null && (typeof value.targetSdk !== "number" || !Number.isInteger(value.targetSdk) || value.targetSdk <= 0))
+        throw new Error("Gradle printed an invalid Android project source model");
+      const sources = (field) => {
+        const list2 = value[field];
+        if (!Array.isArray(list2) || !list2.every((file) => typeof file === "string" && import_node_path116.default.isAbsolute(file)))
+          throw new Error(`Gradle printed invalid Android ${field} source paths`);
+        return list2.map(String);
+      };
+      if (!Array.isArray(value.dependencies))
+        throw new Error("Gradle printed invalid Android dependencies");
+      const dependencies = value.dependencies.map(
+        (entry) => {
+          if (isRecord(entry) && typeof entry.name === "string" && entry.name) {
+            if (entry.kind === "module" && typeof entry.group === "string" && entry.group && typeof entry.version === "string" && entry.version)
+              return {
+                kind: entry.kind,
+                group: entry.group,
+                name: entry.name,
+                version: entry.version
+              };
+            if (entry.kind === "project" || entry.kind === "file")
+              return { kind: entry.kind, name: entry.name };
+          }
+          throw new Error("Gradle printed an invalid Android dependency");
+        }
+      );
+      return {
+        projectDir,
+        projectPath: value.projectPath,
+        variant: variant2,
+        applicationId: value.applicationId,
+        namespace: value.namespace,
+        targetSdk: value.targetSdk,
+        kotlin: sources("kotlin"),
+        java: sources("java"),
+        dependencies
+      };
+    });
+  } finally {
+    import_node_fs114.default.rmSync(work, { recursive: true, force: true });
+  }
+}
+var import_node_child_process50, import_node_crypto59, import_node_fs114, import_node_path116, import_node_util19, run9, modelQuery;
+var init_android_gradle_sources = __esm({
+  "src/android-gradle-sources.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    import_node_child_process50 = require("node:child_process");
+    import_node_crypto59 = require("node:crypto");
+    import_node_fs114 = __toESM(require("node:fs"), 1);
+    import_node_path116 = __toESM(require("node:path"), 1);
+    import_node_util19 = require("node:util");
+    init_forked_script_contract();
+    init_is_record();
+    init_kotlin_toolchain();
+    run9 = (0, import_node_util19.promisify)(import_node_child_process50.execFile);
+    modelQuery = `
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import org.gradle.api.artifacts.FileCollectionDependency
+import org.gradle.api.artifacts.component.ModuleComponentIdentifier
+import org.gradle.api.artifacts.component.ProjectComponentIdentifier
+import org.gradle.api.artifacts.result.ResolvedDependencyResult
+import org.gradle.api.attributes.Category
+
+def request = new JsonSlurper().parseText(new String(Base64.decoder.decode('__PEACH_REQUEST__'), 'UTF-8'))
+def selectedVariants = [:]
+gradle.beforeProject { project ->
+    def directory = project.projectDir.canonicalPath
+    if (project.rootProject.projectDir.canonicalPath != request.root || !request.projects.contains(directory)) return
+    ['com.android.application', 'com.android.library'].each { plugin ->
+        project.pluginManager.withPlugin(plugin) {
+            def components = project.extensions.getByName('androidComponents')
+            components.onVariants(components.selector().withName(request.variant)) { variant ->
+                selectedVariants[directory] = variant
+            }
+        }
+    }
+}
+gradle.projectsEvaluated {
+    if (gradle.rootProject.projectDir.canonicalPath != request.root) return
+    def selected = []
+    request.projects.eachWithIndex { directory, index ->
+        def matches = gradle.rootProject.allprojects.findAll { it.projectDir.canonicalPath == directory }
+        if (matches.size() != 1) throw new GradleException('Expected one Android project for ' + directory)
+        def project = matches[0]
+        if (project.pluginManager.hasPlugin('org.jetbrains.kotlin.multiplatform')) {
+            throw new GradleException('Kotlin multiplatform source selection is not supported: ' + project.path)
+        }
+        def library = project.pluginManager.hasPlugin('com.android.library')
+        if (!library && !project.pluginManager.hasPlugin('com.android.application')) {
+            throw new GradleException('Project has no Android application or library plugin: ' + project.path)
+        }
+        def variant = selectedVariants[directory]
+        if (variant == null) throw new GradleException('Android variant ' + request.variant + ' is absent: ' + project.path)
+        def generators = []
+        if (project.pluginManager.hasPlugin('com.facebook.react')) {
+            generators.add(project.tasks.named('generateCodegenArtifactsFromSchema'))
+        }
+        def kotlin = project.tasks.findByName('compile' + variant.name.capitalize() + 'Kotlin')
+        def kotlinSources = kotlin == null ? project.files() : kotlin.sources
+        def javaSources = project.tasks.named('compile' + variant.name.capitalize() + 'JavaWithJavac').get().source
+        def query = project.tasks.register(request.task) {
+            dependsOn(generators)
+            dependsOn(kotlinSources.buildDependencies, javaSources.buildDependencies)
+            doLast {
+                def files = (kotlinSources.files + javaSources.files).unique()
+                def unknown = files.find { !it.name.endsWith('.kt') && !it.name.endsWith('.java') }
+                if (unknown != null) throw new GradleException('Unsupported Android source: ' + unknown)
+                def dependencies = [variant.compileConfiguration, variant.runtimeConfiguration].collectMany { configuration ->
+                    def modules = configuration.incoming.resolutionResult.rootComponent.get().dependencies.findAll { !it.constraint }.collectMany { dependency ->
+                        if (!(dependency instanceof ResolvedDependencyResult)) throw new GradleException('Unresolved Android dependency: ' + dependency.requested, dependency.failure)
+                        def category = dependency.resolvedVariant.attributes.getAttribute(Category.CATEGORY_ATTRIBUTE)?.name
+                        if (category == Category.REGULAR_PLATFORM || category == Category.ENFORCED_PLATFORM) return []
+                        def id = dependency.selected.id
+                        if (id instanceof ModuleComponentIdentifier) return [[kind:'module', group:id.group, name:id.module, version:id.version]]
+                        if (id instanceof ProjectComponentIdentifier) return [[kind:'project', name:id.displayName]]
+                        throw new GradleException('Unsupported Android dependency component: ' + id.displayName)
+                    }
+                    def local = configuration.allDependencies.withType(FileCollectionDependency).collectMany { dependency ->
+                        dependency.files.files.collect { [kind:'file', name:it.absolutePath] }
+                    }
+                    modules + local
+                }.unique()
+                new File(request.output, index.toString() + '.json').text = JsonOutput.toJson([
+                    projectDir:project.projectDir.canonicalPath,
+                    projectPath:project.path,
+                    variant:variant.name,
+                    applicationId:library ? null : variant.applicationId.get(),
+                    namespace:variant.namespace.get(),
+                    targetSdk:library ? null : variant.targetSdk.apiLevel,
+                    kotlin:files.findAll { it.name.endsWith('.kt') }.collect { it.absolutePath }.sort(),
+                    java:files.findAll { it.name.endsWith('.java') }.collect { it.absolutePath }.sort(),
+                    dependencies:dependencies
+                ])
+            }
+        }
+        selected.add(query)
+    }
+    gradle.rootProject.tasks.register(request.task + 'All') { dependsOn(selected) }
+}
+`;
+  }
+});
+
 // src/android-bridge-packages.ts
 function readBridgeMethod(value) {
   if (!isRecord(value) || typeof value.name !== "string" || typeof value.blocking !== "boolean" || value.returns !== null && typeof value.returns !== "string" || !Array.isArray(value.params))
@@ -12942,27 +13166,27 @@ function readBridgeFiles(output2) {
   });
 }
 function androidAppSources(appRoot) {
-  const moduleDir = import_node_path116.default.join(appRoot, "android", "app");
-  const gradle = ["build.gradle", "build.gradle.kts"].map((name3) => import_node_path116.default.join(moduleDir, name3)).find((file) => import_node_fs114.default.existsSync(file));
+  const moduleDir = import_node_path117.default.join(appRoot, "android", "app");
+  const gradle = ["build.gradle", "build.gradle.kts"].map((name3) => import_node_path117.default.join(moduleDir, name3)).find((file) => import_node_fs115.default.existsSync(file));
   if (!gradle) return null;
   const id = /\bapplicationId\s*=?\s*["']([^"']+)["']/.exec(
-    import_node_fs114.default.readFileSync(gradle, "utf8")
+    import_node_fs115.default.readFileSync(gradle, "utf8")
   );
   if (!id) throw new Error(`${gradle}: no applicationId`);
   const kotlin = [];
   const java = [];
   const walk3 = (dir) => {
-    if (!import_node_fs114.default.existsSync(dir)) return;
-    for (const child of import_node_fs114.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const file = import_node_path116.default.join(dir, child.name);
+    if (!import_node_fs115.default.existsSync(dir)) return;
+    for (const child of import_node_fs115.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const file = import_node_path117.default.join(dir, child.name);
       if (child.isSymbolicLink()) throw new Error(`Android source is a symlink: ${file}`);
       if (child.isDirectory()) walk3(file);
       else if (child.name.endsWith(".kt")) kotlin.push(file);
       else if (child.name.endsWith(".java")) java.push(file);
     }
   };
-  walk3(import_node_path116.default.join(moduleDir, "src", "main", "java"));
-  walk3(import_node_path116.default.join(moduleDir, "src", "main", "kotlin"));
+  walk3(import_node_path117.default.join(moduleDir, "src", "main", "java"));
+  walk3(import_node_path117.default.join(moduleDir, "src", "main", "kotlin"));
   return { applicationId: id[1], kotlin, java };
 }
 function declares(source, owner, name3) {
@@ -12971,7 +13195,7 @@ function declares(source, owner, name3) {
 }
 function selectBridgePackages(applicationId, files2, javaFiles) {
   const texts = new Map(
-    files2.map((file) => [file.file, import_node_fs114.default.readFileSync(file.file, "utf8")])
+    files2.map((file) => [file.file, import_node_fs115.default.readFileSync(file.file, "utf8")])
   );
   const owners = /* @__PURE__ */ new Map();
   for (const file of files2)
@@ -12979,8 +13203,8 @@ function selectBridgePackages(applicationId, files2, javaFiles) {
       owners.set(name3, [...owners.get(name3) ?? [], file]);
   const javaDeclarations = javaFiles.map((file) => ({
     file,
-    package: /^\s*package\s+([\w.]+)\s*;/m.exec(import_node_fs114.default.readFileSync(file, "utf8"))?.[1] ?? "",
-    name: import_node_path116.default.basename(file, ".java")
+    package: /^\s*package\s+([\w.]+)\s*;/m.exec(import_node_fs115.default.readFileSync(file, "utf8"))?.[1] ?? "",
+    name: import_node_path117.default.basename(file, ".java")
   }));
   const closure = (root) => {
     const seen = /* @__PURE__ */ new Set([root]);
@@ -13053,65 +13277,15 @@ function moduleName(text6, className2) {
   );
   return match ? match[1] : null;
 }
-var import_node_fs114, import_node_path116, qualified2;
+var import_node_fs115, import_node_path117, qualified2;
 var init_android_bridge_packages = __esm({
   "src/android-bridge-packages.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    import_node_fs114 = __toESM(require("node:fs"), 1);
-    import_node_path116 = __toESM(require("node:path"), 1);
-    init_is_record();
-    qualified2 = (file, name3) => file.package ? `${file.package}.${name3}` : name3;
-  }
-});
-
-// src/kotlin-module.ts
-function peachKotlinModuleRoot() {
-  if (!IS_STANDALONE)
-    return import_node_path117.default.resolve(import_node_path117.default.dirname((0, import_node_url9.fileURLToPath)(__sootsim_import_meta_url)), "..", "kotlin");
-  if (installedRoot) return installedRoot;
-  const files2 = __PEACH_BUNDLED_KOTLIN__;
-  const digest3 = (0, import_node_crypto59.createHash)("sha256").update(JSON.stringify(files2)).digest("hex");
-  const parent = import_node_path117.default.join(rnxHomeDir(), "kotlin", "modules");
-  const root = import_node_path117.default.join(parent, digest3);
-  import_node_fs115.default.mkdirSync(parent, { recursive: true });
-  if (!import_node_fs115.default.existsSync(root)) {
-    const pending = import_node_fs115.default.mkdtempSync(import_node_path117.default.join(parent, ".install-"));
-    try {
-      for (const [name3, contents] of Object.entries(files2)) {
-        const file = import_node_path117.default.join(pending, name3);
-        import_node_fs115.default.mkdirSync(import_node_path117.default.dirname(file), { recursive: true });
-        import_node_fs115.default.writeFileSync(file, Buffer.from(contents, "base64"));
-      }
-      try {
-        import_node_fs115.default.renameSync(pending, root);
-      } catch (error) {
-        if (!isRecord(error) || error.code !== "EEXIST" && error.code !== "ENOTEMPTY")
-          throw error;
-      }
-    } finally {
-      import_node_fs115.default.rmSync(pending, { recursive: true, force: true });
-    }
-  }
-  for (const [name3, contents] of Object.entries(files2)) {
-    if (!import_node_fs115.default.readFileSync(import_node_path117.default.join(root, name3)).equals(Buffer.from(contents, "base64")))
-      throw new Error(`packaged Kotlin module differs from this CLI: ${name3}`);
-  }
-  installedRoot = root;
-  return root;
-}
-var import_node_crypto59, import_node_fs115, import_node_path117, import_node_url9, installedRoot;
-var init_kotlin_module = __esm({
-  "src/kotlin-module.ts"() {
-    "use strict";
-    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    import_node_crypto59 = require("node:crypto");
     import_node_fs115 = __toESM(require("node:fs"), 1);
     import_node_path117 = __toESM(require("node:path"), 1);
-    import_node_url9 = require("node:url");
-    init_standalone();
-    init_home_paths();
     init_is_record();
+    qualified2 = (file, name3) => file.package ? `${file.package}.${name3}` : name3;
   }
 });
 
@@ -13131,7 +13305,7 @@ async function readJavaModuleSpecs(files2, sdkRoot, toolchain) {
       import_node_fs116.default.writeFileSync(target, bytes);
       origins.set(target, file);
     }
-    const { stdout } = await run9(
+    const { stdout } = await run10(
       import_node_path118.default.join(toolchain.javaHome, "bin", "java"),
       [
         "-cp",
@@ -13144,7 +13318,14 @@ async function readJavaModuleSpecs(files2, sdkRoot, toolchain) {
         ...origins.keys()
       ],
       { maxBuffer: 16 * 1024 * 1024 }
-    );
+    ).catch((cause) => {
+      if (!isRecord(cause) || typeof cause.stderr !== "string") throw cause;
+      let diagnostic = cause.stderr;
+      for (const [temporary, original] of origins)
+        diagnostic = diagnostic.replaceAll(temporary, original);
+      throw new Error(`Java module read failed:
+${diagnostic.trim()}`, { cause });
+    });
     const specs = stdout.split("\n").filter(Boolean).map((line) => {
       const row = JSON.parse(line);
       if (!isRecord(row) || typeof row.file !== "string" || typeof row.className !== "string" || row.name !== null && typeof row.name !== "string" || typeof row.source !== "string" || !Array.isArray(row.methods))
@@ -13182,7 +13363,7 @@ async function compileJavaModuleAbi(input) {
     ].join("\n")
   );
   const name3 = `peach-java-abi-${hash}`;
-  await run9(
+  await run10(
     toolchain.kotlinc,
     [
       "-J-Xmx2g",
@@ -13206,7 +13387,7 @@ async function compileJavaModuleAbi(input) {
     { maxBuffer: 16 * 1024 * 1024 }
   );
   const library = import_node_path118.default.join(directory2, "java-abi.klib");
-  await run9(
+  await run10(
     import_node_path118.default.join(toolchain.javaHome, "bin", "java"),
     [
       "-cp",
@@ -13223,24 +13404,308 @@ async function compileJavaModuleAbi(input) {
   );
   return library;
 }
-var import_node_child_process50, import_node_crypto60, import_node_fs116, import_node_path118, import_node_util19, run9, JAVA_BINDINGS_INITIALIZER;
+var import_node_child_process51, import_node_crypto60, import_node_fs116, import_node_path118, import_node_util20, run10, JAVA_BINDINGS_INITIALIZER;
 var init_java_module_abi = __esm({
   "src/java-module-abi.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    import_node_child_process50 = require("node:child_process");
+    import_node_child_process51 = require("node:child_process");
     import_node_crypto60 = require("node:crypto");
     import_node_fs116 = __toESM(require("node:fs"), 1);
     import_node_path118 = __toESM(require("node:path"), 1);
-    import_node_util19 = require("node:util");
+    import_node_util20 = require("node:util");
     init_android_bridge_packages();
     init_is_record();
     init_kotlin_toolchain();
-    run9 = (0, import_node_util19.promisify)(import_node_child_process50.execFile);
+    run10 = (0, import_node_util20.promisify)(import_node_child_process51.execFile);
     JAVA_BINDINGS_INITIALIZER = "initializeJavaBindings";
   }
 });
 
+// src/kotlinSdkContract.ts
+function readKotlinSdkManifest(source, compilerSha256) {
+  const value = JSON.parse(source);
+  if (!isRecord(value) || value.format !== 1 || value.abi !== 1 || value.compilerSha256 !== compilerSha256 || typeof value.sourceDigest !== "string" || !/^[a-f0-9]{64}$/.test(value.sourceDigest) || !isRecord(value.files) || Object.keys(value.files).length !== KOTLIN_SDK_FILES.length)
+    throw new Error("Kotlin SDK manifest is incompatible with this compiler");
+  const files2 = {};
+  for (const name3 of KOTLIN_SDK_FILES) {
+    const file = value.files[name3];
+    if (!isRecord(file) || typeof file.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(file.sha256) || typeof file.bytes !== "number" || !Number.isSafeInteger(file.bytes) || file.bytes < 1)
+      throw new Error(`Kotlin SDK has no verified binary ${name3}`);
+    files2[name3] = { sha256: file.sha256, bytes: file.bytes };
+  }
+  return {
+    format: 1,
+    abi: 1,
+    compilerSha256,
+    sourceDigest: value.sourceDigest,
+    files: files2
+  };
+}
+var platform, KOTLIN_SDK_PROFILES, KOTLIN_SDK_FILES;
+var init_kotlinSdkContract = __esm({
+  "src/kotlinSdkContract.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    init_is_record();
+    platform = ["Sources", "JniPlatformSources", "JniSources"];
+    KOTLIN_SDK_PROFILES = {
+      core: { compose: false, directories: platform },
+      compose: { compose: true, directories: platform },
+      views: { compose: true, directories: [...platform, "ComposeSources"] },
+      jni: { compose: false, directories: [...platform, "JniTransportSources"] },
+      jniCompose: {
+        compose: true,
+        directories: [...platform, "JniTransportSources"]
+      },
+      jniViews: {
+        compose: true,
+        directories: [...platform, "JniTransportSources", "ComposeSources"]
+      },
+      expo: {
+        compose: false,
+        directories: [...platform, "ExpoSources", "BridgeSources", "AndroidViewSources"]
+      },
+      expoCompose: {
+        compose: true,
+        directories: [
+          ...platform,
+          "ExpoSources",
+          "BridgeSources",
+          "AndroidViewSources",
+          "ComposeSources",
+          "AndroidComposeSources",
+          "ExpoComposeSources"
+        ]
+      },
+      app: {
+        compose: true,
+        directories: [
+          ...platform,
+          "ComposeSources",
+          "AppSources",
+          "AndroidViewSources",
+          "AndroidComposeSources"
+        ]
+      }
+    };
+    KOTLIN_SDK_FILES = [
+      "plugin.jar",
+      "tools.jar",
+      ...Object.keys(KOTLIN_SDK_PROFILES).map((name3) => `${name3}.klib`)
+    ];
+  }
+});
+
+// src/kotlin-sdk.ts
+function verifyKotlinSdkDirectory(root, compilerSha256) {
+  const expectedNames = ["manifest.json", ...KOTLIN_SDK_FILES];
+  const names = import_node_fs117.default.readdirSync(root);
+  if (names.length !== expectedNames.length || names.some((name3) => !expectedNames.includes(name3)))
+    throw new Error("Kotlin SDK directory contains unexpected inputs");
+  const manifestStat = import_node_fs117.default.lstatSync(import_node_path119.default.join(root, "manifest.json"));
+  if (!manifestStat.isFile() || manifestStat.nlink !== 1)
+    throw new Error("Kotlin SDK manifest is not a regular file");
+  const manifest = readKotlinSdkManifest(
+    import_node_fs117.default.readFileSync(import_node_path119.default.join(root, "manifest.json"), "utf8"),
+    compilerSha256
+  );
+  for (const [name3, expected] of Object.entries(manifest.files)) {
+    const target = import_node_path119.default.join(root, name3);
+    const stat2 = import_node_fs117.default.lstatSync(target);
+    if (!stat2.isFile() || stat2.nlink !== 1)
+      throw new Error(`Kotlin SDK binary is not a regular file: ${name3}`);
+    const bytes = import_node_fs117.default.readFileSync(target);
+    if (bytes.length !== expected.bytes || (0, import_node_crypto61.createHash)("sha256").update(bytes).digest("hex") !== expected.sha256)
+      throw new Error(`Kotlin SDK binary differs from its manifest: ${name3}`);
+  }
+  return manifest;
+}
+async function installKotlinSdkArchive(archive, compilerSha256) {
+  const sha2564 = (0, import_node_crypto61.createHash)("sha256").update(archive).digest("hex");
+  const parent = import_node_path119.default.join(kotlinHome(), "sdk");
+  const root = import_node_path119.default.join(parent, sha2564);
+  if (import_node_fs117.default.existsSync(root))
+    return { root, sha256: sha2564, manifest: verifyKotlinSdkDirectory(root, compilerSha256) };
+  import_node_fs117.default.mkdirSync(parent, { recursive: true });
+  const work = import_node_fs117.default.mkdtempSync(import_node_path119.default.join(parent, ".install-"));
+  try {
+    const packed = import_node_path119.default.join(work, "sdk.tar.gz");
+    import_node_fs117.default.writeFileSync(packed, archive);
+    const { stdout } = await run11("tar", ["-tzf", packed]);
+    const names = stdout.trim().split("\n");
+    const expected = ["manifest.json", ...KOTLIN_SDK_FILES];
+    if (names.length !== expected.length || new Set(names).size !== names.length || names.some((name3) => !expected.includes(name3)))
+      throw new Error("Kotlin SDK archive contains unexpected inputs");
+    await run11("tar", ["-xzf", packed, "-C", work, "--", ...expected]);
+    import_node_fs117.default.rmSync(packed);
+    const manifest = verifyKotlinSdkDirectory(work, compilerSha256);
+    try {
+      import_node_fs117.default.renameSync(work, root);
+    } catch (error) {
+      if (!import_node_fs117.default.existsSync(root)) throw error;
+      verifyKotlinSdkDirectory(root, compilerSha256);
+    }
+    return { root, sha256: sha2564, manifest };
+  } finally {
+    import_node_fs117.default.rmSync(work, { recursive: true, force: true });
+  }
+}
+var import_node_child_process52, import_node_crypto61, import_node_fs117, import_node_path119, import_node_util21, run11;
+var init_kotlin_sdk = __esm({
+  "src/kotlin-sdk.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    import_node_child_process52 = require("node:child_process");
+    import_node_crypto61 = require("node:crypto");
+    import_node_fs117 = __toESM(require("node:fs"), 1);
+    import_node_path119 = __toESM(require("node:path"), 1);
+    import_node_util21 = require("node:util");
+    init_kotlin_toolchain();
+    init_kotlinSdkContract();
+    run11 = (0, import_node_util21.promisify)(import_node_child_process52.execFile);
+  }
+});
+
+// src/android-bridge-dependencies.ts
+async function collectAndroidBridgeDependencies(appRoot, moduleRoot) {
+  const root = import_node_path120.default.join(appRoot, "android");
+  if (!import_node_fs118.default.existsSync(import_node_path120.default.join(root, "gradlew"))) return null;
+  const dependencies = (await resolveReactNativeAndroidAutolinking(appRoot)).flatMap(
+    (dependency) => dependency.sourceDir === null || dependency.packageInstance === null ? [] : [
+      {
+        ...dependency,
+        sourceDir: dependency.sourceDir,
+        packageInstance: dependency.packageInstance
+      }
+    ]
+  );
+  if (dependencies.length === 0) return null;
+  const models = await resolveAndroidGradleSources({
+    root,
+    projects: [
+      import_node_path120.default.join(root, "app"),
+      ...dependencies.map((dependency) => dependency.sourceDir)
+    ],
+    variant: "debug"
+  });
+  const applicationId = models[0].applicationId;
+  if (applicationId === null) throw new Error(`${root}/app is not an Android application`);
+  const toolchain = readToolchain(moduleRoot);
+  const [sdk, ready] = await Promise.all([
+    installKotlinSdkArchive(
+      import_node_fs118.default.readFileSync(import_node_path120.default.join(moduleRoot, "sdk.tar.gz")),
+      toolchain.compiler.sha256
+    ),
+    ensureToolchain(toolchain)
+  ]);
+  const packages = [];
+  for (const dependency of dependencies) {
+    const model = models.find(
+      (entry) => entry.projectDir === import_node_fs118.default.realpathSync(dependency.sourceDir)
+    );
+    try {
+      const className2 = /^import\s+([\w.]+)\s*;$/.exec(
+        dependency.packageImportPath ?? ""
+      )?.[1];
+      const constructor = /^new\s+([\w.]+)\s*\(\s*\)$/.exec(
+        dependency.packageInstance
+      )?.[1];
+      if (!className2 || constructor !== className2 && constructor !== className2.split(".").pop())
+        throw new Error(
+          "native package registration requires a constructor without arguments"
+        );
+      const declarations = await readJavaModuleSpecs(model.java, sdk.root, ready);
+      const modules = declarations.specs.flatMap(
+        (spec) => spec.name === null ? [] : [
+          {
+            className: spec.className,
+            name: spec.name,
+            methods: spec.methods
+          }
+        ]
+      );
+      if (modules.length === 0) continue;
+      packages.push({
+        className: className2,
+        modules,
+        sources: model.kotlin,
+        javaSpecs: model.java,
+        unsupported: null
+      });
+    } catch (error) {
+      console.error(
+        `[peach] ${dependency.name} native source is unavailable: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return packages.length ? { applicationId, packages } : null;
+}
+var import_node_fs118, import_node_path120;
+var init_android_bridge_dependencies = __esm({
+  "src/android-bridge-dependencies.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    import_node_fs118 = __toESM(require("node:fs"), 1);
+    import_node_path120 = __toESM(require("node:path"), 1);
+    init_android_autolinking();
+    init_android_gradle_sources();
+    init_java_module_abi();
+    init_kotlin_sdk();
+    init_kotlin_toolchain();
+  }
+});
+
+// src/kotlin-module.ts
+function peachKotlinModuleRoot() {
+  if (!IS_STANDALONE)
+    return import_node_path121.default.resolve(import_node_path121.default.dirname((0, import_node_url9.fileURLToPath)(__sootsim_import_meta_url)), "..", "kotlin");
+  if (installedRoot) return installedRoot;
+  const files2 = __PEACH_BUNDLED_KOTLIN__;
+  const digest3 = (0, import_node_crypto62.createHash)("sha256").update(JSON.stringify(files2)).digest("hex");
+  const parent = import_node_path121.default.join(rnxHomeDir(), "kotlin", "modules");
+  const root = import_node_path121.default.join(parent, digest3);
+  import_node_fs119.default.mkdirSync(parent, { recursive: true });
+  if (!import_node_fs119.default.existsSync(root)) {
+    const pending = import_node_fs119.default.mkdtempSync(import_node_path121.default.join(parent, ".install-"));
+    try {
+      for (const [name3, contents] of Object.entries(files2)) {
+        const file = import_node_path121.default.join(pending, name3);
+        import_node_fs119.default.mkdirSync(import_node_path121.default.dirname(file), { recursive: true });
+        import_node_fs119.default.writeFileSync(file, Buffer.from(contents, "base64"));
+      }
+      try {
+        import_node_fs119.default.renameSync(pending, root);
+      } catch (error) {
+        if (!isRecord(error) || error.code !== "EEXIST" && error.code !== "ENOTEMPTY")
+          throw error;
+      }
+    } finally {
+      import_node_fs119.default.rmSync(pending, { recursive: true, force: true });
+    }
+  }
+  for (const [name3, contents] of Object.entries(files2)) {
+    if (!import_node_fs119.default.readFileSync(import_node_path121.default.join(root, name3)).equals(Buffer.from(contents, "base64")))
+      throw new Error(`packaged Kotlin module differs from this CLI: ${name3}`);
+  }
+  installedRoot = root;
+  return root;
+}
+var import_node_crypto62, import_node_fs119, import_node_path121, import_node_url9, installedRoot;
+var init_kotlin_module = __esm({
+  "src/kotlin-module.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    import_node_crypto62 = require("node:crypto");
+    import_node_fs119 = __toESM(require("node:fs"), 1);
+    import_node_path121 = __toESM(require("node:path"), 1);
+    import_node_url9 = require("node:url");
+    init_standalone();
+    init_home_paths();
+    init_is_record();
+  }
+});
+
 // src/kotlin-instance-source.ts
 function bindingNames(pattern) {
   if (pattern.type === "Identifier") return [pattern.name];
@@ -13354,144 +13819,6 @@ var init_kotlin_instance_source = __esm({
   }
 });
 
-// src/kotlinSdkContract.ts
-function readKotlinSdkManifest(source, compilerSha256) {
-  const value = JSON.parse(source);
-  if (!isRecord(value) || value.format !== 1 || value.abi !== 1 || value.compilerSha256 !== compilerSha256 || typeof value.sourceDigest !== "string" || !/^[a-f0-9]{64}$/.test(value.sourceDigest) || !isRecord(value.files) || Object.keys(value.files).length !== KOTLIN_SDK_FILES.length)
-    throw new Error("Kotlin SDK manifest is incompatible with this compiler");
-  const files2 = {};
-  for (const name3 of KOTLIN_SDK_FILES) {
-    const file = value.files[name3];
-    if (!isRecord(file) || typeof file.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(file.sha256) || typeof file.bytes !== "number" || !Number.isSafeInteger(file.bytes) || file.bytes < 1)
-      throw new Error(`Kotlin SDK has no verified binary ${name3}`);
-    files2[name3] = { sha256: file.sha256, bytes: file.bytes };
-  }
-  return {
-    format: 1,
-    abi: 1,
-    compilerSha256,
-    sourceDigest: value.sourceDigest,
-    files: files2
-  };
-}
-var platform, KOTLIN_SDK_PROFILES, KOTLIN_SDK_FILES;
-var init_kotlinSdkContract = __esm({
-  "src/kotlinSdkContract.ts"() {
-    "use strict";
-    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    init_is_record();
-    platform = ["Sources", "JniPlatformSources", "JniSources"];
-    KOTLIN_SDK_PROFILES = {
-      core: { compose: false, directories: platform },
-      compose: { compose: true, directories: platform },
-      views: { compose: true, directories: [...platform, "ComposeSources"] },
-      jni: { compose: false, directories: [...platform, "JniTransportSources"] },
-      jniCompose: {
-        compose: true,
-        directories: [...platform, "JniTransportSources"]
-      },
-      jniViews: {
-        compose: true,
-        directories: [...platform, "JniTransportSources", "ComposeSources"]
-      },
-      expo: {
-        compose: false,
-        directories: [...platform, "ExpoSources", "BridgeSources", "AndroidViewSources"]
-      },
-      expoCompose: {
-        compose: true,
-        directories: [
-          ...platform,
-          "ExpoSources",
-          "BridgeSources",
-          "AndroidViewSources",
-          "ComposeSources",
-          "ExpoComposeSources"
-        ]
-      },
-      app: {
-        compose: true,
-        directories: [...platform, "ComposeSources", "AppSources", "AndroidViewSources"]
-      }
-    };
-    KOTLIN_SDK_FILES = [
-      "plugin.jar",
-      "tools.jar",
-      ...Object.keys(KOTLIN_SDK_PROFILES).map((name3) => `${name3}.klib`)
-    ];
-  }
-});
-
-// src/kotlin-sdk.ts
-function verifyKotlinSdkDirectory(root, compilerSha256) {
-  const expectedNames = ["manifest.json", ...KOTLIN_SDK_FILES];
-  const names = import_node_fs117.default.readdirSync(root);
-  if (names.length !== expectedNames.length || names.some((name3) => !expectedNames.includes(name3)))
-    throw new Error("Kotlin SDK directory contains unexpected inputs");
-  const manifestStat = import_node_fs117.default.lstatSync(import_node_path119.default.join(root, "manifest.json"));
-  if (!manifestStat.isFile() || manifestStat.nlink !== 1)
-    throw new Error("Kotlin SDK manifest is not a regular file");
-  const manifest = readKotlinSdkManifest(
-    import_node_fs117.default.readFileSync(import_node_path119.default.join(root, "manifest.json"), "utf8"),
-    compilerSha256
-  );
-  for (const [name3, expected] of Object.entries(manifest.files)) {
-    const target = import_node_path119.default.join(root, name3);
-    const stat2 = import_node_fs117.default.lstatSync(target);
-    if (!stat2.isFile() || stat2.nlink !== 1)
-      throw new Error(`Kotlin SDK binary is not a regular file: ${name3}`);
-    const bytes = import_node_fs117.default.readFileSync(target);
-    if (bytes.length !== expected.bytes || (0, import_node_crypto61.createHash)("sha256").update(bytes).digest("hex") !== expected.sha256)
-      throw new Error(`Kotlin SDK binary differs from its manifest: ${name3}`);
-  }
-  return manifest;
-}
-async function installKotlinSdkArchive(archive, compilerSha256) {
-  const sha2564 = (0, import_node_crypto61.createHash)("sha256").update(archive).digest("hex");
-  const parent = import_node_path119.default.join(kotlinHome(), "sdk");
-  const root = import_node_path119.default.join(parent, sha2564);
-  if (import_node_fs117.default.existsSync(root))
-    return { root, sha256: sha2564, manifest: verifyKotlinSdkDirectory(root, compilerSha256) };
-  import_node_fs117.default.mkdirSync(parent, { recursive: true });
-  const work = import_node_fs117.default.mkdtempSync(import_node_path119.default.join(parent, ".install-"));
-  try {
-    const packed = import_node_path119.default.join(work, "sdk.tar.gz");
-    import_node_fs117.default.writeFileSync(packed, archive);
-    const { stdout } = await run10("tar", ["-tzf", packed]);
-    const names = stdout.trim().split("\n");
-    const expected = ["manifest.json", ...KOTLIN_SDK_FILES];
-    if (names.length !== expected.length || new Set(names).size !== names.length || names.some((name3) => !expected.includes(name3)))
-      throw new Error("Kotlin SDK archive contains unexpected inputs");
-    await run10("tar", ["-xzf", packed, "-C", work, "--", ...expected]);
-    import_node_fs117.default.rmSync(packed);
-    const manifest = verifyKotlinSdkDirectory(work, compilerSha256);
-    try {
-      import_node_fs117.default.renameSync(work, root);
-    } catch (error) {
-      if (!import_node_fs117.default.existsSync(root)) throw error;
-      verifyKotlinSdkDirectory(root, compilerSha256);
-    }
-    return { root, sha256: sha2564, manifest };
-  } finally {
-    import_node_fs117.default.rmSync(work, { recursive: true, force: true });
-  }
-}
-var import_node_child_process51, import_node_crypto61, import_node_fs117, import_node_path119, import_node_util20, run10;
-var init_kotlin_sdk = __esm({
-  "src/kotlin-sdk.ts"() {
-    "use strict";
-    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    import_node_child_process51 = require("node:child_process");
-    import_node_crypto61 = require("node:crypto");
-    import_node_fs117 = __toESM(require("node:fs"), 1);
-    import_node_path119 = __toESM(require("node:path"), 1);
-    import_node_util20 = require("node:util");
-    init_kotlin_toolchain();
-    init_kotlinSdkContract();
-    run10 = (0, import_node_util20.promisify)(import_node_child_process51.execFile);
-  }
-});
-
 // src/kotlin-view-models.ts
 function strings6(value) {
   if (!Array.isArray(value) || !value.every((item) => typeof item === "string"))
@@ -13575,145 +13902,6 @@ var init_kotlin_view_models = __esm({
   }
 });
 
-// src/android-gradle-sources.ts
-var android_gradle_sources_exports = {};
-__export(android_gradle_sources_exports, {
-  resolveAndroidGradleSources: () => resolveAndroidGradleSources
-});
-async function resolveAndroidGradleSources(request) {
-  let { root } = request;
-  const { projects: projectDirs, variant: variant2 } = request;
-  if (projectDirs.length === 0) return [];
-  if (!import_node_path120.default.isAbsolute(root) || projectDirs.some((dir) => !import_node_path120.default.isAbsolute(dir)))
-    throw new Error("Android Gradle source selection requires absolute project paths");
-  if (!variant2) throw new Error("Android Gradle source selection requires a variant");
-  root = import_node_fs118.default.realpathSync(root);
-  const projects2 = [...new Set(projectDirs.map((dir) => import_node_fs118.default.realpathSync(dir)))];
-  const parent = import_node_path120.default.join(kotlinHome(), "gradle-sources");
-  import_node_fs118.default.mkdirSync(parent, { recursive: true });
-  const work = import_node_fs118.default.mkdtempSync(import_node_path120.default.join(parent, ".query-"));
-  const task = `peachAndroidSources${(0, import_node_crypto62.randomBytes)(8).toString("hex")}`;
-  const script = import_node_path120.default.join(work, "sources.gradle");
-  const encoded = Buffer.from(
-    JSON.stringify({ root, projects: projects2, variant: variant2, output: work, task })
-  ).toString("base64");
-  import_node_fs118.default.writeFileSync(script, modelQuery.replace("__PEACH_REQUEST__", encoded));
-  try {
-    await run11(
-      "bash",
-      [
-        import_node_path120.default.join(root, "gradlew"),
-        "--init-script",
-        script,
-        `${task}All`,
-        "--no-daemon",
-        "--no-configuration-cache",
-        "--max-workers=1",
-        "--console=plain"
-      ],
-      {
-        cwd: root,
-        timeout: 3e5,
-        maxBuffer: 8 * 1024 * 1024,
-        env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: "1" }
-      }
-    );
-    return projects2.map((projectDir, index) => {
-      const value = JSON.parse(
-        import_node_fs118.default.readFileSync(import_node_path120.default.join(work, `${index}.json`), "utf8")
-      );
-      if (!isRecord(value) || value.projectDir !== projectDir || value.variant !== variant2 || typeof value.projectPath !== "string" || value.applicationId !== null && typeof value.applicationId !== "string")
-        throw new Error("Gradle printed an invalid Android project source model");
-      const sources = (field) => {
-        const list2 = value[field];
-        if (!Array.isArray(list2) || !list2.every((file) => typeof file === "string" && import_node_path120.default.isAbsolute(file)))
-          throw new Error(`Gradle printed invalid Android ${field} source paths`);
-        return list2.map(String);
-      };
-      return {
-        projectDir,
-        projectPath: value.projectPath,
-        variant: variant2,
-        applicationId: value.applicationId,
-        kotlin: sources("kotlin"),
-        java: sources("java")
-      };
-    });
-  } finally {
-    import_node_fs118.default.rmSync(work, { recursive: true, force: true });
-  }
-}
-var import_node_child_process52, import_node_crypto62, import_node_fs118, import_node_path120, import_node_util21, run11, modelQuery;
-var init_android_gradle_sources = __esm({
-  "src/android-gradle-sources.ts"() {
-    "use strict";
-    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    import_node_child_process52 = require("node:child_process");
-    import_node_crypto62 = require("node:crypto");
-    import_node_fs118 = __toESM(require("node:fs"), 1);
-    import_node_path120 = __toESM(require("node:path"), 1);
-    import_node_util21 = require("node:util");
-    init_forked_script_contract();
-    init_is_record();
-    init_kotlin_toolchain();
-    run11 = (0, import_node_util21.promisify)(import_node_child_process52.execFile);
-    modelQuery = `
-import groovy.json.JsonOutput
-import groovy.json.JsonSlurper
-
-def request = new JsonSlurper().parseText(new String(Base64.decoder.decode('__PEACH_REQUEST__'), 'UTF-8'))
-gradle.projectsEvaluated {
-    if (gradle.rootProject.projectDir.canonicalPath != request.root) return
-    def selected = []
-    request.projects.eachWithIndex { directory, index ->
-        def matches = gradle.rootProject.allprojects.findAll { it.projectDir.canonicalPath == directory }
-        if (matches.size() != 1) throw new GradleException('Expected one Android project for ' + directory)
-        def project = matches[0]
-        if (project.pluginManager.hasPlugin('org.jetbrains.kotlin.multiplatform')) {
-            throw new GradleException('Kotlin multiplatform source selection is not supported: ' + project.path)
-        }
-        def library = project.pluginManager.hasPlugin('com.android.library')
-        if (!library && !project.pluginManager.hasPlugin('com.android.application')) {
-            throw new GradleException('Project has no Android application or library plugin: ' + project.path)
-        }
-        def android = project.extensions.getByName('android')
-        def variants = library ? android.libraryVariants : android.applicationVariants
-        def variant = variants.find { it.name == request.variant }
-        if (variant == null) throw new GradleException('Android variant ' + request.variant + ' is absent: ' + project.path)
-        def generators = []
-        def buildConfig = variant.generateBuildConfigProvider
-        if (buildConfig != null) generators.add(buildConfig)
-        if (project.pluginManager.hasPlugin('com.facebook.react')) {
-            generators.add(project.tasks.named('generateCodegenArtifactsFromSchema'))
-        }
-        def kotlin = project.tasks.findByName('compile' + variant.name.capitalize() + 'Kotlin')
-        def kotlinSources = kotlin == null ? project.files() : kotlin.sources
-        def javaSources = variant.javaCompileProvider.get().source
-        def query = project.tasks.register(request.task) {
-            dependsOn(generators)
-            dependsOn(kotlinSources.buildDependencies, javaSources.buildDependencies)
-            doLast {
-                def files = (kotlinSources.files + javaSources.files).unique()
-                def unknown = files.find { !it.name.endsWith('.kt') && !it.name.endsWith('.java') }
-                if (unknown != null) throw new GradleException('Unsupported Android source: ' + unknown)
-                new File(request.output, index.toString() + '.json').text = JsonOutput.toJson([
-                    projectDir:project.projectDir.canonicalPath,
-                    projectPath:project.path,
-                    variant:variant.name,
-                    applicationId:library ? null : variant.applicationId,
-                    kotlin:files.findAll { it.name.endsWith('.kt') }.collect { it.absolutePath }.sort(),
-                    java:files.findAll { it.name.endsWith('.java') }.collect { it.absolutePath }.sort()
-                ])
-            }
-        }
-        selected.add(query)
-    }
-    gradle.rootProject.tasks.register(request.task + 'All') { dependsOn(selected) }
-}
-`;
-  }
-});
-
 // src/kotlin-host.ts
 var kotlin_host_exports = {};
 __export(kotlin_host_exports, {
@@ -13730,16 +13918,16 @@ __export(kotlin_host_exports, {
 });
 function loadKotlinSdk(moduleRoot, toolchain) {
   return installKotlinSdkArchive(
-    import_node_fs119.default.readFileSync(import_node_path121.default.join(moduleRoot, "sdk.tar.gz")),
+    import_node_fs120.default.readFileSync(import_node_path122.default.join(moduleRoot, "sdk.tar.gz")),
     toolchain.compiler.sha256
   );
 }
 function appKotlinLanguage(root) {
-  const reactNative = import_node_path121.default.dirname(
-    (0, import_node_module19.createRequire)(import_node_path121.default.join(root, "package.json")).resolve("react-native/package.json")
+  const reactNative = import_node_path122.default.dirname(
+    (0, import_node_module19.createRequire)(import_node_path122.default.join(root, "package.json")).resolve("react-native/package.json")
   );
-  const versions = import_node_fs119.default.readFileSync(
-    import_node_path121.default.join(reactNative, "gradle", "libs.versions.toml"),
+  const versions = import_node_fs120.default.readFileSync(
+    import_node_path122.default.join(reactNative, "gradle", "libs.versions.toml"),
     "utf8"
   );
   const match = /^kotlin\s*=\s*"(\d+)\.(\d+)/m.exec(versions);
@@ -13750,9 +13938,9 @@ function appKotlinLanguage(root) {
 function kotlinSources(root, skip = SKIP_DIRS) {
   const sources = [];
   const walk3 = (dir) => {
-    for (const entry of import_node_fs119.default.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs120.default.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || skip.has(entry.name)) continue;
-      const full = import_node_path121.default.join(dir, entry.name);
+      const full = import_node_path122.default.join(dir, entry.name);
       if (entry.isDirectory()) walk3(full);
       else if (entry.isFile() && entry.name.endsWith(".kt")) sources.push(full);
     }
@@ -13814,7 +14002,7 @@ function entrySource(ids) {
   ].join("\n");
 }
 function buildsDir() {
-  return import_node_path121.default.join(kotlinHome(), "builds");
+  return import_node_path122.default.join(kotlinHome(), "builds");
 }
 async function kotlinArtifact(root, moduleRoot, origin, target = "app") {
   const { kotlinSourceId, nativeSourceContract, renderKotlinSourceGlue } = await import("vxrn/native-source-contract");
@@ -13827,7 +14015,7 @@ async function kotlinArtifact(root, moduleRoot, origin, target = "app") {
   const viewIds = [];
   let usesCompose = false;
   for (const file of sources) {
-    const source = import_node_fs119.default.readFileSync(file, "utf8");
+    const source = import_node_fs120.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;
@@ -13918,22 +14106,22 @@ function readExpoTypes(output2) {
 async function scanSources(tool, parse11, toolchain, moduleRoot, files2) {
   const digest3 = (0, import_node_crypto63.createHash)("sha256").update(JSON.stringify(toolchain.compiler));
   const sdk = await loadKotlinSdk(moduleRoot, toolchain);
-  digest3.update(import_node_fs119.default.readFileSync(import_node_path121.default.join(moduleRoot, "sdk.tar.gz")));
+  digest3.update(import_node_fs120.default.readFileSync(import_node_path122.default.join(moduleRoot, "sdk.tar.gz")));
   digest3.update(tool);
-  for (const file of files2) digest3.update(`${file}\0${import_node_fs119.default.readFileSync(file, "utf8")}\0`);
+  for (const file of files2) digest3.update(`${file}\0${import_node_fs120.default.readFileSync(file, "utf8")}\0`);
   const key2 = digest3.digest("hex");
   let scan2 = toolScans.get(key2);
   if (!scan2) {
     scan2 = (async () => {
       const { kotlinc } = await ensureToolchain(toolchain);
       const { stdout } = await run12(
-        import_node_path121.default.join(import_node_path121.default.dirname(kotlinc), "kotlin"),
+        import_node_path122.default.join(import_node_path122.default.dirname(kotlinc), "kotlin"),
         [
           "-cp",
           [
-            import_node_path121.default.resolve(import_node_path121.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
-            import_node_path121.default.join(sdk.root, "tools.jar")
-          ].join(import_node_path121.default.delimiter),
+            import_node_path122.default.resolve(import_node_path122.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
+            import_node_path122.default.join(sdk.root, "tools.jar")
+          ].join(import_node_path122.default.delimiter),
           tool,
           ...files2
         ],
@@ -13951,7 +14139,7 @@ async function scanSources(tool, parse11, toolchain, moduleRoot, files2) {
 async function scanExpoTypes(toolchain, moduleRoot, 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_fs119.default.readFileSync(file, "utf8")
+      import_node_fs120.default.readFileSync(file, "utf8")
     )
   );
   if (candidates.length === 0) return [];
@@ -14095,7 +14283,7 @@ function expoTypeSources(files2) {
       )
     ];
     if (edits.length > 0 || views.length > 0) {
-      let text6 = import_node_fs119.default.readFileSync(file.file, "utf8").replaceAll("\r\n", "\n");
+      let text6 = import_node_fs120.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]))
         text6 = `${text6.slice(0, range2[0])}dev.peach.expo.PeachExpoTypes.initial(${owner}::class, ${literal2(field.key)}, ${field.required}) { ${text6.slice(range2[0], range2[1])} }${text6.slice(range2[1])}`;
       if (views.length > 0) {
@@ -14111,7 +14299,7 @@ function expoTypeSources(files2) {
           `${file.package ? `${file.package}.` : ""}peachExpoViews${index}()`
         );
       }
-      const name3 = `PeachExpoSource_${index}_${import_node_path121.default.basename(file.file)}`;
+      const name3 = `PeachExpoSource_${index}_${import_node_path122.default.basename(file.file)}`;
       generated[name3] = text6;
       origins[name3] = file.file;
     }
@@ -14153,7 +14341,7 @@ async function expoKotlinArtifact(root, moduleRoot, origin, modules) {
   const language = appKotlinLanguage(root);
   const scanned = await scanExpoTypes(toolchain, moduleRoot, modules.sources);
   const usesCompose = scanned.some((file) => file.views.length > 0) || modules.sources.some(
-    (file) => /\bandroidx\.compose\./.test(import_node_fs119.default.readFileSync(file, "utf8"))
+    (file) => /\bandroidx\.compose\./.test(import_node_fs120.default.readFileSync(file, "utf8"))
   );
   const types = expoTypeSources(scanned);
   const rewritten = new Set(Object.values(types.origins));
@@ -14315,6 +14503,7 @@ async function kotlinAppArtifact(app, moduleRoot, origin) {
       toolchain,
       language: app.language,
       sources: app.sources,
+      javaSpecs: app.javaSources,
       generated,
       sdkProfile: "app",
       usesCompose: true,
@@ -14367,7 +14556,7 @@ function appResourceSources(app) {
       entries: app.drawables.map((drawable) => ({
         name: drawable.name,
         init: `listOf(
-${drawable.files.map((file) => drawableInit(file, import_node_path121.default.relative(app.moduleDir, file.file))).join(",\n")}
+${drawable.files.map((file) => drawableInit(file, import_node_path122.default.relative(app.moduleDir, file.file))).join(",\n")}
 )`
       }))
     },
@@ -14436,7 +14625,7 @@ function drawableInit(drawable, file) {
   if (drawable.kind === "xml") return `PeachDrawable.Xml(${where})`;
   if (drawable.kind === "bitmap")
     return `PeachDrawable.Bitmap(${where}, ${drawable.ninePatch}, ${literal2(
-      import_node_fs119.default.readFileSync(drawable.file).toString("base64")
+      import_node_fs120.default.readFileSync(drawable.file).toString("base64")
     )})`;
   const vector = drawable.vector;
   const float3 = (value) => `${value}f`;
@@ -14500,8 +14689,8 @@ async function compileKotlin(input, origin) {
     javaSpecs = []
   } = input;
   const sdk = await loadKotlinSdk(moduleRoot, toolchain);
-  const plugin = import_node_path121.default.join(sdk.root, "plugin.jar");
-  const sdkLibrary = import_node_path121.default.join(sdk.root, `${sdkProfile}.klib`);
+  const plugin = import_node_path122.default.join(sdk.root, "plugin.jar");
+  const sdkLibrary = import_node_path122.default.join(sdk.root, `${sdkProfile}.klib`);
   const java = javaSpecs.length ? await readJavaModuleSpecs(javaSpecs, sdk.root, await ensureToolchain(toolchain)) : null;
   const generated = {
     ...sourceGenerated,
@@ -14524,7 +14713,7 @@ async function compileKotlin(input, origin) {
   };
   const inputs = sources.map((file) => ({
     file,
-    bytes: import_node_fs119.default.readFileSync(file)
+    bytes: import_node_fs120.default.readFileSync(file)
   }));
   const digest3 = (0, import_node_crypto63.createHash)("sha256");
   digest3.update(
@@ -14539,7 +14728,7 @@ async function compileKotlin(input, origin) {
     })
   );
   for (const { file, bytes } of inputs)
-    digest3.update(import_node_path121.default.relative(root, file)).update("\0").update(bytes).update("\0");
+    digest3.update(import_node_path122.default.relative(root, file)).update("\0").update(bytes).update("\0");
   if (viewModels) digest3.update(viewModels.toolClass);
   for (const [name3, text6] of Object.entries(generated))
     digest3.update(`${name3}\0${text6}\0`);
@@ -14548,39 +14737,39 @@ async function compileKotlin(input, origin) {
     url: `${origin}${KOTLIN_ARTIFACT_PREFIX}${hash}/app.mjs`,
     hash
   };
-  const out = import_node_path121.default.join(buildsDir(), hash);
-  if (import_node_fs119.default.existsSync(import_node_path121.default.join(out, "js", "app.wasm"))) return artifact;
+  const out = import_node_path122.default.join(buildsDir(), hash);
+  if (import_node_fs120.default.existsSync(import_node_path122.default.join(out, "js", "app.wasm"))) return artifact;
   const pending = builds.get(hash);
   if (pending) return pending;
   const build = (async () => {
     const ready = await ensureToolchain(toolchain);
     const { kotlinc } = ready;
     const libraries = [...ready.libraries, sdkLibrary];
-    const composeRuntime = import_node_path121.default.join(
+    const composeRuntime = import_node_path122.default.join(
       kotlinHome(),
       toolchain.compiler.version,
       toolchain.composeRuntime.name
     );
     if (usesCompose) {
       for (const library of toolchain.composeLibraries) {
-        const target = import_node_path121.default.join(kotlinHome(), toolchain.compiler.version, library.name);
+        const target = import_node_path122.default.join(kotlinHome(), toolchain.compiler.version, library.name);
         await fetchVerified(library, target);
         libraries.push(target);
       }
       await fetchVerified(toolchain.composeRuntime, composeRuntime);
     }
-    import_node_fs119.default.mkdirSync(buildsDir(), { recursive: true });
-    const work = import_node_fs119.default.mkdtempSync(import_node_path121.default.join(buildsDir(), `${hash}-`));
-    const javaLibrary = java ? import_node_path121.default.join(work, "java-abi", "java-abi.klib") : null;
+    import_node_fs120.default.mkdirSync(buildsDir(), { recursive: true });
+    const work = import_node_fs120.default.mkdtempSync(import_node_path122.default.join(buildsDir(), `${hash}-`));
+    const javaLibrary = java ? import_node_path122.default.join(work, "java-abi", "java-abi.klib") : null;
     if (javaLibrary) libraries.push(javaLibrary);
-    const generatedDir = import_node_path121.default.join(work, "generated");
-    import_node_fs119.default.mkdirSync(generatedDir);
+    const generatedDir = import_node_path122.default.join(work, "generated");
+    import_node_fs120.default.mkdirSync(generatedDir);
     for (const [name3, text6] of Object.entries(generated))
-      import_node_fs119.default.writeFileSync(import_node_path121.default.join(generatedDir, name3), text6);
+      import_node_fs120.default.writeFileSync(import_node_path122.default.join(generatedDir, name3), text6);
     const compiledSources = inputs.map(({ file, bytes }, index) => {
-      const target = import_node_path121.default.join(work, "sources", String(index), import_node_path121.default.basename(file));
-      import_node_fs119.default.mkdirSync(import_node_path121.default.dirname(target), { recursive: true });
-      import_node_fs119.default.writeFileSync(target, bytes);
+      const target = import_node_path122.default.join(work, "sources", String(index), import_node_path122.default.basename(file));
+      import_node_fs120.default.mkdirSync(import_node_path122.default.dirname(target), { recursive: true });
+      import_node_fs120.default.writeFileSync(target, bytes);
       return { file, target };
     });
     const common = [
@@ -14589,19 +14778,19 @@ async function compileKotlin(input, origin) {
       "-Xallow-kotlin-package",
       "-Xwasm-target=js",
       "-libraries",
-      libraries.join(import_node_path121.default.delimiter)
+      libraries.join(import_node_path122.default.delimiter)
     ];
     const compileKlib = (outputDir) => run12(
       kotlinc,
       [
         ...common,
         `-Xplugin=${plugin}`,
-        `-Xfriend-modules=${[sdkLibrary, ...javaLibrary ? [javaLibrary] : []].join(import_node_path121.default.delimiter)}`,
+        `-Xfriend-modules=${[sdkLibrary, ...javaLibrary ? [javaLibrary] : []].join(import_node_path122.default.delimiter)}`,
         ...usesCompose ? [
-          `-Xplugin=${import_node_path121.default.resolve(import_node_path121.default.dirname(kotlinc), "../lib/compose-compiler-plugin.jar")}`
+          `-Xplugin=${import_node_path122.default.resolve(import_node_path122.default.dirname(kotlinc), "../lib/compose-compiler-plugin.jar")}`
         ] : [],
         ...usesSerialization ? [
-          `-Xplugin=${import_node_path121.default.resolve(import_node_path121.default.dirname(kotlinc), "../lib/kotlinx-serialization-compiler-plugin.jar")}`
+          `-Xplugin=${import_node_path122.default.resolve(import_node_path122.default.dirname(kotlinc), "../lib/kotlinx-serialization-compiler-plugin.jar")}`
         ] : [],
         "-language-version",
         language,
@@ -14614,7 +14803,7 @@ async function compileKotlin(input, origin) {
         "-ir-output-name",
         "app",
         ...compiledSources.map(({ target }) => target),
-        ...Object.keys(generated).map((name3) => import_node_path121.default.join(generatedDir, name3))
+        ...Object.keys(generated).map((name3) => import_node_path122.default.join(generatedDir, name3))
       ],
       { maxBuffer: 16 * 1024 * 1024 }
     );
@@ -14633,36 +14822,36 @@ async function compileKotlin(input, origin) {
       if (viewModels && inputs.some(
         ({ file, bytes }) => sources.includes(file) && bytes.includes("ViewModel")
       )) {
-        await compileKlib(import_node_path121.default.join(work, "abi"));
+        await compileKlib(import_node_path122.default.join(work, "abi"));
         const { stdout } = await run12(
-          import_node_path121.default.join(import_node_path121.default.dirname(kotlinc), "kotlin"),
+          import_node_path122.default.join(import_node_path122.default.dirname(kotlinc), "kotlin"),
           [
             "-cp",
             [
-              import_node_path121.default.resolve(import_node_path121.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
-              import_node_path121.default.join(sdk.root, "tools.jar")
-            ].join(import_node_path121.default.delimiter),
+              import_node_path122.default.resolve(import_node_path122.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
+              import_node_path122.default.join(sdk.root, "tools.jar")
+            ].join(import_node_path122.default.delimiter),
             viewModels.toolClass,
-            import_node_path121.default.join(work, "abi")
+            import_node_path122.default.join(work, "abi")
           ],
           { maxBuffer: 64 * 1024 * 1024 }
         );
-        import_node_fs119.default.writeFileSync(
-          import_node_path121.default.join(generatedDir, viewModels.file),
+        import_node_fs120.default.writeFileSync(
+          import_node_path122.default.join(generatedDir, viewModels.file),
           viewModels.render(viewModelClasses(readAbiClasses(stdout)))
         );
       }
-      await compileKlib(import_node_path121.default.join(work, "klib"));
+      await compileKlib(import_node_path122.default.join(work, "klib"));
       await run12(
         kotlinc,
         [
           ...common,
           "-nowarn",
           "-Xpartial-linkage-loglevel=error",
-          `-Xinclude=${import_node_path121.default.join(work, "klib")}`,
+          `-Xinclude=${import_node_path122.default.join(work, "klib")}`,
           "-Xir-produce-js",
           "-ir-output-dir",
-          import_node_path121.default.join(work, "js"),
+          import_node_path122.default.join(work, "js"),
           "-ir-output-name",
           "app"
         ],
@@ -14675,10 +14864,10 @@ async function compileKotlin(input, origin) {
           composeRuntime,
           "skiko.mjs",
           "-d",
-          import_node_path121.default.join(work, "js")
+          import_node_path122.default.join(work, "js")
         ]);
-        const skikoPath = import_node_path121.default.join(work, "js", "skiko.mjs");
-        const upstream = (0, import_acorn3.parse)(import_node_fs119.default.readFileSync(skikoPath, "utf8"), {
+        const skikoPath = import_node_path122.default.join(work, "js", "skiko.mjs");
+        const upstream = (0, import_acorn3.parse)(import_node_fs120.default.readFileSync(skikoPath, "utf8"), {
           ecmaVersion: "latest",
           sourceType: "module"
         });
@@ -14701,7 +14890,7 @@ async function compileKotlin(input, origin) {
           "GL",
           ...bindings
         ];
-        import_node_fs119.default.writeFileSync(
+        import_node_fs120.default.writeFileSync(
           skikoPath,
           [
             "const runtime = globalThis.__peachKotlinSkiko;",
@@ -14715,10 +14904,10 @@ async function compileKotlin(input, origin) {
       if (usesCompose) {
         for (const library of toolchain.composeJsLibraries) {
           let imported = false;
-          for (const file of import_node_fs119.default.readdirSync(import_node_path121.default.join(work, "js"))) {
+          for (const file of import_node_fs120.default.readdirSync(import_node_path122.default.join(work, "js"))) {
             if (!file.endsWith(".mjs")) continue;
-            const target = import_node_path121.default.join(work, "js", file);
-            const source = import_node_fs119.default.readFileSync(target, "utf8");
+            const target = import_node_path122.default.join(work, "js", file);
+            const source = import_node_fs120.default.readFileSync(target, "utf8");
             let next = source;
             for (const quote of ["'", '"'])
               next = next.replaceAll(
@@ -14726,11 +14915,11 @@ async function compileKotlin(input, origin) {
                 `from ${quote}./${library.file}${quote}`
               );
             if (next === source) continue;
-            import_node_fs119.default.writeFileSync(target, next);
+            import_node_fs120.default.writeFileSync(target, next);
             imported = true;
           }
           if (!imported) continue;
-          const archive = import_node_path121.default.join(
+          const archive = import_node_path122.default.join(
             kotlinHome(),
             toolchain.compiler.version,
             library.name
@@ -14739,19 +14928,19 @@ async function compileKotlin(input, origin) {
           const { stdout } = await run12("tar", ["-xOf", archive, library.archiveEntry], {
             maxBuffer: 16 * 1024 * 1024
           });
-          import_node_fs119.default.writeFileSync(import_node_path121.default.join(work, "js", library.file), stdout);
+          import_node_fs120.default.writeFileSync(import_node_path122.default.join(work, "js", library.file), stdout);
         }
       }
     } catch (error) {
-      import_node_fs119.default.rmSync(work, { recursive: true, force: true });
+      import_node_fs120.default.rmSync(work, { recursive: true, force: true });
       let output2 = isRecord(error) ? `${String(error.stderr ?? "")}${String(error.stdout ?? "")}` : "";
       for (const [name3, source] of Object.entries(origins))
-        output2 = output2.replaceAll(import_node_path121.default.join(generatedDir, name3), source);
+        output2 = output2.replaceAll(import_node_path122.default.join(generatedDir, name3), source);
       for (const { file, target } of compiledSources)
-        output2 = output2.replaceAll(target, file).replaceAll(import_node_path121.default.relative(process.cwd(), target), file);
+        output2 = output2.replaceAll(target, file).replaceAll(import_node_path122.default.relative(process.cwd(), target), file);
       for (const [index, spec] of (java?.specs ?? []).entries())
         output2 = output2.replaceAll(
-          import_node_path121.default.join(work, "java-abi", `Spec${index}.kt`),
+          import_node_path122.default.join(work, "java-abi", `Spec${index}.kt`),
           spec.file
         );
       output2 = output2.replace(
@@ -14766,9 +14955,9 @@ ${output2.trim() || (error instanceof Error ? error.message : String(error))}`
     const seams = [
       ["process.release.name", "process.release?.name"]
     ];
-    const js = import_node_fs119.default.readdirSync(import_node_path121.default.join(work, "js")).filter((file) => file.endsWith(".mjs"));
+    const js = import_node_fs120.default.readdirSync(import_node_path122.default.join(work, "js")).filter((file) => file.endsWith(".mjs"));
     if (js.some(
-      (file) => import_node_fs119.default.readFileSync(import_node_path121.default.join(work, "js", file), "utf8").includes("'kotlinx.coroutines.")
+      (file) => import_node_fs120.default.readFileSync(import_node_path122.default.join(work, "js", file), "utf8").includes("'kotlinx.coroutines.")
     ))
       seams.push([
         "(typeof(window) !== 'undefined' && window != null && typeof(window.addEventListener) === 'function') ? window : null",
@@ -14777,12 +14966,12 @@ ${output2.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_path121.default.join(work, "js", file);
-        const text6 = import_node_fs119.default.readFileSync(target, "utf8");
+        const target = import_node_path122.default.join(work, "js", file);
+        const text6 = import_node_fs120.default.readFileSync(target, "utf8");
         const next = text6.replaceAll(from, to);
         if (next !== text6) {
           patched++;
-          import_node_fs119.default.writeFileSync(target, next);
+          import_node_fs120.default.writeFileSync(target, next);
         }
       }
       if (patched === 0)
@@ -14790,11 +14979,11 @@ ${output2.trim() || (error instanceof Error ? error.message : String(error))}`
           `kotlin output no longer contains ${from}; recheck how it detects its host in Peach`
         );
     }
-    const entry = import_node_path121.default.join(work, "js/app.mjs");
-    const entrySource2 = import_node_fs119.default.readFileSync(entry, "utf8");
-    const importsPath = import_node_path121.default.join(work, "js/app.import-object.mjs");
+    const entry = import_node_path122.default.join(work, "js/app.mjs");
+    const entrySource2 = import_node_fs120.default.readFileSync(entry, "utf8");
+    const importsPath = import_node_path122.default.join(work, "js/app.import-object.mjs");
     const importsFactory = kotlinInstanceSource(
-      import_node_fs119.default.readFileSync(importsPath, "utf8"),
+      import_node_fs120.default.readFileSync(importsPath, "utf8"),
       "createKotlinImportObject"
     );
     const runtimeFactory = kotlinInstanceSource(
@@ -14802,9 +14991,9 @@ ${output2.trim() || (error instanceof Error ? error.message : String(error))}`
       "createKotlinInstance",
       /* @__PURE__ */ new Map([["./app.import-object.mjs", "createKotlinImportObject"]])
     );
-    import_node_fs119.default.writeFileSync(importsPath, importsFactory.source);
-    import_node_fs119.default.writeFileSync(import_node_path121.default.join(work, "js/app-runtime.mjs"), runtimeFactory.source);
-    import_node_fs119.default.writeFileSync(
+    import_node_fs120.default.writeFileSync(importsPath, importsFactory.source);
+    import_node_fs120.default.writeFileSync(import_node_path122.default.join(work, "js/app-runtime.mjs"), runtimeFactory.source);
+    import_node_fs120.default.writeFileSync(
       entry,
       [
         "import { createKotlinInstance } from './app-runtime.mjs';",
@@ -14817,10 +15006,10 @@ ${output2.trim() || (error instanceof Error ? error.message : String(error))}`
       ].join("\n")
     );
     try {
-      import_node_fs119.default.renameSync(work, out);
+      import_node_fs120.default.renameSync(work, out);
     } catch (error) {
-      if (!import_node_fs119.default.existsSync(import_node_path121.default.join(out, "js", "app.wasm"))) throw error;
-      import_node_fs119.default.rmSync(work, { recursive: true, force: true });
+      if (!import_node_fs120.default.existsSync(import_node_path122.default.join(out, "js", "app.wasm"))) throw error;
+      import_node_fs120.default.rmSync(work, { recursive: true, force: true });
     }
     return artifact;
   })().finally(() => builds.delete(hash));
@@ -14828,24 +15017,24 @@ ${output2.trim() || (error instanceof Error ? error.message : String(error))}`
   return build;
 }
 function kotlinArtifactFiles(hash) {
-  const dir = import_node_path121.default.join(buildsDir(), hash, "js");
-  return import_node_fs119.default.readdirSync(dir).sort().map((name3) => {
-    const contentType2 = CONTENT_TYPES[import_node_path121.default.extname(name3)];
+  const dir = import_node_path122.default.join(buildsDir(), hash, "js");
+  return import_node_fs120.default.readdirSync(dir).sort().map((name3) => {
+    const contentType2 = CONTENT_TYPES[import_node_path122.default.extname(name3)];
     if (!contentType2) throw new Error(`unexpected kotlin artifact file ${name3}`);
-    return { name: name3, bytes: import_node_fs119.default.readFileSync(import_node_path121.default.join(dir, name3)), contentType: contentType2 };
+    return { name: name3, bytes: import_node_fs120.default.readFileSync(import_node_path122.default.join(dir, name3)), contentType: contentType2 };
   });
 }
 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_path121.default.extname(file)] : void 0;
+  const type = file ? CONTENT_TYPES[import_node_path122.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_path121.default.join(buildsDir(), hash, "js", file);
-  if (!import_node_fs119.default.existsSync(target)) {
+  const target = import_node_path122.default.join(buildsDir(), hash, "js", file);
+  if (!import_node_fs120.default.existsSync(target)) {
     res.statusCode = 404;
     res.end(`kotlin artifact ${hash}/${file} was not built`);
     return true;
@@ -14853,7 +15042,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_fs119.default.readFileSync(target));
+  res.end(import_node_fs120.default.readFileSync(target));
   return true;
 }
 async function serveKotlinRequest(pathname, res, app) {
@@ -14870,16 +15059,16 @@ async function serveKotlinRequest(pathname, res, app) {
   }
   return true;
 }
-var import_node_child_process53, import_node_crypto63, import_node_fs119, import_node_module19, import_node_path121, import_node_util22, import_acorn3, run12, KOTLIN_ARTIFACT_PREFIX, SKIP_DIRS, BUILD_FORMAT, builds, toolScans, BRIDGE_PARAMETERS, BRIDGE_CASTS, BRIDGE_RETURNS, bridgeType, JAVA_CLASSES, argb, escapes2, literal2, CONTENT_TYPES, KOTLIN_PACKAGE_PATH;
+var import_node_child_process53, import_node_crypto63, import_node_fs120, import_node_module19, import_node_path122, import_node_util22, import_acorn3, run12, KOTLIN_ARTIFACT_PREFIX, SKIP_DIRS, BUILD_FORMAT, builds, toolScans, BRIDGE_PARAMETERS, BRIDGE_CASTS, BRIDGE_RETURNS, bridgeType, JAVA_CLASSES, argb, escapes2, literal2, CONTENT_TYPES, KOTLIN_PACKAGE_PATH;
 var init_kotlin_host = __esm({
   "src/kotlin-host.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
     import_node_child_process53 = require("node:child_process");
     import_node_crypto63 = require("node:crypto");
-    import_node_fs119 = __toESM(require("node:fs"), 1);
+    import_node_fs120 = __toESM(require("node:fs"), 1);
     import_node_module19 = require("node:module");
-    import_node_path121 = __toESM(require("node:path"), 1);
+    import_node_path122 = __toESM(require("node:path"), 1);
     import_node_util22 = require("node:util");
     import_acorn3 = require("acorn");
     init_android_bridge_packages();
@@ -14991,8 +15180,8 @@ async function collectExpoKotlinModules(appRoot) {
     for (const project2 of entry.projects) {
       if (!isRecord(project2) || typeof project2.sourceDir !== "string" || !Array.isArray(project2.modules))
         throw new Error("invalid Expo Android project");
-      const sourceDir = import_node_fs120.default.realpathSync(project2.sourceDir);
-      const installed = sourceDir.split(import_node_path122.default.sep).includes("node_modules");
+      const sourceDir = import_node_fs121.default.realpathSync(project2.sourceDir);
+      const installed = sourceDir.split(import_node_path123.default.sep).includes("node_modules");
       if (installed) {
         if (typeof entry.packageName !== "string") continue;
         if (peachAnsweredNativePackages().has(entry.packageName)) {
@@ -15019,9 +15208,9 @@ async function collectExpoKotlinModules(appRoot) {
         group.unsupported ??= reason;
       };
       const walk3 = (dir) => {
-        if (!import_node_fs120.default.existsSync(dir)) return;
-        for (const child of import_node_fs120.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-          const file = import_node_path122.default.join(dir, child.name);
+        if (!import_node_fs121.default.existsSync(dir)) return;
+        for (const child of import_node_fs121.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+          const file = import_node_path123.default.join(dir, child.name);
           if (child.isSymbolicLink()) reject(`Expo Kotlin source is a symlink: ${file}`);
           else if (child.isDirectory()) walk3(file);
           else if (child.name.endsWith(".java"))
@@ -15029,23 +15218,28 @@ async function collectExpoKotlinModules(appRoot) {
           else if (child.name.endsWith(".kt")) group.sources.push(file);
         }
       };
-      walk3(import_node_path122.default.join(sourceDir, "src", "main", "java"));
-      walk3(import_node_path122.default.join(sourceDir, "src", "main", "kotlin"));
+      walk3(import_node_path123.default.join(sourceDir, "src", "main", "java"));
+      walk3(import_node_path123.default.join(sourceDir, "src", "main", "kotlin"));
       result.push(group);
     }
   }
   return result.length === 0 && !answeredInstalled ? null : result;
 }
 async function collectBridgePackages(appRoot) {
+  const dependencies = await collectAndroidBridgeDependencies(
+    appRoot,
+    peachKotlinModuleRoot()
+  );
   const app = androidAppSources(appRoot);
   if (!app || !app.kotlin.some(
-    (file) => /\b(?:Base|Turbo)?ReactPackage\b/.test(import_node_fs120.default.readFileSync(file, "utf8"))
+    (file) => /\b(?:Base|Turbo)?ReactPackage\b/.test(import_node_fs121.default.readFileSync(file, "utf8"))
   ))
-    return null;
+    return dependencies;
   const { scanBridgeFiles: scanBridgeFiles2 } = await Promise.resolve().then(() => (init_kotlin_host(), kotlin_host_exports));
   const files2 = await scanBridgeFiles2(peachKotlinModuleRoot(), app.kotlin);
   const selection = selectBridgePackages(app.applicationId, files2, app.java);
-  return selection.packages.length === 0 ? null : selection;
+  const packages = [...dependencies?.packages ?? [], ...selection.packages];
+  return packages.length ? { applicationId: dependencies?.applicationId ?? selection.applicationId, packages } : null;
 }
 async function compileExpoKotlinModules(root, origin) {
   const expo = await collectExpoKotlinModules(root);
@@ -15099,20 +15293,26 @@ async function compileExpoKotlinModules(root, origin) {
       const artifact = await expoKotlinArtifact2(root, peachKotlinModuleRoot(), origin, {
         modules,
         sources,
+        javaSpecs: [...new Set(hosted.flatMap((entry) => entry.javaSpecs ?? []))],
         bridge: selection && { applicationId: selection.applicationId, packages: hosted }
       });
       return result(artifact);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      const errors = message.match(/^.+\.kt:\d+:\d+: error:.*$/gm);
+      const errors = message.match(/^.+\.(?:kt|java):\d+:\d+: error:.*$/gm);
       if (!errors) throw error;
       const linesFor = (sources2) => errors.filter((line) => sources2.some((source) => line.startsWith(`${source}:`)));
-      const broken = hosted.filter((entry) => linesFor(entry.sources).length > 0);
+      const broken = hosted.filter(
+        (entry) => linesFor([...entry.sources, ...entry.javaSpecs ?? []]).length > 0
+      );
       const brokenProjects = projects2.filter(
         (project2) => project2.installed && linesFor(project2.sources).length > 0
       );
       if (broken.length > 0 || brokenProjects.length > 0) {
-        drop(broken, (entry) => linesFor(entry.sources).join("\n"));
+        drop(
+          broken,
+          (entry) => linesFor([...entry.sources, ...entry.javaSpecs ?? []]).join("\n")
+        );
         dropProjects(brokenProjects, (project2) => linesFor(project2.sources).join("\n"));
         continue;
       }
@@ -15147,7 +15347,7 @@ async function handleExpoKotlinRequest(req, res) {
     return true;
   }
   const root = url.searchParams.get("root");
-  if (!root || !import_node_path122.default.isAbsolute(root)) {
+  if (!root || !import_node_path123.default.isAbsolute(root)) {
     res.writeHead(400);
     res.end("missing absolute app root");
     return true;
@@ -15178,14 +15378,15 @@ async function handleExpoKotlinRequest(req, res) {
   }
   return true;
 }
-var import_node_fs120, import_node_path122, EXPO_KOTLIN_ROUTE, compiling2;
+var import_node_fs121, import_node_path123, EXPO_KOTLIN_ROUTE, compiling2;
 var init_expo_kotlin_host = __esm({
   "src/expo-kotlin-host.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    import_node_fs120 = __toESM(require("node:fs"), 1);
-    import_node_path122 = __toESM(require("node:path"), 1);
+    import_node_fs121 = __toESM(require("node:fs"), 1);
+    import_node_path123 = __toESM(require("node:path"), 1);
     init_android_autolinking();
+    init_android_bridge_dependencies();
     init_android_bridge_packages();
     init_answeredNativePackages();
     init_backend_origin();
@@ -15206,14 +15407,14 @@ function sharedDesktopAuthAccounts(user) {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path123.dirname)((0, import_node_path123.resolve)(explicit));
+    return (0, import_node_path124.dirname)((0, import_node_path124.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path123.resolve)(explicit);
-  return (0, import_node_path123.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path124.resolve)(explicit);
+  return (0, import_node_path124.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -15263,27 +15464,27 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs121.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs122.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs121.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs122.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs121.rmSync)(filepath, { force: true });
+      (0, import_node_fs122.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs121.rmSync)(filepath, { force: true });
+    (0, import_node_fs122.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs121, import_node_path123, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs122, import_node_path124, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    import_node_fs121 = require("node:fs");
-    import_node_path123 = require("node:path");
+    import_node_fs122 = require("node:fs");
+    import_node_path124 = require("node:path");
     init_home_paths();
     init_public_brand();
     SESSION_VERSION = 1;
@@ -15319,32 +15520,32 @@ var init_run_rnx = __esm({
 
 // cli/secure-file.ts
 function writeSecureJsonAtomic(filepath, value) {
-  (0, import_node_fs122.mkdirSync)((0, import_node_path124.dirname)(filepath), { recursive: true });
+  (0, import_node_fs123.mkdirSync)((0, import_node_path125.dirname)(filepath), { recursive: true });
   const temporary = `${filepath}.tmp-${process.pid}-${(0, import_node_crypto64.randomUUID)()}`;
   let descriptor = null;
   try {
-    descriptor = (0, import_node_fs122.openSync)(temporary, "wx", 384);
-    (0, import_node_fs122.fchmodSync)(descriptor, 384);
-    (0, import_node_fs122.writeFileSync)(descriptor, `${JSON.stringify(value, null, 2)}
+    descriptor = (0, import_node_fs123.openSync)(temporary, "wx", 384);
+    (0, import_node_fs123.fchmodSync)(descriptor, 384);
+    (0, import_node_fs123.writeFileSync)(descriptor, `${JSON.stringify(value, null, 2)}
 `);
-    (0, import_node_fs122.fsyncSync)(descriptor);
-    (0, import_node_fs122.closeSync)(descriptor);
+    (0, import_node_fs123.fsyncSync)(descriptor);
+    (0, import_node_fs123.closeSync)(descriptor);
     descriptor = null;
-    (0, import_node_fs122.renameSync)(temporary, filepath);
+    (0, import_node_fs123.renameSync)(temporary, filepath);
   } catch (error) {
-    if (descriptor !== null) (0, import_node_fs122.closeSync)(descriptor);
-    (0, import_node_fs122.rmSync)(temporary, { force: true });
+    if (descriptor !== null) (0, import_node_fs123.closeSync)(descriptor);
+    (0, import_node_fs123.rmSync)(temporary, { force: true });
     throw error;
   }
 }
-var import_node_crypto64, import_node_fs122, import_node_path124;
+var import_node_crypto64, import_node_fs123, import_node_path125;
 var init_secure_file = __esm({
   "cli/secure-file.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
     import_node_crypto64 = require("node:crypto");
-    import_node_fs122 = require("node:fs");
-    import_node_path124 = require("node:path");
+    import_node_fs123 = require("node:fs");
+    import_node_path125 = require("node:path");
   }
 });
 
@@ -15393,25 +15594,25 @@ function isCliApiKeySecret(secret) {
   return secret.startsWith("sk_rnx_");
 }
 function savedApiKeyFile() {
-  return import_node_path125.default.join(rnxHomeDir(), "api-key.json");
+  return import_node_path126.default.join(rnxHomeDir(), "api-key.json");
 }
 function readApiKeyFile(file) {
-  if (!(0, import_node_fs123.existsSync)(file)) return null;
-  const secret = (0, import_node_fs123.readFileSync)(file, "utf8").trim();
+  if (!(0, import_node_fs124.existsSync)(file)) return null;
+  const secret = (0, import_node_fs124.readFileSync)(file, "utf8").trim();
   return isCliApiKeySecret(secret) ? secret : null;
 }
 function saveApiKey(secret) {
   writeSecureJsonAtomic(savedApiKeyFile(), { secret });
 }
 function forgetApiKey() {
-  if (!(0, import_node_fs123.existsSync)(savedApiKeyFile())) return false;
-  (0, import_node_fs123.rmSync)(savedApiKeyFile());
+  if (!(0, import_node_fs124.existsSync)(savedApiKeyFile())) return false;
+  (0, import_node_fs124.rmSync)(savedApiKeyFile());
   return true;
 }
 function readSavedApiKey() {
-  if (!(0, import_node_fs123.existsSync)(savedApiKeyFile())) return null;
+  if (!(0, import_node_fs124.existsSync)(savedApiKeyFile())) return null;
   const saved = savedKeySchema.safeParse(
-    JSON.parse((0, import_node_fs123.readFileSync)(savedApiKeyFile(), "utf8"))
+    JSON.parse((0, import_node_fs124.readFileSync)(savedApiKeyFile(), "utf8"))
   );
   return saved.success && isCliApiKeySecret(saved.data.secret) ? saved.data.secret : null;
 }
@@ -15471,13 +15672,13 @@ function authHeaderOrExit(commandLabel) {
   );
   rnxExit(1);
 }
-var import_node_fs123, import_node_path125, import_zod, GITHUB_TOKEN_PREFIXES, DOWNLOADED_API_KEY_FILE, savedKeySchema, CHOOSE_ACCOUNT_HINT;
+var import_node_fs124, import_node_path126, import_zod, GITHUB_TOKEN_PREFIXES, DOWNLOADED_API_KEY_FILE, savedKeySchema, CHOOSE_ACCOUNT_HINT;
 var init_auth = __esm({
   "cli/auth.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
-    import_node_fs123 = require("node:fs");
-    import_node_path125 = __toESM(require("node:path"), 1);
+    import_node_fs124 = require("node:fs");
+    import_node_path126 = __toESM(require("node:path"), 1);
     import_zod = require("zod");
     init_shared_session();
     init_home_paths();
@@ -17135,8 +17336,8 @@ function metroIosAssetDestRelatives(httpServerLocation, filename) {
   }
   const out = [];
   for (const dir of dirs) {
-    const path109 = `${dir}/${filename}`;
-    if (!out.includes(path109)) out.push(path109);
+    const path110 = `${dir}/${filename}`;
+    if (!out.includes(path110)) out.push(path110);
   }
   if (!out.includes(filename)) out.push(filename);
   return out;
@@ -17841,27 +18042,27 @@ function resolveCloudOrigin(value) {
   return normalizeCloudOrigin(source);
 }
 function readImmutableBundleSource(bundlePath, command) {
-  const filepath = (0, import_node_path126.resolve)(bundlePath);
-  if ((0, import_node_path126.extname)(filepath) === ".hbc") {
+  const filepath = (0, import_node_path127.resolve)(bundlePath);
+  if ((0, import_node_path127.extname)(filepath) === ".hbc") {
     const platform2 = filepath.includes("/android/") ? "android" : "ios";
     throw new Error(
       `${command} cannot preview Hermes bytecode (${bundlePath}). Export plain JavaScript with \`npx expo export --platform ${platform2} --no-bytecode\` and preview the .js bundle instead.`
     );
   }
-  if ((0, import_node_path126.extname)(filepath) !== ".js") {
+  if ((0, import_node_path127.extname)(filepath) !== ".js") {
     throw new Error(`${command} requires one local .js bundle`);
   }
-  const descriptor = (0, import_node_fs124.openSync)(filepath, "r");
+  const descriptor = (0, import_node_fs125.openSync)(filepath, "r");
   try {
-    const before = (0, import_node_fs124.fstatSync)(descriptor, { bigint: true });
+    const before = (0, import_node_fs125.fstatSync)(descriptor, { bigint: true });
     if (!before.isFile()) {
       throw new Error(`${command} bundle must be a regular local file`);
     }
     if (before.size <= 0n) {
       throw new Error(`${command} bundle is empty`);
     }
-    const bytes = (0, import_node_fs124.readFileSync)(descriptor);
-    const after = (0, import_node_fs124.fstatSync)(descriptor, { bigint: true });
+    const bytes = (0, import_node_fs125.readFileSync)(descriptor);
+    const after = (0, import_node_fs125.fstatSync)(descriptor, { bigint: true });
     if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeNs !== after.mtimeNs || bytes.length !== Number(before.size)) {
       throw new Error(`${command} bundle changed while it was being read`);
     }
@@ -17873,7 +18074,7 @@ function readImmutableBundleSource(bundlePath, command) {
     }
     return source;
   } finally {
-    (0, import_node_fs124.closeSync)(descriptor);
+    (0, import_node_fs125.closeSync)(descriptor);
   }
 }
 async function fetchBundleSource(bundleUrl, command) {
@@ -17927,15 +18128,15 @@ async function loadBundleSource(bundleInput, command) {
   return source;
 }
 function listMetroAssetDest(assetsPath) {
-  const directory2 = (0, import_node_path126.resolve)(assetsPath);
-  if (!(0, import_node_fs124.existsSync)(directory2)) return { directory: directory2, files: [], truncated: false };
-  const skipNested = (0, import_node_fs124.existsSync)((0, import_node_path126.join)(directory2, "package.json"));
+  const directory2 = (0, import_node_path127.resolve)(assetsPath);
+  if (!(0, import_node_fs125.existsSync)(directory2)) return { directory: directory2, files: [], truncated: false };
+  const skipNested = (0, import_node_fs125.existsSync)((0, import_node_path127.join)(directory2, "package.json"));
   const files2 = [];
   let truncated = false;
   const walk3 = (dir, prefix) => {
     let entries;
     try {
-      entries = (0, import_node_fs124.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs125.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -17947,7 +18148,7 @@ function listMetroAssetDest(assetsPath) {
       if (entry.isDirectory()) {
         if (entry.name === ".git") continue;
         if (skipNested && PROJECT_ONLY_DIRECTORIES.has(entry.name)) continue;
-        walk3((0, import_node_path126.join)(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
+        walk3((0, import_node_path127.join)(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
       } else if (entry.isFile()) {
         files2.push(prefix ? `${prefix}/${entry.name}` : entry.name);
       }
@@ -17982,7 +18183,7 @@ function distinctByContent(directory2, options) {
   for (const relative4 of options) {
     let bytes;
     try {
-      bytes = (0, import_node_fs124.readFileSync)((0, import_node_path126.join)(directory2, relative4));
+      bytes = (0, import_node_fs125.readFileSync)((0, import_node_path127.join)(directory2, relative4));
     } catch {
       continue;
     }
@@ -18027,7 +18228,7 @@ function placeMetroDescriptor(listing, descriptor) {
     let bytes;
     try {
       bytes = combination.map(
-        (relative4) => (0, import_node_fs124.readFileSync)((0, import_node_path126.join)(listing.directory, relative4))
+        (relative4) => (0, import_node_fs125.readFileSync)((0, import_node_path127.join)(listing.directory, relative4))
       );
     } catch {
       continue;
@@ -18055,10 +18256,10 @@ function unverifiedContentKey(dest, fileDigests) {
   return JSON.stringify(
     dest.placements.map(
       (placement) => placement.verified ? null : [...placement.files].map(([scale, relative4]) => {
-        const file = (0, import_node_path126.join)(dest.directory, relative4);
+        const file = (0, import_node_path127.join)(dest.directory, relative4);
         let digest3 = fileDigests.get(file);
         if (digest3 === void 0) {
-          digest3 = (0, import_node_crypto65.createHash)("sha256").update((0, import_node_fs124.readFileSync)(file)).digest("hex");
+          digest3 = (0, import_node_crypto65.createHash)("sha256").update((0, import_node_fs125.readFileSync)(file)).digest("hex");
           fileDigests.set(file, digest3);
         }
         return [scale, digest3];
@@ -18067,42 +18268,42 @@ function unverifiedContentKey(dest, fileDigests) {
   );
 }
 function findExpoExportRoot(bundleDirectory) {
-  let directory2 = (0, import_node_path126.resolve)(bundleDirectory);
+  let directory2 = (0, import_node_path127.resolve)(bundleDirectory);
   for (let depth = 0; depth < 6; depth++) {
-    const metadata = (0, import_node_path126.join)(directory2, "metadata.json");
-    if ((0, import_node_fs124.existsSync)(metadata) && (0, import_node_fs124.existsSync)((0, import_node_path126.join)(directory2, "assets"))) {
+    const metadata = (0, import_node_path127.join)(directory2, "metadata.json");
+    if ((0, import_node_fs125.existsSync)(metadata) && (0, import_node_fs125.existsSync)((0, import_node_path127.join)(directory2, "assets"))) {
       try {
-        if ((0, import_node_fs124.readFileSync)(metadata, "utf8").includes('"fileMetadata"')) {
+        if ((0, import_node_fs125.readFileSync)(metadata, "utf8").includes('"fileMetadata"')) {
           return directory2;
         }
       } catch {
       }
     }
-    const parent = (0, import_node_path126.dirname)(directory2);
+    const parent = (0, import_node_path127.dirname)(directory2);
     if (parent === directory2) return null;
     directory2 = parent;
   }
   return null;
 }
 function searchMetroAssetDest(bundlePath, descriptors, command, assetsDirectory) {
-  const bundleDirectory = (0, import_node_path126.dirname)((0, import_node_path126.resolve)(bundlePath));
+  const bundleDirectory = (0, import_node_path127.dirname)((0, import_node_path127.resolve)(bundlePath));
   const expoRoot = assetsDirectory || isRemoteBundleInput(bundlePath) ? null : findExpoExportRoot(bundleDirectory);
-  const candidates = assetsDirectory ? [(0, import_node_path126.resolve)(assetsDirectory)] : [
-    ...expoRoot ? [(0, import_node_path126.join)(expoRoot, "assets")] : [],
-    (0, import_node_path126.join)(bundleDirectory, "assets"),
+  const candidates = assetsDirectory ? [(0, import_node_path127.resolve)(assetsDirectory)] : [
+    ...expoRoot ? [(0, import_node_path127.join)(expoRoot, "assets")] : [],
+    (0, import_node_path127.join)(bundleDirectory, "assets"),
     bundleDirectory,
-    (0, import_node_path126.resolve)(bundleDirectory, "..", "assets")
+    (0, import_node_path127.resolve)(bundleDirectory, "..", "assets")
   ];
   const cwd = process.cwd();
   let projectDirectory = null;
   for (const start of assetsDirectory ? [] : [bundleDirectory, cwd]) {
-    let directory2 = (0, import_node_path126.resolve)(start);
+    let directory2 = (0, import_node_path127.resolve)(start);
     while (true) {
       if (detectProject(directory2)?.hasMetroConfig) {
         projectDirectory = directory2;
         break;
       }
-      const parent = (0, import_node_path126.dirname)(directory2);
+      const parent = (0, import_node_path127.dirname)(directory2);
       if (parent === directory2) break;
       directory2 = parent;
     }
@@ -18110,11 +18311,11 @@ function searchMetroAssetDest(bundlePath, descriptors, command, assetsDirectory)
   }
   if (projectDirectory) {
     candidates.push(
-      (0, import_node_path126.join)(projectDirectory, "assets"),
-      (0, import_node_path126.join)(projectDirectory, "dist"),
-      (0, import_node_path126.join)(projectDirectory, "dist", "assets"),
-      (0, import_node_path126.join)(projectDirectory, "build"),
-      (0, import_node_path126.join)(projectDirectory, "build", "assets")
+      (0, import_node_path127.join)(projectDirectory, "assets"),
+      (0, import_node_path127.join)(projectDirectory, "dist"),
+      (0, import_node_path127.join)(projectDirectory, "dist", "assets"),
+      (0, import_node_path127.join)(projectDirectory, "build"),
+      (0, import_node_path127.join)(projectDirectory, "build", "assets")
     );
   }
   const searched = [];
@@ -18122,7 +18323,7 @@ function searchMetroAssetDest(bundlePath, descriptors, command, assetsDirectory)
   const stale = [];
   let truncated = false;
   for (const candidate of candidates) {
-    const directory2 = (0, import_node_path126.resolve)(candidate);
+    const directory2 = (0, import_node_path127.resolve)(candidate);
     if (searched.includes(directory2)) continue;
     searched.push(directory2);
     const listing = listMetroAssetDest(directory2);
@@ -18232,7 +18433,7 @@ async function embedBundleAssets(bundlePath, command, assetPolicy, assetsDirecto
       );
     }
     const relative4 = placement?.files.get(variant2.scale);
-    if (relative4 && dest) return (0, import_node_fs124.readFileSync)((0, import_node_path126.join)(dest.directory, relative4));
+    if (relative4 && dest) return (0, import_node_fs125.readFileSync)((0, import_node_path127.join)(dest.directory, relative4));
     if (placement && placement.files.size > 0) return null;
     if (placement && placement.ambiguous.length > 0 && dest) {
       throw new Error(
@@ -18261,7 +18462,7 @@ async function embedBundleAssets(bundlePath, command, assetPolicy, assetsDirecto
     );
     const classic = metroIosAssetDestRelatives(variant2.descriptor.httpServerLocation, filename)[0] ?? filename;
     throw new Error(
-      `${command} could not read ${(0, import_node_path126.join)(dest?.directory ?? ".", classic)} for ${variant2.descriptor.name}.${variant2.descriptor.type} at scale ${variant2.scale}, and has no stand-in for a .${variant2.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`
+      `${command} could not read ${(0, import_node_path127.join)(dest?.directory ?? ".", classic)} for ${variant2.descriptor.name}.${variant2.descriptor.type} at scale ${variant2.scale}, and has no stand-in for a .${variant2.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`
     );
   });
   return {
@@ -18407,14 +18608,14 @@ async function createCloudBox(options) {
     warnings: artifact.warnings
   };
 }
-var import_node_crypto65, import_node_fs124, import_node_path126, import_node_vm, DEFAULT_RNX_CLOUD_ORIGIN, MAX_RNX_CLOUD_BUNDLE_BYTES, REMOTE_COMMAND, PREVIEW_COMMAND, MAX_ASSET_DEST_FILES, ACCOUNT_CHOICE_REFUSALS, PROJECT_ONLY_DIRECTORIES, MAX_PLACEMENT_COMBINATIONS;
+var import_node_crypto65, import_node_fs125, import_node_path127, import_node_vm, DEFAULT_RNX_CLOUD_ORIGIN, MAX_RNX_CLOUD_BUNDLE_BYTES, REMOTE_COMMAND, PREVIEW_COMMAND, MAX_ASSET_DEST_FILES, ACCOUNT_CHOICE_REFUSALS, PROJECT_ONLY_DIRECTORIES, MAX_PLACEMENT_COMBINATIONS;
 var init_cloud_client = __esm({
   "cli/cloud-client.ts"() {
     "use strict";
     init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
     import_node_crypto65 = require("node:crypto");
-    import_node_fs124 = require("node:fs");
-    import_node_path126 = require("node:path");
+    import_node_fs125 = require("node:fs");
+    import_node_path127 = require("node:path");
     import_node_vm = require("node:vm");
     init_metroAssetArtifact();
     init_metroCloudArtifact();
@@ -18580,12 +18781,12 @@ function commandWritesSim(msg) {
 // src/chromium-admission.ts
 init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 function readChromiumQueue(deps, verified2, own) {
-  const { fs: fs85, os: os16, path: path109, childProcess: childProcess2 } = deps;
-  const dir = path109.join(
+  const { fs: fs86, os: os16, path: path110, childProcess: childProcess2 } = deps;
+  const dir = path110.join(
     process.platform === "win32" ? os16.tmpdir() : "/tmp",
     "chromium-admission"
   );
-  fs85.mkdirSync(dir, { recursive: true });
+  fs86.mkdirSync(dir, { recursive: true });
   const limit = Math.max(2, Math.floor(os16.cpus().length / 2));
   const live = (entry) => {
     const match = /^(\d+)-(\d+)-/.exec(entry);
@@ -18613,10 +18814,10 @@ function readChromiumQueue(deps, verified2, own) {
     return same;
   };
   const tickets = [];
-  for (const entry of fs85.readdirSync(dir)) {
+  for (const entry of fs86.readdirSync(dir)) {
     if (entry !== own && !live(entry)) {
       try {
-        fs85.unlinkSync(path109.join(dir, entry));
+        fs86.unlinkSync(path110.join(dir, entry));
       } catch {
       }
       continue;
@@ -18624,7 +18825,7 @@ function readChromiumQueue(deps, verified2, own) {
     try {
       tickets.push({
         entry,
-        created: fs85.statSync(path109.join(dir, entry), { bigint: true }).ctimeNs
+        created: fs86.statSync(path110.join(dir, entry), { bigint: true }).ctimeNs
       });
     } catch {
     }
@@ -21258,7 +21459,7 @@ function scanLocalNative(appDir, pkg, answered, platform2, knownPackages = /* @_
       expoModule: moduleDir ? (0, import_node_path14.relative)(appDir, moduleDir) || "." : null,
       optional: optional3,
       swift: moduleDir ? (nativeFilesByModule.get(moduleDir) ?? []).some(
-        (path109) => path109.endsWith(".swift") && [...(readSmallFile(path109) ?? "").matchAll(/\bName\(\s*"(\w+)"\s*\)/g)].some(
+        (path110) => path110.endsWith(".swift") && [...(readSmallFile(path110) ?? "").matchAll(/\bName\(\s*"(\w+)"\s*\)/g)].some(
           (match) => match[1] === name3
         )
       ) : false,
@@ -22541,8 +22742,8 @@ export *
 }`;
 }
 function swiftPackageIdentity(url) {
-  const path109 = url.endsWith("/") ? url.slice(0, -1) : url;
-  return (path109.split("/").pop() ?? path109).replace(/\.git$/, "").toLowerCase();
+  const path110 = url.endsWith("/") ? url.slice(0, -1) : url;
+  return (path110.split("/").pop() ?? path110).replace(/\.git$/, "").toLowerCase();
 }
 var withoutGlogModuleMap = (flags) => flags.filter(
   (flag) => !(flag.startsWith("-fmodule-map-file=") && flag.endsWith("/glog.modulemap"))
@@ -23089,8 +23290,8 @@ var import_node_fs28 = require("node:fs");
 var import_node_path25 = require("node:path");
 var Refusal = class extends Error {
 };
-var refuse = (path109, reason) => {
-  throw new Refusal(`Generated asset symbols are unproven for ${path109}: ${reason}`);
+var refuse = (path110, reason) => {
+  throw new Refusal(`Generated asset symbols are unproven for ${path110}: ${reason}`);
 };
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var scope = (source) => ({
@@ -23378,14 +23579,14 @@ function addAsset(into, asset) {
 function checkStack(dir, type, devices2) {
   const sets = (parent, allowed) => (0, import_node_fs28.readdirSync)(parent, { withFileTypes: true }).flatMap((entry) => {
     if (entry.name.startsWith(".") || entry.isFile()) return [];
-    const path109 = (0, import_node_path25.join)(parent, entry.name);
+    const path110 = (0, import_node_path25.join)(parent, entry.name);
     const extension = (0, import_node_path25.extname)(entry.name);
     if (!entry.isDirectory() || !allowed.includes(extension))
       return refuse(
-        path109,
+        path110,
         `image stack content other than ${allowed.join(", ")} is unproven`
       );
-    return [{ path: path109, extension }];
+    return [{ path: path110, extension }];
   });
   for (const layer of sets(dir, [`.${type}layer`, ".imageset", ".colorset"])) {
     if (layer.extension !== `.${type}layer`) continue;
@@ -23397,37 +23598,37 @@ function checkStack(dir, type, devices2) {
 function walk(dir, into, devices2, extensions) {
   for (const entry of (0, import_node_fs28.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.isFile()) continue;
-    const path109 = (0, import_node_path25.join)(dir, entry.name);
-    if (!entry.isDirectory()) return refuse(path109, "it is neither a file nor a directory");
+    const path110 = (0, import_node_path25.join)(dir, entry.name);
+    if (!entry.isDirectory()) return refuse(path110, "it is neither a file nor a directory");
     const extension = (0, import_node_path25.extname)(entry.name).slice(1);
     const type = extension.toLowerCase();
     const base = entry.name.slice(0, entry.name.length - extension.length - 1);
     if (type !== extension && knownTypes.has(type))
-      return refuse(path109, "its type extension is not lowercase");
+      return refuse(path110, "its type extension is not lowercase");
     if (type === "colorset" || type === "imageset" || type === "symbolset") {
       addAsset(into, {
         kind: type === "colorset" ? "color" : "image",
         name: base,
-        ...assetState(path109, type, devices2),
+        ...assetState(path110, type, devices2),
         extensions,
-        source: path109
+        source: path110
       });
       continue;
     }
     if (silentTypes.has(type)) continue;
     if (stackTypes.has(type)) {
-      checkStack(path109, type, devices2);
+      checkStack(path110, type, devices2);
       continue;
     }
-    if (unprovenTypes.has(type)) return refuse(path109, `${type} assets are unproven`);
+    if (unprovenTypes.has(type)) return refuse(path110, `${type} assets are unproven`);
     const name3 = type === "spriteatlas" ? base : entry.name;
-    if (!folderProperties((0, import_node_path25.join)(path109, "Contents.json")).namespace) {
-      walk(path109, into, devices2, extensions);
+    if (!folderProperties((0, import_node_path25.join)(path110, "Contents.json")).namespace) {
+      walk(path110, into, devices2, extensions);
       continue;
     }
-    const child = into.namespaces.get(name3) ?? scope(path109);
+    const child = into.namespaces.get(name3) ?? scope(path110);
     into.namespaces.set(name3, child);
-    walk(path109, child, devices2, extensions);
+    walk(path110, child, devices2, extensions);
   }
 }
 var hasKind = (into, kind) => [...into.assets.values()].some((asset) => asset.kind === kind && asset.included) || [...into.namespaces.values()].some((child) => hasKind(child, kind));
@@ -23496,11 +23697,11 @@ function members(into, kind, prefix, extensions) {
   const assets2 = /* @__PURE__ */ new Set();
   const out = [];
   for (const entry of entries) {
-    const path109 = `${prefix}${entry.name}`;
+    const path110 = `${prefix}${entry.name}`;
     const source = entry.child ? entry.child.source : entry.asset.source;
     if (Array.from(entry.name).some((char) => char.charCodeAt(0) > 127))
       refuse(source, "its name is not ASCII");
-    const named = (text7) => `The \\"${escape(path109)}\\" ${text7}`;
+    const named = (text7) => `The \\"${escape(path110)}\\" ${text7}`;
     if (entry.child) {
       const text7 = symbol(entry.name, true);
       if (!text7)
@@ -23523,9 +23724,9 @@ function members(into, kind, prefix, extensions) {
         namespaces.add(text7);
         out.push({
           type: "namespace",
-          path: path109,
+          path: path110,
           symbol: spelled(text7),
-          members: members(entry.child, kind, `${path109}/`, extensions)
+          members: members(entry.child, kind, `${path110}/`, extensions)
         });
       }
       continue;
@@ -23552,7 +23753,7 @@ function members(into, kind, prefix, extensions) {
     else if (!omitted)
       out.push({
         type: "asset",
-        path: path109,
+        path: path110,
         name: entry.name,
         symbol: spelled(text6),
         thinnable: asset.thinnable,
@@ -24086,11 +24287,11 @@ function catalogDigest(directory2) {
     for (const entry of (0, import_node_fs29.readdirSync)(dir, { withFileTypes: true }).sort(
       (a, b) => a.name.localeCompare(b.name)
     )) {
-      const path109 = (0, import_node_path26.join)(dir, entry.name);
-      if (entry.isDirectory()) walk3(path109);
-      else if (entry.isFile() && (0, import_node_fs29.statSync)(path109).size <= 64 * 1024 * 1024)
-        hashes.push([(0, import_node_path26.relative)(directory2, path109), sha2562((0, import_node_fs29.readFileSync)(path109))]);
-      else throw new Error(`Unsupported asset catalog entry: ${path109}`);
+      const path110 = (0, import_node_path26.join)(dir, entry.name);
+      if (entry.isDirectory()) walk3(path110);
+      else if (entry.isFile() && (0, import_node_fs29.statSync)(path110).size <= 64 * 1024 * 1024)
+        hashes.push([(0, import_node_path26.relative)(directory2, path110), sha2562((0, import_node_fs29.readFileSync)(path110))]);
+      else throw new Error(`Unsupported asset catalog entry: ${path110}`);
     }
   };
   walk3(directory2);
@@ -24102,7 +24303,7 @@ function symbolSource(plan, root) {
   const known = symbolTexts.get(key2);
   if (known !== void 0) return { status: "source", text: known };
   const source = assetSymbolSource(
-    plan.catalogs.map(({ path: path109 }) => (0, import_node_path26.join)(root, path109)),
+    plan.catalogs.map(({ path: path110 }) => (0, import_node_path26.join)(root, path110)),
     plan.settings
   );
   if (source.status === "source") symbolTexts.set(key2, source.text);
@@ -24160,9 +24361,9 @@ function planAssetSymbols(resources, root, settings) {
       `Generated asset symbols are proven only for TARGETED_DEVICE_FAMILY 1, 2, 1,2, 1,7, 1,2,6 or 1,2,7; this target resolves to "${families}".`
     );
   const plan = {
-    catalogs: catalogs.map((path109) => ({
-      path: path109,
-      sha256: catalogDigest((0, import_node_path26.join)(root, path109))
+    catalogs: catalogs.map((path110) => ({
+      path: path110,
+      sha256: catalogDigest((0, import_node_path26.join)(root, path110))
     })),
     settings: { deployment: target, devices: devices2, extensions: extensions === "YES" }
   };
@@ -26282,10 +26483,10 @@ function synthesizedInterfaceEnums(interfaceText, module2, graphs) {
     const enclosing = scopes.length > 0 ? scopes[scopes.length - 1].prefix : [];
     if (scope2?.[3] === "enum" && opens > 0 && /(^|\s)(public|open)\s/.test(scope2[2] ?? "") && !/\bwhere\b/.test(first.masked) && first.masked[scope2.index + scope2[0].length] !== "<") {
       const name3 = scope2[4];
-      const path109 = scopeOf(name3, enclosing, false);
-      if (!byPath.has(path109.join(".")) && (path109.length === 1 || byPath.has(path109.slice(0, -1).join(".")))) {
+      const path110 = scopeOf(name3, enclosing, false);
+      if (!byPath.has(path110.join(".")) && (path110.length === 1 || byPath.has(path110.slice(0, -1).join(".")))) {
         const keptAttrs = [...(scope2[1] ?? "").matchAll(/@\w+(?:\([^)]*\))?/g)].map((attr) => attr[0]).filter((attr) => !attr.startsWith("@objc"));
-        const id = `s:peach-synthesized-${module2}-${path109.join(".")}`;
+        const id = `s:peach-synthesized-${module2}-${path110.join(".")}`;
         const body = [];
         let inner = 1;
         let closed = false;
@@ -26340,15 +26541,15 @@ function synthesizedInterfaceEnums(interfaceText, module2, graphs) {
             symbols.push({
               kind: { identifier: "swift.enum" },
               identifier: { precise: id },
-              pathComponents: path109,
+              pathComponents: path110,
               declarationFragments: fragments,
               accessLevel: "public"
             });
-            if (path109.length > 1)
+            if (path110.length > 1)
               relationships.push({
                 kind: "memberOf",
                 source: id,
-                target: byPath.get(path109.slice(0, -1).join("."))
+                target: byPath.get(path110.slice(0, -1).join("."))
               });
             for (const kase of cases) {
               const memberId = `${id}-${kase.leaf}`;
@@ -26357,7 +26558,7 @@ function synthesizedInterfaceEnums(interfaceText, module2, graphs) {
               symbols.push({
                 kind: { identifier: "swift.enum.case" },
                 identifier: { precise: memberId },
-                pathComponents: [...path109, kase.leaf],
+                pathComponents: [...path110, kase.leaf],
                 declarationFragments: [
                   { kind: "keyword", spelling: "case" },
                   { kind: "text", spelling: " " },
@@ -26373,7 +26574,7 @@ function synthesizedInterfaceEnums(interfaceText, module2, graphs) {
               symbols.push({
                 kind: { identifier: "swift.init" },
                 identifier: { precise: initId },
-                pathComponents: [...path109, "init(rawValue:)"],
+                pathComponents: [...path110, "init(rawValue:)"],
                 declarationFragments: [
                   { kind: "keyword", spelling: "init" },
                   { kind: "text", spelling: "?(" },
@@ -26442,7 +26643,7 @@ function emitSwiftStandin(sourceGraphs, options) {
       })
     )
   );
-  const trap = (path109) => `fatalError("${path109} is ${options.placeholder === void 0 ? "a binary framework" : "a placeholder"} peach cannot run")`;
+  const trap = (path110) => `fatalError("${path110} is ${options.placeholder === void 0 ? "a binary framework" : "a placeholder"} peach cannot run")`;
   const skipped = [];
   const behavior = options.behavior ?? /* @__PURE__ */ new Map();
   const used = /* @__PURE__ */ new Set();
@@ -26792,34 +26993,34 @@ function emitSwiftStandin(sourceGraphs, options) {
     lines.push(...physical);
     owners.push(...physical.map(() => current2));
   };
-  const emitAt = (path109, line) => {
-    if (omit.has(path109)) return;
+  const emitAt = (path110, line) => {
+    if (omit.has(path110)) return;
     const previous = current2;
-    current2 = path109;
+    current2 = path110;
     emit(line);
     current2 = previous;
   };
   const emitInertState = (id, indent2, build) => {
-    const path109 = pathOf(byId.get(id));
+    const path110 = pathOf(byId.get(id));
     emitAt(hiddenInit(id), `${indent2}init(_peachInert: Void) { ${build} }`);
     const list2 = conforms.get(id) ?? [];
     const has = (name3) => (children.get(id) ?? []).some((member) => leaf(member) === name3);
     if (list2.includes("Encodable") && !has("encode(to:)"))
       emitAt(
-        `${path109}.encode(to:)`,
+        `${path110}.encode(to:)`,
         `${indent2}public func encode(to encoder: Encoder) throws {}`
       );
     if (list2.includes("Decodable") && !has("init(from:)"))
       emitAt(
-        `${path109}.init(from:)`,
+        `${path110}.init(from:)`,
         `${indent2}public init(from decoder: Decoder) throws { self.init(_peachInert: ()) }`
       );
   };
   const scoped = (body) => (symbol2, ...rest) => {
-    const path109 = pathOf(symbol2);
-    if (omit.has(path109)) return void skipped.push({ path: path109, reason: omit.get(path109) });
+    const path110 = pathOf(symbol2);
+    if (omit.has(path110)) return void skipped.push({ path: path110, reason: omit.get(path110) });
     const previous = current2;
-    current2 = path109;
+    current2 = path110;
     try {
       body(symbol2, ...rest);
     } finally {
@@ -26851,7 +27052,7 @@ function emitSwiftStandin(sourceGraphs, options) {
   };
   const emitMember = scoped(
     (member, indent2, context) => {
-      const path109 = pathOf(member);
+      const path110 = pathOf(member);
       if (TYPE_KINDS.has(member.kind.identifier)) {
         const origin = origins.get(member.identifier.precise)?.split(".")[0];
         const parent = owner.get(member.identifier.precise);
@@ -26868,7 +27069,7 @@ function emitSwiftStandin(sourceGraphs, options) {
       ))
         return;
       if (!MEMBER_KINDS.has(member.kind.identifier)) {
-        skipped.push({ path: path109, reason: `unhandled ${member.kind.identifier}` });
+        skipped.push({ path: path110, reason: `unhandled ${member.kind.identifier}` });
         return;
       }
       const { 1: spelledAttrs, 2: rest } = LEADING_ATTRS.exec(text(member));
@@ -26876,27 +27077,27 @@ function emitSwiftStandin(sourceGraphs, options) {
         /@(\w+)(?:\([^)]*\))?\s*/g,
         (attr, name3) => typeByPath.has(name3) ? "" : attr
       ) : spelledAttrs;
-      const attrs = options.unobjc?.has(path109) ? wrapped.replace(/@objc(?:\([^)]*\))?\s*/g, "") : wrapped;
+      const attrs = options.unobjc?.has(path110) ? wrapped.replace(/@objc(?:\([^)]*\))?\s*/g, "") : wrapped;
       const modifiers = /^((?:(?:required|final|override|convenience|unowned(?:\(\w+\))?|weak|lazy|nonisolated|mutating|nonmutating) )*)(.*)$/s.exec(
         rest
       );
       const flags = new Set(
         modifiers[1].trim().split(/\s+/).filter(Boolean).map((flag) => flag.replace(/\(.*/, ""))
       );
-      const requiredInit = context.inClass && !!options.requiredInits?.has(path109);
-      const restatesRequired = context.inClass && path109.endsWith(".init()") && [...superChain(owner.get(member.identifier.precise) ?? "")].some(
+      const requiredInit = context.inClass && !!options.requiredInits?.has(path110);
+      const restatesRequired = context.inClass && path110.endsWith(".init()") && [...superChain(owner.get(member.identifier.precise) ?? "")].some(
         (at) => options.requiredInits?.has(`${pathOf(byId.get(at))}.init()`)
       );
       const required = context.inClass && (flags.has("required") || requiredInit || restatesRequired);
       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(path109) && !restatesRequired && (flags.has("override") || overrides.has(member.identifier.precise) || options.forcedOverride?.has(path109) || isObjC(member) && path109.endsWith(".init()")) ? "override " : "";
+      const override = context.inClass && !options.plain?.has(path110) && !restatesRequired && (flags.has("override") || overrides.has(member.identifier.precise) || options.forcedOverride?.has(path110) || isObjC(member) && path110.endsWith(".init()")) ? "override " : "";
       const head = `${indent2}${attrs}${access(member, context.openOwner)} ${required ? "required " : ""}${final}${override}${mutating}`;
-      const measured = behavior.get(path109);
-      if (measured) used.add(path109);
+      const measured = behavior.get(path110);
+      if (measured) used.add(path110);
       const overloadBody = /\basync\b/.test(core) ? measured?.asyncBody : /\bResult</.test(core) ? measured?.resultBody : void 0;
-      const body = overloadBody ?? measured?.body ?? (options.inert ? inertBody(member) : trap(path109));
+      const body = overloadBody ?? measured?.body ?? (options.inert ? inertBody(member) : trap(path110));
       switch (member.kind.identifier) {
         case "swift.property":
         case "swift.type.property":
@@ -26909,13 +27110,13 @@ function emitSwiftStandin(sourceGraphs, options) {
           const parameter = !measured && !options.inert && !settable && /:\s*some\s/.test(decl) ? opaqueParameter(member) : void 0;
           const getter = parameter ? `return ({ () -> ${parameter} in ${body} })()` : body;
           const computed = decl.replace(/^((?:static |class )*)let /, "$1var ");
-          const wrapper = options.projections?.get(path109);
+          const wrapper = options.projections?.get(path110);
           if (wrapper) {
             const type = /^var\s+`?\w+`?\s*:\s*(.+)$/s.exec(computed)?.[1];
-            const initial = type && inertValue(type, /* @__PURE__ */ new Set(), [path109]);
+            const initial = type && inertValue(type, /* @__PURE__ */ new Set(), [path110]);
             if (!initial)
               return void skipped.push({
-                path: path109,
+                path: path110,
                 reason: `wrapped by ${wrapper} with no inert initial value`
               });
             const own = new RegExp(
@@ -26936,7 +27137,7 @@ function emitSwiftStandin(sourceGraphs, options) {
             return;
           }
           emit(
-            `${head}${computed} { get${effects} { ${getter} }${settable && !effects ? ` ${parsed.nonmutating ? "nonmutating " : ""}set { ${measured?.set ?? (options.inert ? "" : trap(path109))} }` : ""} }`
+            `${head}${computed} { get${effects} { ${getter} }${settable && !effects ? ` ${parsed.nonmutating ? "nonmutating " : ""}set { ${measured?.set ?? (options.inert ? "" : trap(path110))} }` : ""} }`
           );
           return;
         }
@@ -26995,7 +27196,7 @@ function emitSwiftStandin(sourceGraphs, options) {
   };
   const emitType = scoped(
     (symbol2, indent2) => {
-      const path109 = pathOf(symbol2);
+      const path110 = pathOf(symbol2);
       const id = symbol2.identifier.precise;
       const inner = `${indent2}  `;
       switch (symbol2.kind.identifier) {
@@ -27012,10 +27213,10 @@ function emitSwiftStandin(sourceGraphs, options) {
         case "swift.class": {
           const shape = header(symbol2, "class", indent2);
           if (!shape)
-            return void skipped.push({ path: path109, reason: `unparsed class ${text(symbol2)}` });
-          const parent = options.superclasses?.get(path109) ?? superclass.get(id);
+            return void skipped.push({ path: path110, reason: `unparsed class ${text(symbol2)}` });
+          const parent = options.superclasses?.get(path110) ?? superclass.get(id);
           const blocked = classBlocked(id);
-          if (blocked) return void skipped.push({ path: path109, reason: blocked });
+          if (blocked) return void skipped.push({ path: path110, reason: blocked });
           const ancestors = /* @__PURE__ */ new Set();
           const inherited = /* @__PURE__ */ new Set();
           for (let at = superId.get(id); at; at = superId.get(at)) {
@@ -27031,7 +27232,7 @@ function emitSwiftStandin(sourceGraphs, options) {
                 "Equatable",
                 "CustomStringConvertible",
                 "CustomDebugStringConvertible"
-              ].includes(name3)) && !(name3 === nsObjectProtocol && externalRoot(id) === nsObject) && !options.unconformed?.get(path109)?.has(name3)
+              ].includes(name3)) && !(name3 === nsObjectProtocol && externalRoot(id) === nsObject) && !options.unconformed?.get(path110)?.has(name3)
             )
           ].filter((name3, at, all2) => all2.indexOf(name3) === at);
           const parentSymbol = superId.has(id) ? byId.get(superId.get(id)) : void 0;
@@ -27043,9 +27244,9 @@ function emitSwiftStandin(sourceGraphs, options) {
             `${indent2}${shape.attrs}${objcName ? `@objc(${objcName}) ` : ""}${shape.final}${open ? "open" : "public"} class ${shape.name}${shape.generics}${list2.length ? `: ${list2.join(", ")}` : ""}${selfConforming(shape.where)} {`
           );
           const members2 = membersOf(id);
-          const extra = options.behavior?.get(path109)?.members;
+          const extra = options.behavior?.get(path110)?.members;
           if (extra) {
-            used.add(path109);
+            used.add(path110);
             emit(`${inner}${extra}`);
           }
           for (const member of members2)
@@ -27101,11 +27302,11 @@ function emitSwiftStandin(sourceGraphs, options) {
               if (protocol && member.kind.identifier === "swift.method" && leaf(member).endsWith("()") && have.has(`instance|leaf|${leaf(member).slice(0, -2)}`))
                 propertyWitnesses.push({
                   owner: current2,
-                  head: `extension ${pathOf(protocol)} where Self: ${path109} {`,
+                  head: `extension ${pathOf(protocol)} where Self: ${path110} {`,
                   member,
-                  path: path109
+                  path: path110
                 });
-              else emitWitness(member, inner, path109, open && isObjC(member));
+              else emitWitness(member, inner, path110, open && isObjC(member));
             }
           }
           if (options.inert && designated2 && classBuild(id) === "hidden")
@@ -27113,13 +27314,13 @@ function emitSwiftStandin(sourceGraphs, options) {
           const coder = members2.some((member) => leaf(member) === "init(coder:)");
           if (designated2 && !coder && externalRoot(id) !== "NSObject" && externalRoot(id) !== null)
             emit(
-              `${inner}public required init?(coder: NSCoder) { ${options.inert ? "return nil" : trap(`${path109}.init(coder:)`)} }`
+              `${inner}public required init?(coder: NSCoder) { ${options.inert ? "return nil" : trap(`${path110}.init(coder:)`)} }`
             );
           if (designated2 && !members2.some((member) => leaf(member) === "init()") && [...superChain(id)].some(
             (at) => options.requiredInits?.has(`${pathOf(byId.get(at))}.init()`)
           ))
             emit(
-              `${inner}public required init() { ${options.inert ? superInit(id) : trap(`${path109}.init()`)} }`
+              `${inner}public required init() { ${options.inert ? superInit(id) : trap(`${path110}.init()`)} }`
             );
           emit(`${indent2}}`);
           return;
@@ -27127,7 +27328,7 @@ function emitSwiftStandin(sourceGraphs, options) {
         case "swift.struct": {
           const shape = header(symbol2, "struct", indent2);
           if (!shape)
-            return void skipped.push({ path: path109, reason: `unparsed struct ${text(symbol2)}` });
+            return void skipped.push({ path: path110, reason: `unparsed struct ${text(symbol2)}` });
           const members2 = membersOf(id);
           const raw2 = rawType(members2);
           const list2 = inheritance(id);
@@ -27168,7 +27369,7 @@ function emitSwiftStandin(sourceGraphs, options) {
             emitInertState(
               id,
               inner,
-              raw2 ? `self.rawValue = ${inertValue(raw2, /* @__PURE__ */ new Set(), [path109]) ?? "0"}` : ""
+              raw2 ? `self.rawValue = ${inertValue(raw2, /* @__PURE__ */ new Set(), [path110]) ?? "0"}` : ""
             );
           emit(`${indent2}}`);
           return;
@@ -27176,7 +27377,7 @@ function emitSwiftStandin(sourceGraphs, options) {
         case "swift.enum": {
           const shape = header(symbol2, "enum", indent2);
           if (!shape)
-            return void skipped.push({ path: path109, reason: `unparsed enum ${text(symbol2)}` });
+            return void skipped.push({ path: path110, reason: `unparsed enum ${text(symbol2)}` });
           const members2 = membersOf(id);
           const cases = members2.filter(
             (member) => member.kind.identifier === "swift.enum.case"
@@ -27186,7 +27387,7 @@ function emitSwiftStandin(sourceGraphs, options) {
           const missing2 = raw2 ? cases.filter((member) => !values.has(member.identifier.precise)) : [];
           if (raw2 && (isObjC(symbol2) || /^c:@C?M@[^@]+@E@/.test(id)) && missing2.length > 0)
             return void skipped.push({
-              path: path109,
+              path: path110,
               reason: `no header value for ${missing2.map(leaf).join(", ")}`
             });
           const list2 = inheritance(id, raw2 ?? void 0).filter(
@@ -27226,8 +27427,8 @@ function emitSwiftStandin(sourceGraphs, options) {
             });
           }
           if (options.inert) {
-            const value = options.trapped?.has(hiddenInit(id)) ? null : inertValue(path109, /* @__PURE__ */ new Set(), []);
-            emitInertState(id, inner, value === null ? trap(path109) : `self = ${value}`);
+            const value = options.trapped?.has(hiddenInit(id)) ? null : inertValue(path110, /* @__PURE__ */ new Set(), []);
+            emitInertState(id, inner, value === null ? trap(path110) : `self = ${value}`);
           }
           emit(`${indent2}}`);
           return;
@@ -27236,14 +27437,14 @@ function emitSwiftStandin(sourceGraphs, options) {
           const shape = header(symbol2, "protocol", indent2);
           if (!shape)
             return void skipped.push({
-              path: path109,
+              path: path110,
               reason: `unparsed protocol ${text(symbol2)}`
             });
           const native = nativeObjcProtocols.has(id);
           const objcName = native ? /^c:objc\(pl\)(\w+)$/.exec(id)?.[1] : void 0;
           if (native && !objcName)
             return void skipped.push({
-              path: path109,
+              path: path110,
               reason: `unknown Objective-C protocol identity ${id}`
             });
           const list2 = [
@@ -27271,7 +27472,7 @@ function emitSwiftStandin(sourceGraphs, options) {
           }
           emit(`${indent2}}`);
           if (defaults.length > 0) {
-            emit(`${indent2}extension ${path109} {`);
+            emit(`${indent2}extension ${path110} {`);
             for (const member of defaults) {
               const decl = text(member);
               if (optional3.has(member.identifier.precise) && member.kind.identifier === "swift.method" && !decl.replace(/\([^)]*\)/g, "").includes("->") && !/ async\b/.test(decl))
@@ -27363,7 +27564,7 @@ function emitSwiftStandin(sourceGraphs, options) {
   };
   const atWidth = (value, raw2) => (raw2 === "UInt" || raw2 === "Swift.UInt") && value === "18446744073709551615" ? "4294967295" : (raw2 === "Int" || raw2 === "Swift.Int") && value === "9223372036854775807" ? "2147483647" : (raw2 === "Int" || raw2 === "Swift.Int") && value === "-9223372036854775808" ? "-2147483648" : value;
   const emitGlobal = scoped((symbol2) => {
-    const path109 = pathOf(symbol2);
+    const path110 = pathOf(symbol2);
     const kind = symbol2.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(text(symbol2));
@@ -27372,20 +27573,20 @@ function emitSwiftStandin(sourceGraphs, options) {
         if (leaf(symbol2).endsWith("(_:)") && !/^(?:prefix|infix|postfix)\b/.test(spelled2))
           spelled2 = `prefix ${spelled2}`;
       }
-      const measured = behavior.get(path109);
-      if (measured) used.add(path109);
+      const measured = behavior.get(path110);
+      if (measured) used.add(path110);
       const overloadBody = /\basync\b/.test(spelled2) ? measured?.asyncBody : /\bResult</.test(spelled2) ? measured?.resultBody : void 0;
       emit(
-        `${attrs}public ${spelled2} { ${overloadBody ?? measured?.body ?? (options.inert ? inertBody(symbol2) : trap(path109))} }`
+        `${attrs}public ${spelled2} { ${overloadBody ?? measured?.body ?? (options.inert ? inertBody(symbol2) : trap(path110))} }`
       );
     } else if (kind === "swift.var") {
       const parsed = splitAccessors(text(symbol2).replace(/^let /, "var "));
-      const measured = behavior.get(path109);
-      if (measured) used.add(path109);
+      const measured = behavior.get(path110);
+      if (measured) used.add(path110);
       emit(
-        `public ${parsed.decl} { ${measured?.body ?? (options.inert ? inertBody(symbol2) : trap(path109))} }`
+        `public ${parsed.decl} { ${measured?.body ?? (options.inert ? inertBody(symbol2) : trap(path110))} }`
       );
-    } else skipped.push({ path: path109, reason: `unhandled top-level ${kind}` });
+    } else skipped.push({ path: path110, reason: `unhandled top-level ${kind}` });
   });
   const cExports = new Set(
     [...byId.values()].flatMap((symbol2) => {
@@ -27402,7 +27603,7 @@ function emitSwiftStandin(sourceGraphs, options) {
     return !name3 || !cExports.has(`${name3}|${text(symbol2)}`);
   }).sort((a, b) => pathOf(a).localeCompare(pathOf(b)));
   for (const symbol2 of roots) {
-    const path109 = pathOf(symbol2);
+    const path110 = pathOf(symbol2);
     if (TYPE_KINDS.has(symbol2.kind.identifier)) emitType(symbol2, "");
     else emitGlobal(symbol2);
   }
@@ -27463,9 +27664,9 @@ function emitSwiftStandin(sourceGraphs, options) {
     "#endif",
     ""
   ];
-  for (const path109 of behavior.keys())
-    if (!used.has(path109))
-      skipped.push({ path: path109, reason: "behavior names no emitted declaration" });
+  for (const path110 of behavior.keys())
+    if (!used.has(path110))
+      skipped.push({ path: path110, reason: "behavior names no emitted declaration" });
   return {
     source: `${[...banner, ...lines].join("\n")}
 `,
@@ -29564,9 +29765,9 @@ var EXCERPT = /^(\s*)(\d+)( \| )(.*)$/;
 var MARKER = /^(\s*)( \| )(.*)$/;
 function designTimeDiagnostic(output2, files2) {
   const rewritten = /* @__PURE__ */ new Map();
-  const linesOf = (path109) => {
+  const linesOf = (path110) => {
     const file = Object.keys(files2).find(
-      (name3) => name3.endsWith(".swift") && (path109 === name3 || path109.endsWith(`/${name3}`))
+      (name3) => name3.endsWith(".swift") && (path110 === name3 || path110.endsWith(`/${name3}`))
     );
     if (file === void 0) return null;
     let lines = rewritten.get(file);
@@ -46364,7 +46565,7 @@ init_package_tree_digest();
 init_swift_native_pin();
 var EXPO_NATIVE_ENTRY_NAME = "ios";
 function expoNativeCompilerDigestValue() {
-  return true ? "a082fa51188812213cde34848db6d0579eed90b5b5957ef704fd61ac81d69bbb" : expoNativeCompilerDigest(__sootsim_import_meta_dirname);
+  return true ? "f762ea33a95654cc6dff527029e56f7d981bb2bf78a66b40799cf4af340546c3" : expoNativeCompilerDigest(__sootsim_import_meta_dirname);
 }
 var IDENTITY_SOURCE_SKIPS = 1 | 4 | 8 | 16 | 32 | 64 | 128 | 4096;
 function readSources(value) {
@@ -47550,7 +47751,7 @@ function resolveSwiftPackages(options) {
         headers.set(name3, import_node_path71.default.relative(binary2.dir, dir));
     };
     visit3(pkg, binary2.target);
-    binary2.headerDependencies = [...headers].map(([module2, path109]) => ({ module: module2, path: path109 }));
+    binary2.headerDependencies = [...headers].map(([module2, path110]) => ({ module: module2, path: path110 }));
   }
   for (const owner of options.owners ?? []) {
     const found = productClosure(owner.products);
@@ -52570,8 +52771,8 @@ function imagesetFiles(images) {
     ];
   }).sort((a, b) => a.scale - b.scale);
 }
-function flatScale(path109) {
-  const match = /@([23])x\.[^./]+$/.exec(path109);
+function flatScale(path110) {
+  const match = /@([23])x\.[^./]+$/.exec(path110);
   return match ? Number(match[1]) : 1;
 }
 function providesNamespace(text6) {
@@ -52598,8 +52799,8 @@ function catalogEntryName(contentsPath, kind, readText) {
   }
   return segments.join("/");
 }
-function isFlatResourceImage(path109) {
-  return path109.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path109));
+function isFlatResourceImage(path110) {
+  return path110.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path110));
 }
 function enumerateBundleImages(paths, readText, bundleForFile = () => ".") {
   const table = [];
@@ -52612,7 +52813,7 @@ function enumerateBundleImages(paths, readText, bundleForFile = () => ".") {
     seen.set(bundlePath, names);
     return { bundlePath, names };
   };
-  const catalogs = paths.filter((path109) => baseOf(path109) === "Contents.json");
+  const catalogs = paths.filter((path110) => baseOf(path110) === "Contents.json");
   for (const contentsPath of catalogs) {
     const name3 = catalogEntryName(contentsPath, ".imageset", readText);
     if (name3 === null) continue;
@@ -52644,13 +52845,13 @@ function enumerateBundleImages(paths, readText, bundleForFile = () => ".") {
         ...intent === "template" || intent === "original" ? { renderingMode: intent } : {}
       });
   }
-  for (const path109 of paths) {
-    if (!isFlatResourceImage(path109)) continue;
-    const name3 = baseOf(path109).slice(0, -extOf(path109).length);
-    const { bundlePath, names } = namesFor(path109);
+  for (const path110 of paths) {
+    if (!isFlatResourceImage(path110)) continue;
+    const name3 = baseOf(path110).slice(0, -extOf(path110).length);
+    const { bundlePath, names } = namesFor(path110);
     if (name3 === "" || names.has(name3)) continue;
     names.add(name3);
-    table.push({ name: name3, file: path109, scale: flatScale(path109), bundlePath });
+    table.push({ name: name3, file: path110, scale: flatScale(path110), bundlePath });
   }
   return table;
 }
@@ -52685,7 +52886,7 @@ function colorsetValue(color) {
 }
 function enumerateBundleColors(paths, readText) {
   const table = {};
-  for (const contentsPath of paths.filter((path109) => baseOf(path109) === "Contents.json")) {
+  for (const contentsPath of paths.filter((path110) => baseOf(path110) === "Contents.json")) {
     const name3 = catalogEntryName(contentsPath, ".colorset", readText);
     if (name3 === null || name3 in table) continue;
     let colors;
@@ -52766,8 +52967,8 @@ function axisExtremes(points) {
 function pathBounds(d) {
   const xs = [];
   const ys = [];
-  for (const path109 of d)
-    (0, import_svgpath.default)(path109).abs().unshort().unarc().iterate((segment, _index, x, y) => {
+  for (const path110 of d)
+    (0, import_svgpath.default)(path110).abs().unshort().unarc().iterate((segment, _index, x, y) => {
       const [command, ...args] = segment;
       if (command === "M" || command === "L") {
         xs.push(Number(args[0]));
@@ -52794,7 +52995,7 @@ function guide(svg, id, axis) {
 }
 function enumerateBundleSymbols(paths, readText, bundleForFile) {
   const table = {};
-  for (const contentsPath of paths.filter((path109) => baseOf(path109) === "Contents.json")) {
+  for (const contentsPath of paths.filter((path110) => baseOf(path110) === "Contents.json")) {
     const name3 = catalogEntryName(contentsPath, ".symbolset", readText);
     if (name3 === null) continue;
     const bundle = bundleForFile(contentsPath);
@@ -52853,8 +53054,8 @@ function enumerateBundleSymbols(paths, readText, bundleForFile) {
           advance,
           box: [12 - wide / 2, 12 - tall / 2, wide, tall],
           ...customLayout ? { customLayout } : {},
-          layers: d.map((path109) => ({
-            d: (0, import_svgpath.default)(path109).abs().scale(em).translate(translateX, translateY).round(3).toString()
+          layers: d.map((path110) => ({
+            d: (0, import_svgpath.default)(path110).abs().scale(em).translate(translateX, translateY).round(3).toString()
           }))
         };
         table[vectorKey] = vector;
@@ -52866,18 +53067,18 @@ function enumerateBundleSymbols(paths, readText, bundleForFile) {
   return table;
 }
 var COMPILED_EXTENSIONS = /* @__PURE__ */ new Set([".swift", ".metal", ".storyboard", ".xib"]);
-function isCopiedResource(path109, copiedBundle) {
-  if (copiedBundle || path109.split("/").some((segment) => /\.(atlasc|bundle|storyboardc|nib)$/.test(segment)))
+function isCopiedResource(path110, copiedBundle) {
+  if (copiedBundle || path110.split("/").some((segment) => /\.(atlasc|bundle|storyboardc|nib)$/.test(segment)))
     return true;
-  const ext = extOf(path109);
+  const ext = extOf(path110);
   if (ext === ".json" || ext === ".xcstrings") return true;
-  return !RASTER_EXTENSIONS.has(ext) && !COMPILED_EXTENSIONS.has(ext) && !path109.split("/").some((segment) => segment.endsWith(".xcassets"));
+  return !RASTER_EXTENSIONS.has(ext) && !COMPILED_EXTENSIONS.has(ext) && !path110.split("/").some((segment) => segment.endsWith(".xcassets"));
 }
 function enumerateBundleResources(paths, copiedBundle = false) {
   const found = [];
   const seen = /* @__PURE__ */ new Set();
   const ordered = [...paths].filter(
-    (path109) => path109.split("/").includes("Resources") && path109.split("/").every((segment) => segment !== "" && segment !== "..") && isCopiedResource(path109, copiedBundle)
+    (path110) => path110.split("/").includes("Resources") && path110.split("/").every((segment) => segment !== "" && segment !== "..") && isCopiedResource(path110, copiedBundle)
   ).sort((a, b) => {
     const aDepth = a.split("/").length;
     const bDepth = b.split("/").length;
@@ -52989,31 +53190,31 @@ function tokens(text6) {
   }
   return result;
 }
-function qualified(language, key2, path109) {
-  return `(${language}: ${key2}${path109 === "" ? "" : "|==|" + path109})`;
+function qualified(language, key2, path110) {
+  return `(${language}: ${key2}${path110 === "" ? "" : "|==|" + path110})`;
 }
-function requiresNumber(language, key2, path109) {
+function requiresNumber(language, key2, path110) {
   return Error(
-    "Plural variation requires referencing the number in the string. To maintain grammatical correctness for strings that do not reference the number of items, use separate top-level strings for one and greater than one. " + qualified(language, key2, path109)
+    "Plural variation requires referencing the number in the string. To maintain grammatical correctness for strings that do not reference the number of items, use separate top-level strings for one and greater than one. " + qualified(language, key2, path110)
   );
 }
-function moreThanOne(language, key2, path109) {
+function moreThanOne(language, key2, path110) {
   return Error(
-    "Cannot infer format specifier for string group because more than one numerical specifier was found " + qualified(language, key2, path109)
+    "Cannot infer format specifier for string group because more than one numerical specifier was found " + qualified(language, key2, path110)
   );
 }
 function schemaPath(segments) {
   return segments.map((segment) => `'${segment}'`).join(" -> ");
 }
-function checkUnitShape(node, path109) {
+function checkUnitShape(node, path110) {
   const raw2 = node.stringUnit;
   if (raw2 === void 0)
-    throw Error(`Missing required key 'stringUnit' inside ${schemaPath(path109)}`);
+    throw Error(`Missing required key 'stringUnit' inside ${schemaPath(path110)}`);
   if (raw2 === null)
-    throw Error(`Missing required value for key 'stringUnit' inside ${schemaPath(path109)}`);
+    throw Error(`Missing required value for key 'stringUnit' inside ${schemaPath(path110)}`);
   if (!isRecord3(raw2))
-    throw Error(`Expected dictionary for key 'stringUnit' inside ${schemaPath(path109)}`);
-  const unitPath = [...path109, "stringUnit"];
+    throw Error(`Expected dictionary for key 'stringUnit' inside ${schemaPath(path110)}`);
+  const unitPath = [...path110, "stringUnit"];
   if (!Object.hasOwn(raw2, "state"))
     throw Error(`Missing required key 'state' inside ${schemaPath(unitPath)}`);
   const state = raw2.state;
@@ -53030,38 +53231,38 @@ function checkUnitShape(node, path109) {
     throw Error(`Expected string for key 'value' inside ${schemaPath(unitPath)}`);
   return value;
 }
-function checkPluralShape(node, path109) {
+function checkPluralShape(node, path110) {
   for (const [category, raw2] of Object.entries(node)) {
-    const categoryPath = [...path109, category];
+    const categoryPath = [...path110, category];
     if (raw2 === null)
       throw Error(
-        `Missing required value for key '${category}' inside ${schemaPath(path109)}`
+        `Missing required value for key '${category}' inside ${schemaPath(path110)}`
       );
     if (!isRecord3(raw2))
-      throw Error(`Expected dictionary for key '${category}' inside ${schemaPath(path109)}`);
+      throw Error(`Expected dictionary for key '${category}' inside ${schemaPath(path110)}`);
     checkUnitShape(raw2, categoryPath);
   }
 }
-function checkLocalizationShape(node, path109, deviceValue = false) {
+function checkLocalizationShape(node, path110, deviceValue = false) {
   if (node === null)
     throw Error(
-      `Missing required value for key '${path109[path109.length - 1]}' inside ${schemaPath(path109.slice(0, -1))}`
+      `Missing required value for key '${path110[path110.length - 1]}' inside ${schemaPath(path110.slice(0, -1))}`
     );
   if (!isRecord3(node))
     throw Error(
-      `Expected dictionary for key '${path109[path109.length - 1]}' inside ${schemaPath(path109.slice(0, -1))}`
+      `Expected dictionary for key '${path110[path110.length - 1]}' inside ${schemaPath(path110.slice(0, -1))}`
     );
-  if (Object.hasOwn(node, "variations")) checkVariationsShape(node.variations, path109);
+  if (Object.hasOwn(node, "variations")) checkVariationsShape(node.variations, path110);
   if (!deviceValue && Object.hasOwn(node, "substitutions"))
-    checkSubstitutionsShape(node.substitutions, path109);
-  if (!Object.hasOwn(node, "variations")) checkUnitShape(node, path109);
+    checkSubstitutionsShape(node.substitutions, path110);
+  if (!Object.hasOwn(node, "variations")) checkUnitShape(node, path110);
 }
-function checkVariationsShape(variations, path109) {
+function checkVariationsShape(variations, path110) {
   if (variations === null)
-    throw Error(`Missing required value for key 'variations' inside ${schemaPath(path109)}`);
+    throw Error(`Missing required value for key 'variations' inside ${schemaPath(path110)}`);
   if (!isRecord3(variations))
-    throw Error(`Expected dictionary for key 'variations' inside ${schemaPath(path109)}`);
-  const variationsPath = [...path109, "variations"];
+    throw Error(`Expected dictionary for key 'variations' inside ${schemaPath(path110)}`);
+  const variationsPath = [...path110, "variations"];
   for (const [type, raw2] of Object.entries(variations)) {
     if (raw2 === null)
       throw Error(
@@ -53087,11 +53288,11 @@ function checkVariationsShape(variations, path109) {
       }
   }
 }
-function checkSubstitutionsShape(substitutions, path109) {
+function checkSubstitutionsShape(substitutions, path110) {
   if (substitutions === null) return;
   if (!isRecord3(substitutions))
-    throw Error(`Expected dictionary for key 'substitutions' inside ${schemaPath(path109)}`);
-  const substitutionsPath = [...path109, "substitutions"];
+    throw Error(`Expected dictionary for key 'substitutions' inside ${schemaPath(path110)}`);
+  const substitutionsPath = [...path110, "substitutions"];
   for (const [name3, raw2] of Object.entries(substitutions)) {
     const subPath = [...substitutionsPath, name3];
     if (raw2 === null)
@@ -53133,10 +53334,10 @@ function scanSpecs(forms) {
   }
   return specs;
 }
-function inferPlural(forms, language, key2, path109) {
+function inferPlural(forms, language, key2, path110) {
   const specs = scanSpecs(forms);
-  if (specs.size === 0) throw requiresNumber(language, key2, path109);
-  if (specs.size > 1) throw moreThanOne(language, key2, path109);
+  if (specs.size === 0) throw requiresNumber(language, key2, path110);
+  if (specs.size > 1) throw moreThanOne(language, key2, path110);
   return [...specs.values()][0] ?? { specifier: "", argument: 0 };
 }
 function unit(value) {
@@ -53968,8 +54169,8 @@ function plist4(value, depth) {
 }
 function compileStringCatalog(source, name3) {
   return Object.fromEntries(
-    Object.entries(compileCatalogTables(source, name3)).map(([path109, table]) => [
-      path109,
+    Object.entries(compileCatalogTables(source, name3)).map(([path110, table]) => [
+      path110,
       '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n' + plist4(table, 0) + "</plist>\n"
     ])
   );
@@ -54795,8 +54996,8 @@ function sourceEntryPath() {
     return null;
   }
 }
-function isCliEntry(path109) {
-  const name3 = (0, import_node_path81.basename)(path109);
+function isCliEntry(path110) {
+  const name3 = (0, import_node_path81.basename)(path110);
   return name3 === "bin.ts" || name3 === "bin.js";
 }
 function rnxSelfInvocation() {
@@ -59465,11 +59666,11 @@ function stringList(value) {
 function externalSpecMembers(root, requested) {
   const children = (spec) => Array.isArray(spec.subspecs) ? spec.subspecs.filter(object5) : [];
   const chains = /* @__PURE__ */ new Map();
-  const select = (path109) => {
-    const key2 = path109.join("/");
+  const select = (path110) => {
+    const key2 = path110.join("/");
     if (chains.has(key2)) return;
     const chain = [root];
-    for (const part of path109) {
+    for (const part of path110) {
       const child = children(chain.at(-1)).find((sub) => sub.name === part);
       if (!child) throw new Error(`${String(root.name)} has no subspec ${key2}`);
       chain.push(child);
@@ -59478,7 +59679,7 @@ function externalSpecMembers(root, requested) {
     const spec = chain.at(-1);
     const defaults = stringList(spec.default_subspecs ?? spec.default_subspec);
     const activated = defaults[0] === "none" ? [] : defaults.length > 0 ? defaults : children(spec).map((sub) => String(sub.name));
-    for (const name3 of activated) select([...path109, ...name3.split("/")]);
+    for (const name3 of activated) select([...path110, ...name3.split("/")]);
     for (const member of chain)
       for (const dependencies of [member.dependencies, iosOf(member)?.dependencies])
         for (const dependency of object5(dependencies) ? Object.keys(dependencies) : []) {
@@ -66638,9 +66839,9 @@ function safeChildPlistName(value) {
     name: file.toLowerCase().endsWith(".plist") ? file : `${file}.plist`
   };
 }
-async function readableSettingsBundle(path109) {
+async function readableSettingsBundle(path110) {
   try {
-    const root = await (0, import_promises10.stat)((0, import_node_path102.join)(path109, "Root.plist"));
+    const root = await (0, import_promises10.stat)((0, import_node_path102.join)(path110, "Root.plist"));
     return root.isFile() && root.size <= MAX_PLIST_BYTES;
   } catch {
     return false;
@@ -66685,11 +66886,11 @@ async function settingsBundleFingerprint(bundlePath) {
     return null;
   }
 }
-async function parsePlistRecord(path109) {
+async function parsePlistRecord(path110) {
   try {
-    const metadata = await (0, import_promises10.stat)(path109);
+    const metadata = await (0, import_promises10.stat)(path110);
     if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
-    const source = await (0, import_promises10.readFile)(path109, "utf8");
+    const source = await (0, import_promises10.readFile)(path110, "utf8");
     const parsed = parsePlistSource(source);
     return isRecord(parsed) ? parsed : null;
   } catch {
@@ -67128,7 +67329,7 @@ async function tcpPing(port, timeout = TCP_GATE_MS) {
     return null;
   }
 }
-function httpGet(hostname, port, path109, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(hostname, port, path110, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve7) => {
     let settled = false;
     let killing = false;
@@ -67137,7 +67338,7 @@ function httpGet(hostname, port, path109, method = "GET", timeout = TIMEOUT_MS,
       settled = true;
       resolve7(value);
     };
-    const req = import_http.default.request({ hostname, port, path: path109, method, headers }, (res) => {
+    const req = import_http.default.request({ hostname, port, path: path110, method, headers }, (res) => {
       let body = "";
       res.on("data", (c) => body += c.toString());
       const contentType2 = (() => {