@absolutejs/absolute 0.20.0-beta.103 → 0.20.0-beta.104

package/dist/cli/{mobile-6xe6zysv.js → mobile-njmnd7vc.js}

@@ -7,12 +7,12 @@ import {
 } from "./index-zh6hhrwy.js";
 import {
   start
-} from "./index-rvpd4w9t.js";
+} from "./index-27hhdgtg.js";
 import {
   ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
   ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
   resolveAbsoluteMobileRoute
-} from "./index-6ff78meg.js";
+} from "./index-67kedtn7.js";
 import"./index-bzs19w3r.js";
 import"./index-s2tazax7.js";
 import {
@@ -16777,14 +16777,14 @@ var require_main = __commonJS(function(exports) {
 // src/cli/scripts/mobile.ts
 import {
   access as access13,
-  mkdir as mkdir13,
+  mkdir as mkdir14,
   mkdtemp as mkdtemp4,
-  readFile as readFile17,
+  readFile as readFile18,
   rm as rm7,
-  writeFile as writeFile15
+  writeFile as writeFile16
 } from "fs/promises";
 import { createPublicKey as createPublicKey2 } from "crypto";
-import { join as join14, relative as relative12, resolve as resolve13 } from "path";
+import { join as join15, relative as relative12, resolve as resolve13 } from "path";
 import { createInterface } from "readline/promises";
 
 // src/mobile/nativeDeepLinks.ts
@@ -18454,14 +18454,156 @@ var applyAbsoluteNativeObservability = async (config, platforms = config.platfor
   return { changed: changed.some(Boolean) };
 };
 
+// src/mobile/nativeReleaseReadiness.ts
+import { mkdir as mkdir3, readFile as readFile6, readdir as readdir3, rename as rename6, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname3, join as join6 } from "path";
+var START3 = "// absolutejs:release-readiness:start";
+var END3 = "// absolutejs:release-readiness:end";
+var ANDROID_PLUGIN3 = "AbsoluteReleaseReadinessPlugin.java";
+var optionalSource4 = async (path) => {
+  try {
+    return await readFile6(path, "utf8");
+  } catch (error) {
+    if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "ENOENT")
+      return null;
+    throw error;
+  }
+};
+var writeChanged4 = async (path, source) => {
+  const current = await optionalSource4(path);
+  if (current === source)
+    return false;
+  await mkdir3(dirname3(path), { recursive: true });
+  if (current === null) {
+    await writeFile6(path, source, { flag: "wx" });
+    return true;
+  }
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile6(temporary, source, { flag: "wx" });
+  await rename6(temporary, path);
+  return true;
+};
+var activityInRoot = async (root) => {
+  let entries;
+  try {
+    entries = await readdir3(root, { recursive: true });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "ENOENT")
+      return;
+    throw error;
+  }
+  const candidate = entries.find((entry) => entry.endsWith("/MainActivity.java") || entry.endsWith("/MainActivity.kt") || entry === "MainActivity.java" || entry === "MainActivity.kt");
+  return candidate ? join6(root, candidate) : undefined;
+};
+var activityPath = async (config) => {
+  const roots = [
+    join6(config.nativeProjectDirectory, "android/app/src/main/java"),
+    join6(config.nativeProjectDirectory, "android/app/src/main/kotlin")
+  ];
+  const candidates = await Promise.all(roots.map(activityInRoot));
+  const candidate = candidates.find((value) => value !== undefined);
+  if (candidate)
+    return candidate;
+  throw new TypeError("Android MainActivity.java or MainActivity.kt was not found.");
+};
+var registrationRegion = (kotlin, generatedMethod) => {
+  if (generatedMethod)
+    return kotlin ? `    ${START3}
+    override fun onCreate(savedInstanceState: android.os.Bundle?) {
+        registerPlugin(AbsoluteReleaseReadinessPlugin::class.java)
+        super.onCreate(savedInstanceState)
+    }
+    ${END3}
+` : `    ${START3}
+    @Override
+    public void onCreate(android.os.Bundle savedInstanceState) {
+        registerPlugin(AbsoluteReleaseReadinessPlugin.class);
+        super.onCreate(savedInstanceState);
+    }
+    ${END3}
+`;
+  return kotlin ? `        ${START3}
+        registerPlugin(AbsoluteReleaseReadinessPlugin::class.java)
+        ${END3}
+` : `        ${START3}
+        registerPlugin(AbsoluteReleaseReadinessPlugin.class);
+        ${END3}
+`;
+};
+var injectRegistration = (source) => {
+  const kotlin = /\bfun\s+onCreate\s*\(/u.test(source) || source.includes("BridgeActivity()");
+  const existingStart = source.indexOf(START3);
+  const existingEnd = source.indexOf(END3);
+  if (existingStart < 0 !== existingEnd < 0 || existingStart >= 0 && existingEnd < existingStart)
+    throw new TypeError("AbsoluteJS release-readiness markers are malformed.");
+  if (existingStart >= 0) {
+    const from = source.lastIndexOf(`
+`, existingStart) + 1;
+    const newline = source.indexOf(`
+`, existingEnd + END3.length);
+    const through = newline < 0 ? source.length : newline + 1;
+    const generatedMethod = source.slice(from, through).includes("onCreate(");
+    return `${source.slice(0, from)}${registrationRegion(kotlin, generatedMethod)}${source.slice(through)}`;
+  }
+  const onCreate = kotlin ? source.search(/\boverride\s+fun\s+onCreate\s*\([^)]*\)\s*\{/u) : source.search(/\b(?:public|protected)\s+void\s+onCreate\s*\([^)]*\)\s*\{/u);
+  if (onCreate >= 0) {
+    const brace = source.indexOf("{", onCreate);
+    const insert = source.indexOf(`
+`, brace) + 1;
+    if (insert <= 0)
+      throw new TypeError("Could not inject Android release readiness into MainActivity.");
+    return `${source.slice(0, insert)}${registrationRegion(kotlin, false)}${source.slice(insert)}`;
+  }
+  const close = source.lastIndexOf("}");
+  if (close < 0)
+    throw new TypeError("Could not find the Android MainActivity class body.");
+  const separator = source[close - 1] === `
+` ? "" : `
+`;
+  return `${source.slice(0, close)}${separator}${registrationRegion(kotlin, true)}${source.slice(close)}`;
+};
+var pluginSource = (packageName) => `package ${packageName};
+
+import android.util.Log;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin(name = "AbsoluteReleaseReadiness")
+public final class AbsoluteReleaseReadinessPlugin extends Plugin {
+    @PluginMethod
+    public void ready(PluginCall call) {
+        Log.i("AbsoluteJS", "Capacitor embedded web content ready");
+        call.resolve(new JSObject().put("ready", true));
+    }
+}
+`;
+var applyAbsoluteNativeReleaseReadiness = async (config, platforms = config.platforms) => {
+  if (config.engine !== "capacitor" || !platforms.includes("android"))
+    return { changed: false };
+  const mainActivityPath = await activityPath(config);
+  const activity = await readFile6(mainActivityPath, "utf8");
+  const packageName = activity.match(/^\s*package\s+([A-Za-z0-9_.]+)\s*[;\n]/mu)?.[1];
+  if (!packageName)
+    throw new TypeError("Android MainActivity package declaration was not found.");
+  const pluginPath = join6(config.nativeProjectDirectory, "android/app/src/main/java", packageName.replaceAll(".", "/"), ANDROID_PLUGIN3);
+  const changed = await Promise.all([
+    writeChanged4(mainActivityPath, injectRegistration(activity)),
+    writeChanged4(pluginPath, pluginSource(packageName))
+  ]);
+  return { changed: changed.some(Boolean) };
+};
+
 // src/mobile/associationFiles.ts
 import {
   access,
-  mkdir as mkdir3,
-  readFile as readFile6,
-  rename as rename6,
+  mkdir as mkdir4,
+  readFile as readFile7,
+  rename as rename7,
   rm as rm3,
-  writeFile as writeFile6
+  writeFile as writeFile7
 } from "fs/promises";
 import { resolve } from "path";
 import { Elysia } from "elysia";
@@ -18525,7 +18667,7 @@ var createAbsoluteMobileAssociationDocuments = (config, options = {}) => {
 var writeAtomic = async (path, source) => {
   let current;
   try {
-    current = await readFile6(path, "utf8");
+    current = await readFile7(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -18534,8 +18676,8 @@ var writeAtomic = async (path, source) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile6(temporary, source, { flag: "wx" });
-  await rename6(temporary, path);
+  await writeFile7(temporary, source, { flag: "wx" });
+  await rename7(temporary, path);
   return true;
 };
 var exists = async (path) => {
@@ -18550,7 +18692,7 @@ var assertOwnedOutput = async (root) => {
   const path = resolve(root, OWNERSHIP_FILE);
   let ownership;
   try {
-    ownership = JSON.parse(await readFile6(path, "utf8"));
+    ownership = JSON.parse(await readFile7(path, "utf8"));
   } catch {
     throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
   }
@@ -18564,12 +18706,12 @@ var publishGeneratedDirectory = async (temporary, root) => {
     await assertOwnedOutput(root);
   const backup = `${root}.${crypto.randomUUID()}.previous`;
   if (hasCurrent)
-    await rename6(root, backup);
+    await rename7(root, backup);
   try {
-    await rename6(temporary, root);
+    await rename7(temporary, root);
   } catch (error) {
     if (hasCurrent)
-      await rename6(backup, root);
+      await rename7(backup, root);
     throw error;
   }
   if (hasCurrent)
@@ -18577,7 +18719,7 @@ var publishGeneratedDirectory = async (temporary, root) => {
 };
 var materializeHost = async (root, host, files) => {
   const directory = resolve(root, host, ".well-known");
-  await mkdir3(directory, { recursive: true });
+  await mkdir4(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document2]) => {
     const path = resolve(directory, name);
     await writeAtomic(path, `${JSON.stringify(document2, null, 2)}
@@ -18615,7 +18757,7 @@ var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory)
   if (documents.apple) {
     files.push(["apple-app-site-association", documents.apple]);
   }
-  await mkdir3(temporary, { recursive: true });
+  await mkdir4(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
     await writeAtomic(resolve(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
@@ -18660,8 +18802,8 @@ var verifyAbsoluteMobileAssociationFiles = async (config, request = globalThis.f
 };
 
 // src/mobile/androidWebView.ts
-import { mkdir as mkdir4, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname3, resolve as resolve2 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname4, resolve as resolve2 } from "path";
 var CDP_COMMAND_TIMEOUT_MS = 1e4;
 var WEBVIEW_ATTACH_TIMEOUT_MS = 30000;
 var WEBVIEW_POLL_MS = 200;
@@ -18955,8 +19097,8 @@ var createSession = (options, capture, socket, hostPort, target, connection) =>
         throw new Error("Android WebView screenshot returned no image data.");
       }
       const absolutePath = resolve2(path);
-      await mkdir4(dirname3(absolutePath), { recursive: true });
-      await writeFile7(absolutePath, Buffer.from(data, "base64"));
+      await mkdir5(dirname4(absolutePath), { recursive: true });
+      await writeFile8(absolutePath, Buffer.from(data, "base64"));
       return absolutePath;
     },
     tap: async (coordinateX, coordinateY) => {
@@ -19103,13 +19245,13 @@ var waitForAbsoluteAndroidHmrApply = async (session, options) => {
 };
 
 // src/mobile/releaseDoctor.ts
-import { access as access4, readFile as readFile8, readdir as readdir3 } from "fs/promises";
-import { dirname as dirname5, extname, join as join7, relative as relative3 } from "path";
+import { access as access4, readFile as readFile9, readdir as readdir4 } from "fs/promises";
+import { dirname as dirname6, extname, join as join8, relative as relative3 } from "path";
 
 // src/mobile/mobileBundleInspection.ts
 import { createHash } from "crypto";
-import { access as access2, readFile as readFile7, stat } from "fs/promises";
-import { join as join6, relative, resolve as resolve3 } from "path";
+import { access as access2, readFile as readFile8, stat } from "fs/promises";
+import { join as join7, relative, resolve as resolve3 } from "path";
 var MOBILE_FRAMEWORKS = new Set([
   "angular",
   "ember",
@@ -19134,7 +19276,7 @@ var pathExists = async (path) => {
   }
 };
 var readObject = async (path) => {
-  const value = JSON.parse(await readFile7(path, "utf8"));
+  const value = JSON.parse(await readFile8(path, "utf8"));
   if (!isObject(value))
     throw new TypeError("JSON root must be an object.");
   return value;
@@ -19162,14 +19304,14 @@ var requireBundleFile = async (root, value, field, expectedHash) => {
   if (expectedHash !== undefined) {
     if (!SHA256_PATTERN.test(expectedHash))
       throw new TypeError(`${field} has an invalid SHA-256 digest.`);
-    const actual = createHash("sha256").update(await readFile7(path)).digest("hex");
+    const actual = createHash("sha256").update(await readFile8(path)).digest("hex");
     if (actual !== expectedHash)
       throw new TypeError(`${field} failed its SHA-256 integrity check.`);
   }
   return portable;
 };
 var inspectAbsoluteMobileBundle = async (config, projectRoot) => {
-  const manifestPath = join6(config.bundleDirectory, "absolute-mobile-manifest.json");
+  const manifestPath = join7(config.bundleDirectory, "absolute-mobile-manifest.json");
   const manifest = portablePath(projectRoot, manifestPath);
   if (!await pathExists(manifestPath))
     return { manifest, status: "missing" };
@@ -19266,8 +19408,8 @@ import {
   createPublicKey,
   X509Certificate
 } from "crypto";
-import { access as access3, mkdir as mkdir5 } from "fs/promises";
-import { dirname as dirname4, isAbsolute, relative as relative2, resolve as resolve4, sep } from "path";
+import { access as access3, mkdir as mkdir6 } from "fs/promises";
+import { dirname as dirname5, isAbsolute, relative as relative2, resolve as resolve4, sep } from "path";
 import { pathToFileURL } from "url";
 import { Elysia as Elysia2 } from "elysia";
 var ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT = 1;
@@ -19484,7 +19626,7 @@ var writeAbsoluteMobileUpdateRegistry = async (options) => {
       return;
     });
   }
-  await mkdir5(dirname4(path), { recursive: true });
+  await mkdir6(dirname5(path), { recursive: true });
   await Bun.write(path, renderAbsoluteMobileUpdateRegistry({
     ...options.health ? { health: options.health } : {},
     ...options.rollout ? { rollout: options.rollout } : {},
@@ -19527,14 +19669,14 @@ var inspectReleaseAsset = async (path, isDirectory, isFile) => {
     return findHmrAsset(path);
   if (!isFile || !RELEASE_ASSET_EXTENSIONS.has(extname(path)))
     return;
-  const source = await readFile8(path, "utf8");
+  const source = await readFile9(path, "utf8");
   return HMR_ASSET_PATTERN.test(source) ? path : undefined;
 };
 var findHmrAsset = async (root) => {
   if (!await pathExists2(root))
     return;
-  const entries = await readdir3(root, { withFileTypes: true });
-  const matches = await Promise.all(entries.map((entry) => inspectReleaseAsset(join7(root, entry.name), entry.isDirectory(), entry.isFile())));
+  const entries = await readdir4(root, { withFileTypes: true });
+  const matches = await Promise.all(entries.map((entry) => inspectReleaseAsset(join8(root, entry.name), entry.isDirectory(), entry.isFile())));
   return matches.find((match) => match !== undefined);
 };
 var pass = (id, detail, path) => ({ detail, id, path, status: "pass" });
@@ -19564,7 +19706,7 @@ var mobileUpdateServerCheck = async (config, projectRoot) => {
 };
 var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var readJsonObject = async (path) => {
-  const value = JSON.parse(await readFile8(path, "utf8"));
+  const value = JSON.parse(await readFile9(path, "utf8"));
   if (typeof value !== "object" || value === null || Array.isArray(value))
     throw new TypeError("JSON root must be an object.");
   return Object.fromEntries(Object.entries(value));
@@ -19583,7 +19725,7 @@ var packageDeclarations = (manifest) => {
 };
 var versionCore = (version) => version.split("-")[0]?.split(".").slice(0, 2).join(".");
 var capacitorVersionCheck = async (config, projectRoot) => {
-  const manifestPath = join7(projectRoot, "package.json");
+  const manifestPath = join8(projectRoot, "package.json");
   try {
     const manifest = await readJsonObject(manifestPath);
     const declarations = packageDeclarations(manifest);
@@ -19596,7 +19738,7 @@ var capacitorVersionCheck = async (config, projectRoot) => {
       const declared = declarations.get(name);
       if (!declared || !EXACT_VERSION_PATTERN.test(declared))
         throw new TypeError(`${name} must be a direct exact dependency.`);
-      const installed = await readJsonObject(join7(projectRoot, "node_modules", name, "package.json"));
+      const installed = await readJsonObject(await findAbsoluteInstalledPackageManifest(projectRoot, name));
       if (installed.version !== declared)
         throw new TypeError(`${name} does not match its installed version.`);
       return declared;
@@ -19619,7 +19761,7 @@ var satisfiesGeneratedVersion = (declared, installed) => {
   return actual[0] === expected[0] && actual[1] === expected[1] && (actual[2] ?? NOT_FOUND3) >= (expected[2] ?? 0);
 };
 var expoVersionCheck = async (config) => {
-  const manifestPath = join7(config.nativeProjectDirectory, "package.json");
+  const manifestPath = join8(config.nativeProjectDirectory, "package.json");
   try {
     const manifest = await readJsonObject(manifestPath);
     const declarations = packageDeclarations(manifest);
@@ -19629,13 +19771,13 @@ var expoVersionCheck = async (config) => {
       throw new TypeError(`Generated Expo project is missing ${missingRequired}.`);
     const installedVersions = await Promise.all([...declarations].map(async ([name, declared]) => ({
       declared,
-      installed: await readJsonObject(join7(config.nativeProjectDirectory, "node_modules", name, "package.json")),
+      installed: await readJsonObject(join8(config.nativeProjectDirectory, "node_modules", name, "package.json")),
       name
     })));
     const mismatch = installedVersions.find(({ declared, installed }) => typeof installed.version !== "string" || !satisfiesGeneratedVersion(declared, installed.version));
     if (mismatch)
       throw new TypeError(`Generated Expo dependency ${mismatch.name}@${mismatch.declared} does not match its installed version.`);
-    if (!await pathExists2(join7(config.nativeProjectDirectory, "bun.lock")))
+    if (!await pathExists2(join8(config.nativeProjectDirectory, "bun.lock")))
       throw new TypeError("Generated Expo dependency lockfile is missing.");
     return pass("mobile.expo-versions", `Generated Expo SDK dependencies are pinned, installed, and locked (${declarations.get("expo")}).`, manifestPath);
   } catch (error) {
@@ -19643,9 +19785,9 @@ var expoVersionCheck = async (config) => {
   }
 };
 var dependencyLockAt = async (directory) => (await Promise.all(LOCK_FILES.map(async (name) => ({
-  exists: await pathExists2(join7(directory, name)),
+  exists: await pathExists2(join8(directory, name)),
   name,
-  path: join7(directory, name)
+  path: join8(directory, name)
 })))).find(({ exists: exists2 }) => exists2);
 var declaredWorkspacePatterns = (declared) => {
   if (Array.isArray(declared))
@@ -19655,7 +19797,7 @@ var declaredWorkspacePatterns = (declared) => {
   return [];
 };
 var ownsWorkspace = async (directory, projectRoot) => {
-  const manifest = await readJsonObject(join7(directory, "package.json")).catch(() => {
+  const manifest = await readJsonObject(join8(directory, "package.json")).catch(() => {
     return;
   });
   const workspacePath = relative3(directory, projectRoot).replace(/\\/gu, "/");
@@ -19666,7 +19808,7 @@ var ancestorDirectories = (projectRoot) => {
   let directory = projectRoot;
   while (true) {
     directories.push(directory);
-    const parent = dirname5(directory);
+    const parent = dirname6(directory);
     if (parent === directory)
       return directories;
     directory = parent;
@@ -19681,6 +19823,18 @@ var findAbsoluteDependencyLock = async (projectRoot) => {
   }));
   return candidates.find((candidate) => candidate !== undefined);
 };
+var findAbsoluteInstalledPackageManifest = async (projectRoot, name) => {
+  const candidates = await Promise.all(ancestorDirectories(projectRoot).map(async (directory, index) => {
+    if (index > 0 && !await ownsWorkspace(directory, projectRoot))
+      return;
+    const candidate = join8(directory, "node_modules", name, "package.json");
+    return await pathExists2(candidate) ? candidate : undefined;
+  }));
+  const installed = candidates.find((candidate) => candidate !== undefined);
+  if (installed)
+    return installed;
+  throw new TypeError(`${name} is not installed for this application.`);
+};
 var dependencyLockCheck = async (projectRoot) => {
   const present = await findAbsoluteDependencyLock(projectRoot);
   return present ? pass("mobile.dependency-lock", `Dependency graph is locked by ${present.name}.`, present.path) : fail("mobile.dependency-lock", "No supported dependency lockfile is present.", projectRoot, "Install dependencies with the project package manager and commit its lockfile before release.");
@@ -19725,7 +19879,7 @@ var capacitorConfigReleaseCheck = async (nativeConfigPath) => {
   if (!await pathExists2(nativeConfigPath)) {
     return fail("android.capacitor-config", "The generated Android Capacitor config is missing.", nativeConfigPath, "Run `absolute mobile sync android` before release validation.");
   }
-  const unsafe = isUnsafeCapacitorConfig(await readFile8(nativeConfigPath, "utf8"));
+  const unsafe = isUnsafeCapacitorConfig(await readFile9(nativeConfigPath, "utf8"));
   return unsafe ? fail("android.capacitor-config", "Android Capacitor config contains a development server URL, cleartext transport, navigation allowlist, or invalid JSON.", nativeConfigPath, "Run `absolute mobile sync android`; do not ship development transport overrides.") : pass("android.capacitor-config", "Android Capacitor config contains no development transport overrides.", nativeConfigPath);
 };
 var capacitorIdentityCheck = async (config, platform, nativeConfigPath) => {
@@ -19742,12 +19896,12 @@ var manifestReleaseCheck = async (manifestPath) => {
   if (!await pathExists2(manifestPath)) {
     return fail("android.cleartext", "The Android manifest is missing.", manifestPath, "Run `absolute mobile sync android` before release validation.");
   }
-  const source = await readFile8(manifestPath, "utf8");
+  const source = await readFile9(manifestPath, "utf8");
   const cleartext = /android:usesCleartextTraffic=["']true["']/u.test(source);
   const networkConfigName = source.match(/android:networkSecurityConfig=["']@xml\/([a-z0-9_]+)["']/u)?.[1];
-  const networkConfigPath = networkConfigName ? join7(dirname5(manifestPath), "res", "xml", `${networkConfigName}.xml`) : undefined;
+  const networkConfigPath = networkConfigName ? join8(dirname6(manifestPath), "res", "xml", `${networkConfigName}.xml`) : undefined;
   const developmentTrustReference = /android:networkSecurityConfig=["']@xml\/absolutejs_dev_network_security["']/u.test(source);
-  const developmentTrustContents = networkConfigPath ? await readFile8(networkConfigPath, "utf8").then((value) => value.includes("@raw/absolutejs_dev_ca")).catch(() => false) : false;
+  const developmentTrustContents = networkConfigPath ? await readFile9(networkConfigPath, "utf8").then((value) => value.includes("@raw/absolutejs_dev_ca")).catch(() => false) : false;
   const developmentTrust = developmentTrustReference || developmentTrustContents;
   return cleartext || developmentTrust ? fail("android.cleartext", developmentTrust ? "Android still references the AbsoluteJS development certificate authority." : "Android explicitly permits cleartext traffic.", manifestPath, "Run `absolute mobile sync android`; do not ship development transport or trust overrides.") : pass("android.cleartext", "Android does not explicitly permit cleartext traffic.", manifestPath);
 };
@@ -19758,13 +19912,13 @@ var hmrAssetsReleaseCheck = async (publicRoot) => {
 var embeddedBundleReleaseCheck = async (config, projectRoot, platform, publicRoot) => {
   const inspection = await inspectAbsoluteMobileBundle({ ...config, bundleDirectory: publicRoot }, projectRoot);
   if (inspection.status === "valid")
-    return pass(`${platform}.bundle-integrity`, `Packaged mobile manifest, runtime, routes, and ${inspection.pageCount ?? 0} page asset(s) passed structural and SHA-256 validation.`, join7(publicRoot, "absolute-mobile-manifest.json"));
-  return fail(`${platform}.bundle-integrity`, inspection.status === "missing" ? "The packaged mobile manifest is missing." : `The packaged mobile bundle is invalid: ${inspection.issue ?? "unknown validation error"}`, join7(publicRoot, "absolute-mobile-manifest.json"), "Rebuild the production mobile bundle and run Capacitor sync for this platform.");
+    return pass(`${platform}.bundle-integrity`, `Packaged mobile manifest, runtime, routes, and ${inspection.pageCount ?? 0} page asset(s) passed structural and SHA-256 validation.`, join8(publicRoot, "absolute-mobile-manifest.json"));
+  return fail(`${platform}.bundle-integrity`, inspection.status === "missing" ? "The packaged mobile manifest is missing." : `The packaged mobile bundle is invalid: ${inspection.issue ?? "unknown validation error"}`, join8(publicRoot, "absolute-mobile-manifest.json"), "Rebuild the production mobile bundle and run Capacitor sync for this platform.");
 };
 var contentSecurityPolicyCheck = async (config, platform, publicRoot) => {
-  const path = join7(publicRoot, "index.html");
+  const path = join8(publicRoot, "index.html");
   try {
-    const source = await readFile8(path, "utf8");
+    const source = await readFile9(path, "utf8");
     const requirements = [
       "Content-Security-Policy",
       "default-src 'self'",
@@ -19793,12 +19947,12 @@ var validateExpoCodeSigningProjection = async (config, expo) => {
     return;
   if (!generatedUpdates || generatedUpdates.codeSigningCertificate !== "./certs/absolute-mobile-update.pem" || !isRecord3(generatedUpdates.codeSigningMetadata) || generatedUpdates.codeSigningMetadata.keyid !== configuredSigning.keyId || generatedUpdates.codeSigningMetadata.alg !== configuredSigning.algorithm)
     throw new TypeError("Generated Expo code-signing metadata does not match mobile config.");
-  const generatedCertificate = await readFile8(join7(config.nativeProjectDirectory, "certs", "absolute-mobile-update.pem"), "utf8");
+  const generatedCertificate = await readFile9(join8(config.nativeProjectDirectory, "certs", "absolute-mobile-update.pem"), "utf8");
   if (generatedCertificate !== configuredSigning.certificatePem)
     throw new TypeError("Generated Expo code-signing certificate does not match mobile config.");
 };
 var expoApplicationConfigCheck = async (config, projectRoot) => {
-  const path = join7(config.nativeProjectDirectory, "app.json");
+  const path = join8(config.nativeProjectDirectory, "app.json");
   try {
     const root = await readJsonObject(path);
     if (!isRecord3(root.expo))
@@ -19821,12 +19975,12 @@ var expoApplicationConfigCheck = async (config, projectRoot) => {
   }
 };
 var expoEmbeddedAssetsCheck = async (config) => {
-  const generated = join7(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
-  const assetsRoot = join7(config.nativeProjectDirectory, "assets", "absolute");
+  const generated = join8(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
+  const assetsRoot = join8(config.nativeProjectDirectory, "assets", "absolute");
   try {
     const [source, manifest] = await Promise.all([
-      readFile8(generated, "utf8"),
-      readJsonObject(join7(config.bundleDirectory, "absolute-mobile-manifest.json"))
+      readFile9(generated, "utf8"),
+      readJsonObject(join8(config.bundleDirectory, "absolute-mobile-manifest.json"))
     ]);
     if (source.includes("embedded AbsoluteJS bundle is unavailable") || typeof manifest.appBuild !== "string" || !source.includes(JSON.stringify(manifest.appBuild)) || !source.includes(JSON.stringify(config.productionOrigin))) {
       throw new TypeError("Generated Expo assets do not contain the prepared production release identity.");
@@ -19841,7 +19995,7 @@ var expoEmbeddedAssetsCheck = async (config) => {
     }))).sort();
     if (sourceFiles.length === 0 || embeddedFiles.length !== 1)
       throw new TypeError("Generated Expo asset count does not match the prepared mobile bundle.");
-    const contents = await Promise.all(sourceFiles.map((path) => readFile8(join7(config.bundleDirectory, path))));
+    const contents = await Promise.all(sourceFiles.map((path) => readFile9(join8(config.bundleDirectory, path))));
     let offset = 0;
     const entries = sourceFiles.map((path, index) => {
       const entry = {
@@ -19852,7 +20006,7 @@ var expoEmbeddedAssetsCheck = async (config) => {
       offset += entry.length;
       return entry;
     });
-    const archive = await readFile8(join7(assetsRoot, embeddedFiles[0] ?? ""));
+    const archive = await readFile9(join8(assetsRoot, embeddedFiles[0] ?? ""));
     if (!archive.equals(Buffer.concat(contents)) || entries.some((entry) => !source.includes(JSON.stringify(entry))))
       throw new TypeError("Generated Expo asset bytes differ from the prepared mobile bundle.");
     return pass("expo.bundle-projection", `Expo embeds the complete signed mobile bundle as one opaque archive containing ${sourceFiles.length} file(s).`, generated);
@@ -19864,20 +20018,20 @@ var sourceFiles = async (root, extensions) => {
   if (!await pathExists2(root))
     return [];
   const files = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: root, onlyFiles: true }));
-  return files.filter((file) => extensions.has(extname(file))).map((file) => join7(root, file));
+  return files.filter((file) => extensions.has(extname(file))).map((file) => join8(root, file));
 };
 var containsPattern = async (paths, pattern) => {
-  const sources = await Promise.all(paths.map((path) => readFile8(path, "utf8")));
+  const sources = await Promise.all(paths.map((path) => readFile9(path, "utf8")));
   const index = sources.findIndex((source) => pattern.test(source));
   return index === NOT_FOUND3 ? undefined : paths[index];
 };
 var androidNativeSecurityCheck = async (androidRoot) => {
-  const manifestPath = join7(androidRoot, "app/src/main/AndroidManifest.xml");
+  const manifestPath = join8(androidRoot, "app/src/main/AndroidManifest.xml");
   try {
-    const manifest = await readFile8(manifestPath, "utf8");
+    const manifest = await readFile9(manifestPath, "utf8");
     if (/android:debuggable=["']true["']/u.test(manifest))
       throw new TypeError("Android release manifest explicitly enables application debugging.");
-    const sources = await sourceFiles(join7(androidRoot, "app/src/main"), new Set([".java", ".kt"]));
+    const sources = await sourceFiles(join8(androidRoot, "app/src/main"), new Set([".java", ".kt"]));
     const debugSource = await containsPattern(sources, /setWebContentsDebuggingEnabled\s*\(\s*true\s*\)/u);
     if (debugSource)
       return fail("android.native-debugging", "Android application source unconditionally enables WebView debugging.", debugSource, "Remove the unconditional WebView debugging call; use the platform debug-build behavior during development.");
@@ -19887,7 +20041,7 @@ var androidNativeSecurityCheck = async (androidRoot) => {
   }
 };
 var androidExportedComponentsCheck = async (manifestPath) => {
-  const source = await readFile8(manifestPath, "utf8").catch(() => "");
+  const source = await readFile9(manifestPath, "utf8").catch(() => "");
   const exported = [
     ...source.matchAll(/<(?:activity|activity-alias|provider|receiver|service)\b[^>]*>/giu)
   ].map(([tag]) => tag).filter((tag) => /android:exported=["']true["']/iu.test(tag)).map((tag) => tag.match(/android:name=["']([^"']+)["']/iu)?.[1]).filter((name) => Boolean(name) && name !== ".MainActivity");
@@ -19895,7 +20049,7 @@ var androidExportedComponentsCheck = async (manifestPath) => {
 };
 var androidDeepLinkProjectionCheck = async (config, manifestPath) => {
   try {
-    const source = await readFile8(manifestPath, "utf8");
+    const source = await readFile9(manifestPath, "utf8");
     const hasWebHost = (host) => [...source.matchAll(/<data\b[^>]*>/giu)].some(([tag]) => tag.includes('android:scheme="https"') && tag.includes(`android:host="${host}"`));
     if (!source.includes('android:autoVerify="true"') || !source.includes("android.intent.category.BROWSABLE") || config.deepLinkHosts.some((host) => !hasWebHost(host)) || config.deepLinkScheme && !source.includes(`android:scheme="${config.deepLinkScheme}"`))
       throw new TypeError("Android App Link or custom-scheme projection does not match mobile config.");
@@ -19909,15 +20063,15 @@ var nativeUpdateWatchdogCheck = async (config, platform) => {
     return;
   const timeout = String(config.updates.bootTimeoutMs);
   if (platform === "ios") {
-    const path = join7(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
-    const configPath = join7(config.nativeProjectDirectory, "ios/App/App/capacitor.config.json");
+    const path = join8(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
+    const configPath = join8(config.nativeProjectDirectory, "ios/App/App/capacitor.config.json");
     const [source, nativeConfig] = await Promise.all([
-      readFile8(path, "utf8").catch(() => ""),
-      readFile8(configPath, "utf8").catch(() => "")
+      readFile9(path, "utf8").catch(() => ""),
+      readFile9(configPath, "utf8").catch(() => "")
     ]);
     return source.includes("AbsoluteMobileUpdateWatchdogPlugin") && source.includes("recoverInterruptedBoot()") && source.includes(`.milliseconds(${timeout})`) && source.includes("quarantinedReleases") && nativeConfig.includes("AbsoluteMobileUpdateWatchdogPlugin") ? pass("ios.update-watchdog", `The native update boot watchdog is projected with a ${timeout}ms deadline.`, path) : fail("ios.update-watchdog", "The iOS update boot watchdog does not match mobile config.", path, "Run `absolute mobile sync ios` before building the release.");
   }
-  const sourceRoot = join7(config.nativeProjectDirectory, "android/app/src/main");
+  const sourceRoot = join8(config.nativeProjectDirectory, "android/app/src/main");
   const sources = await sourceFiles(sourceRoot, new Set([".java", ".kt"]));
   const [activity, plugin] = await Promise.all([
     containsPattern(sources, /recoverInterruptedBoot\s*\(\s*this\s*\)/u),
@@ -19930,27 +20084,27 @@ var nativeObservabilityProjectionCheck = async (config, platform) => {
     return;
   const nativeRoot = config.nativeProjectDirectory;
   if (config.engine === "expo") {
-    const moduleRoot = join7(nativeRoot, "modules", "absolute-mobile-observability");
-    const configPath = join7(moduleRoot, "expo-module.config.json");
-    const sourcePath = platform === "android" ? join7(moduleRoot, "android/src/main/java/expo/modules/absolutemobileobservability/AbsoluteMobileObservabilityModule.kt") : join7(moduleRoot, "ios/AbsoluteMobileObservabilityModule.swift");
+    const moduleRoot = join8(nativeRoot, "modules", "absolute-mobile-observability");
+    const configPath = join8(moduleRoot, "expo-module.config.json");
+    const sourcePath = platform === "android" ? join8(moduleRoot, "android/src/main/java/expo/modules/absolutemobileobservability/AbsoluteMobileObservabilityModule.kt") : join8(moduleRoot, "ios/AbsoluteMobileObservabilityModule.swift");
     const [moduleConfig, source] = await Promise.all([
-      readFile8(configPath, "utf8").catch(() => ""),
-      readFile8(sourcePath, "utf8").catch(() => "")
+      readFile9(configPath, "utf8").catch(() => ""),
+      readFile9(sourcePath, "utf8").catch(() => "")
     ]);
     const valid = moduleConfig.includes("AbsoluteMobileObservabilityModule") && source.includes("AbsoluteMobileObservability") && (platform === "android" ? source.includes("getHistoricalProcessExitReasons") : source.includes("MXMetricManagerSubscriber"));
     return valid ? pass(`${platform}.native-observability`, `The Expo ${platform} native process collector is projected and autolinkable.`, sourcePath) : fail(`${platform}.native-observability`, `The Expo ${platform} native process collector is missing or incomplete.`, sourcePath, `Run \`absolute mobile build ${platform}\` before building the release.`);
   }
   if (platform === "ios") {
-    const delegatePath = join7(nativeRoot, "ios/App/App/AppDelegate.swift");
-    const configPath = join7(nativeRoot, "ios/App/App/capacitor.config.json");
+    const delegatePath = join8(nativeRoot, "ios/App/App/AppDelegate.swift");
+    const configPath = join8(nativeRoot, "ios/App/App/capacitor.config.json");
     const [delegate, nativeConfig] = await Promise.all([
-      readFile8(delegatePath, "utf8").catch(() => ""),
-      readFile8(configPath, "utf8").catch(() => "")
+      readFile9(delegatePath, "utf8").catch(() => ""),
+      readFile9(configPath, "utf8").catch(() => "")
     ]);
     const valid = delegate.includes("AbsoluteMobileObservabilityPlugin") && delegate.includes("MXMetricManagerSubscriber") && nativeConfig.includes("AbsoluteMobileObservabilityPlugin");
     return valid ? pass("ios.native-observability", "The iOS MetricKit native process collector is projected and registered.", delegatePath) : fail("ios.native-observability", "The iOS MetricKit native process collector is missing or unregistered.", delegatePath, "Run `absolute mobile sync ios` before building the release.");
   }
-  const sourceRoot = join7(nativeRoot, "android/app/src/main");
+  const sourceRoot = join8(nativeRoot, "android/app/src/main");
   const sources = await sourceFiles(sourceRoot, new Set([".java", ".kt"]));
   const [registration, plugin] = await Promise.all([
     containsPattern(sources, /registerPlugin\s*\(\s*AbsoluteMobileObservabilityPlugin(?:::class\.java|\.class)\s*\)/u),
@@ -19971,14 +20125,14 @@ var iosNativeSecurityCheck = async (iosRoot) => {
   return pass("ios.native-debugging", "iOS source does not enable release debugger attachment or WebView inspection.", entitlementPaths[0] ?? iosRoot);
 };
 var iosDeepLinkProjectionCheck = async (config, iosRoot) => {
-  const infoPath = join7(iosRoot, "App/App/Info.plist");
-  const entitlementsPath = join7(iosRoot, "App/AbsoluteJS.entitlements");
-  const projectPath2 = join7(iosRoot, "App/App.xcodeproj/project.pbxproj");
+  const infoPath = join8(iosRoot, "App/App/Info.plist");
+  const entitlementsPath = join8(iosRoot, "App/AbsoluteJS.entitlements");
+  const projectPath2 = join8(iosRoot, "App/App.xcodeproj/project.pbxproj");
   try {
     const [info, entitlements, project] = await Promise.all([
-      readFile8(infoPath, "utf8"),
-      readFile8(entitlementsPath, "utf8"),
-      readFile8(projectPath2, "utf8")
+      readFile9(infoPath, "utf8"),
+      readFile9(entitlementsPath, "utf8"),
+      readFile9(projectPath2, "utf8")
     ]);
     if (config.deepLinkScheme && (!info.includes("<key>CFBundleURLTypes</key>") || !info.includes(`<string>${config.deepLinkScheme}</string>`)))
       throw new TypeError("iOS custom URL scheme does not match mobile config.");
@@ -19994,7 +20148,7 @@ var iosDeepLinkProjectionCheck = async (config, iosRoot) => {
 var syncSchemaReleaseCheck = (projectRoot) => {
   if (!projectUsesAbsoluteSync(projectRoot))
     return;
-  const manifestPath = join7(projectRoot, "package.json");
+  const manifestPath = join8(projectRoot, "package.json");
   try {
     const schema = discoverAbsoluteSyncSchema(projectRoot);
     const versions = schema.components.map((component) => `${component.id}@${component.version}`).join(", ");
@@ -20024,8 +20178,8 @@ var IOS_USAGE_KEYS = {
 var androidDevicePermissionCheck = async (config, permissions) => {
   if (!config.platforms.includes("android") || permissions.length === 0)
     return;
-  const path = join7(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile8(path, "utf8");
+  const path = join8(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile9(path, "utf8");
   const missing = permissions.filter((permission) => !source.includes(`android:name="${permission}"`) && !source.includes(`android:name='${permission}'`));
   if (missing.length === 0)
     return;
@@ -20034,9 +20188,9 @@ var androidDevicePermissionCheck = async (config, permissions) => {
 var iosDevicePermissionCheck = async (config, purposes) => {
   if (!config.platforms.includes("ios") || purposes.length === 0)
     return;
-  const iosRoot = join7(config.nativeProjectDirectory, "ios");
-  const path = config.engine === "expo" ? await uniqueExpoIosFile(iosRoot, "**/Info.plist", "Info.plist") : join7(iosRoot, "App/App/Info.plist");
-  const source = await readFile8(path, "utf8");
+  const iosRoot = join8(config.nativeProjectDirectory, "ios");
+  const path = config.engine === "expo" ? await uniqueExpoIosFile(iosRoot, "**/Info.plist", "Info.plist") : join8(iosRoot, "App/App/Info.plist");
+  const source = await readFile9(path, "utf8");
   const missing = purposes.filter((purpose) => !source.includes(`<key>${IOS_USAGE_KEYS[purpose]}</key>`));
   if (missing.length === 0)
     return;
@@ -20046,7 +20200,7 @@ var expoIosPrivacyCapabilityCheck = async (iosRoot, project, requirements) => {
   if (requirements.iosPrivacyAccessedApis.length === 0)
     return;
   const privacyPath = await uniqueExpoIosFile(iosRoot, "**/PrivacyInfo.xcprivacy", "privacy manifest");
-  const privacy = await readFile8(privacyPath, "utf8");
+  const privacy = await readFile9(privacyPath, "utf8");
   const missing = requirements.iosPrivacyAccessedApis.some(({ api, reasons }) => !privacy.includes(`<string>${api}</string>`) || reasons.some((reason) => !privacy.includes(`<string>${reason}</string>`)));
   if (!missing && project.includes(privacyPath.split(/[\\/]/u).at(-1) ?? ""))
     return;
@@ -20056,15 +20210,15 @@ var expoIosPushCapabilityCheck = async (iosRoot, requirements) => {
   if (!requirements.iosPushNotifications)
     return;
   const entitlementsPath = await uniqueExpoIosFile(iosRoot, "**/*.entitlements", "entitlements");
-  const entitlements = await readFile8(entitlementsPath, "utf8");
+  const entitlements = await readFile9(entitlementsPath, "utf8");
   if (entitlements.includes("<key>aps-environment</key>"))
     return;
   return fail("mobile.device-capabilities", "Expo iOS push entitlement does not match detected capabilities.", entitlementsPath, "Run `absolute mobile build ios` to regenerate native push integration.");
 };
 var expoIosCapabilityProjectionCheck = async (config, requirements) => {
-  const iosRoot = join7(config.nativeProjectDirectory, "ios");
+  const iosRoot = join8(config.nativeProjectDirectory, "ios");
   const projectPath2 = await uniqueExpoIosFile(iosRoot, "**/*.xcodeproj/project.pbxproj", "Xcode project");
-  const project = await readFile8(projectPath2, "utf8");
+  const project = await readFile9(projectPath2, "utf8");
   const privacy = await expoIosPrivacyCapabilityCheck(iosRoot, project, requirements);
   if (privacy)
     return privacy;
@@ -20075,28 +20229,28 @@ var iosCapabilityProjectionCheck = async (config, requirements) => {
     return;
   if (config.engine === "expo")
     return expoIosCapabilityProjectionCheck(config, requirements);
-  const appRoot = join7(config.nativeProjectDirectory, "ios/App/App");
-  const infoPath = join7(appRoot, "Info.plist");
-  const info = await readFile8(infoPath, "utf8").catch(() => "");
+  const appRoot = join8(config.nativeProjectDirectory, "ios/App/App");
+  const infoPath = join8(appRoot, "Info.plist");
+  const info = await readFile9(infoPath, "utf8").catch(() => "");
   if (requirements.iosSystemBars && !/<key>UIViewControllerBasedStatusBarAppearance<\/key>\s*<true\s*\/>/u.test(info))
     return fail("mobile.device-capabilities", "iOS system-bar capability is missing its required view-controller setting.", infoPath, "Run `absolute mobile sync ios` to regenerate native capability settings.");
   if (requirements.iosPrivacyAccessedApis.length > 0) {
-    const privacyPath = join7(appRoot, "PrivacyInfo.xcprivacy");
-    const projectPath2 = join7(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+    const privacyPath = join8(appRoot, "PrivacyInfo.xcprivacy");
+    const projectPath2 = join8(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
     const [privacy, project] = await Promise.all([
-      readFile8(privacyPath, "utf8").catch(() => ""),
-      readFile8(projectPath2, "utf8").catch(() => "")
+      readFile9(privacyPath, "utf8").catch(() => ""),
+      readFile9(projectPath2, "utf8").catch(() => "")
     ]);
     const missing = requirements.iosPrivacyAccessedApis.some(({ api, reasons }) => !privacy.includes(`<string>${api}</string>`) || reasons.some((reason) => !privacy.includes(`<string>${reason}</string>`)));
     if (missing || !project.includes("PrivacyInfo.xcprivacy in Resources"))
       return fail("mobile.device-capabilities", "iOS privacy manifest or target membership does not match detected native capabilities.", privacyPath, "Run `absolute mobile sync ios` to regenerate and target PrivacyInfo.xcprivacy.");
   }
   if (requirements.iosPushNotifications) {
-    const entitlementsPath = join7(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
-    const delegatePath = join7(appRoot, "AppDelegate.swift");
+    const entitlementsPath = join8(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+    const delegatePath = join8(appRoot, "AppDelegate.swift");
     const [entitlements, delegate] = await Promise.all([
-      readFile8(entitlementsPath, "utf8").catch(() => ""),
-      readFile8(delegatePath, "utf8").catch(() => "")
+      readFile9(entitlementsPath, "utf8").catch(() => ""),
+      readFile9(delegatePath, "utf8").catch(() => "")
     ]);
     if (!entitlements.includes("<key>aps-environment</key>") || !delegate.includes("capacitorDidRegisterForRemoteNotifications") || !delegate.includes("capacitorDidFailToRegisterForRemoteNotifications"))
       return fail("mobile.device-capabilities", "iOS push entitlement or AppDelegate forwarding does not match detected capabilities.", entitlementsPath, "Run `absolute mobile sync ios` to regenerate native push integration.");
@@ -20104,13 +20258,13 @@ var iosCapabilityProjectionCheck = async (config, requirements) => {
   return;
 };
 var deviceCapabilityReleaseCheck = async (config, projectRoot) => {
-  const manifestPath = join7(projectRoot, "package.json");
+  const manifestPath = join8(projectRoot, "package.json");
   try {
     const plan = resolveAbsoluteDeviceCapabilityPlan(projectRoot, config.engine);
     const assertPackages = async () => {
       if (config.engine === "capacitor")
         return assertAbsoluteDeviceCapabilityPackages(projectRoot, plan);
-      const generated = await readJsonObject(join7(config.nativeProjectDirectory, "package.json"));
+      const generated = await readJsonObject(join8(config.nativeProjectDirectory, "package.json"));
       const declarations = packageDeclarations(generated);
       const missing = plan.requiredPackages.filter((spec) => {
         const separator = spec.lastIndexOf("@");
@@ -20137,11 +20291,11 @@ var deviceCapabilityReleaseCheck = async (config, projectRoot) => {
   }
 };
 var inspectAndroidRelease = async (config, projectRoot) => {
-  const androidRoot = join7(config.nativeProjectDirectory, "android");
-  const nativeConfigPath = join7(androidRoot, "app", "src", "main", "assets", "capacitor.config.json");
-  const manifestPath = join7(androidRoot, "app", "src", "main", "AndroidManifest.xml");
-  const publicRoot = join7(androidRoot, "app", "src", "main", "assets", "public");
-  const journalPath = join7(projectRoot, ".absolutejs", "mobile", "dev-session", "journal.json");
+  const androidRoot = join8(config.nativeProjectDirectory, "android");
+  const nativeConfigPath = join8(androidRoot, "app", "src", "main", "assets", "capacitor.config.json");
+  const manifestPath = join8(androidRoot, "app", "src", "main", "AndroidManifest.xml");
+  const publicRoot = join8(androidRoot, "app", "src", "main", "assets", "public");
+  const journalPath = join8(projectRoot, ".absolutejs", "mobile", "dev-session", "journal.json");
   const checks = await Promise.all([
     journalReleaseCheck(journalPath, "android"),
     capacitorConfigReleaseCheck(nativeConfigPath),
@@ -20162,9 +20316,9 @@ var inspectAndroidRelease = async (config, projectRoot) => {
   }));
 };
 var inspectExpoAndroidRelease = async (config, projectRoot) => {
-  const androidRoot = join7(config.nativeProjectDirectory, "android");
-  const manifestPath = join7(androidRoot, "app", "src", "main", "AndroidManifest.xml");
-  const journalPath = join7(projectRoot, ".absolutejs", "mobile", "expo-dev-session", "journal.json");
+  const androidRoot = join8(config.nativeProjectDirectory, "android");
+  const manifestPath = join8(androidRoot, "app", "src", "main", "AndroidManifest.xml");
+  const journalPath = join8(projectRoot, ".absolutejs", "mobile", "expo-dev-session", "journal.json");
   const checks = await Promise.all([
     journalReleaseCheck(journalPath, "android"),
     expoApplicationConfigCheck(config, projectRoot),
@@ -20190,7 +20344,7 @@ var uniqueExpoIosFile = async (iosRoot, pattern, label) => {
   const [path] = paths;
   if (!path)
     throw new TypeError(`Generated Expo iOS project is missing its ${label}.`);
-  return join7(iosRoot, path);
+  return join8(iosRoot, path);
 };
 var expoIosNativeProjectionCheck = async (config, iosRoot) => {
   try {
@@ -20200,9 +20354,9 @@ var expoIosNativeProjectionCheck = async (config, iosRoot) => {
       uniqueExpoIosFile(iosRoot, "**/*.xcodeproj/project.pbxproj", "Xcode project")
     ]);
     const [info, entitlements, project] = await Promise.all([
-      readFile8(infoPath, "utf8"),
-      readFile8(entitlementsPath, "utf8"),
-      readFile8(projectPath2, "utf8")
+      readFile9(infoPath, "utf8"),
+      readFile9(entitlementsPath, "utf8"),
+      readFile9(projectPath2, "utf8")
     ]);
     if (/<key>NSAllowsArbitraryLoads<\/key>\s*<true\s*\/>/u.test(info))
       throw new TypeError("Expo iOS App Transport Security permits arbitrary network loads.");
@@ -20218,8 +20372,8 @@ var expoIosNativeProjectionCheck = async (config, iosRoot) => {
   }
 };
 var inspectExpoIosRelease = async (config, projectRoot) => {
-  const iosRoot = join7(config.nativeProjectDirectory, "ios");
-  const journalPath = join7(projectRoot, ".absolutejs", "mobile", "expo-dev-session", "journal.json");
+  const iosRoot = join8(config.nativeProjectDirectory, "ios");
+  const journalPath = join8(projectRoot, ".absolutejs", "mobile", "expo-dev-session", "journal.json");
   const checks = [
     await journalReleaseCheck(journalPath, "ios")
   ];
@@ -20242,11 +20396,11 @@ var inspectExpoIosRelease = async (config, projectRoot) => {
   }));
 };
 var inspectIosRelease = async (config, projectRoot) => {
-  const iosAppRoot = join7(config.nativeProjectDirectory, "ios", "App", "App");
-  const nativeConfigPath = join7(iosAppRoot, "capacitor.config.json");
-  const infoPath = join7(iosAppRoot, "Info.plist");
-  const publicRoot = join7(iosAppRoot, "public");
-  const journalPath = join7(projectRoot, ".absolutejs", "mobile", "ios-dev-session", "journal.json");
+  const iosAppRoot = join8(config.nativeProjectDirectory, "ios", "App", "App");
+  const nativeConfigPath = join8(iosAppRoot, "capacitor.config.json");
+  const infoPath = join8(iosAppRoot, "Info.plist");
+  const publicRoot = join8(iosAppRoot, "public");
+  const journalPath = join8(projectRoot, ".absolutejs", "mobile", "ios-dev-session", "journal.json");
   const checks = [
     await journalReleaseCheck(journalPath, "ios")
   ];
@@ -20258,7 +20412,7 @@ var inspectIosRelease = async (config, projectRoot) => {
   }
   if (!await pathExists2(nativeConfigPath)) {
     checks.push(fail("ios.capacitor-config", "The generated iOS Capacitor config is missing.", nativeConfigPath, "Run `absolute mobile sync ios` before release validation."));
-  } else if (isUnsafeCapacitorConfig(await readFile8(nativeConfigPath, "utf8"))) {
+  } else if (isUnsafeCapacitorConfig(await readFile9(nativeConfigPath, "utf8"))) {
     checks.push(fail("ios.capacitor-config", "iOS Capacitor config contains a development server URL, cleartext transport, navigation allowlist, or invalid JSON.", nativeConfigPath, "Run `absolute mobile sync ios`; do not ship development transport overrides."));
   } else {
     checks.push(pass("ios.capacitor-config", "iOS Capacitor config contains no development transport overrides.", nativeConfigPath));
@@ -20267,12 +20421,12 @@ var inspectIosRelease = async (config, projectRoot) => {
   if (!await pathExists2(infoPath)) {
     checks.push(fail("ios.transport-security", "The iOS Info.plist is missing.", infoPath, "Run `absolute mobile sync ios` before release validation."));
   } else {
-    const info = await readFile8(infoPath, "utf8");
+    const info = await readFile9(infoPath, "utf8");
     checks.push(/<key>NSAllowsArbitraryLoads<\/key>\s*<true\s*\/>/u.test(info) ? fail("ios.transport-security", "iOS App Transport Security permits arbitrary network loads.", infoPath, "Remove NSAllowsArbitraryLoads from the release Info.plist.") : pass("ios.transport-security", "iOS App Transport Security does not permit arbitrary loads.", infoPath));
   }
   const hmrAsset = await findHmrAsset(publicRoot);
   checks.push(hmrAsset ? fail("ios.hmr-assets", "A packaged iOS asset contains the development HMR client.", hmrAsset, "Rebuild the production mobile bundle and run Capacitor sync again.") : pass("ios.hmr-assets", "Packaged iOS assets contain no development HMR markers.", publicRoot));
-  checks.push(await embeddedBundleReleaseCheck(config, projectRoot, "ios", publicRoot), await contentSecurityPolicyCheck(config, "ios", publicRoot), await iosNativeSecurityCheck(join7(config.nativeProjectDirectory, "ios")), await iosDeepLinkProjectionCheck(config, join7(config.nativeProjectDirectory, "ios")));
+  checks.push(await embeddedBundleReleaseCheck(config, projectRoot, "ios", publicRoot), await contentSecurityPolicyCheck(config, "ios", publicRoot), await iosNativeSecurityCheck(join8(config.nativeProjectDirectory, "ios")), await iosDeepLinkProjectionCheck(config, join8(config.nativeProjectDirectory, "ios")));
   const nativeObservability = await nativeObservabilityProjectionCheck(config, "ios");
   if (nativeObservability)
     checks.push(nativeObservability);
@@ -20342,16 +20496,16 @@ import { createHash as createHash2 } from "crypto";
 import {
   access as access5,
   copyFile,
-  mkdir as mkdir6,
+  mkdir as mkdir7,
   mkdtemp,
-  readFile as readFile9,
+  readFile as readFile10,
   realpath,
-  rename as rename7,
+  rename as rename8,
   rm as rm4,
   stat as stat2,
-  writeFile as writeFile8
+  writeFile as writeFile9
 } from "fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute2, join as join8, relative as relative4, resolve as resolve5, sep as sep2 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute2, join as join9, relative as relative4, resolve as resolve5, sep as sep2 } from "path";
 var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1;
 var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var requireManifest = (value) => {
@@ -20430,7 +20584,7 @@ var windowsJarsignerPath = (path, capture) => {
   }
   return translated;
 };
-var sha256File = async (path) => createHash2("sha256").update(await readFile9(path)).digest("hex");
+var sha256File = async (path) => createHash2("sha256").update(await readFile10(path)).digest("hex");
 var fingerprintExpoAndroidProject = async (nativeDirectory) => {
   const root = await realpath(nativeDirectory);
   const files = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: root, onlyFiles: true }));
@@ -20438,7 +20592,7 @@ var fingerprintExpoAndroidProject = async (nativeDirectory) => {
     const parts = path.replaceAll("\\", "/").split("/");
     return !parts.includes(".gradle") && !parts.includes("build");
   }).sort().map(async (path) => {
-    const contents = await readFile9(join8(root, path));
+    const contents = await readFile10(join9(root, path));
     return `${path.replaceAll("\\", "/")}\x00${createHash2("sha256").update(contents).digest("hex")}\x00`;
   }));
   return createHash2("sha256").update(records.join("")).digest("hex");
@@ -20453,11 +20607,11 @@ var safeOutputDirectory = (projectRoot, requested) => {
   return output;
 };
 var installRelease = async (artifactPath, metadata, outputRoot) => {
-  const releaseRoot = join8(outputRoot, metadata.releaseId);
+  const releaseRoot = join9(outputRoot, metadata.releaseId);
   const artifactName = "app-release.aab";
-  const destination = join8(releaseRoot, artifactName);
+  const destination = join9(releaseRoot, artifactName);
   if (await pathExists3(releaseRoot)) {
-    const existing = requireManifestIdentity(JSON.parse(await readFile9(join8(releaseRoot, "release.json"), "utf8")), metadata);
+    const existing = requireManifestIdentity(JSON.parse(await readFile10(join9(releaseRoot, "release.json"), "utf8")), metadata);
     const [installedBytes, installedSha256] = await Promise.all([
       stat2(destination).then(({ size }) => size),
       sha256File(destination)
@@ -20467,17 +20621,17 @@ var installRelease = async (artifactPath, metadata, outputRoot) => {
     }
     return { artifactPath: destination, metadata: existing, releaseRoot };
   }
-  await mkdir6(dirname6(releaseRoot), { recursive: true });
-  const staging = await mkdtemp(join8(dirname6(releaseRoot), ".android-stage-"));
+  await mkdir7(dirname7(releaseRoot), { recursive: true });
+  const staging = await mkdtemp(join9(dirname7(releaseRoot), ".android-stage-"));
   try {
-    await copyFile(artifactPath, join8(staging, artifactName));
+    await copyFile(artifactPath, join9(staging, artifactName));
     const complete = {
       ...metadata,
       artifact: artifactName
     };
-    await writeFile8(join8(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+    await writeFile9(join9(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
 `, { flag: "wx" });
-    await rename7(staging, releaseRoot);
+    await rename8(staging, releaseRoot);
     return { artifactPath: destination, metadata: complete, releaseRoot };
   } finally {
     await rm4(staging, { force: true, recursive: true }).catch(() => {
@@ -20505,8 +20659,8 @@ var buildAbsoluteAndroidRelease = async (options) => {
   const projectRoot = resolve5(options.projectRoot);
   const host = options.host ?? detectAbsoluteMobileHost();
   const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host);
-  const nativeDirectory = join8(options.config.nativeProjectDirectory, "android");
-  const manifest = requireManifest(JSON.parse(await readFile9(join8(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  const nativeDirectory = join9(options.config.nativeProjectDirectory, "android");
+  const manifest = requireManifest(JSON.parse(await readFile10(join9(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
   if (manifest.appId !== options.config.appId) {
     throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
   }
@@ -20595,20 +20749,20 @@ var buildAbsoluteAndroidRelease = async (options) => {
 import { createHash as createHash3 } from "crypto";
 import {
   access as access6,
-  mkdir as mkdir7,
+  mkdir as mkdir8,
   mkdtemp as mkdtemp2,
-  readFile as readFile10,
-  rename as rename8,
+  readFile as readFile11,
+  rename as rename9,
   rm as rm5,
   stat as stat3,
-  writeFile as writeFile9
+  writeFile as writeFile10
 } from "fs/promises";
 import { homedir } from "os";
 import {
   basename,
-  dirname as dirname7,
+  dirname as dirname8,
   isAbsolute as isAbsolute3,
-  join as join9,
+  join as join10,
   relative as relative5,
   resolve as resolve6,
   sep as sep3
@@ -20662,7 +20816,10 @@ var parseAbsoluteAndroidInstalledApp = (appId, output) => {
 var ABSOLUTE_BUNDLETOOL_VERSION = "1.18.3";
 var ABSOLUTE_BUNDLETOOL_SHA256 = "a099cfa1543f55593bc2ed16a70a7c67fe54b1747bb7301f37fdfd6d91028e29";
 var ABSOLUTE_BUNDLETOOL_URL = `https://github.com/google/bundletool/releases/download/${ABSOLUTE_BUNDLETOOL_VERSION}/bundletool-all-${ABSOLUTE_BUNDLETOOL_VERSION}.jar`;
-var EMBEDDED_READY_MARKER = "Expo embedded web content ready";
+var EMBEDDED_READY_MARKERS = {
+  capacitor: "Capacitor embedded web content ready",
+  expo: "Expo embedded web content ready"
+};
 var RELEASE_READY_POLL_MS = 250;
 var RELEASE_READY_TIMEOUT_MS = 30000;
 var RELEASE_STABILITY_MS = 2000;
@@ -20675,7 +20832,7 @@ var exists2 = async (path) => {
     return false;
   }
 };
-var sha256 = async (path) => createHash3("sha256").update(await readFile10(path)).digest("hex");
+var sha256 = async (path) => createHash3("sha256").update(await readFile11(path)).digest("hex");
 var inside = (root, candidate) => {
   const path = relative5(resolve6(root), resolve6(candidate));
   return path === "" || !isAbsolute3(path) && path !== ".." && !path.startsWith(`..${sep3}`);
@@ -20717,7 +20874,7 @@ var parseMetadata = (value) => {
     throw new TypeError("Android release ID does not match its artifact digest.");
   return metadata;
 };
-var absoluteBundletoolPath = (root = process.env.ABSOLUTE_BUNDLETOOL_ROOT ?? join9(homedir(), ".absolutejs", "tools", "bundletool")) => join9(root, ABSOLUTE_BUNDLETOOL_VERSION, "bundletool.jar");
+var absoluteBundletoolPath = (root = process.env.ABSOLUTE_BUNDLETOOL_ROOT ?? join10(homedir(), ".absolutejs", "tools", "bundletool")) => join10(root, ABSOLUTE_BUNDLETOOL_VERSION, "bundletool.jar");
 var inspectAbsoluteBundletool = async (root) => {
   const path = absoluteBundletoolPath(root);
   if (!await exists2(path))
@@ -20731,9 +20888,9 @@ var readAbsoluteAndroidRelease = async (projectRoot, requested) => {
   const selected = resolve6(root, requested);
   if (!inside(root, selected))
     throw new TypeError("mobile test android --release must remain inside the project.");
-  const metadataPath = basename(selected) === "release.json" ? selected : join9(selected, "release.json");
-  const releaseRoot = dirname7(metadataPath);
-  const metadata = parseMetadata(JSON.parse(await readFile10(metadataPath, "utf8")));
+  const metadataPath = basename(selected) === "release.json" ? selected : join10(selected, "release.json");
+  const releaseRoot = dirname8(metadataPath);
+  const metadata = parseMetadata(JSON.parse(await readFile11(metadataPath, "utf8")));
   const artifactPath = resolve6(releaseRoot, metadata.artifact);
   if (!inside(releaseRoot, artifactPath) || basename(artifactPath) !== metadata.artifact)
     throw new TypeError("Android release artifact path is invalid.");
@@ -20761,12 +20918,12 @@ var ensureAbsoluteBundletool = async (options) => {
   const digest = createHash3("sha256").update(bytes).digest("hex");
   if (digest !== ABSOLUTE_BUNDLETOOL_SHA256)
     throw new TypeError("Downloaded Bundletool failed checksum verification.");
-  await mkdir7(dirname7(inspected.path), { recursive: true });
-  const staging = await mkdtemp2(join9(dirname7(inspected.path), ".install-"));
-  const candidate = join9(staging, "bundletool.jar");
+  await mkdir8(dirname8(inspected.path), { recursive: true });
+  const staging = await mkdtemp2(join10(dirname8(inspected.path), ".install-"));
+  const candidate = join10(staging, "bundletool.jar");
   try {
-    await writeFile9(candidate, bytes, { flag: "wx" });
-    await rename8(candidate, inspected.path).catch(async (error) => {
+    await writeFile10(candidate, bytes, { flag: "wx" });
+    await rename9(candidate, inspected.path).catch(async (error) => {
       if (await exists2(inspected.path))
         return;
       throw error;
@@ -20803,7 +20960,7 @@ var adb = (path, serial, ...args) => [
   serial,
   ...args
 ];
-var waitForMarker = async (run, adbPath, serial, appId, timeoutMs) => {
+var waitForMarker = async (run, adbPath, serial, appId, engine, timeoutMs) => {
   const startedAt = performance.now();
   const inspect = async () => {
     if (performance.now() - startedAt >= timeoutMs)
@@ -20814,9 +20971,9 @@ var waitForMarker = async (run, adbPath, serial, appId, timeoutMs) => {
     ]);
     if (process2.exitCode !== 0 || !process2.stdout.trim())
       throw new Error("The installed Android release exited before becoming ready.");
-    if (logs.stdout.includes(EMBEDDED_READY_MARKER))
+    if (logs.stdout.includes(EMBEDDED_READY_MARKERS[engine]))
       return;
-    const failedPhase = /Expo embedded web phase: (assets-(?:root|directory|destination|module|source|download|copy|read|write|finalize|unexpected)|devices)-failed/u.exec(logs.stdout)?.[1];
+    const failedPhase = engine === "expo" ? /Expo embedded web phase: (assets-(?:root|directory|destination|module|source|download|copy|read|write|finalize|unexpected)|devices)-failed/u.exec(logs.stdout)?.[1] : undefined;
     if (failedPhase)
       throw new Error(`The installed release could not initialize its embedded ${failedPhase} runtime offline.`);
     await Bun.sleep(RELEASE_READY_POLL_MS);
@@ -20834,14 +20991,12 @@ var launch = async (run, adbPath, serial, appId, launchUrl) => {
   return Math.round(performance.now() - startedAt);
 };
 var runAbsoluteAndroidReleaseAcceptance = async (options) => {
-  if (options.release.metadata.engine !== "expo")
-    throw new TypeError("Installed AAB release acceptance currently requires the Expo engine.");
   if (!options.serial.startsWith("emulator-"))
     throw new TypeError("Installed release acceptance changes network state and therefore requires an Android emulator.");
   const run = options.run ?? defaultRun;
   const startedAt = performance.now();
-  await mkdir7(options.artifactDirectory, { recursive: true });
-  const apksPath = join9(options.artifactDirectory, "release.apks");
+  await mkdir8(options.artifactDirectory, { recursive: true });
+  const apksPath = join10(options.artifactDirectory, "release.apks");
   const windowsJava = (options.host ?? detectAbsoluteMobileHost()) === "wsl" && options.java.toLowerCase().endsWith(".exe");
   const toolPath = async (path) => {
     if (!windowsJava)
@@ -20896,12 +21051,12 @@ var runAbsoluteAndroidReleaseAcceptance = async (options) => {
     ]);
     await requireSuccess(run, adb(options.adb, options.serial, "shell", "am", "force-stop", options.release.metadata.appId), "Android release stop");
     launchMs = await launch(run, options.adb, options.serial, options.release.metadata.appId, options.launchUrl);
-    await waitForMarker(run, options.adb, options.serial, options.release.metadata.appId, RELEASE_READY_TIMEOUT_MS);
+    await waitForMarker(run, options.adb, options.serial, options.release.metadata.appId, options.release.metadata.engine, RELEASE_READY_TIMEOUT_MS);
     await Bun.sleep(options.stabilityMs ?? RELEASE_STABILITY_MS);
     await requireSuccess(run, adb(options.adb, options.serial, "shell", "am", "force-stop", options.release.metadata.appId), "Android release relaunch stop");
     await requireSuccess(run, adb(options.adb, options.serial, "logcat", "-c"), "Android release relaunch log isolation");
     relaunchMs = await launch(run, options.adb, options.serial, options.release.metadata.appId, options.launchUrl);
-    await waitForMarker(run, options.adb, options.serial, options.release.metadata.appId, RELEASE_READY_TIMEOUT_MS);
+    await waitForMarker(run, options.adb, options.serial, options.release.metadata.appId, options.release.metadata.engine, RELEASE_READY_TIMEOUT_MS);
   } finally {
     await Promise.all([
       requireSuccess(run, adb(options.adb, options.serial, "shell", "svc", "wifi", wifi.stdout.trim() === "1" ? "enable" : "disable"), "Android Wi-Fi restore"),
@@ -20969,7 +21124,7 @@ var testAbsoluteIosPhysicalDevice = async (options) => {
 };
 
 // src/mobile/iosConformance.ts
-import { readFile as readFile11, stat as stat4 } from "fs/promises";
+import { readFile as readFile12, stat as stat4 } from "fs/promises";
 var HMR_LINE = new RegExp(String.raw`\[hmr:ios\]\s+([^\n]*?)\s+(applied in|falling back to reload after|failed after)\s+(\d+)ms(?:; server\s+(\d+)ms, client\s+(\d+)ms)?`, "u");
 var parseAbsoluteIosHmrLog = (line) => {
   const match = HMR_LINE.exec(line);
@@ -21007,7 +21162,7 @@ var waitForAbsoluteIosHmrLog = async (options) => {
     if (Date.now() > deadline)
       throw new Error(`No iOS native HMR acknowledgement was observed within ${timeoutMs}ms.`);
     options.signal?.throwIfAborted();
-    const contents = await readFile11(options.logPath).catch(() => Buffer.alloc(0));
+    const contents = await readFile12(options.logPath).catch(() => Buffer.alloc(0));
     if (contents.byteLength < offset) {
       offset = 0;
       buffered = "";
@@ -21028,8 +21183,8 @@ var waitForAbsoluteIosHmrLog = async (options) => {
 };
 
 // src/mobile/nativeTestReport.ts
-import { mkdir as mkdir8, readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
-import { join as join10 } from "path";
+import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile11 } from "fs/promises";
+import { join as join11 } from "path";
 var secretPattern = /(authorization|access[_ -]?token|refresh[_ -]?token|socket[_ -]?ticket|password|cookie)(\s*[=:]\s*)([^\s,;]+)/giu;
 var bearerPattern = /bearer\s+[^\s,;]+/giu;
 var coordinatePattern = /\b(latitude|longitude|lat|lng)(\s*[=:]\s*)-?\d+(?:\.\d+)?/giu;
@@ -21158,7 +21313,7 @@ var createAbsoluteNativeTestReport = (options) => ({
   run: options.run
 });
 var readPackageVersionForNativeReport = async (packageJsonPath) => {
-  const manifest = JSON.parse(await readFile12(packageJsonPath, "utf8"));
+  const manifest = JSON.parse(await readFile13(packageJsonPath, "utf8"));
   if (typeof manifest !== "object" || manifest === null)
     return "unknown";
   const version = Reflect.get(manifest, "version");
@@ -21196,13 +21351,13 @@ ${table(report.manualChecks)}
 `;
 };
 var writeAbsoluteNativeTestReport = async (directory, report) => {
-  await mkdir8(directory, { recursive: true });
-  const jsonPath = join10(directory, "report.json");
-  const markdownPath = join10(directory, "report.md");
+  await mkdir9(directory, { recursive: true });
+  const jsonPath = join11(directory, "report.json");
+  const markdownPath = join11(directory, "report.md");
   await Promise.all([
-    writeFile10(jsonPath, `${JSON.stringify(report, null, 2)}
+    writeFile11(jsonPath, `${JSON.stringify(report, null, 2)}
 `),
-    writeFile10(markdownPath, renderAbsoluteNativeTestReport(report))
+    writeFile11(markdownPath, renderAbsoluteNativeTestReport(report))
   ]);
   return { directory, jsonPath, markdownPath };
 };
@@ -21553,8 +21708,8 @@ var publishAbsoluteIosRelease = async (options) => {
 };
 
 // src/mobile/mobileInspect.ts
-import { access as access8, readFile as readFile13 } from "fs/promises";
-import { join as join11, relative as relative7, resolve as resolve8 } from "path";
+import { access as access8, readFile as readFile14 } from "fs/promises";
+import { join as join12, relative as relative7, resolve as resolve8 } from "path";
 var ABSOLUTE_MOBILE_INSPECTION_FORMAT = 1;
 var MOBILE_PACKAGE_NAMES = new Set([
   "@absolutejs/absolute",
@@ -21581,7 +21736,7 @@ var pathExists4 = async (path) => {
   }
 };
 var readObject2 = async (path) => {
-  const value = JSON.parse(await readFile13(path, "utf8"));
+  const value = JSON.parse(await readFile14(path, "utf8"));
   if (!isObject2(value))
     throw new TypeError("JSON root must be an object.");
   return value;
@@ -21593,13 +21748,13 @@ var addPackageDeclarations = (declarations, value) => {
     declarations.set(name, declared);
 };
 var packageInspections = async (projectRoot, additionalNames) => {
-  const project = await readObject2(join11(projectRoot, "package.json"));
+  const project = await readObject2(join12(projectRoot, "package.json"));
   const declarations = new Map;
   for (const field2 of ["dependencies", "devDependencies"])
     addPackageDeclarations(declarations, project[field2]);
   const names = [...new Set([...declarations.keys(), ...additionalNames])].filter((name) => MOBILE_PACKAGE_NAMES.has(name) || name.startsWith("@capacitor/") || additionalNames.includes(name)).sort();
   return Promise.all(names.map(async (name) => {
-    const installedManifest = await readObject2(join11(projectRoot, "node_modules", name, "package.json")).catch(() => {
+    const installedManifest = await readObject2(join12(projectRoot, "node_modules", name, "package.json")).catch(() => {
       return;
     });
     const installed = installedManifest?.version;
@@ -21658,7 +21813,7 @@ var inspectAbsoluteMobileProject = async (config, projectRoot, options = {}) =>
     },
     format: ABSOLUTE_MOBILE_INSPECTION_FORMAT,
     nativeProjects: await Promise.all(config.platforms.map(async (platform) => {
-      const path = join11(config.nativeProjectDirectory, platform);
+      const path = join12(config.nativeProjectDirectory, platform);
       return {
         initialized: await pathExists4(path),
         path: portablePath2(projectRoot, path),
@@ -21715,8 +21870,8 @@ var renderAbsoluteMobileProjectInspection = (report) => {
 
 // src/mobile/ciWorkflow.ts
 import { existsSync } from "fs";
-import { access as access9, mkdir as mkdir9, readFile as readFile14, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname8, extname as extname2, relative as relative8, resolve as resolve9, sep as sep5 } from "path";
+import { access as access9, mkdir as mkdir10, readFile as readFile15, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname9, extname as extname2, relative as relative8, resolve as resolve9, sep as sep5 } from "path";
 var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1;
 var SECRET_NAME_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
 var CI_ENV_INDENTATION = 6;
@@ -22191,12 +22346,12 @@ ${bundleAuditSteps}${platforms.includes("android") ? androidJob({ customSecrets,
 var writeAbsoluteMobileGithubWorkflow = async (options) => {
   const path = workflowOutputPath(options.projectRoot, options.outputPath);
   const generated = createAbsoluteMobileGithubWorkflow(options);
-  const previous = await exists3(path) ? await readFile14(path, "utf8") : undefined;
+  const previous = await exists3(path) ? await readFile15(path, "utf8") : undefined;
   if (previous !== undefined && previous !== generated.workflow && !options.force)
     throw new TypeError(`${relative8(options.projectRoot, path)} already exists and differs. Rerun with --force to replace the generated workflow.`);
   if (previous !== generated.workflow) {
-    await mkdir9(dirname8(path), { recursive: true });
-    await writeFile11(path, generated.workflow);
+    await mkdir10(dirname9(path), { recursive: true });
+    await writeFile12(path, generated.workflow);
   }
   return {
     changed: previous !== generated.workflow,
@@ -22212,23 +22367,23 @@ var writeAbsoluteMobileGithubWorkflow = async (options) => {
 import { createHash as createHash4, sign, verify } from "crypto";
 import {
   cp,
-  mkdir as mkdir10,
+  mkdir as mkdir11,
   mkdtemp as mkdtemp3,
-  readdir as readdir4,
-  readFile as readFile15,
-  rename as rename9,
+  readdir as readdir5,
+  readFile as readFile16,
+  rename as rename10,
   rm as rm6,
   stat as stat5,
-  writeFile as writeFile12
+  writeFile as writeFile13
 } from "fs/promises";
-import { dirname as dirname9, join as join12, relative as relative9, resolve as resolve10 } from "path";
+import { dirname as dirname10, join as join13, relative as relative9, resolve as resolve10 } from "path";
 var UPDATE_MANIFEST_FILE = "update.json";
 var UPDATE_FILES_DIRECTORY = "files";
 var sha2562 = (value) => createHash4("sha256").update(value).digest("hex");
 var listFiles = async (root, directory = root) => {
-  const entries = await readdir4(directory, { withFileTypes: true });
+  const entries = await readdir5(directory, { withFileTypes: true });
   const paths = await Promise.all(entries.map(async (entry) => {
-    const path = join12(directory, entry.name);
+    const path = join13(directory, entry.name);
     if (entry.isDirectory())
       return listFiles(root, path);
     if (!entry.isFile())
@@ -22238,10 +22393,10 @@ var listFiles = async (root, directory = root) => {
   return paths.flat().sort((left, right) => left.localeCompare(right));
 };
 var inspectFiles = async (root, paths) => Promise.all(paths.map(async (path) => {
-  const source = join12(root, path);
+  const source = join13(root, path);
   const [metadata, contents] = await Promise.all([
     stat5(source),
-    readFile15(source)
+    readFile16(source)
   ]);
   return { bytes: metadata.size, path, sha256: sha2562(contents) };
 }));
@@ -22276,17 +22431,17 @@ var buildAbsoluteMobileUpdate = async (options) => {
       value: signature.toString("base64")
     }
   });
-  await mkdir10(outputRoot, { recursive: true });
-  const outputDirectory = join12(outputRoot, manifest.releaseId);
-  const staging = await mkdtemp3(join12(outputRoot, ".stage-"));
+  await mkdir11(outputRoot, { recursive: true });
+  const outputDirectory = join13(outputRoot, manifest.releaseId);
+  const staging = await mkdtemp3(join13(outputRoot, ".stage-"));
   try {
-    await cp(bundleDirectory, join12(staging, UPDATE_FILES_DIRECTORY), {
+    await cp(bundleDirectory, join13(staging, UPDATE_FILES_DIRECTORY), {
       force: true,
       recursive: true
     });
-    await writeFile12(join12(staging, UPDATE_MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+    await writeFile13(join13(staging, UPDATE_MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `);
-    await rename9(staging, outputDirectory);
+    await rename10(staging, outputDirectory);
   } catch (error) {
     await rm6(staging, { force: true, recursive: true });
     if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "EEXIST")
@@ -22295,11 +22450,11 @@ var buildAbsoluteMobileUpdate = async (options) => {
   }
   return {
     manifest,
-    manifestPath: join12(outputDirectory, UPDATE_MANIFEST_FILE),
+    manifestPath: join13(outputDirectory, UPDATE_MANIFEST_FILE),
     outputDirectory
   };
 };
-var readAbsoluteMobileUpdate = async (directory) => parseAbsoluteMobileUpdateManifest(JSON.parse(await readFile15(join12(resolve10(directory), UPDATE_MANIFEST_FILE), "utf8")));
+var readAbsoluteMobileUpdate = async (directory) => parseAbsoluteMobileUpdateManifest(JSON.parse(await readFile16(join13(resolve10(directory), UPDATE_MANIFEST_FILE), "utf8")));
 var verifyAbsoluteMobileUpdateSignature = (manifestValue, publicKey) => {
   const manifest = parseAbsoluteMobileUpdateManifest(manifestValue);
   const valid = verify("sha256", absoluteMobileUpdateSigningPayload(unsignedAbsoluteMobileUpdate(manifest)), { dsaEncoding: "ieee-p1363", key: publicKey }, Buffer.from(manifest.signature.value, "base64"));
@@ -22309,8 +22464,8 @@ var verifyAbsoluteMobileUpdateSignature = (manifestValue, publicKey) => {
 };
 
 // src/mobile/expoUpdate.ts
-import { access as access10, mkdir as mkdir11, readFile as readFile16, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname10, extname as extname3, join as join13 } from "path";
+import { access as access10, mkdir as mkdir12, readFile as readFile17, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname11, extname as extname3, join as join14 } from "path";
 var ABSOLUTE_EXPO_UPDATE_DESCRIPTOR = "_absolute/expo-update.json";
 var ABSOLUTE_EXPO_UPDATE_FORMAT = 1;
 var object2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -22376,7 +22531,7 @@ var parseAbsoluteExpoUpdateDescriptor = (value) => {
   };
 };
 var finalizeAbsoluteExpoUpdateExport = async (options) => {
-  const metadata = JSON.parse(await readFile16(join13(options.exportDirectory, "metadata.json"), "utf8"));
+  const metadata = JSON.parse(await readFile17(join14(options.exportDirectory, "metadata.json"), "utf8"));
   if (!object2(metadata) || !object2(metadata.fileMetadata))
     throw new TypeError("Expo export metadata.json is invalid.");
   const descriptor = parseAbsoluteExpoUpdateDescriptor({
@@ -22387,20 +22542,20 @@ var finalizeAbsoluteExpoUpdateExport = async (options) => {
     runtimeVersion: options.runtimeVersion
   });
   const referenced = Object.values(descriptor.platforms).flatMap((entry) => entry ? [entry.launchAsset, ...entry.assets] : []);
-  await Promise.all(referenced.map(({ path }) => access10(join13(options.exportDirectory, path)).catch(() => {
+  await Promise.all(referenced.map(({ path }) => access10(join14(options.exportDirectory, path)).catch(() => {
     throw new TypeError(`Expo export metadata references missing asset ${path}.`);
   })));
-  const destination = join13(options.exportDirectory, ABSOLUTE_EXPO_UPDATE_DESCRIPTOR);
-  await mkdir11(dirname10(destination), { recursive: true });
-  await writeFile13(destination, `${JSON.stringify(descriptor, null, "\t")}
+  const destination = join14(options.exportDirectory, ABSOLUTE_EXPO_UPDATE_DESCRIPTOR);
+  await mkdir12(dirname11(destination), { recursive: true });
+  await writeFile14(destination, `${JSON.stringify(descriptor, null, "\t")}
 `);
   return { descriptor, path: destination };
 };
 
 // src/mobile/expoCodeSigning.ts
 var import_code_signing_certificates = __toESM(require_main(), 1);
-import { access as access11, mkdir as mkdir12, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute5, relative as relative10, resolve as resolve11, sep as sep6 } from "path";
+import { access as access11, mkdir as mkdir13, writeFile as writeFile15 } from "fs/promises";
+import { dirname as dirname12, isAbsolute as isAbsolute5, relative as relative10, resolve as resolve11, sep as sep6 } from "path";
 var exists4 = async (path) => access11(path).then(() => true).catch(() => false);
 var inside2 = (root, path) => {
   const location = relative10(root, path);
@@ -22410,7 +22565,7 @@ var generateAbsoluteExpoCodeSigning = async (options) => {
   const root = resolve11(options.projectRoot);
   const certificatePath = resolve11(root, options.certificatePath);
   const privateKeyPath = resolve11(root, options.privateKeyPath);
-  const publicKeyPath = resolve11(root, options.publicKeyPath ?? resolve11(dirname11(privateKeyPath), "public-key.pem"));
+  const publicKeyPath = resolve11(root, options.publicKeyPath ?? resolve11(dirname12(privateKeyPath), "public-key.pem"));
   if (!inside2(root, certificatePath))
     throw new TypeError("Expo code-signing certificate must be written inside the project so store builds can embed it.");
   if (inside2(root, privateKeyPath) || inside2(root, publicKeyPath))
@@ -22440,11 +22595,11 @@ var generateAbsoluteExpoCodeSigning = async (options) => {
   import_code_signing_certificates.validateSelfSignedCertificate(certificate, keyPair);
   const { privateKeyPEM, publicKeyPEM } = import_code_signing_certificates.convertKeyPairToPEM(keyPair);
   const certificatePem = import_code_signing_certificates.convertCertificateToCertificatePEM(certificate);
-  await Promise.all([certificatePath, privateKeyPath, publicKeyPath].map((path) => mkdir12(dirname11(path), { recursive: true })));
+  await Promise.all([certificatePath, privateKeyPath, publicKeyPath].map((path) => mkdir13(dirname12(path), { recursive: true })));
   await Promise.all([
-    writeFile14(certificatePath, certificatePem, { flag: "wx", mode: 420 }),
-    writeFile14(privateKeyPath, privateKeyPEM, { flag: "wx", mode: 384 }),
-    writeFile14(publicKeyPath, publicKeyPEM, { flag: "wx", mode: 420 })
+    writeFile15(certificatePath, certificatePem, { flag: "wx", mode: 420 }),
+    writeFile15(privateKeyPath, privateKeyPEM, { flag: "wx", mode: 384 }),
+    writeFile15(publicKeyPath, publicKeyPEM, { flag: "wx", mode: 420 })
   ]);
   return {
     certificatePath,
@@ -22672,7 +22827,7 @@ var CAPACITOR_SYNC_PACKAGE_SPECS = [
 ];
 var packageNameFromSpec = (spec) => spec.slice(0, spec.lastIndexOf("@"));
 var directProjectPackages = async (projectRoot) => {
-  const manifest = JSON.parse(await readFile17(join14(projectRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(await readFile18(join15(projectRoot, "package.json"), "utf8"));
   if (!isRecord7(manifest))
     throw new TypeError("Application package.json must contain an object.");
   const names = new Set;
@@ -22686,7 +22841,7 @@ var directProjectPackages = async (projectRoot) => {
 };
 var resolvedPackageVersion = async (projectRoot, packageName) => {
   try {
-    const manifest = JSON.parse(await readFile17(join14(projectRoot, "node_modules", packageName, "package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile18(join15(projectRoot, "node_modules", packageName, "package.json"), "utf8"));
     return isRecord7(manifest) && typeof manifest.version === "string" ? manifest.version : undefined;
   } catch {
     return;
@@ -22736,18 +22891,8 @@ var requireMobileConfig = (value) => {
   }
   return value;
 };
-var capacitorExecutable = async (projectRoot) => {
-  const executable = join14(projectRoot, "node_modules", ".bin", "cap");
-  try {
-    await access13(executable);
-    return executable;
-  } catch {
-    throw new TypeError(`Capacitor is not installed in this app. Run: bun add ${CAPACITOR_PACKAGES.join(" ")}`);
-  }
-};
 var runCapacitor = async (projectRoot, args) => {
-  const executable = await capacitorExecutable(projectRoot);
-  const process2 = Bun.spawn([executable, ...args], {
+  const process2 = Bun.spawn(["bun", "x", "--no-install", "cap", ...args], {
     cwd: projectRoot,
     stderr: "inherit",
     stdin: "inherit",
@@ -22755,12 +22900,12 @@ var runCapacitor = async (projectRoot, args) => {
   });
   const exitCode = await process2.exited;
   if (exitCode !== 0) {
-    throw new TypeError(`Capacitor exited with status ${exitCode}.`);
+    throw new TypeError(`Capacitor exited with status ${exitCode}. Ensure this app directly depends on: ${CAPACITOR_PACKAGES.join(" ")}`);
   }
 };
 var runCapacitorForPlatforms = (projectRoot, command, platforms) => platforms.reduce((pending, platform2) => pending.then(() => runCapacitor(projectRoot, [command, platform2])), Promise.resolve());
 var expoExecutable = async (project) => {
-  const executable = join14(project, "node_modules", ".bin", "expo");
+  const executable = join15(project, "node_modules", ".bin", "expo");
   try {
     await access13(executable);
     return executable;
@@ -22794,14 +22939,14 @@ var runExpo = async (project, args, options = {}) => {
 };
 var ensureExpoPackages = async (project, args) => {
   try {
-    const manifest = JSON.parse(await readFile17(join14(project, "package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile18(join15(project, "package.json"), "utf8"));
     const dependencies = typeof manifest === "object" && manifest !== null ? Reflect.get(manifest, "dependencies") : undefined;
     if (typeof dependencies !== "object" || dependencies === null || Array.isArray(dependencies))
       throw new TypeError("Generated Expo dependencies are invalid.");
     await Promise.all(Object.entries(dependencies).map(async ([name, expected]) => {
       if (typeof expected !== "string")
         throw new TypeError("Generated Expo dependency version is invalid.");
-      const installed = JSON.parse(await readFile17(join14(project, "node_modules", name, "package.json"), "utf8"));
+      const installed = JSON.parse(await readFile18(join15(project, "node_modules", name, "package.json"), "utf8"));
       const actual = typeof installed === "object" && installed !== null ? Reflect.get(installed, "version") : undefined;
       if (typeof actual !== "string")
         throw new TypeError("Installed Expo dependency version is invalid.");
@@ -22959,6 +23104,7 @@ var initialize = async (args) => {
   await applyAbsoluteNativeBackgroundSync(projectRoot, mobile);
   await applyAbsoluteNativeUpdates(mobile);
   await applyAbsoluteNativeObservability(mobile);
+  await applyAbsoluteNativeReleaseReadiness(mobile);
 };
 var sync = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
@@ -22994,6 +23140,7 @@ var sync = async (args) => {
   await applyAbsoluteNativeBackgroundSync(projectRoot, mobile, platforms);
   await applyAbsoluteNativeUpdates(mobile, platforms);
   await applyAbsoluteNativeObservability(mobile, platforms);
+  await applyAbsoluteNativeReleaseReadiness(mobile, platforms);
 };
 var associations = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
@@ -23160,9 +23307,9 @@ var prepareExpoMobileUpdateExport = async (options) => {
       temporaryDirectory: undefined
     };
   await ensureExpoPackages(mobile.nativeProjectDirectory, options.args);
-  const temporaryParent = join14(options.projectRoot, ".absolutejs", "mobile", "expo-update-exports");
-  await mkdir13(temporaryParent, { recursive: true });
-  const temporaryDirectory = await mkdtemp4(join14(temporaryParent, ".stage-"));
+  const temporaryParent = join15(options.projectRoot, ".absolutejs", "mobile", "expo-update-exports");
+  await mkdir14(temporaryParent, { recursive: true });
+  const temporaryDirectory = await mkdtemp4(join15(temporaryParent, ".stage-"));
   try {
     await runExpo(mobile.nativeProjectDirectory, [
       "export",
@@ -23174,7 +23321,7 @@ var prepareExpoMobileUpdateExport = async (options) => {
       temporaryDirectory,
       "--clear"
     ], { production: true });
-    const generatedApp = JSON.parse(await readFile17(join14(mobile.nativeProjectDirectory, "app.json"), "utf8"));
+    const generatedApp = JSON.parse(await readFile18(join15(mobile.nativeProjectDirectory, "app.json"), "utf8"));
     const expoConfig = isRecord7(generatedApp) ? generatedApp.expo : undefined;
     if (!isRecord7(expoConfig))
       throw new TypeError("Generated Expo app configuration is invalid.");
@@ -23217,11 +23364,11 @@ var buildMobileUpdate = async (args) => {
   let expoExportDirectory;
   try {
     await start(mobileBuildServerEntry(args), valueAfter(args, "--web-outdir"), configPath, { prepareOnly: true });
-    const embedded = JSON.parse(await readFile17(join14(mobile.bundleDirectory, "absolute-mobile-manifest.json"), "utf8"));
+    const embedded = JSON.parse(await readFile18(join15(mobile.bundleDirectory, "absolute-mobile-manifest.json"), "utf8"));
     const runtimeFingerprint = isRecord7(embedded) ? embedded.nativeRuntime : undefined;
     if (typeof runtimeFingerprint !== "string" || !/^[a-f0-9]{64}$/u.test(runtimeFingerprint))
       throw new TypeError("Prepared mobile bundle is missing its native runtime fingerprint.");
-    const privateKey = await readFile17(resolve13(projectRoot, signingKeyPath));
+    const privateKey = await readFile18(resolve13(projectRoot, signingKeyPath));
     const configuredPublicKey = Buffer.from(mobile.updates.publicKeys[keyId], "base64");
     const derivedPublicKey = createPublicKey2(privateKey).export({
       format: "der",
@@ -23242,7 +23389,7 @@ var buildMobileUpdate = async (args) => {
       channel: mobile.updates.channel,
       classification,
       keyId,
-      outputDirectory: valueAfter(args, "--outdir") ?? join14(projectRoot, ".absolutejs", "mobile", "updates"),
+      outputDirectory: valueAfter(args, "--outdir") ?? join15(projectRoot, ".absolutejs", "mobile", "updates"),
       privateKey,
       runtimeFingerprint
     });
@@ -23770,6 +23917,7 @@ var prepareCapacitorAndroidReleaseProject = async (mobile, projectRoot) => {
   await applyAbsoluteNativeBackgroundSync(projectRoot, mobile, ["android"]);
   await applyAbsoluteNativeUpdates(mobile, ["android"]);
   await applyAbsoluteNativeObservability(mobile, ["android"]);
+  await applyAbsoluteNativeReleaseReadiness(mobile, ["android"]);
 };
 var prepareAndroidReleaseProject = (mobile, projectRoot, args) => mobile.engine === "expo" ? prepareExpoAndroidReleaseProject(mobile, projectRoot, args) : prepareCapacitorAndroidReleaseProject(mobile, projectRoot);
 var buildAndroid = async (args, prepareVersionCode) => {
@@ -23821,7 +23969,7 @@ var buildAndroid = async (args, prepareVersionCode) => {
     const durationMs = Math.round(performance.now() - startedAt);
     console.log(`Built ${release.metadata.signed ? "signed" : "unsigned"} Android App Bundle in ${getDurationString(durationMs)}.`);
     console.log(`Artifact: ${release.artifactPath}`);
-    console.log(`Metadata: ${join14(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join15(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:android-release-build", {
@@ -23977,7 +24125,7 @@ var buildIos = async (args, prepareBuildNumber) => {
     const durationMs = Math.round(performance.now() - startedAt);
     console.log(`Built ${release.metadata.signed ? "signed" : "unsigned"} iOS IPA ${release.metadata.marketingVersion}${release.metadata.buildNumber ? ` (${release.metadata.buildNumber})` : ""} in ${getDurationString(durationMs)}.`);
     console.log(`Artifact: ${release.artifactPath}`);
-    console.log(`Metadata: ${join14(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join15(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     stopListeningForCancellation();
@@ -24089,7 +24237,7 @@ var appendSyncSchemaDoctorCheck = (checks, projectRoot) => {
     checks.push({
       id: "sync.storage-schema",
       label: `Offline schema ${schema.components.map((component) => `${component.id}@${component.version}`).join(", ")}`,
-      path: join14(projectRoot, "package.json"),
+      path: join15(projectRoot, "package.json"),
       platform: "host",
       status: "pass"
     });
@@ -24097,7 +24245,7 @@ var appendSyncSchemaDoctorCheck = (checks, projectRoot) => {
     checks.push({
       id: "sync.storage-schema",
       label: "Offline schema metadata is invalid",
-      path: join14(projectRoot, "package.json"),
+      path: join15(projectRoot, "package.json"),
       platform: "host",
       remediation: error instanceof Error ? error.message : String(error),
       status: "fail"
@@ -24308,12 +24456,12 @@ var waitForRequestedAndroidHmr = async (args, session, checks, timeoutMs) => {
   });
 };
 var writeAndroidFailureArtifacts = async (options) => {
-  await mkdir13(options.artifactRoot, { recursive: true });
-  const screenshot = options.session ? await options.session.screenshot(join14(options.artifactRoot, "android-failure.png")).catch(() => {
+  await mkdir14(options.artifactRoot, { recursive: true });
+  const screenshot = options.session ? await options.session.screenshot(join15(options.artifactRoot, "android-failure.png")).catch(() => {
     return;
   }) : undefined;
-  const diagnosticPath = join14(options.artifactRoot, "android-failure.json");
-  await writeFile15(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join15(options.artifactRoot, "android-failure.json");
+  await writeFile16(diagnosticPath, `${JSON.stringify({
     diagnostics: options.session?.diagnostics ?? [],
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "android",
@@ -24334,7 +24482,7 @@ var captureAndroidReleaseScreenshot = async (adb2, serial, destination) => {
   ]);
   if (exitCode !== 0)
     throw new Error(`Android release screenshot failed: ${stderr.trim() || `status ${exitCode}`}`);
-  await writeFile15(destination, bytes);
+  await writeFile16(destination, bytes);
   return destination;
 };
 var printAndroidReleaseAcceptance = (result, json) => {
@@ -24351,8 +24499,6 @@ var testAndroidRelease = async (args, mobile, projectRoot) => {
     throw new TypeError("mobile test android --release requires a release directory or release.json path.");
   if (!mobile.platforms.includes("android"))
     throw new TypeError("mobile test android requires android in mobile.platforms.");
-  if (mobile.engine !== "expo")
-    throw new TypeError("mobile test android --release currently requires mobile.engine: expo; use the ordinary test command for Capacitor.");
   const release = await readAbsoluteAndroidRelease(projectRoot, requested);
   if (release.metadata.appId !== mobile.appId)
     throw new TypeError(`Android release app ID ${release.metadata.appId} does not match mobile.appId ${mobile.appId}.`);
@@ -24390,7 +24536,7 @@ var testAndroidRelease = async (args, mobile, projectRoot) => {
       release,
       serial
     });
-    const screenshot = reportRoot ? await captureAndroidReleaseScreenshot(adb2, serial, join14(reportRoot, "android-release.png")) : undefined;
+    const screenshot = reportRoot ? await captureAndroidReleaseScreenshot(adb2, serial, join15(reportRoot, "android-release.png")) : undefined;
     sendTelemetryEvent("mobile:android-release-conformance", {
       durationMs: result.durationMs,
       engine: result.engine,
@@ -24437,9 +24583,9 @@ var testAndroidRelease = async (args, mobile, projectRoot) => {
       platform: "android",
       success: false
     });
-    await mkdir13(artifactRoot, { recursive: true });
-    const diagnosticPath = join14(artifactRoot, "android-release-failure.json");
-    await writeFile15(diagnosticPath, `${JSON.stringify({
+    await mkdir14(artifactRoot, { recursive: true });
+    const diagnosticPath = join15(artifactRoot, "android-release-failure.json");
+    await writeFile16(diagnosticPath, `${JSON.stringify({
       error: sanitizeNativeReportText(error instanceof Error ? error.message : String(error)),
       platform: "android",
       provider: mobile.engine,
@@ -24533,7 +24679,7 @@ var testAndroid = async (args) => {
       console.log(JSON.stringify(report, null, 2));
     else
       printAndroidTestReport(report);
-    const screenshot = reportRoot ? await session.screenshot(join14(artifactRoot, "android-emulator.png")) : undefined;
+    const screenshot = reportRoot ? await session.screenshot(join15(artifactRoot, "android-emulator.png")) : undefined;
     await writeRequestedAndroidReport({
       adb: adb2,
       args,
@@ -24732,8 +24878,8 @@ var requireCapturedCommand = (command, label) => {
   return result;
 };
 var writeIosFailureArtifacts = async (options) => {
-  await mkdir13(options.artifactRoot, { recursive: true });
-  const screenshot = join14(options.artifactRoot, "ios-failure.png");
+  await mkdir14(options.artifactRoot, { recursive: true });
+  const screenshot = join15(options.artifactRoot, "ios-failure.png");
   const screenshotResult = captureCommand3([
     options.xcrun,
     "simctl",
@@ -24742,8 +24888,8 @@ var writeIosFailureArtifacts = async (options) => {
     "screenshot",
     screenshot
   ]);
-  const diagnosticPath = join14(options.artifactRoot, "ios-failure.json");
-  await writeFile15(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join15(options.artifactRoot, "ios-failure.json");
+  await writeFile16(diagnosticPath, `${JSON.stringify({
     appId: options.appId,
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "ios",
@@ -24996,8 +25142,8 @@ var testIos = async (args) => {
       mobile.appId
     ], "iOS app launch");
     await waitForIosHmrClient({ https, port, timeoutMs });
-    await mkdir13(artifactRoot, { recursive: true });
-    const screenshot = join14(artifactRoot, "ios-simulator.png");
+    await mkdir14(artifactRoot, { recursive: true });
+    const screenshot = join15(artifactRoot, "ios-simulator.png");
     requireCapturedCommand([xcrun, "simctl", "io", simulator.udid, "screenshot", screenshot], "iOS simulator screenshot");
     const hmrApply = await waitForRequestedIosHmr(args, instance, timeoutMs);
     const report = {