@absolutejs/absolute 0.20.0-beta.100 → 0.20.0-beta.102

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

@@ -7,12 +7,12 @@ import {
 } from "./index-zh6hhrwy.js";
 import {
   start
-} from "./index-fdycyj4v.js";
+} from "./index-rvpd4w9t.js";
 import {
   ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
   ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
   resolveAbsoluteMobileRoute
-} from "./index-0bcf7pdw.js";
+} from "./index-6ff78meg.js";
 import"./index-bzs19w3r.js";
 import"./index-s2tazax7.js";
 import {
@@ -67,10 +67,10 @@ import {
   syncAbsoluteExpoWebAssets,
   unsignedAbsoluteMobileUpdate,
   writeAbsoluteExpoProject
-} from "./index-qd6mqgsc.js";
+} from "./index-d5fr1xp3.js";
 import {
   buildAbsoluteExpoAndroidWslBundle
-} from "./index-kr23b0fp.js";
+} from "./index-28nxv57v.js";
 import {
   normalizeAbsoluteIosDeviceIdentifier
 } from "./index-j66p8hn5.js";
@@ -88,6 +88,7 @@ import {
   writeAbsoluteCapacitorConfig
 } from "./index-28pbrd3q.js";
 import {
+  ABSOLUTE_ANDROID_AVD_NAME,
   absoluteManagedAndroidSdkRoot,
   detectAbsoluteMobileHost,
   inspectAbsoluteMobileToolchain
@@ -4411,9 +4412,9 @@ var require_sha256 = __commonJS(function(exports, module) {
   var forge = require_forge();
   require_md();
   require_util();
-  var sha2562 = module.exports = forge.sha256 = forge.sha256 || {};
-  forge.md.sha256 = forge.md.algorithms.sha256 = sha2562;
-  sha2562.create = function() {
+  var sha2563 = module.exports = forge.sha256 = forge.sha256 || {};
+  forge.md.sha256 = forge.md.algorithms.sha256 = sha2563;
+  sha2563.create = function() {
     if (!_initialized) {
       _init();
     }
@@ -16775,15 +16776,15 @@ var require_main = __commonJS(function(exports) {
 
 // src/cli/scripts/mobile.ts
 import {
-  access as access12,
-  mkdir as mkdir12,
-  mkdtemp as mkdtemp3,
-  readFile as readFile16,
-  rm as rm6,
-  writeFile as writeFile14
+  access as access13,
+  mkdir as mkdir13,
+  mkdtemp as mkdtemp4,
+  readFile as readFile17,
+  rm as rm7,
+  writeFile as writeFile15
 } from "fs/promises";
 import { createPublicKey as createPublicKey2 } from "crypto";
-import { join as join13, relative as relative11, resolve as resolve12 } from "path";
+import { join as join14, relative as relative12, resolve as resolve13 } from "path";
 import { createInterface } from "readline/promises";
 
 // src/mobile/nativeDeepLinks.ts
@@ -19495,7 +19496,7 @@ var writeAbsoluteMobileUpdateRegistry = async (options) => {
 
 // src/mobile/releaseDoctor.ts
 var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1;
-var HMR_ASSET_PATTERN = /(?:__HMR_WS__|hmr-timing|__absolute_target|absolutejs-error-overlay)/u;
+var HMR_ASSET_PATTERN = /(?:hmr-timing|__absolute_target|absolutejs-error-overlay)/u;
 var RELEASE_ASSET_EXTENSIONS = new Set([".html", ".js", ".mjs"]);
 var EXACT_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u;
 var NOT_FOUND3 = -1;
@@ -19641,12 +19642,48 @@ var expoVersionCheck = async (config) => {
     return fail("mobile.expo-versions", error instanceof Error ? error.message : "Generated Expo dependency versions could not be validated.", manifestPath, "Run `absolute mobile init --yes`, then rebuild the production Expo project.");
   }
 };
+var dependencyLockAt = async (directory) => (await Promise.all(LOCK_FILES.map(async (name) => ({
+  exists: await pathExists2(join7(directory, name)),
+  name,
+  path: join7(directory, name)
+})))).find(({ exists: exists2 }) => exists2);
+var declaredWorkspacePatterns = (declared) => {
+  if (Array.isArray(declared))
+    return declared;
+  if (isRecord3(declared) && Array.isArray(declared.packages))
+    return declared.packages;
+  return [];
+};
+var ownsWorkspace = async (directory, projectRoot) => {
+  const manifest = await readJsonObject(join7(directory, "package.json")).catch(() => {
+    return;
+  });
+  const workspacePath = relative3(directory, projectRoot).replace(/\\/gu, "/");
+  return declaredWorkspacePatterns(manifest?.workspaces).some((pattern) => typeof pattern === "string" && new Bun.Glob(pattern).match(workspacePath));
+};
+var ancestorDirectories = (projectRoot) => {
+  const directories = [];
+  let directory = projectRoot;
+  while (true) {
+    directories.push(directory);
+    const parent = dirname5(directory);
+    if (parent === directory)
+      return directories;
+    directory = parent;
+  }
+};
+var findAbsoluteDependencyLock = async (projectRoot) => {
+  const candidates = await Promise.all(ancestorDirectories(projectRoot).map(async (directory, index) => {
+    const present = await dependencyLockAt(directory);
+    if (!present || index > 0 && !await ownsWorkspace(directory, projectRoot))
+      return;
+    return present;
+  }));
+  return candidates.find((candidate) => candidate !== undefined);
+};
 var dependencyLockCheck = async (projectRoot) => {
-  const present = (await Promise.all(LOCK_FILES.map(async (name) => ({
-    exists: await pathExists2(join7(projectRoot, name)),
-    name
-  })))).find(({ exists: exists2 }) => exists2);
-  return present ? pass("mobile.dependency-lock", `Dependency graph is locked by ${present.name}.`, join7(projectRoot, present.name)) : fail("mobile.dependency-lock", "No supported dependency lockfile is present.", projectRoot, "Install dependencies with the project package manager and commit its lockfile before release.");
+  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.");
 };
 var productionOriginCheck = (config, projectRoot) => {
   const origin = new URL(config.productionOrigin);
@@ -19802,21 +19839,23 @@ var expoEmbeddedAssetsCheck = async (config) => {
       cwd: assetsRoot,
       onlyFiles: true
     }))).sort();
-    if (sourceFiles.length === 0 || sourceFiles.length !== embeddedFiles.length)
+    if (sourceFiles.length === 0 || embeddedFiles.length !== 1)
       throw new TypeError("Generated Expo asset count does not match the prepared mobile bundle.");
-    const matches = await Promise.all(sourceFiles.map(async (path, index) => {
-      const embedded = embeddedFiles[index];
-      if (!embedded)
-        return false;
-      const [left, right] = await Promise.all([
-        readFile8(join7(config.bundleDirectory, path)),
-        readFile8(join7(assetsRoot, embedded))
-      ]);
-      return left.equals(right);
-    }));
-    if (matches.some((value) => !value))
+    const contents = await Promise.all(sourceFiles.map((path) => readFile8(join7(config.bundleDirectory, path))));
+    let offset = 0;
+    const entries = sourceFiles.map((path, index) => {
+      const entry = {
+        length: contents[index]?.byteLength ?? 0,
+        offset,
+        path: path.replaceAll("\\", "/")
+      };
+      offset += entry.length;
+      return entry;
+    });
+    const archive = await readFile8(join7(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 ${embeddedFiles.length} opaque asset(s).`, generated);
+    return pass("expo.bundle-projection", `Expo embeds the complete signed mobile bundle as one opaque archive containing ${sourceFiles.length} file(s).`, generated);
   } catch (error) {
     return fail("expo.bundle-projection", error instanceof Error ? error.message : "Generated Expo assets could not be validated.", generated, "Run `absolute mobile build <platform>` to regenerate and verify the production asset projection.");
   }
@@ -20383,6 +20422,14 @@ var signAab = (artifactPath, capture, jarsigner, signing) => {
   if (result.exitCode !== 0)
     throw new TypeError("jarsigner could not sign the Android App Bundle with the configured CI identity.");
 };
+var windowsJarsignerPath = (path, capture) => {
+  const result = capture(["wslpath", "-w", path]);
+  const translated = result.stdout.trim();
+  if (result.exitCode !== 0 || !translated) {
+    throw new TypeError(`Could not translate an Android signing path for the Windows JDK: ${path}`);
+  }
+  return translated;
+};
 var sha256File = async (path) => createHash2("sha256").update(await readFile9(path)).digest("hex");
 var fingerprintExpoAndroidProject = async (nativeDirectory) => {
   const root = await realpath(nativeDirectory);
@@ -20500,13 +20547,19 @@ var buildAbsoluteAndroidRelease = async (options) => {
     throw new TypeError(`Android Gradle did not produce the expected App Bundle: ${artifactPath}`);
   }
   const capture = options.capture ?? defaultCapture;
-  const jarsigner = options.jarsigner === undefined ? Bun.which("jarsigner") : options.jarsigner;
-  let signed = verifyAabSignature(artifactPath, capture, jarsigner);
-  if (signed === false && options.signing) {
+  const jarsigner = options.jarsigner === undefined ? Bun.which("jarsigner") ?? (host === "wsl" || host === "windows" ? Bun.which("jarsigner.exe") : null) : options.jarsigner;
+  const usesWindowsJarsigner = host === "wsl" && jarsigner?.toLowerCase().endsWith(".exe");
+  const signerArtifactPath = usesWindowsJarsigner ? windowsJarsignerPath(artifactPath, capture) : artifactPath;
+  const signing = usesWindowsJarsigner && options.signing ? {
+    ...options.signing,
+    keystorePath: windowsJarsignerPath(options.signing.keystorePath, capture)
+  } : options.signing;
+  let signed = verifyAabSignature(signerArtifactPath, capture, jarsigner);
+  if (signed === false && signing) {
     if (!jarsigner)
       throw new TypeError("Could not sign the Android App Bundle because jarsigner is unavailable.");
-    signAab(artifactPath, capture, jarsigner, options.signing);
-    signed = verifyAabSignature(artifactPath, capture, jarsigner);
+    signAab(signerArtifactPath, capture, jarsigner, signing);
+    signed = verifyAabSignature(signerArtifactPath, capture, jarsigner);
     if (!signed)
       throw new TypeError("Android App Bundle signature verification failed after CI signing.");
   }
@@ -20538,6 +20591,343 @@ var buildAbsoluteAndroidRelease = async (options) => {
   return installRelease(artifactPath, metadata, safeOutputDirectory(projectRoot, options.outputDirectory));
 };
 
+// src/mobile/androidReleaseAcceptance.ts
+import { createHash as createHash3 } from "crypto";
+import {
+  access as access6,
+  mkdir as mkdir7,
+  mkdtemp as mkdtemp2,
+  readFile as readFile10,
+  rename as rename8,
+  rm as rm5,
+  stat as stat3,
+  writeFile as writeFile9
+} from "fs/promises";
+import { homedir } from "os";
+import {
+  basename,
+  dirname as dirname7,
+  isAbsolute as isAbsolute3,
+  join as join9,
+  relative as relative5,
+  resolve as resolve6,
+  sep as sep3
+} from "path";
+
+// src/mobile/androidUpgradeConformance.ts
+var captureCommand2 = async (command) => {
+  const process2 = Bun.spawn(command, { stderr: "pipe", stdout: "pipe" });
+  const [exitCode, stderr, stdout] = await Promise.all([
+    process2.exited,
+    new Response(process2.stderr).text(),
+    new Response(process2.stdout).text()
+  ]);
+  return { exitCode, stderr, stdout };
+};
+var field = (output, name) => new RegExp(`^\\s*${name}=([^\\r\\n]+)$`, "mu").exec(output)?.[1]?.trim();
+var inspectAbsoluteAndroidInstalledApp = async (adb, serial, appId, run = captureCommand2) => {
+  const result = await run([
+    adb,
+    "-s",
+    serial,
+    "shell",
+    "dumpsys",
+    "package",
+    appId
+  ]);
+  if (result.exitCode !== 0)
+    throw new Error(`Could not inspect installed Android app ${appId}: ${result.stderr.trim() || result.stdout.trim()}`);
+  const installed = parseAbsoluteAndroidInstalledApp(appId, result.stdout);
+  if (!installed)
+    throw new Error(`Android app ${appId} is not installed on ${serial}.`);
+  return installed;
+};
+var parseAbsoluteAndroidInstalledApp = (appId, output) => {
+  const packageName = /^\s*Package \[([^\]]+)\]/mu.exec(output)?.[1];
+  if (packageName !== appId && !output.includes(`package:${appId}`))
+    return null;
+  const versionCodeText = /^\s*versionCode=(\d+)/mu.exec(output)?.[1];
+  return {
+    appId,
+    ...field(output, "dataDir") ? { dataDirectory: field(output, "dataDir") } : {},
+    ...field(output, "firstInstallTime") ? { firstInstallTime: field(output, "firstInstallTime") } : {},
+    ...field(output, "lastUpdateTime") ? { lastUpdateTime: field(output, "lastUpdateTime") } : {},
+    ...field(output, "userId") || field(output, "appId") ? { uid: field(output, "userId") ?? field(output, "appId") } : {},
+    ...versionCodeText ? { versionCode: Number(versionCodeText) } : {},
+    ...field(output, "versionName") ? { versionName: field(output, "versionName") } : {}
+  };
+};
+
+// src/mobile/androidReleaseAcceptance.ts
+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 RELEASE_READY_POLL_MS = 250;
+var RELEASE_READY_TIMEOUT_MS = 30000;
+var RELEASE_STABILITY_MS = 2000;
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var exists2 = async (path) => {
+  try {
+    await access6(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var sha256 = async (path) => createHash3("sha256").update(await readFile10(path)).digest("hex");
+var inside = (root, candidate) => {
+  const path = relative5(resolve6(root), resolve6(candidate));
+  return path === "" || !isAbsolute3(path) && path !== ".." && !path.startsWith(`..${sep3}`);
+};
+var requireString2 = (value, name) => {
+  if (typeof value !== "string" || !value)
+    throw new TypeError(`Android release ${name} is invalid.`);
+  return value;
+};
+var parseMetadata = (value) => {
+  if (!isRecord5(value))
+    throw new TypeError("Android release metadata must contain an object.");
+  const { bytes } = value;
+  const { versionCode } = value;
+  if (!Number.isSafeInteger(bytes) || Number(bytes) < 1)
+    throw new TypeError("Android release bytes is invalid.");
+  if (versionCode !== undefined && (!Number.isSafeInteger(versionCode) || Number(versionCode) < 1))
+    throw new TypeError("Android release versionCode is invalid.");
+  if (value.format !== 1 || value.platform !== "android" || value.type !== "aab" || value.engine !== "capacitor" && value.engine !== "expo" || typeof value.signed !== "boolean")
+    throw new TypeError("Android release metadata contract is invalid.");
+  const metadata = {
+    appBuild: requireString2(value.appBuild, "appBuild"),
+    appId: requireString2(value.appId, "appId"),
+    artifact: requireString2(value.artifact, "artifact"),
+    bytes: Number(bytes),
+    engine: value.engine,
+    format: 1,
+    platform: "android",
+    releaseId: requireString2(value.releaseId, "releaseId"),
+    runtime: requireString2(value.runtime, "runtime"),
+    sha256: requireString2(value.sha256, "sha256"),
+    signed: value.signed,
+    type: "aab",
+    ...versionCode === undefined ? {} : { versionCode: Number(versionCode) }
+  };
+  if (!/^[a-f0-9]{64}$/u.test(metadata.sha256))
+    throw new TypeError("Android release sha256 is invalid.");
+  if (metadata.releaseId !== `amobile_android_${metadata.sha256}`)
+    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 inspectAbsoluteBundletool = async (root) => {
+  const path = absoluteBundletoolPath(root);
+  if (!await exists2(path))
+    return { path, ready: false };
+  if (await sha256(path) !== ABSOLUTE_BUNDLETOOL_SHA256)
+    throw new TypeError(`Managed Bundletool ${ABSOLUTE_BUNDLETOOL_VERSION} failed checksum verification. Remove ${path} and rerun the command.`);
+  return { path, ready: true };
+};
+var readAbsoluteAndroidRelease = async (projectRoot, requested) => {
+  const root = resolve6(projectRoot);
+  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 artifactPath = resolve6(releaseRoot, metadata.artifact);
+  if (!inside(releaseRoot, artifactPath) || basename(artifactPath) !== metadata.artifact)
+    throw new TypeError("Android release artifact path is invalid.");
+  const [artifactStat, artifactSha256] = await Promise.all([
+    stat3(artifactPath),
+    sha256(artifactPath)
+  ]);
+  if (artifactStat.size !== metadata.bytes || artifactSha256 !== metadata.sha256)
+    throw new TypeError(`Immutable Android release ${metadata.releaseId} is missing or modified.`);
+  return { artifactPath, metadata, metadataPath, releaseRoot };
+};
+var defaultDownload = async (url) => {
+  const response = await fetch(url);
+  if (!response.ok)
+    throw new Error(`Bundletool download failed (${response.status}).`);
+  return new Uint8Array(await response.arrayBuffer());
+};
+var ensureAbsoluteBundletool = async (options) => {
+  const inspected = await inspectAbsoluteBundletool(options.root);
+  if (inspected.ready)
+    return inspected.path;
+  if (!options.approved)
+    throw new TypeError(`Bundletool ${ABSOLUTE_BUNDLETOOL_VERSION} is required. Rerun with --yes to download the checksum-pinned official release.`);
+  const bytes = await (options.download ?? defaultDownload)(ABSOLUTE_BUNDLETOOL_URL);
+  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");
+  try {
+    await writeFile9(candidate, bytes, { flag: "wx" });
+    await rename8(candidate, inspected.path).catch(async (error) => {
+      if (await exists2(inspected.path))
+        return;
+      throw error;
+    });
+  } finally {
+    await rm5(staging, { force: true, recursive: true });
+  }
+  if (await sha256(inspected.path) !== ABSOLUTE_BUNDLETOOL_SHA256)
+    throw new TypeError("Installed Bundletool failed checksum verification.");
+  return inspected.path;
+};
+var defaultRun = async (command) => {
+  const process2 = Bun.spawn(command, {
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  const [exitCode, stderr, stdout] = await Promise.all([
+    process2.exited,
+    new Response(process2.stderr).text(),
+    new Response(process2.stdout).text()
+  ]);
+  return { exitCode, stderr, stdout };
+};
+var requireSuccess = async (run, command, label) => {
+  const result = await run(command);
+  if (result.exitCode !== 0)
+    throw new Error(`${label} failed: ${result.stderr.trim() || result.stdout.trim()}`);
+  return result;
+};
+var adb = (path, serial, ...args) => [
+  path,
+  "-s",
+  serial,
+  ...args
+];
+var waitForMarker = async (run, adbPath, serial, appId, timeoutMs) => {
+  const startedAt = performance.now();
+  const inspect = async () => {
+    if (performance.now() - startedAt >= timeoutMs)
+      throw new Error("The installed release launched but its embedded web content did not become ready offline.");
+    const [logs, process2] = await Promise.all([
+      run(adb(adbPath, serial, "logcat", "-d", "-s", "AbsoluteJS:I", "*:S")),
+      run(adb(adbPath, serial, "shell", "pidof", appId))
+    ]);
+    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))
+      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];
+    if (failedPhase)
+      throw new Error(`The installed release could not initialize its embedded ${failedPhase} runtime offline.`);
+    await Bun.sleep(RELEASE_READY_POLL_MS);
+    await inspect();
+  };
+  return inspect();
+};
+var launch = async (run, adbPath, serial, appId, launchUrl) => {
+  const resolved = await requireSuccess(run, adb(adbPath, serial, "shell", "cmd", "package", "resolve-activity", "--brief", appId), "Android launch activity discovery");
+  const activity = resolved.stdout.split(/\r?\n/u).map((line) => line.trim()).findLast((line) => line.includes("/"));
+  if (!activity)
+    throw new Error(`Android could not resolve a launch activity for ${appId}.`);
+  const startedAt = performance.now();
+  await requireSuccess(run, adb(adbPath, serial, "shell", "am", "start", "-W", "-n", activity, ...launchUrl ? ["-a", "android.intent.action.VIEW", "-d", launchUrl] : []), "Android release launch");
+  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");
+  const windowsJava = (options.host ?? detectAbsoluteMobileHost()) === "wsl" && options.java.toLowerCase().endsWith(".exe");
+  const toolPath = async (path) => {
+    if (!windowsJava)
+      return path;
+    const converted = await requireSuccess(run, ["wslpath", "-w", path], "Bundletool Windows path translation");
+    const translated = converted.stdout.trim();
+    if (!translated)
+      throw new Error(`Bundletool could not translate ${basename(path)} for the Windows JDK.`);
+    return translated;
+  };
+  const [bundletoolPath, artifactPath, outputPath, adbPath] = await Promise.all([
+    toolPath(options.bundletool),
+    toolPath(options.release.artifactPath),
+    toolPath(apksPath),
+    toolPath(options.adb)
+  ]);
+  await requireSuccess(run, [
+    options.java,
+    "-jar",
+    bundletoolPath,
+    "build-apks",
+    `--bundle=${artifactPath}`,
+    `--output=${outputPath}`,
+    "--mode=universal",
+    "--overwrite"
+  ], "Bundletool APK generation");
+  const installStartedAt = performance.now();
+  await requireSuccess(run, [
+    options.java,
+    "-jar",
+    bundletoolPath,
+    "install-apks",
+    `--apks=${outputPath}`,
+    `--adb=${adbPath}`,
+    `--device-id=${options.serial}`
+  ], "Bundletool release installation");
+  const installMs = Math.round(performance.now() - installStartedAt);
+  const installed = await inspectAbsoluteAndroidInstalledApp(options.adb, options.serial, options.release.metadata.appId, run);
+  if (options.release.metadata.versionCode !== undefined && installed.versionCode !== options.release.metadata.versionCode)
+    throw new Error(`Installed Android versionCode ${installed.versionCode ?? "unknown"} does not match release ${options.release.metadata.versionCode}.`);
+  await requireSuccess(run, adb(options.adb, options.serial, "logcat", "-c"), "Android release log isolation");
+  const [wifi, mobile] = await Promise.all([
+    requireSuccess(run, adb(options.adb, options.serial, "shell", "settings", "get", "global", "wifi_on"), "Android Wi-Fi state inspection"),
+    requireSuccess(run, adb(options.adb, options.serial, "shell", "settings", "get", "global", "mobile_data"), "Android mobile-data state inspection")
+  ]);
+  let launchMs;
+  let relaunchMs;
+  try {
+    await Promise.all([
+      requireSuccess(run, adb(options.adb, options.serial, "shell", "svc", "wifi", "disable"), "Android Wi-Fi disable"),
+      requireSuccess(run, adb(options.adb, options.serial, "shell", "svc", "data", "disable"), "Android mobile-data disable")
+    ]);
+    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 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);
+  } finally {
+    await Promise.all([
+      requireSuccess(run, adb(options.adb, options.serial, "shell", "svc", "wifi", wifi.stdout.trim() === "1" ? "enable" : "disable"), "Android Wi-Fi restore"),
+      requireSuccess(run, adb(options.adb, options.serial, "shell", "svc", "data", mobile.stdout.trim() === "1" ? "enable" : "disable"), "Android mobile-data restore")
+    ]);
+  }
+  return {
+    apksBytes: await stat3(apksPath).then(({ size }) => size),
+    artifactBytes: options.release.metadata.bytes,
+    artifactSha256: options.release.metadata.sha256,
+    durationMs: Math.round(performance.now() - startedAt),
+    embeddedOffline: true,
+    engine: options.release.metadata.engine,
+    installed: {
+      ...installed.versionCode === undefined ? {} : { versionCode: installed.versionCode },
+      ...installed.versionName === undefined ? {} : { versionName: installed.versionName }
+    },
+    installMs,
+    launchMs,
+    relaunchMs,
+    releaseId: options.release.metadata.releaseId,
+    signed: options.release.metadata.signed,
+    status: "pass"
+  };
+};
+
 // src/mobile/iosDeviceAcceptance.ts
 var absoluteIosDeviceAcceptanceCommands = (options) => {
   const xcrun = options.xcrun ?? "/usr/bin/xcrun";
@@ -20556,20 +20946,20 @@ var absoluteIosDeviceAcceptanceCommands = (options) => {
     ]
   };
 };
-var requireSuccess = (result, message) => {
+var requireSuccess2 = (result, message) => {
   if (result.exitCode !== 0)
     throw new Error(message);
   return result;
 };
 var testAbsoluteIosPhysicalDevice = async (options) => {
   const commands = absoluteIosDeviceAcceptanceCommands(options);
-  requireSuccess(await options.capture(commands.details), "The selected physical iOS device is unavailable. Pair it in Xcode Device Hub, trust this Mac, unlock it, and enable Developer Mode.");
-  const apps = requireSuccess(await options.capture(commands.apps), "AbsoluteJS could not inspect installed apps on the physical iOS device.");
+  requireSuccess2(await options.capture(commands.details), "The selected physical iOS device is unavailable. Pair it in Xcode Device Hub, trust this Mac, unlock it, and enable Developer Mode.");
+  const apps = requireSuccess2(await options.capture(commands.apps), "AbsoluteJS could not inspect installed apps on the physical iOS device.");
   if (!apps.stdout.includes(options.appId))
     throw new Error("The AbsoluteJS app is not installed on the selected physical iOS device. Start bun dev with the same --ios-device value first.");
   const now = options.now ?? performance.now.bind(performance);
   const startedAt = now();
-  requireSuccess(await options.capture(commands.launch), "AbsoluteJS could not relaunch the app on the physical iOS device.");
+  requireSuccess2(await options.capture(commands.launch), "AbsoluteJS could not relaunch the app on the physical iOS device.");
   await options.waitForHmr();
   return {
     hmrConnected: true,
@@ -20579,7 +20969,7 @@ var testAbsoluteIosPhysicalDevice = async (options) => {
 };
 
 // src/mobile/iosConformance.ts
-import { readFile as readFile10, stat as stat3 } from "fs/promises";
+import { readFile as readFile11, 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);
@@ -20611,13 +21001,13 @@ var waitForAbsoluteIosHmrLog = async (options) => {
   const sleep = options.sleep ?? Bun.sleep;
   const timeoutMs = options.timeoutMs ?? 30000;
   const deadline = Date.now() + timeoutMs;
-  let offset = options.startOffset ?? await stat3(options.logPath).then(({ size }) => size).catch(() => 0);
+  let offset = options.startOffset ?? await stat4(options.logPath).then(({ size }) => size).catch(() => 0);
   let buffered = "";
   const poll = async () => {
     if (Date.now() > deadline)
       throw new Error(`No iOS native HMR acknowledgement was observed within ${timeoutMs}ms.`);
     options.signal?.throwIfAborted();
-    const contents = await readFile10(options.logPath).catch(() => Buffer.alloc(0));
+    const contents = await readFile11(options.logPath).catch(() => Buffer.alloc(0));
     if (contents.byteLength < offset) {
       offset = 0;
       buffered = "";
@@ -20638,8 +21028,8 @@ var waitForAbsoluteIosHmrLog = async (options) => {
 };
 
 // src/mobile/nativeTestReport.ts
-import { mkdir as mkdir7, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
-import { join as join9 } from "path";
+import { mkdir as mkdir8, readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import { join as join10 } 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;
@@ -20663,6 +21053,14 @@ var createAbsoluteNativeAutomatedChecks = (run) => {
     artifactDetails = "Physical-device screen capture was intentionally skipped; use Xcode Device Hub for manual visual evidence.";
     artifactResult = "SKIPPED";
   }
+  let developmentDetails = run.status === "pass" ? `The app launched and connected to native HMR in ${run.durationMs}ms.${routeDetails}` : `The automated native run failed after ${run.durationMs}ms: ${run.error ?? "No error detail was available."}`;
+  if (run.release)
+    developmentDetails = run.status === "pass" ? `The ${run.release.engine} release was installed from its generated APK set, launched offline in ${run.release.launchMs}ms, and relaunched in ${run.release.relaunchMs}ms.` : `Installed ${run.release.engine} release acceptance failed after ${run.durationMs}ms.`;
+  let hmrDetails = "Correlated edit timing was not requested. Rerun with --wait-for-hmr.";
+  if (run.release)
+    hmrDetails = "HMR is intentionally not part of installed production-release acceptance.";
+  if (run.hmr)
+    hmrDetails = `Observed native HMR ${run.hmr.outcome} in ${run.hmr.durationMs}ms${run.hmr.serverMs === undefined ? "" : ` (server ${run.hmr.serverMs}ms, client ${run.hmr.clientMs}ms)`}.`;
   const checks = [
     {
       details: `Captured host, toolchain, Bun, and AbsoluteJS metadata for ${target}.`,
@@ -20670,13 +21068,13 @@ var createAbsoluteNativeAutomatedChecks = (run) => {
       result: "PASS"
     },
     {
-      details: run.status === "pass" ? `The app launched and connected to native HMR in ${run.durationMs}ms.${routeDetails}` : `The automated native run failed after ${run.durationMs}ms: ${run.error ?? "No error detail was available."}`,
+      details: developmentDetails,
       ...evidence ? { evidence } : {},
       id: "AUTO-DEV-01",
       result: run.status === "pass" ? "PASS" : "FAIL"
     },
     {
-      details: run.hmr ? `Observed native HMR ${run.hmr.outcome} in ${run.hmr.durationMs}ms${run.hmr.serverMs === undefined ? "" : ` (server ${run.hmr.serverMs}ms, client ${run.hmr.clientMs}ms)`}.` : "Correlated edit timing was not requested. Rerun with --wait-for-hmr.",
+      details: hmrDetails,
       id: "AUTO-HMR-01",
       result: hmrResult
     },
@@ -20687,6 +21085,17 @@ var createAbsoluteNativeAutomatedChecks = (run) => {
       result: artifactResult
     }
   ];
+  if (run.release) {
+    checks.push({
+      details: `Validated immutable release ${run.release.releaseId} (${run.release.artifactBytes} bytes, SHA-256 ${run.release.artifactSha256}); Bundletool produced a ${run.release.apksBytes}-byte APK set and installed it in ${run.release.installMs}ms.`,
+      id: "AUTO-RELEASE-01",
+      result: run.status === "pass" ? "PASS" : "FAIL"
+    }, {
+      details: run.release.embeddedOffline ? "The generated release rendered its embedded web content and survived a process relaunch with Wi-Fi and mobile data disabled." : "The generated release did not prove embedded offline rendering.",
+      id: "AUTO-RELEASE-OFFLINE-01",
+      result: run.release.embeddedOffline ? "PASS" : "FAIL"
+    });
+  }
   if (run.upgrade) {
     const { upgrade } = run;
     checks.push({
@@ -20749,7 +21158,7 @@ var createAbsoluteNativeTestReport = (options) => ({
   run: options.run
 });
 var readPackageVersionForNativeReport = async (packageJsonPath) => {
-  const manifest = JSON.parse(await readFile11(packageJsonPath, "utf8"));
+  const manifest = JSON.parse(await readFile12(packageJsonPath, "utf8"));
   if (typeof manifest !== "object" || manifest === null)
     return "unknown";
   const version = Reflect.get(manifest, "version");
@@ -20787,13 +21196,13 @@ ${table(report.manualChecks)}
 `;
 };
 var writeAbsoluteNativeTestReport = async (directory, report) => {
-  await mkdir7(directory, { recursive: true });
-  const jsonPath = join9(directory, "report.json");
-  const markdownPath = join9(directory, "report.md");
+  await mkdir8(directory, { recursive: true });
+  const jsonPath = join10(directory, "report.json");
+  const markdownPath = join10(directory, "report.md");
   await Promise.all([
-    writeFile9(jsonPath, `${JSON.stringify(report, null, 2)}
+    writeFile10(jsonPath, `${JSON.stringify(report, null, 2)}
 `),
-    writeFile9(markdownPath, renderAbsoluteNativeTestReport(report))
+    writeFile10(markdownPath, renderAbsoluteNativeTestReport(report))
   ]);
   return { directory, jsonPath, markdownPath };
 };
@@ -21021,6 +21430,8 @@ var MANUAL_CHECKS2 = [
     "Review this directory for sensitive content and complete every row."
   ]
 ];
+var portableAdbVersion = (version) => version.split(/\r?\n/u).filter((line) => !/^\s*(?:Installed as|Running on)\b/iu.test(line)).join(`
+`).trim();
 var createAbsoluteAndroidTestReport = (options) => {
   const { serial, ...run } = options.run;
   return createAbsoluteNativeTestReport({
@@ -21028,10 +21439,10 @@ var createAbsoluteAndroidTestReport = (options) => {
     manualChecks: MANUAL_CHECKS2,
     metadata: {
       absolutejsVersion: options.absolutejsVersion,
-      adbVersion: options.adbVersion,
+      adbVersion: portableAdbVersion(options.adbVersion),
       bunVersion: options.bunVersion,
       host: options.host,
-      provider: "capacitor"
+      provider: options.provider ?? "capacitor"
     },
     run: {
       ...run,
@@ -21043,8 +21454,8 @@ var createAbsoluteAndroidTestReport = (options) => {
 };
 
 // src/mobile/releasePublisher.ts
-import { access as access6 } from "fs/promises";
-import { isAbsolute as isAbsolute3, relative as relative5, resolve as resolve6, sep as sep3 } from "path";
+import { access as access7 } from "fs/promises";
+import { isAbsolute as isAbsolute4, relative as relative6, resolve as resolve7, sep as sep4 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -21067,24 +21478,24 @@ var prepareAbsoluteAndroidRelease = async (publisher, options) => {
   }
   return versionCode;
 };
-var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isPublisher = (value) => isRecord5(value) && typeof value.publish === "function";
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPublisher = (value) => isRecord6(value) && typeof value.publish === "function";
 var publisherModulePath = (projectRoot, requested) => {
-  const root = resolve6(projectRoot);
-  const path = resolve6(root, requested);
-  const projectRelative = relative5(root, path);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep3}`) || isAbsolute3(projectRelative)) {
+  const root = resolve7(projectRoot);
+  const path = resolve7(root, requested);
+  const projectRelative = relative6(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep4}`) || isAbsolute4(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
   return path;
 };
 var loadAbsoluteNativeReleasePublisher = async (projectRoot, requestedModulePath) => {
   const modulePath = publisherModulePath(projectRoot, requestedModulePath);
-  await access6(modulePath).catch(() => {
+  await access7(modulePath).catch(() => {
     throw new TypeError(`Native release registry module does not exist: ${modulePath}`);
   });
   const loaded = await import(pathToFileURL2(modulePath).href);
-  const publisher = isRecord5(loaded) ? loaded.default ?? loaded.registry : undefined;
+  const publisher = isRecord6(loaded) ? loaded.default ?? loaded.registry : undefined;
   if (!isPublisher(publisher)) {
     throw new TypeError("Native release registry module must default-export a registry with publish(options).");
   }
@@ -21142,8 +21553,8 @@ var publishAbsoluteIosRelease = async (options) => {
 };
 
 // src/mobile/mobileInspect.ts
-import { access as access7, readFile as readFile12 } from "fs/promises";
-import { join as join10, relative as relative6, resolve as resolve7 } from "path";
+import { access as access8, readFile as readFile13 } from "fs/promises";
+import { join as join11, relative as relative7, resolve as resolve8 } from "path";
 var ABSOLUTE_MOBILE_INSPECTION_FORMAT = 1;
 var MOBILE_PACKAGE_NAMES = new Set([
   "@absolutejs/absolute",
@@ -21158,19 +21569,19 @@ var MOBILE_PACKAGE_NAMES = new Set([
 ]);
 var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var portablePath2 = (projectRoot, path) => {
-  const value = relative6(resolve7(projectRoot), resolve7(path)).replaceAll("\\", "/");
+  const value = relative7(resolve8(projectRoot), resolve8(path)).replaceAll("\\", "/");
   return value || ".";
 };
 var pathExists4 = async (path) => {
   try {
-    await access7(path);
+    await access8(path);
     return true;
   } catch {
     return false;
   }
 };
 var readObject2 = async (path) => {
-  const value = JSON.parse(await readFile12(path, "utf8"));
+  const value = JSON.parse(await readFile13(path, "utf8"));
   if (!isObject2(value))
     throw new TypeError("JSON root must be an object.");
   return value;
@@ -21182,13 +21593,13 @@ var addPackageDeclarations = (declarations, value) => {
     declarations.set(name, declared);
 };
 var packageInspections = async (projectRoot, additionalNames) => {
-  const project = await readObject2(join10(projectRoot, "package.json"));
+  const project = await readObject2(join11(projectRoot, "package.json"));
   const declarations = new Map;
-  for (const field of ["dependencies", "devDependencies"])
-    addPackageDeclarations(declarations, project[field]);
+  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(join10(projectRoot, "node_modules", name, "package.json")).catch(() => {
+    const installedManifest = await readObject2(join11(projectRoot, "node_modules", name, "package.json")).catch(() => {
       return;
     });
     const installed = installedManifest?.version;
@@ -21247,7 +21658,7 @@ var inspectAbsoluteMobileProject = async (config, projectRoot, options = {}) =>
     },
     format: ABSOLUTE_MOBILE_INSPECTION_FORMAT,
     nativeProjects: await Promise.all(config.platforms.map(async (platform) => {
-      const path = join10(config.nativeProjectDirectory, platform);
+      const path = join11(config.nativeProjectDirectory, platform);
       return {
         initialized: await pathExists4(path),
         path: portablePath2(projectRoot, path),
@@ -21304,8 +21715,8 @@ var renderAbsoluteMobileProjectInspection = (report) => {
 
 // src/mobile/ciWorkflow.ts
 import { existsSync } from "fs";
-import { access as access8, mkdir as mkdir8, readFile as readFile13, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname7, extname as extname2, relative as relative7, resolve as resolve8, sep as sep4 } from "path";
+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";
 var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1;
 var SECRET_NAME_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
 var CI_ENV_INDENTATION = 6;
@@ -21324,34 +21735,34 @@ var RESERVED_SECRET_NAMES = new Set([
   "APP_STORE_CONNECT_KEY_ID",
   "APP_STORE_CONNECT_PRIVATE_KEY_BASE64"
 ]);
-var exists2 = async (path) => {
+var exists3 = async (path) => {
   try {
-    await access8(path);
+    await access9(path);
     return true;
   } catch {
     return false;
   }
 };
 var yamlString = (value) => `'${value.replaceAll("'", "''")}'`;
-var projectPath2 = (projectRoot, value, field, options = {}) => {
-  const root = resolve8(projectRoot);
-  const path = resolve8(root, value);
-  const portable = relative7(root, path).replaceAll("\\", "/");
-  if (portable === ".." || portable.startsWith(`..${sep4}`) || portable.startsWith("../") || portable === "") {
-    throw new TypeError(`${field} must remain inside the project root.`);
+var projectPath2 = (projectRoot, value, field2, options = {}) => {
+  const root = resolve9(projectRoot);
+  const path = resolve9(root, value);
+  const portable = relative8(root, path).replaceAll("\\", "/");
+  if (portable === ".." || portable.startsWith(`..${sep5}`) || portable.startsWith("../") || portable === "") {
+    throw new TypeError(`${field2} must remain inside the project root.`);
   }
   if (/\r|\n/u.test(portable) || portable.startsWith("-"))
-    throw new TypeError(`${field} contains an unsafe path.`);
+    throw new TypeError(`${field2} contains an unsafe path.`);
   if (!options.allowMissing && !existsSync(path))
-    throw new TypeError(`${field} does not exist inside the project.`);
+    throw new TypeError(`${field2} does not exist inside the project.`);
   return portable;
 };
 var workflowOutputPath = (projectRoot, value) => {
-  const root = resolve8(projectRoot);
-  const workflows = resolve8(root, ".github/workflows");
-  const path = resolve8(root, value ?? ".github/workflows/absolute-mobile.yml");
-  const portable = relative7(workflows, path);
-  if (portable === ".." || portable.startsWith(`..${sep4}`) || extname2(path) !== ".yml" && extname2(path) !== ".yaml") {
+  const root = resolve9(projectRoot);
+  const workflows = resolve9(root, ".github/workflows");
+  const path = resolve9(root, value ?? ".github/workflows/absolute-mobile.yml");
+  const portable = relative8(workflows, path);
+  if (portable === ".." || portable.startsWith(`..${sep5}`) || extname2(path) !== ".yml" && extname2(path) !== ".yaml") {
     throw new TypeError("mobile ci github --output must be a .yml or .yaml file inside .github/workflows.");
   }
   return path;
@@ -21780,12 +22191,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 exists2(path) ? await readFile13(path, "utf8") : undefined;
+  const previous = await exists3(path) ? await readFile14(path, "utf8") : undefined;
   if (previous !== undefined && previous !== generated.workflow && !options.force)
-    throw new TypeError(`${relative7(options.projectRoot, path)} already exists and differs. Rerun with --force to replace the generated workflow.`);
+    throw new TypeError(`${relative8(options.projectRoot, path)} already exists and differs. Rerun with --force to replace the generated workflow.`);
   if (previous !== generated.workflow) {
-    await mkdir8(dirname7(path), { recursive: true });
-    await writeFile10(path, generated.workflow);
+    await mkdir9(dirname8(path), { recursive: true });
+    await writeFile11(path, generated.workflow);
   }
   return {
     changed: previous !== generated.workflow,
@@ -21798,46 +22209,46 @@ var writeAbsoluteMobileGithubWorkflow = async (options) => {
 };
 
 // src/mobile/updateSigning.ts
-import { createHash as createHash3, sign, verify } from "crypto";
+import { createHash as createHash4, sign, verify } from "crypto";
 import {
   cp,
-  mkdir as mkdir9,
-  mkdtemp as mkdtemp2,
+  mkdir as mkdir10,
+  mkdtemp as mkdtemp3,
   readdir as readdir4,
-  readFile as readFile14,
-  rename as rename8,
-  rm as rm5,
-  stat as stat4,
-  writeFile as writeFile11
+  readFile as readFile15,
+  rename as rename9,
+  rm as rm6,
+  stat as stat5,
+  writeFile as writeFile12
 } from "fs/promises";
-import { dirname as dirname8, join as join11, relative as relative8, resolve as resolve9 } from "path";
+import { dirname as dirname9, join as join12, relative as relative9, resolve as resolve10 } from "path";
 var UPDATE_MANIFEST_FILE = "update.json";
 var UPDATE_FILES_DIRECTORY = "files";
-var sha256 = (value) => createHash3("sha256").update(value).digest("hex");
+var sha2562 = (value) => createHash4("sha256").update(value).digest("hex");
 var listFiles = async (root, directory = root) => {
   const entries = await readdir4(directory, { withFileTypes: true });
   const paths = await Promise.all(entries.map(async (entry) => {
-    const path = join11(directory, entry.name);
+    const path = join12(directory, entry.name);
     if (entry.isDirectory())
       return listFiles(root, path);
     if (!entry.isFile())
       throw new TypeError("Mobile updates cannot contain links or special files.");
-    return [relative8(root, path).replaceAll("\\", "/")];
+    return [relative9(root, path).replaceAll("\\", "/")];
   }));
   return paths.flat().sort((left, right) => left.localeCompare(right));
 };
 var inspectFiles = async (root, paths) => Promise.all(paths.map(async (path) => {
-  const source = join11(root, path);
+  const source = join12(root, path);
   const [metadata, contents] = await Promise.all([
-    stat4(source),
-    readFile14(source)
+    stat5(source),
+    readFile15(source)
   ]);
-  return { bytes: metadata.size, path, sha256: sha256(contents) };
+  return { bytes: metadata.size, path, sha256: sha2562(contents) };
 }));
-var releaseIdFor = (value) => `amu_${sha256(canonicalizeAbsoluteMobileUpdate(value))}`;
+var releaseIdFor = (value) => `amu_${sha2562(canonicalizeAbsoluteMobileUpdate(value))}`;
 var buildAbsoluteMobileUpdate = async (options) => {
-  const bundleDirectory = resolve9(options.bundleDirectory);
-  const outputRoot = resolve9(options.outputDirectory);
+  const bundleDirectory = resolve10(options.bundleDirectory);
+  const outputRoot = resolve10(options.outputDirectory);
   if (outputRoot === bundleDirectory || outputRoot.startsWith(`${bundleDirectory}/`))
     throw new TypeError("Mobile update output must be outside the embedded bundle.");
   const paths = await listFiles(bundleDirectory);
@@ -21865,30 +22276,30 @@ var buildAbsoluteMobileUpdate = async (options) => {
       value: signature.toString("base64")
     }
   });
-  await mkdir9(outputRoot, { recursive: true });
-  const outputDirectory = join11(outputRoot, manifest.releaseId);
-  const staging = await mkdtemp2(join11(outputRoot, ".stage-"));
+  await mkdir10(outputRoot, { recursive: true });
+  const outputDirectory = join12(outputRoot, manifest.releaseId);
+  const staging = await mkdtemp3(join12(outputRoot, ".stage-"));
   try {
-    await cp(bundleDirectory, join11(staging, UPDATE_FILES_DIRECTORY), {
+    await cp(bundleDirectory, join12(staging, UPDATE_FILES_DIRECTORY), {
       force: true,
       recursive: true
     });
-    await writeFile11(join11(staging, UPDATE_MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+    await writeFile12(join12(staging, UPDATE_MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `);
-    await rename8(staging, outputDirectory);
+    await rename9(staging, outputDirectory);
   } catch (error) {
-    await rm5(staging, { force: true, recursive: true });
+    await rm6(staging, { force: true, recursive: true });
     if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "EEXIST")
       throw new TypeError(`Mobile update ${manifest.releaseId} already exists.`, { cause: error });
     throw error;
   }
   return {
     manifest,
-    manifestPath: join11(outputDirectory, UPDATE_MANIFEST_FILE),
+    manifestPath: join12(outputDirectory, UPDATE_MANIFEST_FILE),
     outputDirectory
   };
 };
-var readAbsoluteMobileUpdate = async (directory) => parseAbsoluteMobileUpdateManifest(JSON.parse(await readFile14(join11(resolve9(directory), UPDATE_MANIFEST_FILE), "utf8")));
+var readAbsoluteMobileUpdate = async (directory) => parseAbsoluteMobileUpdateManifest(JSON.parse(await readFile15(join12(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"));
@@ -21898,17 +22309,17 @@ var verifyAbsoluteMobileUpdateSignature = (manifestValue, publicKey) => {
 };
 
 // src/mobile/expoUpdate.ts
-import { access as access9, mkdir as mkdir10, readFile as readFile15, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname9, extname as extname3, join as join12 } from "path";
+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";
 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);
-var safePath = (value, field) => {
+var safePath = (value, field2) => {
   if (typeof value !== "string" || value.length === 0)
-    throw new TypeError(`Expo update ${field} is invalid.`);
+    throw new TypeError(`Expo update ${field2} is invalid.`);
   const path = value.replaceAll("\\", "/");
   if (path.startsWith("/") || path.split("/").some((segment) => !segment || segment === "." || segment === ".."))
-    throw new TypeError(`Expo update ${field} must be a relative path.`);
+    throw new TypeError(`Expo update ${field2} must be a relative path.`);
   return path;
 };
 var extension = (value, path) => {
@@ -21965,7 +22376,7 @@ var parseAbsoluteExpoUpdateDescriptor = (value) => {
   };
 };
 var finalizeAbsoluteExpoUpdateExport = async (options) => {
-  const metadata = JSON.parse(await readFile15(join12(options.exportDirectory, "metadata.json"), "utf8"));
+  const metadata = JSON.parse(await readFile16(join13(options.exportDirectory, "metadata.json"), "utf8"));
   if (!object2(metadata) || !object2(metadata.fileMetadata))
     throw new TypeError("Expo export metadata.json is invalid.");
   const descriptor = parseAbsoluteExpoUpdateDescriptor({
@@ -21976,33 +22387,33 @@ 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 }) => access9(join12(options.exportDirectory, path)).catch(() => {
+  await Promise.all(referenced.map(({ path }) => access10(join13(options.exportDirectory, path)).catch(() => {
     throw new TypeError(`Expo export metadata references missing asset ${path}.`);
   })));
-  const destination = join12(options.exportDirectory, ABSOLUTE_EXPO_UPDATE_DESCRIPTOR);
-  await mkdir10(dirname9(destination), { recursive: true });
-  await writeFile12(destination, `${JSON.stringify(descriptor, null, "\t")}
+  const destination = join13(options.exportDirectory, ABSOLUTE_EXPO_UPDATE_DESCRIPTOR);
+  await mkdir11(dirname10(destination), { recursive: true });
+  await writeFile13(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 access10, mkdir as mkdir11, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname10, isAbsolute as isAbsolute4, relative as relative9, resolve as resolve10, sep as sep5 } from "path";
-var exists3 = async (path) => access10(path).then(() => true).catch(() => false);
-var inside = (root, path) => {
-  const location = relative9(root, path);
-  return location === "" || location !== ".." && !location.startsWith(`..${sep5}`) && !isAbsolute4(location);
+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";
+var exists4 = async (path) => access11(path).then(() => true).catch(() => false);
+var inside2 = (root, path) => {
+  const location = relative10(root, path);
+  return location === "" || location !== ".." && !location.startsWith(`..${sep6}`) && !isAbsolute5(location);
 };
 var generateAbsoluteExpoCodeSigning = async (options) => {
-  const root = resolve10(options.projectRoot);
-  const certificatePath = resolve10(root, options.certificatePath);
-  const privateKeyPath = resolve10(root, options.privateKeyPath);
-  const publicKeyPath = resolve10(root, options.publicKeyPath ?? resolve10(dirname10(privateKeyPath), "public-key.pem"));
-  if (!inside(root, certificatePath))
+  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"));
+  if (!inside2(root, certificatePath))
     throw new TypeError("Expo code-signing certificate must be written inside the project so store builds can embed it.");
-  if (inside(root, privateKeyPath) || inside(root, publicKeyPath))
+  if (inside2(root, privateKeyPath) || inside2(root, publicKeyPath))
     throw new TypeError("Expo code-signing private/public key output must remain outside the project and source control.");
   const commonName = options.commonName.trim();
   if (!commonName || commonName.length > 64)
@@ -22011,7 +22422,7 @@ var generateAbsoluteExpoCodeSigning = async (options) => {
   if (!Number.isSafeInteger(validityYears) || validityYears < 1 || validityYears > 20)
     throw new TypeError("Expo code-signing validity must be an integer from 1 through 20 years.");
   const collisions = (await Promise.all([certificatePath, privateKeyPath, publicKeyPath].map(async (path) => ({
-    exists: await exists3(path),
+    exists: await exists4(path),
     path
   })))).filter((entry) => entry.exists);
   if (collisions.length > 0)
@@ -22029,11 +22440,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) => mkdir11(dirname10(path), { recursive: true })));
+  await Promise.all([certificatePath, privateKeyPath, publicKeyPath].map((path) => mkdir12(dirname11(path), { recursive: true })));
   await Promise.all([
-    writeFile13(certificatePath, certificatePem, { flag: "wx", mode: 420 }),
-    writeFile13(privateKeyPath, privateKeyPEM, { flag: "wx", mode: 384 }),
-    writeFile13(publicKeyPath, publicKeyPEM, { flag: "wx", mode: 420 })
+    writeFile14(certificatePath, certificatePem, { flag: "wx", mode: 420 }),
+    writeFile14(privateKeyPath, privateKeyPEM, { flag: "wx", mode: 384 }),
+    writeFile14(publicKeyPath, publicKeyPEM, { flag: "wx", mode: 420 })
   ]);
   return {
     certificatePath,
@@ -22044,8 +22455,8 @@ var generateAbsoluteExpoCodeSigning = async (options) => {
 };
 
 // src/mobile/updatePublisher.ts
-import { access as access11 } from "fs/promises";
-import { isAbsolute as isAbsolute5, relative as relative10, resolve as resolve11, sep as sep6 } from "path";
+import { access as access12 } from "fs/promises";
+import { isAbsolute as isAbsolute6, relative as relative11, resolve as resolve12, sep as sep7 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 var lifecycleMethod = (publisher, name) => {
   const method = publisher[name];
@@ -22154,16 +22565,16 @@ var pruneAbsoluteMobileUpdates = async (options) => {
 var object3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isPublisher2 = (value) => object3(value) && typeof value.publishUpdate === "function" && typeof value.promoteUpdate === "function" && typeof value.rollbackUpdate === "function";
 var projectPath3 = (projectRoot, requested, label) => {
-  const root = resolve11(projectRoot);
-  const path = resolve11(root, requested);
-  const projectRelative = relative10(root, path);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute5(projectRelative))
+  const root = resolve12(projectRoot);
+  const path = resolve12(root, requested);
+  const projectRelative = relative11(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep7}`) || isAbsolute6(projectRelative))
     throw new TypeError(`${label} must remain inside the project.`);
   return path;
 };
 var loadAbsoluteMobileUpdatePublisher = async (projectRoot, requestedModulePath) => {
   const modulePath = projectPath3(projectRoot, requestedModulePath, "mobile update registry");
-  await access11(modulePath).catch(() => {
+  await access12(modulePath).catch(() => {
     throw new TypeError(`Mobile update registry does not exist: ${modulePath}`);
   });
   const loaded = await import(pathToFileURL3(modulePath).href);
@@ -22216,10 +22627,12 @@ var rollbackAbsoluteMobileUpdate = async (options) => {
 
 // src/cli/scripts/mobile.ts
 var NOT_FOUND4 = -1;
-var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var ANDROID_EMULATOR_BOOT_POLL_MS = 500;
+var ANDROID_EMULATOR_BOOT_TIMEOUT_MS = 180000;
+var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var expoPublicConfig = (config) => {
   const result = { ...config };
-  if (!isRecord6(result.updates))
+  if (!isRecord7(result.updates))
     return result;
   const {
     codeSigningCertificate: _codeSigningCertificate,
@@ -22259,13 +22672,13 @@ var CAPACITOR_SYNC_PACKAGE_SPECS = [
 ];
 var packageNameFromSpec = (spec) => spec.slice(0, spec.lastIndexOf("@"));
 var directProjectPackages = async (projectRoot) => {
-  const manifest = JSON.parse(await readFile16(join13(projectRoot, "package.json"), "utf8"));
-  if (!isRecord6(manifest))
+  const manifest = JSON.parse(await readFile17(join14(projectRoot, "package.json"), "utf8"));
+  if (!isRecord7(manifest))
     throw new TypeError("Application package.json must contain an object.");
   const names = new Set;
-  for (const field of ["dependencies", "devDependencies"]) {
-    const dependencies = Reflect.get(manifest, field);
-    if (isRecord6(dependencies))
+  for (const field2 of ["dependencies", "devDependencies"]) {
+    const dependencies = Reflect.get(manifest, field2);
+    if (isRecord7(dependencies))
       for (const name of Object.keys(dependencies))
         names.add(name);
   }
@@ -22273,8 +22686,8 @@ var directProjectPackages = async (projectRoot) => {
 };
 var resolvedPackageVersion = async (projectRoot, packageName) => {
   try {
-    const manifest = JSON.parse(await readFile16(join13(projectRoot, "node_modules", packageName, "package.json"), "utf8"));
-    return isRecord6(manifest) && typeof manifest.version === "string" ? manifest.version : undefined;
+    const manifest = JSON.parse(await readFile17(join14(projectRoot, "node_modules", packageName, "package.json"), "utf8"));
+    return isRecord7(manifest) && typeof manifest.version === "string" ? manifest.version : undefined;
   } catch {
     return;
   }
@@ -22324,9 +22737,9 @@ var requireMobileConfig = (value) => {
   return value;
 };
 var capacitorExecutable = async (projectRoot) => {
-  const executable = join13(projectRoot, "node_modules", ".bin", "cap");
+  const executable = join14(projectRoot, "node_modules", ".bin", "cap");
   try {
-    await access12(executable);
+    await access13(executable);
     return executable;
   } catch {
     throw new TypeError(`Capacitor is not installed in this app. Run: bun add ${CAPACITOR_PACKAGES.join(" ")}`);
@@ -22347,9 +22760,9 @@ var runCapacitor = async (projectRoot, args) => {
 };
 var runCapacitorForPlatforms = (projectRoot, command, platforms) => platforms.reduce((pending, platform2) => pending.then(() => runCapacitor(projectRoot, [command, platform2])), Promise.resolve());
 var expoExecutable = async (project) => {
-  const executable = join13(project, "node_modules", ".bin", "expo");
+  const executable = join14(project, "node_modules", ".bin", "expo");
   try {
-    await access12(executable);
+    await access13(executable);
     return executable;
   } catch {
     throw new TypeError("Expo dependencies are not installed in the generated shell. Run `absolute mobile init --yes`.");
@@ -22381,14 +22794,14 @@ var runExpo = async (project, args, options = {}) => {
 };
 var ensureExpoPackages = async (project, args) => {
   try {
-    const manifest = JSON.parse(await readFile16(join13(project, "package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile17(join14(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 readFile16(join13(project, "node_modules", name, "package.json"), "utf8"));
+      const installed = JSON.parse(await readFile17(join14(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.");
@@ -22515,7 +22928,7 @@ var unpairRemoteMac = async (args) => {
 var initialize = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
   if (mobile.engine === "expo") {
-    console.warn("Experimental: Expo Android builds and publishing are available; iOS releases and physical-device acceptance are not complete.");
+    console.warn("Experimental: Expo Android and iOS release automation is available; real macOS and physical-device acceptance remains pending.");
     const generated2 = await writeAbsoluteExpoProject(mobile, {
       force: args.includes("--force"),
       projectRoot
@@ -22584,7 +22997,7 @@ var sync = async (args) => {
 };
 var associations = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
-  const outputDirectory = resolve12(projectRoot, valueAfter(args, "--outdir") ?? ".absolutejs/mobile/associations");
+  const outputDirectory = resolve13(projectRoot, valueAfter(args, "--outdir") ?? ".absolutejs/mobile/associations");
   if (args.includes("--verify")) {
     const result2 = await verifyAbsoluteMobileAssociationFiles(mobile);
     console.log(`Verified ${result2.results.length} hosted association files`);
@@ -22636,7 +23049,7 @@ var generateGithubCi = async (args) => {
   const publicResult = {
     changed: result.changed,
     format: result.format,
-    path: relative11(projectRoot, result.path).replaceAll("\\", "/"),
+    path: relative12(projectRoot, result.path).replaceAll("\\", "/"),
     platforms: result.platforms,
     publishing: result.publishing,
     requiredSecrets: result.requiredSecrets
@@ -22747,9 +23160,9 @@ var prepareExpoMobileUpdateExport = async (options) => {
       temporaryDirectory: undefined
     };
   await ensureExpoPackages(mobile.nativeProjectDirectory, options.args);
-  const temporaryParent = join13(options.projectRoot, ".absolutejs", "mobile", "expo-update-exports");
-  await mkdir12(temporaryParent, { recursive: true });
-  const temporaryDirectory = await mkdtemp3(join13(temporaryParent, ".stage-"));
+  const temporaryParent = join14(options.projectRoot, ".absolutejs", "mobile", "expo-update-exports");
+  await mkdir13(temporaryParent, { recursive: true });
+  const temporaryDirectory = await mkdtemp4(join14(temporaryParent, ".stage-"));
   try {
     await runExpo(mobile.nativeProjectDirectory, [
       "export",
@@ -22761,9 +23174,9 @@ var prepareExpoMobileUpdateExport = async (options) => {
       temporaryDirectory,
       "--clear"
     ], { production: true });
-    const generatedApp = JSON.parse(await readFile16(join13(mobile.nativeProjectDirectory, "app.json"), "utf8"));
-    const expoConfig = isRecord6(generatedApp) ? generatedApp.expo : undefined;
-    if (!isRecord6(expoConfig))
+    const generatedApp = JSON.parse(await readFile17(join14(mobile.nativeProjectDirectory, "app.json"), "utf8"));
+    const expoConfig = isRecord7(generatedApp) ? generatedApp.expo : undefined;
+    if (!isRecord7(expoConfig))
       throw new TypeError("Generated Expo app configuration is invalid.");
     const publicExpoConfig = expoPublicConfig(expoConfig);
     const computedRuntime = resolveAbsoluteMobileUpdateRuntime(mobile, options.projectRoot).fingerprint;
@@ -22779,7 +23192,7 @@ var prepareExpoMobileUpdateExport = async (options) => {
       temporaryDirectory
     };
   } catch (error) {
-    await rm6(temporaryDirectory, { force: true, recursive: true });
+    await rm7(temporaryDirectory, { force: true, recursive: true });
     throw error;
   }
 };
@@ -22804,11 +23217,11 @@ var buildMobileUpdate = async (args) => {
   let expoExportDirectory;
   try {
     await start(mobileBuildServerEntry(args), valueAfter(args, "--web-outdir"), configPath, { prepareOnly: true });
-    const embedded = JSON.parse(await readFile16(join13(mobile.bundleDirectory, "absolute-mobile-manifest.json"), "utf8"));
-    const runtimeFingerprint = isRecord6(embedded) ? embedded.nativeRuntime : undefined;
+    const embedded = JSON.parse(await readFile17(join14(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 readFile16(resolve12(projectRoot, signingKeyPath));
+    const privateKey = await readFile17(resolve13(projectRoot, signingKeyPath));
     const configuredPublicKey = Buffer.from(mobile.updates.publicKeys[keyId], "base64");
     const derivedPublicKey = createPublicKey2(privateKey).export({
       format: "der",
@@ -22829,7 +23242,7 @@ var buildMobileUpdate = async (args) => {
       channel: mobile.updates.channel,
       classification,
       keyId,
-      outputDirectory: valueAfter(args, "--outdir") ?? join13(projectRoot, ".absolutejs", "mobile", "updates"),
+      outputDirectory: valueAfter(args, "--outdir") ?? join14(projectRoot, ".absolutejs", "mobile", "updates"),
       privateKey,
       runtimeFingerprint
     });
@@ -22841,7 +23254,7 @@ var buildMobileUpdate = async (args) => {
     return result;
   } finally {
     if (expoExportDirectory)
-      await rm6(expoExportDirectory, { force: true, recursive: true });
+      await rm7(expoExportDirectory, { force: true, recursive: true });
     sendTelemetryEvent("mobile:update-build", {
       classification: classification ?? "invalid",
       durationMs: Math.round(performance.now() - startedAt),
@@ -22871,7 +23284,7 @@ var generateExpoUpdateSigning = async (args) => {
     ...valueAfter(args, "--public-key") ? { publicKeyPath: valueAfter(args, "--public-key") } : {},
     ...validityYears === undefined ? {} : { validityYears }
   });
-  const certificatePath = relative11(projectRoot, result.certificatePath).replaceAll("\\", "/");
+  const certificatePath = relative12(projectRoot, result.certificatePath).replaceAll("\\", "/");
   sendTelemetryEvent("mobile:update-code-signing-generated", {
     engine: "expo",
     validityYears: validityYears ?? 10
@@ -22933,7 +23346,7 @@ var provisionMobileUpdate = async (args) => {
     publicKeys: mobile.updates.publicKeys,
     storage: requestedStorage
   });
-  console.log(`Provisioned ${requestedStorage === "local" ? "local development" : "durable S3-compatible"} mobile update storage in ${relative11(projectRoot, path).replaceAll("\\", "/")}.`);
+  console.log(`Provisioned ${requestedStorage === "local" ? "local development" : "durable S3-compatible"} mobile update storage in ${relative12(projectRoot, path).replaceAll("\\", "/")}.`);
   if (requestedStorage === "local")
     console.log("Production release checks will require durable storage. Re-run with --storage s3 --force before deploying.");
   else
@@ -23375,8 +23788,10 @@ var buildAndroid = async (args, prepareVersionCode) => {
       phaseSuccess = true;
       return result;
     } finally {
+      const durationMs = Math.round(performance.now() - phaseStartedAt);
+      console.log(`[mobile:android-release] ${phase} ${phaseSuccess ? "completed" : "failed"} in ${getDurationString(durationMs)}`);
       sendTelemetryEvent("mobile:android-release-phase", {
-        durationMs: Math.round(performance.now() - phaseStartedAt),
+        durationMs,
         engine: mobile.engine,
         host,
         phase,
@@ -23406,7 +23821,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: ${join13(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join14(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:android-release-build", {
@@ -23562,7 +23977,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: ${join13(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join14(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     stopListeningForCancellation();
@@ -23674,7 +24089,7 @@ var appendSyncSchemaDoctorCheck = (checks, projectRoot) => {
     checks.push({
       id: "sync.storage-schema",
       label: `Offline schema ${schema.components.map((component) => `${component.id}@${component.version}`).join(", ")}`,
-      path: join13(projectRoot, "package.json"),
+      path: join14(projectRoot, "package.json"),
       platform: "host",
       status: "pass"
     });
@@ -23682,7 +24097,7 @@ var appendSyncSchemaDoctorCheck = (checks, projectRoot) => {
     checks.push({
       id: "sync.storage-schema",
       label: "Offline schema metadata is invalid",
-      path: join13(projectRoot, "package.json"),
+      path: join14(projectRoot, "package.json"),
       platform: "host",
       remediation: error instanceof Error ? error.message : String(error),
       status: "fail"
@@ -23749,7 +24164,7 @@ AbsoluteJS can configure ${installPlatform} emulation:`);
 Emulator setup verification:`);
   printDoctorChecks(result.checks.filter((check) => check.platform === "host" || check.platform === installPlatform));
 };
-var captureCommand2 = (command) => {
+var captureCommand3 = (command) => {
   const result = Bun.spawnSync(command, {
     stderr: "pipe",
     stdin: "ignore",
@@ -23770,7 +24185,7 @@ var requireAndroidTestPort = (args, projectRoot) => {
     }
     return { https: args.includes("--https"), port };
   }
-  const instances = listLiveInstances().filter((instance2) => resolve12(instance2.cwd) === resolve12(projectRoot) && instance2.source === "dev" && instance2.port !== null);
+  const instances = listLiveInstances().filter((instance2) => resolve13(instance2.cwd) === resolve13(projectRoot) && instance2.source === "dev" && instance2.port !== null);
   if (instances.length !== 1) {
     throw new TypeError(instances.length === 0 ? "No running AbsoluteJS dev server was found for this project. Start `bun dev`, wait for Android to report ready, then run `absolute mobile test android`." : "Multiple dev servers are running for this project. Select one with mobile test android --port <port>.");
   }
@@ -23792,14 +24207,14 @@ var androidTestTimeout = (args) => {
 };
 var requireAndroidAdb = async () => {
   const checks = await inspectAbsoluteMobileToolchain();
-  const adb = checks.find((check) => check.id === "android.adb" && check.status === "pass")?.path;
-  if (!adb) {
+  const adb2 = checks.find((check) => check.id === "android.adb" && check.status === "pass")?.path;
+  if (!adb2) {
     throw new TypeError("Android Debug Bridge is unavailable. Run `absolute mobile doctor android --fix`.");
   }
-  return adb;
+  return adb2;
 };
-var selectAndroidSerial = (adb, explicitSerial) => {
-  const devices = captureCommand2([adb, "devices"]);
+var selectAndroidSerial = (adb2, explicitSerial) => {
+  const devices = captureCommand3([adb2, "devices"]);
   if (devices.exitCode !== 0) {
     throw new Error(`Could not list Android targets: ${devices.stderr.trim() || devices.stdout.trim()}`);
   }
@@ -23816,9 +24231,56 @@ var selectAndroidSerial = (adb, explicitSerial) => {
   }
   return selected;
 };
+var selectOrStartAndroidReleaseEmulator = async (adb2, emulator, explicitSerial, json) => {
+  if (explicitSerial)
+    return selectAndroidSerial(adb2, explicitSerial);
+  const current = captureCommand3([adb2, "devices"]);
+  const ready = current.exitCode === 0 ? parseAdbDevices(current.stdout).find((serial) => serial.startsWith("emulator-")) : undefined;
+  if (ready)
+    return ready;
+  if (!emulator)
+    throw new TypeError("Android Emulator is unavailable. Run `absolute mobile doctor android --fix`.");
+  (json ? console.error : console.log)(`Starting managed Android emulator ${ABSOLUTE_ANDROID_AVD_NAME}\u2026`);
+  const launched = Bun.spawn([
+    emulator,
+    "-avd",
+    ABSOLUTE_ANDROID_AVD_NAME,
+    "-netdelay",
+    "none",
+    "-netspeed",
+    "full"
+  ], { stderr: "ignore", stdin: "ignore", stdout: "ignore" });
+  launched.unref();
+  const startedAt = performance.now();
+  const bootedSerial = () => {
+    const devices = captureCommand3([adb2, "devices"]);
+    const serial = devices.exitCode === 0 ? parseAdbDevices(devices.stdout).find((candidate) => candidate.startsWith("emulator-")) : undefined;
+    if (!serial)
+      return;
+    const booted = captureCommand3([
+      adb2,
+      "-s",
+      serial,
+      "shell",
+      "getprop",
+      "sys.boot_completed"
+    ]);
+    return booted.exitCode === 0 && booted.stdout.trim() === "1" ? serial : undefined;
+  };
+  const waitForBoot = async () => {
+    if (performance.now() - startedAt >= ANDROID_EMULATOR_BOOT_TIMEOUT_MS)
+      throw new Error(`Managed Android emulator ${ABSOLUTE_ANDROID_AVD_NAME} did not finish booting within 180 seconds.`);
+    const serial = bootedSerial();
+    if (serial)
+      return serial;
+    await Bun.sleep(ANDROID_EMULATOR_BOOT_POLL_MS);
+    return waitForBoot();
+  };
+  return waitForBoot();
+};
 var safeArtifactRoot = (projectRoot, value) => {
-  const root = resolve12(projectRoot, value ?? ".absolutejs/mobile/test-artifacts");
-  if (root !== projectRoot && !root.startsWith(`${resolve12(projectRoot)}/`)) {
+  const root = resolve13(projectRoot, value ?? ".absolutejs/mobile/test-artifacts");
+  if (root !== projectRoot && !root.startsWith(`${resolve13(projectRoot)}/`)) {
     throw new TypeError("mobile test --artifacts must remain inside the project.");
   }
   return root;
@@ -23846,12 +24308,12 @@ var waitForRequestedAndroidHmr = async (args, session, checks, timeoutMs) => {
   });
 };
 var writeAndroidFailureArtifacts = async (options) => {
-  await mkdir12(options.artifactRoot, { recursive: true });
-  const screenshot = options.session ? await options.session.screenshot(join13(options.artifactRoot, "android-failure.png")).catch(() => {
+  await mkdir13(options.artifactRoot, { recursive: true });
+  const screenshot = options.session ? await options.session.screenshot(join14(options.artifactRoot, "android-failure.png")).catch(() => {
     return;
   }) : undefined;
-  const diagnosticPath = join13(options.artifactRoot, "android-failure.json");
-  await writeFile14(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join14(options.artifactRoot, "android-failure.json");
+  await writeFile15(diagnosticPath, `${JSON.stringify({
     diagnostics: options.session?.diagnostics ?? [],
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "android",
@@ -23863,16 +24325,171 @@ var writeAndroidFailureArtifacts = async (options) => {
 `);
   return { diagnosticPath, screenshot };
 };
+var captureAndroidReleaseScreenshot = async (adb2, serial, destination) => {
+  const process2 = Bun.spawn([adb2, "-s", serial, "exec-out", "screencap", "-p"], { stderr: "pipe", stdin: "ignore", stdout: "pipe" });
+  const [exitCode, bytes, stderr] = await Promise.all([
+    process2.exited,
+    new Response(process2.stdout).bytes(),
+    new Response(process2.stderr).text()
+  ]);
+  if (exitCode !== 0)
+    throw new Error(`Android release screenshot failed: ${stderr.trim() || `status ${exitCode}`}`);
+  await writeFile15(destination, bytes);
+  return destination;
+};
+var printAndroidReleaseAcceptance = (result, json) => {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`\u2713 Installed immutable ${result.engine} release ${result.releaseId} with Bundletool in ${getDurationString(result.installMs)}.`);
+  console.log(`\u2713 Embedded web content booted offline in ${getDurationString(result.launchMs)} and relaunched in ${getDurationString(result.relaunchMs)}.`);
+};
+var testAndroidRelease = async (args, mobile, projectRoot) => {
+  const requested = valueAfter(args, "--release");
+  if (!requested || requested.startsWith("--"))
+    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}.`);
+  if (release.metadata.engine !== mobile.engine)
+    throw new TypeError(`Android release engine ${release.metadata.engine} does not match configured engine ${mobile.engine}.`);
+  if (mobile.engine === "expo" && mobile.expoNativeRoutes[mobile.entry])
+    throw new TypeError("Offline Expo release acceptance requires mobile.entry to be an embedded web route; the configured entry is native and requires trusted server page data.");
+  const checks = await inspectAbsoluteMobileToolchain();
+  const adb2 = checks.find((check) => check.id === "android.adb" && check.status === "pass")?.path;
+  const java = checks.find((check) => check.id === "android.java" && check.status === "pass")?.path;
+  const emulator = checks.find((check) => check.id === "android.emulator" && check.status === "pass")?.path;
+  if (!adb2)
+    throw new TypeError("Android Debug Bridge is unavailable. Run `absolute mobile doctor android --fix`.");
+  if (!java)
+    throw new TypeError("Java is unavailable. Install the JDK required by the Android toolchain and rerun `absolute mobile doctor android`.");
+  const serial = await selectOrStartAndroidReleaseEmulator(adb2, emulator, valueAfter(args, "--serial"), args.includes("--json"));
+  const inspectedBundletool = await inspectAbsoluteBundletool();
+  const approved = inspectedBundletool.ready || args.includes("--yes") || await confirmInstall(`Bundletool ${ABSOLUTE_BUNDLETOOL_VERSION} is required to install the exact App Bundle. Download and checksum-verify it now?`);
+  const bundletool = await ensureAbsoluteBundletool({
+    approved: approved === true
+  });
+  const reportRoot = nativeReportRoot(args, projectRoot, "android");
+  const artifactRoot = reportRoot ?? safeArtifactRoot(projectRoot, valueAfter(args, "--artifacts") ?? `.absolutejs/mobile/test-artifacts/${release.metadata.releaseId}`);
+  const startedAt = performance.now();
+  try {
+    const result = await runAbsoluteAndroidReleaseAcceptance({
+      adb: adb2,
+      artifactDirectory: artifactRoot,
+      bundletool,
+      host: detectAbsoluteMobileHost(),
+      java,
+      ...mobile.deepLinkScheme ? {
+        launchUrl: `${mobile.deepLinkScheme}://${mobile.entry}`
+      } : {},
+      release,
+      serial
+    });
+    const screenshot = reportRoot ? await captureAndroidReleaseScreenshot(adb2, serial, join14(reportRoot, "android-release.png")) : undefined;
+    sendTelemetryEvent("mobile:android-release-conformance", {
+      durationMs: result.durationMs,
+      engine: result.engine,
+      installMs: result.installMs,
+      launchMs: result.launchMs,
+      platform: "android",
+      relaunchMs: result.relaunchMs,
+      success: true
+    });
+    await writeRequestedAndroidReport({
+      adb: adb2,
+      args,
+      projectRoot,
+      provider: mobile.engine,
+      reportRoot,
+      run: {
+        appId: mobile.appId,
+        durationMs: result.durationMs,
+        hmrConnected: false,
+        release: {
+          apksBytes: result.apksBytes,
+          artifactBytes: result.artifactBytes,
+          artifactSha256: result.artifactSha256,
+          embeddedOffline: result.embeddedOffline,
+          engine: result.engine,
+          installMs: result.installMs,
+          launchMs: result.launchMs,
+          relaunchMs: result.relaunchMs,
+          releaseId: result.releaseId,
+          signed: result.signed
+        },
+        ...screenshot ? { screenshot } : {},
+        serial,
+        status: "pass"
+      }
+    });
+    printAndroidReleaseAcceptance(result, args.includes("--json"));
+    return result;
+  } catch (error) {
+    const durationMs = Math.round(performance.now() - startedAt);
+    sendTelemetryEvent("mobile:android-release-conformance", {
+      durationMs,
+      engine: mobile.engine,
+      platform: "android",
+      success: false
+    });
+    await mkdir13(artifactRoot, { recursive: true });
+    const diagnosticPath = join14(artifactRoot, "android-release-failure.json");
+    await writeFile15(diagnosticPath, `${JSON.stringify({
+      error: sanitizeNativeReportText(error instanceof Error ? error.message : String(error)),
+      platform: "android",
+      provider: mobile.engine,
+      releaseId: release.metadata.releaseId,
+      status: "fail"
+    }, null, 2)}
+`);
+    await writeRequestedAndroidReport({
+      adb: adb2,
+      args,
+      projectRoot,
+      provider: mobile.engine,
+      reportRoot,
+      run: {
+        appId: mobile.appId,
+        durationMs,
+        error: "Installed release acceptance failed; inspect the local diagnostic artifact before sharing evidence.",
+        hmrConnected: false,
+        release: {
+          apksBytes: 0,
+          artifactBytes: release.metadata.bytes,
+          artifactSha256: release.metadata.sha256,
+          embeddedOffline: false,
+          engine: release.metadata.engine,
+          installMs: 0,
+          launchMs: 0,
+          relaunchMs: 0,
+          releaseId: release.metadata.releaseId,
+          signed: release.metadata.signed
+        },
+        serial,
+        status: "fail"
+      }
+    });
+    throw new Error(`${error instanceof Error ? error.message : String(error)} Failure diagnostics: ${diagnosticPath}`, { cause: error });
+  }
+};
 var testAndroid = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
+  if (args.includes("--release")) {
+    return testAndroidRelease(args, mobile, projectRoot);
+  }
   requireCapacitorEngine(mobile, "mobile test android");
   if (!mobile.platforms.includes("android")) {
     throw new TypeError("mobile test android requires android in mobile.platforms.");
   }
   const { https, port } = requireAndroidTestPort(args, projectRoot);
   const timeoutMs = androidTestTimeout(args);
-  const adb = await requireAndroidAdb();
-  const serial = selectAndroidSerial(adb, valueAfter(args, "--serial"));
+  const adb2 = await requireAndroidAdb();
+  const serial = selectAndroidSerial(adb2, valueAfter(args, "--serial"));
   const routes = valuesAfter(args, "--route");
   if (routes.length === 0)
     routes.push(mobile.entry);
@@ -23882,7 +24499,7 @@ var testAndroid = async (args) => {
   let session;
   try {
     session = await attachAbsoluteAndroidWebView({
-      adb,
+      adb: adb2,
       appId: mobile.appId,
       serial,
       timeoutMs
@@ -23916,9 +24533,9 @@ var testAndroid = async (args) => {
       console.log(JSON.stringify(report, null, 2));
     else
       printAndroidTestReport(report);
-    const screenshot = reportRoot ? await session.screenshot(join13(artifactRoot, "android-emulator.png")) : undefined;
+    const screenshot = reportRoot ? await session.screenshot(join14(artifactRoot, "android-emulator.png")) : undefined;
     await writeRequestedAndroidReport({
-      adb,
+      adb: adb2,
       args,
       projectRoot,
       run: {
@@ -23959,7 +24576,7 @@ var testAndroid = async (args) => {
       session
     });
     await writeRequestedAndroidReport({
-      adb,
+      adb: adb2,
       args,
       projectRoot,
       run: {
@@ -23985,14 +24602,14 @@ var requireIosTestContext = (args, projectRoot) => {
     const port = Number(explicit);
     if (!Number.isInteger(port) || port < 1 || port > 65535)
       throw new TypeError("mobile test --port must be a valid TCP port.");
-    const instance2 = listLiveInstances().find((candidate) => resolve12(candidate.cwd) === resolve12(projectRoot) && candidate.source === "dev" && candidate.port === port);
+    const instance2 = listLiveInstances().find((candidate) => resolve13(candidate.cwd) === resolve13(projectRoot) && candidate.source === "dev" && candidate.port === port);
     return {
       https: instance2?.https ?? args.includes("--https"),
       instance: instance2,
       port
     };
   }
-  const instances = listLiveInstances().filter((instance2) => resolve12(instance2.cwd) === resolve12(projectRoot) && instance2.source === "dev" && instance2.port !== null);
+  const instances = listLiveInstances().filter((instance2) => resolve13(instance2.cwd) === resolve13(projectRoot) && instance2.source === "dev" && instance2.port !== null);
   if (instances.length !== 1)
     throw new TypeError(instances.length === 0 ? "No running AbsoluteJS dev server was found for this project. Start `bun dev`, wait for iOS to report ready, then run `absolute mobile test ios`." : "Multiple dev servers are running for this project. Select one with mobile test ios --port <port>.");
   const [instance] = instances;
@@ -24010,7 +24627,7 @@ var waitForIosHmrClient = async (options) => {
       return;
     });
     const status = response?.ok ? await response.json().catch(() => null) : null;
-    const targets = isRecord6(status) && isRecord6(status.connectedTargets) ? status.connectedTargets : undefined;
+    const targets = isRecord7(status) && isRecord7(status.connectedTargets) ? status.connectedTargets : undefined;
     if (targets && typeof targets["capacitor-ios"] === "number" && targets["capacitor-ios"] > 0)
       return;
     await Bun.sleep(100);
@@ -24082,11 +24699,11 @@ var physicalIosCapture = async (options) => {
     remote: false,
     xcodeVersion: requireCapturedCommand(["/usr/bin/xcodebuild", "-version"], "Xcode version inspection").stdout.trim(),
     xcrun: "/usr/bin/xcrun",
-    capture: async (command) => captureCommand2(command)
+    capture: async (command) => captureCommand3(command)
   };
 };
 var selectIosSimulator = (xcrun, explicitUdid) => {
-  const result = captureCommand2([
+  const result = captureCommand3([
     xcrun,
     "simctl",
     "list",
@@ -24109,15 +24726,15 @@ var selectIosSimulator = (xcrun, explicitUdid) => {
   return selected;
 };
 var requireCapturedCommand = (command, label) => {
-  const result = captureCommand2(command);
+  const result = captureCommand3(command);
   if (result.exitCode !== 0)
     throw new Error(`${label} failed: ${result.stderr.trim() || result.stdout.trim() || `status ${result.exitCode}`}`);
   return result;
 };
 var writeIosFailureArtifacts = async (options) => {
-  await mkdir12(options.artifactRoot, { recursive: true });
-  const screenshot = join13(options.artifactRoot, "ios-failure.png");
-  const screenshotResult = captureCommand2([
+  await mkdir13(options.artifactRoot, { recursive: true });
+  const screenshot = join14(options.artifactRoot, "ios-failure.png");
+  const screenshotResult = captureCommand3([
     options.xcrun,
     "simctl",
     "io",
@@ -24125,8 +24742,8 @@ var writeIosFailureArtifacts = async (options) => {
     "screenshot",
     screenshot
   ]);
-  const diagnosticPath = join13(options.artifactRoot, "ios-failure.json");
-  await writeFile14(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join14(options.artifactRoot, "ios-failure.json");
+  await writeFile15(diagnosticPath, `${JSON.stringify({
     appId: options.appId,
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "ios",
@@ -24153,8 +24770,8 @@ var nativeReportRoot = (args, projectRoot, platform2) => {
 var absolutejsVersionForReport = async () => {
   let absolutejsVersion = process.env.ABSOLUTE_VERSION ?? "unknown";
   const versions = await Promise.all([
-    resolve12(import.meta.dir, "..", "..", "package.json"),
-    resolve12(import.meta.dir, "..", "..", "..", "package.json")
+    resolve13(import.meta.dir, "..", "..", "package.json"),
+    resolve13(import.meta.dir, "..", "..", "..", "package.json")
   ].map((candidate) => readPackageVersionForIosReport(candidate).catch(() => "unknown")));
   for (const version of versions) {
     if (version === "unknown")
@@ -24165,7 +24782,7 @@ var absolutejsVersionForReport = async () => {
   return absolutejsVersion;
 };
 var writeRequestedAndroidReport = async (options) => {
-  const reportRoot = nativeReportRoot(options.args, options.projectRoot, "android");
+  const reportRoot = options.reportRoot ?? nativeReportRoot(options.args, options.projectRoot, "android");
   if (!reportRoot)
     return;
   const adbVersion = requireCapturedCommand([options.adb, "version"], "ADB version inspection").stdout.trim();
@@ -24174,6 +24791,7 @@ var writeRequestedAndroidReport = async (options) => {
     adbVersion,
     bunVersion: Bun.version,
     host: `${process.platform}-${process.arch}`,
+    ...options.provider ? { provider: options.provider } : {},
     run: options.run
   });
   const paths = await writeAbsoluteNativeTestReport(reportRoot, report);
@@ -24378,8 +24996,8 @@ var testIos = async (args) => {
       mobile.appId
     ], "iOS app launch");
     await waitForIosHmrClient({ https, port, timeoutMs });
-    await mkdir12(artifactRoot, { recursive: true });
-    const screenshot = join13(artifactRoot, "ios-simulator.png");
+    await mkdir13(artifactRoot, { recursive: true });
+    const screenshot = join14(artifactRoot, "ios-simulator.png");
     requireCapturedCommand([xcrun, "simctl", "io", simulator.udid, "screenshot", screenshot], "iOS simulator screenshot");
     const hmrApply = await waitForRequestedIosHmr(args, instance, timeoutMs);
     const report = {
@@ -24565,7 +25183,7 @@ var runMobile = async (args) => {
     await publishIos(args.slice(2));
     return;
   }
-  throw new TypeError("Usage: absolute mobile <pair mac <name> <user@host> [--port n] [--workspace path] | remotes [inspect [name] [--json] | clean [name] --yes | --json] | unpair mac <name> | init [--no-native] [--force] | sync [ios|android] | inspect [--json] [--require-bundle] | associations [--outdir dir] [--verify] | ci github [server-entry] [--publish] [--registry module] [--secret-env NAME] [--output path] [--force] [--json] | doctor [ios|android|release [ios|android]] [--remote name] [--json|--fix [--yes]] | build <android|ios> [server-entry] [--remote name] [--outdir dir] [--web-outdir dir] [--unsigned] | update provision [--storage local|s3] [--registry module] [--force] [--yes] | update signing generate --private-key path [--certificate path] [--public-key path] [--key-id id] [--common-name name] [--validity-years n] | update build [server-entry] --classification bug-fix|content|security --key-id id --signing-key path --within-submitted-purpose [--outdir dir] [--web-outdir dir] | update publish <release-directory> [--rollout fraction] [--registry module] | update promote --release id --rollout fraction [--registry module] | update rollback [--release id] [--registry module] | update status [--registry module] [--json] | update advance [--rollout fraction] [--registry module] [--json] | update pause|resume|cancel|reconcile [--registry module] [--json] | update storage [--retain count] [--min-age-days days] [--registry module] [--json] | update gc [--retain count] [--min-age-days days] [--grace-days days] [--apply] [--registry module] [--json] | publish android [server-entry] [--registry module] [--channel name] [--play-track track] [--play-status completed|draft|halted|in-progress] [--play-rollout fraction] [--play-name name] [--play-notes language=text] [--play-update-priority 0..5] [--play-hold-review] [--play-cancel-existing-review] [--outdir dir] [--web-outdir dir] [--unsigned] | publish ios [server-entry] [--remote name] [--registry module] [--channel name] [--testflight-group name-or-id] [--testflight-notes locale=text] [--testflight-submit-review] [--outdir dir] [--web-outdir dir] [--unsigned] | test android [--route path] [--wait-for-hmr] [--report [dir]] [--timeout ms] [--port n] [--serial id] [--artifacts dir] [--json]> [--config path]");
+  throw new TypeError("Usage: absolute mobile <pair mac <name> <user@host> [--port n] [--workspace path] | remotes [inspect [name] [--json] | clean [name] --yes | --json] | unpair mac <name> | init [--no-native] [--force] | sync [ios|android] | inspect [--json] [--require-bundle] | associations [--outdir dir] [--verify] | ci github [server-entry] [--publish] [--registry module] [--secret-env NAME] [--output path] [--force] [--json] | doctor [ios|android|release [ios|android]] [--remote name] [--json|--fix [--yes]] | build <android|ios> [server-entry] [--remote name] [--outdir dir] [--web-outdir dir] [--unsigned] | update provision [--storage local|s3] [--registry module] [--force] [--yes] | update signing generate --private-key path [--certificate path] [--public-key path] [--key-id id] [--common-name name] [--validity-years n] | update build [server-entry] --classification bug-fix|content|security --key-id id --signing-key path --within-submitted-purpose [--outdir dir] [--web-outdir dir] | update publish <release-directory> [--rollout fraction] [--registry module] | update promote --release id --rollout fraction [--registry module] | update rollback [--release id] [--registry module] | update status [--registry module] [--json] | update advance [--rollout fraction] [--registry module] [--json] | update pause|resume|cancel|reconcile [--registry module] [--json] | update storage [--retain count] [--min-age-days days] [--registry module] [--json] | update gc [--retain count] [--min-age-days days] [--grace-days days] [--apply] [--registry module] [--json] | publish android [server-entry] [--registry module] [--channel name] [--play-track track] [--play-status completed|draft|halted|in-progress] [--play-rollout fraction] [--play-name name] [--play-notes language=text] [--play-update-priority 0..5] [--play-hold-review] [--play-cancel-existing-review] [--outdir dir] [--web-outdir dir] [--unsigned] | publish ios [server-entry] [--remote name] [--registry module] [--channel name] [--testflight-group name-or-id] [--testflight-notes locale=text] [--testflight-submit-review] [--outdir dir] [--web-outdir dir] [--unsigned] | test android [--release release-dir [--yes] | --route path [--wait-for-hmr] [--port n]] [--report [dir]] [--serial id] [--artifacts dir] [--json] [--config path]");
 };
 export {
   runMobile