@absolutejs/absolute 0.20.0-beta.1 → 0.20.0-beta.2

package/dist/cli/index.js

@@ -774,6 +774,14 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     throw new TypeError("mobile.deepLinks.apple.appIdPrefix must contain ten letters or digits.");
   }
   return normalized;
+}, normalizeIosVersion = (value) => {
+  if (value === undefined)
+    return;
+  const normalized = requireText(value, "mobile.ios.version");
+  if (!/^\d+(?:\.\d+){0,2}$/u.test(normalized)) {
+    throw new TypeError("mobile.ios.version must contain one to three dot-separated integer components, for example 1.4.0.");
+  }
+  return normalized;
 }, normalizeCertificateFingerprints = (values) => [
   ...new Set((values ?? []).map((value) => requireText(value, "mobile.deepLinks.android.sha256CertificateFingerprints").replaceAll(":", "").toUpperCase()).map((value) => {
     if (!CERTIFICATE_FINGERPRINT_PATTERN.test(value)) {
@@ -801,6 +809,7 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     deepLinkScheme,
     engine: "capacitor",
     entry: normalizeEntry(config.entry),
+    iosVersion: normalizeIosVersion(config.ios?.version),
     nativeProjectDirectory: resolveProjectPath(projectRoot, config.nativeProject?.directory ?? "mobile", "mobile.nativeProject.directory"),
     platforms: normalizePlatforms(config.platforms),
     productionOrigin
@@ -1643,12 +1652,13 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     throw new Error("Capacitor Android settings did not declare any native dependencies.");
   }
   return { dependencies, rewrittenSettings };
-}, encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task) => {
+}, encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task, gradleArguments) => {
   const sourceDirectory = Buffer.from(windowsSource, "utf8").toString("base64");
   const buildDirectory = Buffer.from(windowsDirectory, "utf8").toString("base64");
   const androidRoot = Buffer.from(windowsAndroidRoot, "utf8").toString("base64");
   const dependencyData = Buffer.from(JSON.stringify(dependencies), "utf8").toString("base64");
   const settingsData = Buffer.from(rewrittenSettings, "utf8").toString("base64");
+  const argumentsData = Buffer.from(JSON.stringify(gradleArguments), "utf8").toString("base64");
   const source = [
     "$ErrorActionPreference = 'Stop'",
     `$source = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${sourceDirectory}'))`,
@@ -1656,6 +1666,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     `$androidHome = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${androidRoot}'))`,
     `$dependencies = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${dependencyData}')) | ConvertFrom-Json`,
     `$settings = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${settingsData}'))`,
+    `$gradleArguments = @([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${argumentsData}')) | ConvertFrom-Json)`,
     "$env:ANDROID_HOME = $androidHome",
     "$env:ANDROID_SDK_ROOT = $androidHome",
     "New-Item -ItemType Directory -Force -Path $directory | Out-Null",
@@ -1665,7 +1676,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     "foreach ($dependency in @($dependencies)) { $target = Join-Path $directory ('.absolutejs-dependencies\\' + $dependency.name); New-Item -ItemType Directory -Force -Path $target | Out-Null; & robocopy.exe $dependency.windowsSource $target /MIR /XD .gradle build /NFL /NDL /NJH /NJS /NP; if ($LASTEXITCODE -ge 8) { exit $LASTEXITCODE } }",
     "[IO.File]::WriteAllText((Join-Path $directory 'capacitor.settings.gradle'), $settings)",
     "$wrapper = Join-Path $directory 'gradlew.bat'",
-    `& $wrapper --no-daemon --console=plain -p $directory ${task}`,
+    `& $wrapper --no-daemon --console=plain -p $directory @gradleArguments ${task}`,
     "if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }",
     "exit 0"
   ].join("; ");
@@ -1690,6 +1701,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   const capture = options.capture ?? captureCommand2;
   const run = options.run ?? runCommand;
   const env = options.env ?? process.env;
+  const gradleArguments = options.gradleArguments ?? [];
   if (project.host === "wsl") {
     const windowsSource = windowsPathFromWsl(project.nativeDirectory, capture);
     const buildId = Bun.hash(project.projectRoot).toString(HASH_RADIX);
@@ -1701,7 +1713,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
       "powershell.exe",
       "-NoProfile",
       "-EncodedCommand",
-      encodedWindowsGradleCommand(windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task)
+      encodedWindowsGradleCommand(windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task, gradleArguments)
     ], "Android Gradle build", run, { env, signal: options.signal });
     const artifactPath2 = await resolveGradleArtifactPath(managedBuildDirectory, task);
     const unsigned = artifactPath2.endsWith("-unsigned.apk");
@@ -1711,7 +1723,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     };
   }
   const wrapper = project.host === "windows" ? "gradlew.bat" : "./gradlew";
-  await requireSuccess([wrapper, "--no-daemon", "--console=plain", task], "Android Gradle build", run, { cwd: project.nativeDirectory, env, signal: options.signal });
+  await requireSuccess([wrapper, "--no-daemon", "--console=plain", ...gradleArguments, task], "Android Gradle build", run, { cwd: project.nativeDirectory, env, signal: options.signal });
   const artifactPath = await resolveGradleArtifactPath(project.nativeDirectory, task);
   return { artifactPath, installPath: artifactPath };
 }, buildAndroidDebugApp = async (project, capture, run, env, signal) => (await buildAbsoluteAndroidGradleArtifact({
@@ -14523,10 +14535,40 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists3 = async (path) => {
     ...check2,
     path: check2.path ? relative19(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
   }));
+}, inspectIosRelease = async (config, projectRoot) => {
+  const iosAppRoot = join41(config.nativeProjectDirectory, "ios", "App", "App");
+  const nativeConfigPath = join41(iosAppRoot, "capacitor.config.json");
+  const infoPath = join41(iosAppRoot, "Info.plist");
+  const publicRoot = join41(iosAppRoot, "public");
+  const checks = [];
+  if (!config.iosVersion) {
+    checks.push(fail5("ios.marketing-version", "iOS has no explicit App Store marketing version.", projectRoot, "Add mobile.ios.version to absolutejs.config.ts, for example 1.0.0."));
+  } else {
+    checks.push(pass("ios.marketing-version", `The iOS marketing version is ${config.iosVersion}.`));
+  }
+  if (!await pathExists3(nativeConfigPath)) {
+    checks.push(fail5("ios.capacitor-config", "The generated iOS Capacitor config is missing.", nativeConfigPath, "Run `absolute mobile sync ios` before release validation."));
+  } else if (isUnsafeCapacitorConfig(await readFile10(nativeConfigPath, "utf8"))) {
+    checks.push(fail5("ios.capacitor-config", "iOS Capacitor config contains a development server URL, cleartext transport, navigation allowlist, or invalid JSON.", nativeConfigPath, "Run `absolute mobile sync ios`; do not ship development transport overrides."));
+  } else {
+    checks.push(pass("ios.capacitor-config", "iOS Capacitor config contains no development transport overrides.", nativeConfigPath));
+  }
+  if (!await pathExists3(infoPath)) {
+    checks.push(fail5("ios.transport-security", "The iOS Info.plist is missing.", infoPath, "Run `absolute mobile sync ios` before release validation."));
+  } else {
+    const info2 = await readFile10(infoPath, "utf8");
+    checks.push(/<key>NSAllowsArbitraryLoads<\/key>\s*<true\s*\/>/u.test(info2) ? fail5("ios.transport-security", "iOS App Transport Security permits arbitrary network loads.", infoPath, "Remove NSAllowsArbitraryLoads from the release Info.plist.") : pass("ios.transport-security", "iOS App Transport Security does not permit arbitrary loads.", infoPath));
+  }
+  const hmrAsset = await findHmrAsset(publicRoot);
+  checks.push(hmrAsset ? fail5("ios.hmr-assets", "A packaged iOS asset contains the development HMR client.", hmrAsset, "Rebuild the production mobile bundle and run Capacitor sync again.") : pass("ios.hmr-assets", "Packaged iOS assets contain no development HMR markers.", publicRoot));
+  return checks.map((check2) => ({
+    ...check2,
+    path: check2.path ? relative19(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
+  }));
 }, inspectAbsoluteMobileRelease = async (config, projectRoot) => {
   const checks = config.platforms.includes("android") ? await inspectAndroidRelease(config, projectRoot) : [];
   if (config.platforms.includes("ios")) {
-    checks.push(fail5("ios.release-validation", "iOS release validation is not available in this Android phase.", config.nativeProjectDirectory, "Do not treat this result as release-ready until the iOS release checks ship."));
+    checks.push(...await inspectIosRelease(config, projectRoot));
   }
   return {
     checks,
@@ -14651,12 +14693,32 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord11 = (value) => typeof value ==
   }
   return { ...expected, artifact };
 }, buildAbsoluteAndroidRelease = async (options) => {
+  if (options.versionCode !== undefined && options.prepareVersionCode) {
+    throw new TypeError("Android release versionCode and prepareVersionCode cannot be combined.");
+  }
+  if (options.versionCode !== undefined && (!Number.isSafeInteger(options.versionCode) || options.versionCode < 1 || options.versionCode > 2100000000)) {
+    throw new TypeError("Android versionCode must be an integer from 1 through 2100000000.");
+  }
   const projectRoot = resolve35(options.projectRoot);
   const host = options.host ?? detectAbsoluteMobileHost();
   const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host);
   const nativeDirectory = join42(options.config.nativeProjectDirectory, "android");
+  const manifest = requireManifest(JSON.parse(await readFile11(join42(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  if (manifest.appId !== options.config.appId) {
+    throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
+  }
+  let { versionCode } = options;
+  if (options.prepareVersionCode) {
+    const nativeFingerprint = await fingerprintAbsoluteAndroidNativeProject({ nativeDirectory });
+    const buildIdentity = createHash9("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}`).digest("hex");
+    versionCode = await options.prepareVersionCode(buildIdentity);
+  }
+  if (versionCode !== undefined && (!Number.isSafeInteger(versionCode) || versionCode < 1 || versionCode > 2100000000)) {
+    throw new TypeError("Android versionCode must be an integer from 1 through 2100000000.");
+  }
   const { artifactPath } = await buildAbsoluteAndroidGradleArtifact({
     capture: options.capture,
+    gradleArguments: versionCode === undefined ? [] : [`-Pandroid.injected.version.code=${versionCode}`],
     project: {
       androidRoot,
       config: options.config,
@@ -14678,10 +14740,6 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord11 = (value) => typeof value ==
   if (!signed2 && !options.allowUnsigned) {
     throw new TypeError("Android Gradle produced an unsigned App Bundle. Configure the release signingConfig in the source-owned Android project (prefer external Gradle properties), or pass --unsigned only for a non-publishable build.");
   }
-  const manifest = requireManifest(JSON.parse(await readFile11(join42(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
-  if (manifest.appId !== options.config.appId) {
-    throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
-  }
   const [bytes, sha2562] = await Promise.all([
     stat(artifactPath).then(({ size }) => size),
     sha256File(artifactPath)
@@ -14698,7 +14756,8 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord11 = (value) => typeof value ==
     runtime: manifest.runtime,
     sha256: sha2562,
     signed: signed2 === true,
-    type: "aab"
+    type: "aab",
+    ...versionCode === undefined ? {} : { versionCode }
   };
   return installRelease(artifactPath, metadata, safeOutputDirectory(projectRoot, options.outputDirectory));
 };
@@ -14707,13 +14766,377 @@ var init_androidRelease = __esm(() => {
   init_androidEmulatorController();
 });
 
+// src/mobile/iosRelease.ts
+import { createHash as createHash10 } from "crypto";
+import {
+  access as access8,
+  copyFile as copyFile4,
+  mkdir as mkdir9,
+  mkdtemp as mkdtemp5,
+  readdir as readdir4,
+  readFile as readFile12,
+  rename as rename8,
+  rm as rm7,
+  stat as stat2,
+  writeFile as writeFile9
+} from "fs/promises";
+import { dirname as dirname25, isAbsolute as isAbsolute5, join as join43, relative as relative21, resolve as resolve36, sep as sep4 } from "path";
+var isRecord12 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), requireManifest2 = (value) => {
+  if (!isRecord12(value) || typeof value.appBuild !== "string" || typeof value.appId !== "string" || typeof value.runtime !== "string") {
+    throw new TypeError("Invalid embedded AbsoluteJS mobile manifest.");
+  }
+  return {
+    appBuild: value.appBuild,
+    appId: value.appId,
+    runtime: value.runtime
+  };
+}, pathExists5 = async (path) => {
+  try {
+    await access8(path);
+    return true;
+  } catch {
+    return false;
+  }
+}, defaultRun2 = async (command, options = {}) => {
+  const process2 = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  return process2.exited;
+}, defaultCapture3 = (command, options = {}) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      cwd: options.cwd,
+      env: options.env,
+      stderr: "pipe",
+      stdin: "ignore",
+      stdout: "pipe"
+    });
+    return {
+      exitCode: result.exitCode,
+      stderr: result.stderr.toString(),
+      stdout: result.stdout.toString()
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : String(error),
+      stdout: ""
+    };
+  }
+}, ignoredFingerprintDirectories, fingerprintFiles = async (root, current = root) => {
+  const entries = await readdir4(current, { withFileTypes: true });
+  const nested = await Promise.all(entries.sort((left, right) => left.name.localeCompare(right.name)).map(async (entry) => {
+    const path = join43(current, entry.name);
+    const projectRelative = relative21(root, path).replaceAll("\\", "/");
+    const ignored = entry.isDirectory() && (ignoredFingerprintDirectories.has(entry.name) || projectRelative === "App/App/public");
+    if (ignored)
+      return [];
+    if (entry.isDirectory())
+      return fingerprintFiles(root, path);
+    return entry.isFile() ? [path] : [];
+  }));
+  return nested.flat();
+}, fingerprintAbsoluteIosNativeProject = async (nativeDirectory) => {
+  const hasher = createHash10("sha256");
+  const files = await fingerprintFiles(nativeDirectory);
+  const contents = await Promise.all(files.map((file) => readFile12(file)));
+  files.forEach((file, index) => {
+    hasher.update(relative21(nativeDirectory, file).replaceAll("\\", "/"));
+    hasher.update("\x00");
+    hasher.update(contents[index] ?? new Uint8Array);
+    hasher.update("\x00");
+  });
+  return hasher.digest("hex");
+}, safeOutputDirectory2 = (projectRoot, requested) => {
+  const root = resolve36(projectRoot);
+  const output = resolve36(root, requested ?? ".absolutejs/mobile/releases/ios");
+  const projectRelative = relative21(root, output);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep4}`) || isAbsolute5(projectRelative)) {
+    throw new TypeError("mobile build --outdir must remain inside the project.");
+  }
+  return output;
+}, sha256File2 = async (path) => createHash10("sha256").update(await readFile12(path)).digest("hex"), findByExtension = async (root, extension) => {
+  if (!await pathExists5(root))
+    return;
+  const entries = await readdir4(root, { withFileTypes: true });
+  const matches = await Promise.all(entries.map(async (entry) => {
+    const path = join43(root, entry.name);
+    if (entry.isDirectory() && entry.name.endsWith(extension))
+      return path;
+    if (entry.isFile() && entry.name.endsWith(extension))
+      return path;
+    return entry.isDirectory() ? findByExtension(path, extension) : undefined;
+  }));
+  return matches.find((match) => match !== undefined);
+}, exportOptions = () => `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+	<key>destination</key><string>export</string>
+	<key>manageAppVersionAndBuildNumber</key><false/>
+	<key>method</key><string>app-store-connect</string>
+	<key>signingStyle</key><string>automatic</string>
+	<key>stripSwiftSymbols</key><true/>
+	<key>uploadSymbols</key><true/>
+</dict></plist>
+`, requireBuildNumber = (value) => {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value < 1))
+    throw new TypeError("iOS build number must be a positive integer.");
+  return value;
+}, installRelease2 = async (artifactPath, metadata, outputRoot) => {
+  const releaseRoot = join43(outputRoot, metadata.releaseId);
+  const destination = join43(releaseRoot, "App.ipa");
+  if (await pathExists5(releaseRoot)) {
+    const value = JSON.parse(await readFile12(join43(releaseRoot, "release.json"), "utf8"));
+    if (!isRecord12(value) || value.artifact !== "App.ipa" || Object.entries(metadata).some(([key, expected]) => Reflect.get(value, key) !== expected)) {
+      throw new TypeError(`Immutable iOS release ${metadata.releaseId} does not match its content.`);
+    }
+    const [bytes, sha2562] = await Promise.all([
+      stat2(destination).then(({ size }) => size),
+      sha256File2(destination)
+    ]);
+    if (bytes !== metadata.bytes || sha2562 !== metadata.sha256)
+      throw new TypeError(`Immutable iOS release ${metadata.releaseId} artifact is missing or modified.`);
+    return {
+      artifactPath: destination,
+      metadata: {
+        ...metadata,
+        artifact: "App.ipa"
+      },
+      releaseRoot
+    };
+  }
+  await mkdir9(dirname25(releaseRoot), { recursive: true });
+  const staging = await mkdtemp5(join43(dirname25(releaseRoot), ".ios-stage-"));
+  try {
+    await copyFile4(artifactPath, join43(staging, "App.ipa"));
+    const complete = {
+      ...metadata,
+      artifact: "App.ipa"
+    };
+    await writeFile9(join43(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+`, { flag: "wx" });
+    await rename8(staging, releaseRoot);
+    return { artifactPath: destination, metadata: complete, releaseRoot };
+  } finally {
+    await rm7(staging, { force: true, recursive: true }).catch(() => {
+      return;
+    });
+  }
+}, buildAbsoluteIosRelease = async (options) => {
+  if (options.buildNumber !== undefined && options.prepareBuildNumber)
+    throw new TypeError("iOS release buildNumber and prepareBuildNumber cannot be combined.");
+  if ((options.host ?? detectAbsoluteMobileHost()) !== "macos")
+    throw new TypeError("iOS release builds require macOS and Xcode.");
+  const marketingVersion = options.config.iosVersion;
+  if (!marketingVersion)
+    throw new TypeError("iOS release builds require mobile.ios.version in absolutejs.config.ts.");
+  const manifest = requireManifest2(JSON.parse(await readFile12(join43(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  if (manifest.appId !== options.config.appId)
+    throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
+  const nativeDirectory = join43(options.config.nativeProjectDirectory, "ios");
+  let buildNumber = requireBuildNumber(options.buildNumber);
+  if (options.prepareBuildNumber) {
+    const nativeFingerprint = await fingerprintAbsoluteIosNativeProject(nativeDirectory);
+    const buildIdentity = createHash10("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}\x00${marketingVersion}`).digest("hex");
+    buildNumber = requireBuildNumber(await options.prepareBuildNumber(buildIdentity));
+  }
+  const stagingParent = resolve36(options.projectRoot, ".absolutejs/mobile");
+  await mkdir9(stagingParent, { recursive: true });
+  const staging = await mkdtemp5(join43(stagingParent, ".ios-build-"));
+  const archivePath = join43(staging, "App.xcarchive");
+  const exportPath = join43(staging, "export");
+  const exportPlist = join43(staging, "ExportOptions.plist");
+  await mkdir9(exportPath, { recursive: true });
+  await writeFile9(exportPlist, exportOptions());
+  const run = options.run ?? defaultRun2;
+  try {
+    const versionArguments = [
+      `MARKETING_VERSION=${marketingVersion}`,
+      ...buildNumber === undefined ? [] : [`CURRENT_PROJECT_VERSION=${buildNumber}`]
+    ];
+    const archiveExit = await run([
+      "xcodebuild",
+      "-workspace",
+      join43(nativeDirectory, "App", "App.xcworkspace"),
+      "-scheme",
+      "App",
+      "-configuration",
+      "Release",
+      "-destination",
+      "generic/platform=iOS",
+      "-archivePath",
+      archivePath,
+      ...versionArguments,
+      "archive"
+    ], { cwd: nativeDirectory });
+    if (archiveExit !== 0)
+      throw new TypeError("Xcode failed to archive the iOS app.");
+    const archivedApp = await findByExtension(join43(archivePath, "Products", "Applications"), ".app");
+    const capture = options.capture ?? defaultCapture3;
+    const signed2 = archivedApp ? capture([
+      "codesign",
+      "--verify",
+      "--deep",
+      "--strict",
+      archivedApp
+    ]).exitCode === 0 : false;
+    if (!signed2 && !options.allowUnsigned)
+      throw new TypeError("Xcode produced an unsigned iOS archive. Configure signing in the source-owned Xcode project, or pass --unsigned only for a non-publishable build.");
+    const exportExit = await run([
+      "xcodebuild",
+      "-exportArchive",
+      "-archivePath",
+      archivePath,
+      "-exportPath",
+      exportPath,
+      "-exportOptionsPlist",
+      exportPlist
+    ], { cwd: nativeDirectory });
+    if (exportExit !== 0)
+      throw new TypeError("Xcode failed to export the App Store IPA.");
+    const artifactPath = await findByExtension(exportPath, ".ipa");
+    if (!artifactPath)
+      throw new TypeError("Xcode did not produce an exported IPA.");
+    const [bytes, sha2562] = await Promise.all([
+      stat2(artifactPath).then(({ size }) => size),
+      sha256File2(artifactPath)
+    ]);
+    const releaseId = `amobile_ios_${sha2562}`;
+    return await installRelease2(artifactPath, {
+      appBuild: manifest.appBuild,
+      appId: manifest.appId,
+      ...buildNumber === undefined ? {} : { buildNumber },
+      bytes,
+      engine: "capacitor",
+      format: 1,
+      marketingVersion,
+      platform: "ios",
+      releaseId,
+      runtime: manifest.runtime,
+      sha256: sha2562,
+      signed: signed2,
+      type: "ipa"
+    }, safeOutputDirectory2(options.projectRoot, options.outputDirectory));
+  } finally {
+    await rm7(staging, { force: true, recursive: true }).catch(() => {
+      return;
+    });
+  }
+};
+var init_iosRelease = __esm(() => {
+  init_emulatorDoctor();
+  ignoredFingerprintDirectories = new Set([
+    "Pods",
+    "DerivedData",
+    "build",
+    "xcuserdata"
+  ]);
+});
+
+// src/mobile/releasePublisher.ts
+import { access as access9 } from "fs/promises";
+import { isAbsolute as isAbsolute6, relative as relative22, resolve as resolve37, sep as sep5 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var prepareAbsoluteIosRelease = async (publisher, options) => {
+  if (typeof publisher.prepareIosRelease !== "function") {
+    throw new TypeError("App Store Connect publishing requires a registry module created with @absolutejs/deploy/app-store-connect.");
+  }
+  const { buildNumber } = await publisher.prepareIosRelease(options);
+  if (!Number.isSafeInteger(buildNumber) || buildNumber < 1) {
+    throw new TypeError("App Store Connect publisher returned an invalid iOS build number.");
+  }
+  return buildNumber;
+}, prepareAbsoluteAndroidRelease = async (publisher, options) => {
+  if (typeof publisher.prepareAndroidRelease !== "function") {
+    throw new TypeError("Google Play publishing requires a registry module created with @absolutejs/deploy/google-play.");
+  }
+  const prepared = await publisher.prepareAndroidRelease(options);
+  const { versionCode } = prepared;
+  if (typeof versionCode !== "number" || !Number.isSafeInteger(versionCode) || versionCode < 1 || versionCode > 2100000000) {
+    throw new TypeError("Google Play publisher returned an invalid Android versionCode.");
+  }
+  return versionCode;
+}, isRecord13 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), isPublisher = (value) => isRecord13(value) && typeof value.publish === "function", publisherModulePath = (projectRoot, requested) => {
+  const root = resolve37(projectRoot);
+  const path = resolve37(root, requested);
+  const projectRelative = relative22(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep5}`) || isAbsolute6(projectRelative)) {
+    throw new TypeError("mobile publish --registry must remain inside the project.");
+  }
+  return path;
+}, loadAbsoluteNativeReleasePublisher = async (projectRoot, requestedModulePath) => {
+  const modulePath = publisherModulePath(projectRoot, requestedModulePath);
+  await access9(modulePath).catch(() => {
+    throw new TypeError(`Native release registry module does not exist: ${modulePath}`);
+  });
+  const loaded = await import(pathToFileURL2(modulePath).href);
+  const publisher = isRecord13(loaded) ? loaded.default ?? loaded.registry : undefined;
+  if (!isPublisher(publisher)) {
+    throw new TypeError("Native release registry module must default-export a registry with publish(options).");
+  }
+  return publisher;
+}, publishAbsoluteAndroidRelease = async (options) => {
+  const publisher = await loadAbsoluteNativeReleasePublisher(options.projectRoot, options.modulePath);
+  const publication = await publisher.publish({
+    allowUnsigned: options.allowUnsigned,
+    channel: options.channel,
+    googlePlay: options.googlePlay,
+    releaseRoot: options.release.releaseRoot,
+    signal: options.signal
+  });
+  const expected = options.release.metadata;
+  const actual = publication.record?.metadata;
+  if (!actual || actual.appId !== expected.appId || actual.platform !== "android" || actual.releaseId !== expected.releaseId || actual.sha256 !== expected.sha256 || actual.signed !== expected.signed || actual.versionCode !== expected.versionCode || typeof publication.reused !== "boolean") {
+    throw new TypeError("Native release registry returned a different Android release identity.");
+  }
+  if (options.channel !== undefined && (publication.channel?.channel !== options.channel || publication.channel.releaseId !== expected.releaseId)) {
+    throw new TypeError("Native release registry did not promote the requested channel.");
+  }
+  const { googlePlay } = publication;
+  if (options.googlePlay) {
+    if (!expected.versionCode || !googlePlay || googlePlay.receipt.provider !== "google-play" || googlePlay.receipt.packageName !== expected.appId || googlePlay.receipt.releaseId !== expected.releaseId || googlePlay.receipt.sha256 !== expected.sha256 || googlePlay.receipt.stage !== "committed" || googlePlay.receipt.intent.track !== options.googlePlay.track || typeof googlePlay.receipt.versionCode !== "string" || !/^\d+$/.test(googlePlay.receipt.versionCode) || Number(googlePlay.receipt.versionCode) !== expected.versionCode || typeof googlePlay.reused !== "boolean") {
+      throw new TypeError("Native release publisher did not commit the requested Google Play release.");
+    }
+  }
+  return publication;
+}, publishAbsoluteIosRelease = async (options) => {
+  const publisher = await loadAbsoluteNativeReleasePublisher(options.projectRoot, options.modulePath);
+  const publication = await publisher.publish({
+    allowUnsigned: options.allowUnsigned,
+    appStoreConnect: options.appStoreConnect,
+    channel: options.channel,
+    releaseRoot: options.release.releaseRoot,
+    signal: options.signal
+  });
+  const expected = options.release.metadata;
+  const actual = publication.record?.metadata;
+  if (!actual || actual.appId !== expected.appId || actual.platform !== "ios" || actual.releaseId !== expected.releaseId || actual.sha256 !== expected.sha256 || actual.signed !== expected.signed || actual.buildNumber !== expected.buildNumber || actual.marketingVersion !== expected.marketingVersion || typeof publication.reused !== "boolean") {
+    throw new TypeError("Native release registry returned a different iOS release identity.");
+  }
+  if (options.channel !== undefined && (publication.channel?.channel !== options.channel || publication.channel.releaseId !== expected.releaseId)) {
+    throw new TypeError("Native release registry did not promote the requested channel.");
+  }
+  if (options.appStoreConnect) {
+    const distributed = publication.appStoreConnect;
+    if (!expected.buildNumber || !distributed || distributed.receipt.provider !== "app-store-connect" || distributed.receipt.releaseId !== expected.releaseId || distributed.receipt.sha256 !== expected.sha256 || distributed.receipt.buildNumber !== expected.buildNumber || distributed.receipt.marketingVersion !== expected.marketingVersion || !["distributed", "review-submitted"].includes(distributed.receipt.stage) || JSON.stringify([...distributed.receipt.intent.groups].sort()) !== JSON.stringify([...options.appStoreConnect.groups ?? []].sort()) || distributed.receipt.intent.submitForReview !== (options.appStoreConnect.submitForReview ?? false) || typeof distributed.reused !== "boolean") {
+      throw new TypeError("Native release publisher did not complete the requested App Store Connect release.");
+    }
+  }
+  return publication;
+};
+var init_releasePublisher = () => {};
+
 // src/cli/scripts/mobile.ts
 var exports_mobile = {};
 __export(exports_mobile, {
   runMobile: () => runMobile
 });
-import { access as access8, mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
-import { join as join43, resolve as resolve36 } from "path";
+import { access as access10, mkdir as mkdir10, writeFile as writeFile10 } from "fs/promises";
+import { join as join44, resolve as resolve38 } from "path";
 import { createInterface } from "readline/promises";
 var NOT_FOUND2 = -1, CAPACITOR_PACKAGES, valueAfter = (args, flag) => {
   const index = args.indexOf(flag);
@@ -14727,9 +15150,9 @@ var NOT_FOUND2 = -1, CAPACITOR_PACKAGES, valueAfter = (args, flag) => {
   }
   return value;
 }, capacitorExecutable = async (projectRoot) => {
-  const executable = join43(projectRoot, "node_modules", ".bin", "cap");
+  const executable = join44(projectRoot, "node_modules", ".bin", "cap");
   try {
-    await access8(executable);
+    await access10(executable);
     return executable;
   } catch {
     throw new TypeError(`Capacitor is not installed in this app. Run: bun add ${CAPACITOR_PACKAGES.join(" ")}`);
@@ -14770,7 +15193,7 @@ var NOT_FOUND2 = -1, CAPACITOR_PACKAGES, valueAfter = (args, flag) => {
   await applyAbsoluteNativeDeepLinks(mobile, platforms);
 }, associations = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
-  const outputDirectory = resolve36(projectRoot, valueAfter(args, "--outdir") ?? ".absolutejs/mobile/associations");
+  const outputDirectory = resolve38(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`);
@@ -14830,7 +15253,21 @@ Mobile release transport checks failed.`);
     throw new TypeError("Mobile release validation failed. Resolve every failed check before signing or publishing the app.");
   }
 }, mobileBuildServerEntry = (args) => {
-  const valueFlags = new Set(["--config", "--outdir", "--web-outdir"]);
+  const valueFlags = new Set([
+    "--channel",
+    "--config",
+    "--outdir",
+    "--play-name",
+    "--play-notes",
+    "--play-rollout",
+    "--play-status",
+    "--play-track",
+    "--play-update-priority",
+    "--registry",
+    "--testflight-group",
+    "--testflight-notes",
+    "--web-outdir"
+  ]);
   const skipped = new Set;
   args.forEach((value, index) => {
     if (valueFlags.has(value)) {
@@ -14839,6 +15276,111 @@ Mobile release transport checks failed.`);
     }
   });
   return args.find((value, index) => !skipped.has(index) && value !== "--unsigned" && !value.startsWith("-")) ?? DEFAULT_SERVER_ENTRY;
+}, requireValueAfter = (args, flag) => {
+  const value = valueAfter(args, flag);
+  if (!value || value.startsWith("-")) {
+    throw new TypeError(`mobile publish android requires ${flag} <value>.`);
+  }
+  return value;
+}, requireIosValueAfter = (args, flag) => {
+  const value = valueAfter(args, flag);
+  if (!value || value.startsWith("-")) {
+    throw new TypeError(`mobile publish ios requires ${flag} <value>.`);
+  }
+  return value;
+}, appStoreConnectTarget = (args) => {
+  const testFlightFlags = args.filter((value) => value.startsWith("--testflight-"));
+  if (testFlightFlags.length === 0)
+    return;
+  if (args.some((value, index) => (value === "--testflight-group" || value === "--testflight-notes") && (!args[index + 1] || args[index + 1]?.startsWith("-")))) {
+    throw new TypeError("mobile publish ios requires a value after every TestFlight group or notes flag.");
+  }
+  const groups = valuesAfter(args, "--testflight-group");
+  const submitForReview = args.includes("--testflight-submit-review");
+  if (submitForReview && groups.length === 0) {
+    throw new TypeError("mobile publish ios --testflight-submit-review requires at least one --testflight-group.");
+  }
+  const whatsNew = valuesAfter(args, "--testflight-notes").map((note) => {
+    const separator = note.indexOf("=");
+    if (separator < 1 || separator === note.length - 1) {
+      throw new TypeError("mobile publish ios --testflight-notes must use locale=text.");
+    }
+    return {
+      locale: note.slice(0, separator),
+      text: note.slice(separator + 1)
+    };
+  });
+  return {
+    ...groups.length === 0 ? {} : { groups },
+    submitForReview,
+    ...whatsNew.length === 0 ? {} : { whatsNew }
+  };
+}, googlePlayTarget = (args) => {
+  const playFlags = args.filter((value) => value.startsWith("--play-"));
+  if (playFlags.length === 0)
+    return;
+  if (!args.includes("--play-track")) {
+    throw new TypeError("mobile publish android requires --play-track <track> when using Google Play options.");
+  }
+  const track = requireValueAfter(args, "--play-track");
+  const rolloutValue = args.includes("--play-rollout") ? requireValueAfter(args, "--play-rollout") : undefined;
+  const userFraction = rolloutValue === undefined ? undefined : Number(rolloutValue);
+  if (userFraction !== undefined && (!Number.isFinite(userFraction) || userFraction <= 0 || userFraction >= 1)) {
+    throw new TypeError("mobile publish android --play-rollout must be greater than 0 and less than 1.");
+  }
+  const requestedStatus = args.includes("--play-status") ? requireValueAfter(args, "--play-status") : undefined;
+  const statuses = {
+    completed: "completed",
+    draft: "draft",
+    halted: "halted",
+    "in-progress": "inProgress"
+  };
+  if (requestedStatus !== undefined && !(requestedStatus in statuses)) {
+    throw new TypeError("mobile publish android --play-status must be completed, draft, halted, or in-progress.");
+  }
+  let status2;
+  if (requestedStatus === undefined) {
+    status2 = userFraction === undefined ? "completed" : "inProgress";
+  } else if (requestedStatus === "in-progress") {
+    status2 = statuses["in-progress"];
+  } else if (requestedStatus === "completed") {
+    status2 = statuses.completed;
+  } else if (requestedStatus === "draft") {
+    status2 = statuses.draft;
+  } else {
+    status2 = statuses.halted;
+  }
+  if (userFraction === undefined ? status2 === "inProgress" || status2 === "halted" : status2 !== "inProgress" && status2 !== "halted") {
+    throw new TypeError("mobile publish android staged statuses require --play-rollout, and other statuses forbid it.");
+  }
+  const priorityValue = args.includes("--play-update-priority") ? requireValueAfter(args, "--play-update-priority") : undefined;
+  const inAppUpdatePriority = priorityValue === undefined ? undefined : Number(priorityValue);
+  if (inAppUpdatePriority !== undefined && (!Number.isInteger(inAppUpdatePriority) || inAppUpdatePriority < 0 || inAppUpdatePriority > 5)) {
+    throw new TypeError("mobile publish android --play-update-priority must be an integer from 0 through 5.");
+  }
+  if (args.some((value, index) => value === "--play-notes" && (!args[index + 1] || args[index + 1]?.startsWith("-")))) {
+    throw new TypeError("mobile publish android requires --play-notes <language=text>.");
+  }
+  const releaseNotes = valuesAfter(args, "--play-notes").map((note) => {
+    const separator = note.indexOf("=");
+    if (separator < 1 || separator === note.length - 1) {
+      throw new TypeError("mobile publish android --play-notes must use language=text.");
+    }
+    return {
+      language: note.slice(0, separator),
+      text: note.slice(separator + 1)
+    };
+  });
+  return {
+    changesNotSentForReview: args.includes("--play-hold-review"),
+    ...inAppUpdatePriority === undefined ? {} : { inAppUpdatePriority },
+    ...args.includes("--play-name") ? { name: requireValueAfter(args, "--play-name") } : {},
+    ...releaseNotes.length === 0 ? {} : { releaseNotes },
+    reviewBehavior: args.includes("--play-cancel-existing-review") ? "CANCEL_IN_REVIEW_AND_SUBMIT" : "ERROR_IF_IN_REVIEW",
+    status: status2,
+    track,
+    ...userFraction === undefined ? {} : { userFraction }
+  };
 }, requireAndroidReleaseReady = async (mobile, projectRoot) => {
   const releaseCheck = await inspectAbsoluteMobileRelease({ ...mobile, platforms: ["android"] }, projectRoot);
   if (releaseCheck.ready)
@@ -14852,7 +15394,7 @@ Mobile release transport checks failed.`);
     status: check2.status
   })));
   throw new TypeError("Android release validation failed before Gradle signing.");
-}, buildAndroid = async (args) => {
+}, buildAndroid = async (args, prepareVersionCode) => {
   const configPath2 = valueAfter(args, "--config");
   const { mobile, projectRoot } = await loadMobile(configPath2);
   if (!mobile.platforms.includes("android")) {
@@ -14871,13 +15413,14 @@ Mobile release transport checks failed.`);
       allowUnsigned: args.includes("--unsigned"),
       config: mobile,
       outputDirectory: valueAfter(args, "--outdir"),
-      projectRoot
+      projectRoot,
+      ...prepareVersionCode === undefined ? {} : { prepareVersionCode }
     });
     success = true;
     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: ${join43(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join44(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:android-release-build", {
@@ -14889,6 +15432,154 @@ Mobile release transport checks failed.`);
       unsignedAllowed: args.includes("--unsigned")
     });
   }
+}, printGooglePlayPublication = (googlePlay) => {
+  console.log(`${googlePlay.reused ? "Reused" : "Committed"} Google Play version ${googlePlay.receipt.versionCode} on ${googlePlay.receipt.intent.track}.`);
+}, printAppStoreConnectPublication = (publication) => {
+  const { receipt } = publication;
+  console.log(`${publication.reused ? "Reused" : "Uploaded"} App Store Connect build ${receipt.marketingVersion} (${receipt.buildNumber}); ${receipt.stage}.`);
+}, publishAndroid = async (args) => {
+  const registryModule = args.includes("--registry") ? requireValueAfter(args, "--registry") : "mobile.release.ts";
+  const channel = args.includes("--channel") ? requireValueAfter(args, "--channel") : undefined;
+  const configPath2 = valueAfter(args, "--config");
+  const googlePlay = googlePlayTarget(args);
+  const { mobile, projectRoot } = await loadMobile(configPath2);
+  const startedAt = performance.now();
+  let reused = false;
+  let success = false;
+  try {
+    const publisher = await loadAbsoluteNativeReleasePublisher(projectRoot, registryModule);
+    const release = await buildAndroid(args, googlePlay ? (buildIdentity) => prepareAbsoluteAndroidRelease(publisher, {
+      buildIdentity,
+      googlePlay,
+      packageName: mobile.appId
+    }) : undefined);
+    const publication = await publishAbsoluteAndroidRelease({
+      allowUnsigned: args.includes("--unsigned"),
+      channel,
+      googlePlay,
+      modulePath: registryModule,
+      projectRoot,
+      release
+    });
+    const { reused: publicationReused } = publication;
+    reused = publicationReused;
+    success = true;
+    console.log(`${publication.reused ? "Reused" : "Published"} Android release ${release.metadata.releaseId}${publication.channel ? ` on ${publication.channel.channel}` : ""}.`);
+    if (publication.googlePlay)
+      printGooglePlayPublication(publication.googlePlay);
+    return publication;
+  } finally {
+    sendTelemetryEvent("mobile:android-release-publish", {
+      durationMs: Math.round(performance.now() - startedAt),
+      engine: "capacitor",
+      platform: "android",
+      provider: googlePlay ? "google-play" : "registry-module",
+      reused,
+      success,
+      type: "aab",
+      unsignedAllowed: args.includes("--unsigned")
+    });
+  }
+}, requireIosReleaseReady = async (mobile, projectRoot) => {
+  const releaseCheck = await inspectAbsoluteMobileRelease({ ...mobile, platforms: ["ios"] }, projectRoot);
+  if (releaseCheck.ready)
+    return;
+  printDoctorChecks(releaseCheck.checks.map((check2) => ({
+    id: check2.id,
+    label: check2.detail,
+    path: check2.path,
+    platform: "ios",
+    remediation: check2.remediation,
+    status: check2.status
+  })));
+  throw new TypeError("iOS release validation failed before Xcode signing.");
+}, buildIos = async (args, prepareBuildNumber) => {
+  const configPath2 = valueAfter(args, "--config");
+  const { mobile, projectRoot } = await loadMobile(configPath2);
+  if (!mobile.platforms.includes("ios")) {
+    throw new TypeError("mobile build ios requires ios in mobile.platforms.");
+  }
+  const startedAt = performance.now();
+  let success = false;
+  try {
+    await start(mobileBuildServerEntry(args), valueAfter(args, "--web-outdir"), configPath2, { prepareOnly: true });
+    await writeAbsoluteCapacitorConfig(mobile, { projectRoot });
+    await runCapacitorForPlatforms(projectRoot, "sync", ["ios"]);
+    await applyAbsoluteNativeDeepLinks(mobile, ["ios"]);
+    await requireIosReleaseReady(mobile, projectRoot);
+    const release = await buildAbsoluteIosRelease({
+      allowUnsigned: args.includes("--unsigned"),
+      config: mobile,
+      outputDirectory: valueAfter(args, "--outdir"),
+      ...prepareBuildNumber === undefined ? {} : { prepareBuildNumber },
+      projectRoot
+    });
+    success = true;
+    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: ${join44(release.releaseRoot, "release.json")}`);
+    return release;
+  } finally {
+    sendTelemetryEvent("mobile:ios-release-build", {
+      durationMs: Math.round(performance.now() - startedAt),
+      engine: "capacitor",
+      platform: "ios",
+      success,
+      type: "ipa",
+      unsignedAllowed: args.includes("--unsigned")
+    });
+  }
+}, publishIos = async (args) => {
+  const registryModule = args.includes("--registry") ? requireIosValueAfter(args, "--registry") : "mobile.release.ts";
+  const channel = args.includes("--channel") ? requireIosValueAfter(args, "--channel") : undefined;
+  const configPath2 = valueAfter(args, "--config");
+  const appStoreConnect = appStoreConnectTarget(args);
+  const { mobile, projectRoot } = await loadMobile(configPath2);
+  const startedAt = performance.now();
+  let reused = false;
+  let success = false;
+  try {
+    const publisher = await loadAbsoluteNativeReleasePublisher(projectRoot, registryModule);
+    const release = await buildIos(args, appStoreConnect ? (buildIdentity) => {
+      if (!mobile.iosVersion)
+        throw new TypeError("iOS publishing requires mobile.ios.version.");
+      return prepareAbsoluteIosRelease(publisher, {
+        buildIdentity,
+        bundleId: mobile.appId,
+        marketingVersion: mobile.iosVersion
+      });
+    } : undefined);
+    const publication = await publishAbsoluteIosRelease({
+      allowUnsigned: args.includes("--unsigned"),
+      appStoreConnect,
+      channel,
+      modulePath: registryModule,
+      projectRoot,
+      release
+    });
+    const {
+      appStoreConnect: appStoreConnectPublication,
+      reused: publicationReused
+    } = publication;
+    reused = publicationReused;
+    success = true;
+    console.log(`${publication.reused ? "Reused" : "Published"} iOS release ${release.metadata.releaseId}${publication.channel ? ` on ${publication.channel.channel}` : ""}.`);
+    if (appStoreConnectPublication)
+      printAppStoreConnectPublication(appStoreConnectPublication);
+    return publication;
+  } finally {
+    sendTelemetryEvent("mobile:ios-release-publish", {
+      durationMs: Math.round(performance.now() - startedAt),
+      engine: "capacitor",
+      platform: "ios",
+      provider: appStoreConnect ? "app-store-connect" : "registry-module",
+      reused,
+      success,
+      type: "ipa",
+      unsignedAllowed: args.includes("--unsigned")
+    });
+  }
 }, doctor = async (args) => {
   if (args.includes("release")) {
     await runReleaseDoctor(args);
@@ -14955,7 +15646,7 @@ Emulator setup verification:`);
     }
     return { https: args.includes("--https"), port };
   }
-  const instances = listLiveInstances().filter((instance2) => resolve36(instance2.cwd) === resolve36(projectRoot) && instance2.source === "dev" && instance2.port !== null);
+  const instances = listLiveInstances().filter((instance2) => resolve38(instance2.cwd) === resolve38(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>.");
   }
@@ -14998,8 +15689,8 @@ Emulator setup verification:`);
   }
   return selected;
 }, safeArtifactRoot = (projectRoot, value) => {
-  const root = resolve36(projectRoot, value ?? ".absolutejs/mobile/test-artifacts");
-  if (root !== projectRoot && !root.startsWith(`${resolve36(projectRoot)}/`)) {
+  const root = resolve38(projectRoot, value ?? ".absolutejs/mobile/test-artifacts");
+  if (root !== projectRoot && !root.startsWith(`${resolve38(projectRoot)}/`)) {
     throw new TypeError("mobile test --artifacts must remain inside the project.");
   }
   return root;
@@ -15023,12 +15714,12 @@ Emulator setup verification:`);
     timeoutMs
   });
 }, writeAndroidFailureArtifacts = async (options) => {
-  await mkdir9(options.artifactRoot, { recursive: true });
-  const screenshot = options.session ? await options.session.screenshot(join43(options.artifactRoot, "android-failure.png")).catch(() => {
+  await mkdir10(options.artifactRoot, { recursive: true });
+  const screenshot = options.session ? await options.session.screenshot(join44(options.artifactRoot, "android-failure.png")).catch(() => {
     return;
   }) : undefined;
-  const diagnosticPath = join43(options.artifactRoot, "android-failure.json");
-  await writeFile9(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join44(options.artifactRoot, "android-failure.json");
+  await writeFile10(diagnosticPath, `${JSON.stringify({
     diagnostics: options.session?.diagnostics ?? [],
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "android",
@@ -15138,7 +15829,19 @@ Emulator setup verification:`);
     await buildAndroid(args.slice(2));
     return;
   }
-  throw new TypeError("Usage: absolute mobile <init [--no-native] [--force] | sync [ios|android] | associations [--outdir dir] [--verify] | doctor [ios|android|release] [--json|--fix [--yes]] | build android [server-entry] [--outdir dir] [--web-outdir dir] [--unsigned] | test android [--route path] [--wait-for-hmr] [--timeout ms] [--port n] [--serial id] [--artifacts dir] [--json]> [--config path]");
+  if (command === "build" && args[1] === "ios") {
+    await buildIos(args.slice(2));
+    return;
+  }
+  if (command === "publish" && args[1] === "android") {
+    await publishAndroid(args.slice(2));
+    return;
+  }
+  if (command === "publish" && args[1] === "ios") {
+    await publishIos(args.slice(2));
+    return;
+  }
+  throw new TypeError("Usage: absolute mobile <init [--no-native] [--force] | sync [ios|android] | associations [--outdir dir] [--verify] | doctor [ios|android|release] [--json|--fix [--yes]] | build <android|ios> [server-entry] [--outdir dir] [--web-outdir dir] [--unsigned] | 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] [--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] [--timeout ms] [--port n] [--serial id] [--artifacts dir] [--json]> [--config path]");
 };
 var init_mobile = __esm(() => {
   init_capacitorProject();
@@ -15154,6 +15857,8 @@ var init_mobile = __esm(() => {
   init_telemetryEvent();
   init_releaseDoctor();
   init_androidRelease();
+  init_iosRelease();
+  init_releasePublisher();
   init_start();
   init_utils();
   init_getDurationString();
@@ -15171,10 +15876,10 @@ var exports_typecheck = {};
 __export(exports_typecheck, {
   typecheck: () => typecheck
 });
-import { resolve as resolve37, join as join44 } from "path";
+import { resolve as resolve39, join as join45 } from "path";
 import { existsSync as existsSync42, readFileSync as readFileSync37 } from "fs";
-import { mkdir as mkdir10, writeFile as writeFile10 } from "fs/promises";
-var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve37(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
+import { mkdir as mkdir11, writeFile as writeFile11 } from "fs/promises";
+var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve39(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
   if (!existsSync42(resolveConfigPath(configPath2))) {
     const defaultService = {};
     return [defaultService];
@@ -15196,7 +15901,7 @@ var isCommandService3 = (service) => service.kind === "command" || Array.isArray
   const exitCode = await proc.exited;
   return { exitCode, name, output: (stdout + stderr).trim() };
 }, shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`, runShell = async (name, command) => run(name, ["/bin/bash", "-lc", command]), findBin = (name) => {
-  const local = resolve37("node_modules", ".bin", name);
+  const local = resolve39("node_modules", ".bin", name);
   return existsSync42(local) ? local : null;
 }, ANSI_COLOR_REGEX, ANSI_PURPLE_REGEX, ANSI_CYAN_REGEX, ANSI_TOKEN_END_REGEX, stripAnsi4 = (str) => str.replace(ANSI_COLOR_REGEX, ""), formatSvelteOutput = (output) => {
   const cwd = `${process.cwd()}/`;
@@ -15244,15 +15949,15 @@ Found ${errorCount} error${suffix}.`;
   return formatted;
 }, ABSOLUTE_INTERNAL_EXCLUDES, resolveAbsoluteTypeFile = (fileName) => {
   const candidates = [
-    resolve37("node_modules/@absolutejs/absolute/dist/types", fileName),
-    resolve37(import.meta.dir, "../types", fileName),
-    resolve37(import.meta.dir, "../../types", fileName),
-    resolve37(import.meta.dir, "../../../types", fileName)
+    resolve39("node_modules/@absolutejs/absolute/dist/types", fileName),
+    resolve39(import.meta.dir, "../types", fileName),
+    resolve39(import.meta.dir, "../../types", fileName),
+    resolve39(import.meta.dir, "../../../types", fileName)
   ];
   return candidates.find((candidate) => existsSync42(candidate)) ?? candidates[0];
 }, ABSOLUTE_TYPECHECK_FILES, readProjectTsconfig = () => {
   try {
-    return JSON.parse(readFileSync37(resolve37("tsconfig.json"), "utf-8"));
+    return JSON.parse(readFileSync37(resolve39("tsconfig.json"), "utf-8"));
   } catch {
     return {};
   }
@@ -15280,22 +15985,22 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m vue-tsc is required for Vue type checking. Install it: bun add -d vue-tsc");
     process.exit(1);
   }
-  const vueTsconfigPath = join44(cacheDir, "tsconfig.vue-check.json");
-  return writeFile10(vueTsconfigPath, JSON.stringify({
+  const vueTsconfigPath = join45(cacheDir, "tsconfig.vue-check.json");
+  return writeFile11(vueTsconfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve37("tsconfig.json"),
+    extends: resolve39("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("vue-tsc", [
     vueTscBin,
     "--noEmit",
     "--project",
-    resolve37(vueTsconfigPath),
+    resolve39(vueTsconfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join44(cacheDir, "vue-tsc.tsbuildinfo"),
+    join45(cacheDir, "vue-tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildAngularCheck = async (cacheDir, angularDir) => {
@@ -15304,8 +16009,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m @angular/compiler-cli is required for Angular type checking. Install it: bun add -d @angular/compiler-cli");
     process.exit(1);
   }
-  const angularTsconfigPath = join44(cacheDir, "tsconfig.angular-check.json");
-  await writeFile10(angularTsconfigPath, JSON.stringify({
+  const angularTsconfigPath = join45(cacheDir, "tsconfig.angular-check.json");
+  await writeFile11(angularTsconfigPath, JSON.stringify({
     angularCompilerOptions: {
       strictTemplates: true
     },
@@ -15314,32 +16019,32 @@ Found ${errorCount} error${suffix}.`;
       rootDir: ".."
     },
     exclude: ABSOLUTE_INTERNAL_EXCLUDES.map(toGeneratedConfigPath),
-    extends: resolve37("tsconfig.json"),
+    extends: resolve39("tsconfig.json"),
     include: [`../${angularDir}/**/*`]
   }, null, "\t"));
-  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve37(angularTsconfigPath))}`);
+  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve39(angularTsconfigPath))}`);
 }, buildTscCheck = (cacheDir) => {
   const tscBin = findBin("tsc");
   if (!tscBin) {
     console.error("\x1B[31m\u2717\x1B[0m typescript is required for type checking. Install it: bun add -d typescript");
     process.exit(1);
   }
-  const tscConfigPath = join44(cacheDir, "tsconfig.typecheck.json");
-  return writeFile10(tscConfigPath, JSON.stringify({
+  const tscConfigPath = join45(cacheDir, "tsconfig.typecheck.json");
+  return writeFile11(tscConfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve37("tsconfig.json"),
+    extends: resolve39("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("tsc", [
     tscBin,
     "--noEmit",
     "--project",
-    resolve37(tscConfigPath),
+    resolve39(tscConfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join44(cacheDir, "tsc.tsbuildinfo"),
+    join45(cacheDir, "tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildSvelteCheck = async (cacheDir, svelteDir) => {
@@ -15348,16 +16053,16 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m svelte-check is required for Svelte type checking. Install it: bun add -d svelte-check");
     process.exit(1);
   }
-  const svelteTsconfigPath = join44(cacheDir, "tsconfig.svelte-check.json");
-  await writeFile10(svelteTsconfigPath, JSON.stringify({
-    extends: resolve37("tsconfig.json"),
+  const svelteTsconfigPath = join45(cacheDir, "tsconfig.svelte-check.json");
+  await writeFile11(svelteTsconfigPath, JSON.stringify({
+    extends: resolve39("tsconfig.json"),
     files: ABSOLUTE_TYPECHECK_FILES,
     include: [`../${svelteDir}/**/*`]
   }, null, "\t"));
   return run("svelte-check", [
     svelteBin,
     "--tsconfig",
-    resolve37(svelteTsconfigPath),
+    resolve39(svelteTsconfigPath),
     "--threshold",
     "error",
     "--compiler-warnings",
@@ -15378,7 +16083,7 @@ Found ${errorCount} error${suffix}.`;
     ...new Set(targets.map((config) => config.angularDirectory).filter((dir) => typeof dir === "string" && dir.length > 0))
   ];
   const cacheDir = ".absolutejs";
-  await mkdir10(cacheDir, { recursive: true });
+  await mkdir11(cacheDir, { recursive: true });
   const checks = [];
   checks.push(hasVue ? buildVueTscCheck(cacheDir) : buildTscCheck(cacheDir));
   for (const svelteDir of hasSvelte ? svelteDirs : []) {
@@ -15551,11 +16256,11 @@ var DEFAULT_RELAY_PORT = 8787, DEFAULT_REQUEST_TIMEOUT_MS = 30000, headersToObje
         url: url.pathname + url.search,
         ...bodyBytes && bodyBytes.length > 0 ? { bodyBase64: Buffer.from(bodyBytes).toString("base64") } : {}
       };
-      const responsePromise = new Promise((resolve38) => {
-        pending.set(id, resolve38);
+      const responsePromise = new Promise((resolve40) => {
+        pending.set(id, resolve40);
       });
       client.send(encodeTunnelMessage(message));
-      const timeout = new Promise((resolve38) => setTimeout(() => resolve38({ id, message: "timeout", type: "error" }), requestTimeoutMs));
+      const timeout = new Promise((resolve40) => setTimeout(() => resolve40({ id, message: "timeout", type: "error" }), requestTimeoutMs));
       const result = await Promise.race([responsePromise, timeout]);
       pending.delete(id);
       if (result.type === "error") {