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

package/dist/mobile/index.js

@@ -615,7 +615,7 @@ var verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes
   return release;
 };
 // src/mobile/androidRelease.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import {
   access as access3,
   copyFile as copyFile2,
@@ -702,6 +702,7 @@ import {
   rm as rm2,
   writeFile as writeFile3
 } from "fs/promises";
+import { createHash as createHash3, randomUUID } from "crypto";
 import {
   dirname,
   isAbsolute,
@@ -762,6 +763,8 @@ var writeAbsoluteCapacitorConfig = async (config, options) => {
 // src/mobile/androidEmulatorController.ts
 init_getDurationString();
 var HASH_RADIX = 16;
+var EXECUTABLE_MODE_MASK = 73;
+var NATIVE_PUBLIC_PATH_SEGMENTS = 5;
 var CAPACITOR_PROJECT_DIRECTORY_PATTERN = /project\(['"](:[^'"]+)['"]\)\.projectDir\s*=\s*new File\(['"]([^'"]+)['"]\)/gu;
 var pathExists = async (path) => {
   try {
@@ -826,6 +829,75 @@ var throwIfAborted = (signal) => {
     return;
   throw new DOMException("Android development startup was cancelled.", "AbortError");
 };
+var nativeDependencySources = async (nativeDirectory) => {
+  const settings = await readFile3(join3(nativeDirectory, "capacitor.settings.gradle"), "utf8");
+  const pattern = new RegExp(CAPACITOR_PROJECT_DIRECTORY_PATTERN.source, CAPACITOR_PROJECT_DIRECTORY_PATTERN.flags);
+  const dependencies = [...settings.matchAll(pattern)].map((match) => ({
+    name: (match[1] ?? "").slice(1).replaceAll(/[^a-zA-Z0-9_.-]/gu, "_"),
+    source: resolve2(nativeDirectory, match[2] ?? "")
+  }));
+  if (dependencies.length === 0) {
+    throw new Error("Capacitor Android settings did not declare any native dependencies.");
+  }
+  return { dependencies, settings };
+};
+var shouldIgnoreNativePath = (relativePath, ignorePublicBundle) => {
+  const parts = relativePath.split(sep);
+  if (parts.includes(".gradle") || parts.includes("build") || parts.includes(".absolutejs-dependencies")) {
+    return true;
+  }
+  return ignorePublicBundle && parts.slice(0, NATIVE_PUBLIC_PATH_SEGMENTS).join("/") === "app/src/main/assets/public";
+};
+var collectNativePath = async (root, label, path, isDirectory, isFile, isSymbolicLink, ignorePublicBundle) => {
+  const relativePath = relative2(root, path);
+  if (shouldIgnoreNativePath(relativePath, ignorePublicBundle))
+    return [];
+  const identity = `${label}:${relativePath.split(sep).join("/")}\x00`;
+  if (isDirectory) {
+    return collectNativeDirectory(root, label, path, ignorePublicBundle);
+  }
+  if (isSymbolicLink) {
+    return [`link\x00${identity}${await readlink(path)}\x00`];
+  }
+  if (!isFile)
+    return [];
+  const [metadata, contents] = await Promise.all([
+    lstat(path),
+    readFile3(path)
+  ]);
+  const contentDigest = createHash3("sha256").update(contents).digest("hex");
+  return [
+    `file\x00${identity}${metadata.mode & EXECUTABLE_MODE_MASK}\x00${contentDigest}\x00`
+  ];
+};
+var collectNativeDirectory = async (root, label, directory, ignorePublicBundle) => {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  entries.sort((left, right) => left.name.localeCompare(right.name));
+  const records = await Promise.all(entries.map((entry) => collectNativePath(root, label, join3(directory, entry.name), entry.isDirectory(), entry.isFile(), entry.isSymbolicLink(), ignorePublicBundle)));
+  return records.flat();
+};
+var hashNativeTree = async (root, label, ignorePublicBundle) => {
+  const resolvedRoot = await realpath(root);
+  const records = await collectNativeDirectory(resolvedRoot, label, resolvedRoot, ignorePublicBundle);
+  return createHash3("sha256").update(records.join("")).digest("hex");
+};
+var fingerprintAbsoluteAndroidNativeProject = async (project) => {
+  const { dependencies } = await nativeDependencySources(project.nativeDirectory);
+  const roots = [
+    {
+      ignorePublicBundle: true,
+      label: "android",
+      source: project.nativeDirectory
+    },
+    ...dependencies.sort((left, right) => left.name.localeCompare(right.name)).map((dependency) => ({
+      ignorePublicBundle: false,
+      label: `dependency:${dependency.name}`,
+      source: dependency.source
+    }))
+  ];
+  const treeDigests = await Promise.all(roots.map((root) => hashNativeTree(root.source, root.label, root.ignorePublicBundle)));
+  return createHash3("sha256").update(treeDigests.join("\x00")).digest("hex");
+};
 var windowsPathFromWsl = (path, capture) => {
   const result = capture(["wslpath", "-w", path]);
   if (result.exitCode !== 0 || !result.stdout.trim()) {
@@ -851,12 +923,13 @@ var mirroredCapacitorDependencies = async (project, capture) => {
   }
   return { dependencies, rewrittenSettings };
 };
-var encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task) => {
+var 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}'))`,
@@ -864,6 +937,7 @@ var encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndro
     `$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",
@@ -873,7 +947,7 @@ var encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndro
     "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("; ");
@@ -901,6 +975,7 @@ var buildAbsoluteAndroidGradleArtifact = async (options) => {
   const capture = options.capture ?? captureCommand;
   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);
@@ -912,7 +987,7 @@ var buildAbsoluteAndroidGradleArtifact = async (options) => {
       "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");
@@ -922,7 +997,7 @@ var buildAbsoluteAndroidGradleArtifact = async (options) => {
     };
   }
   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 };
 };
@@ -983,7 +1058,7 @@ var verifyAabSignature = (artifactPath, capture, jarsigner) => {
   ]);
   return result.exitCode === 0 && /jar verified/iu.test(result.stdout);
 };
-var sha256File = async (path) => createHash3("sha256").update(await readFile4(path)).digest("hex");
+var sha256File = async (path) => createHash4("sha256").update(await readFile4(path)).digest("hex");
 var safeOutputDirectory = (projectRoot, requested) => {
   const root = resolve3(projectRoot);
   const output = resolve3(root, requested ?? ".absolutejs/mobile/releases/android");
@@ -1037,12 +1112,32 @@ var requireManifestIdentity = (value, expected) => {
   return { ...expected, artifact };
 };
 var 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 = resolve3(options.projectRoot);
   const host = options.host ?? detectAbsoluteMobileHost();
   const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host);
   const nativeDirectory = join4(options.config.nativeProjectDirectory, "android");
+  const manifest = requireManifest(JSON.parse(await readFile4(join4(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 = createHash4("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,
@@ -1064,10 +1159,6 @@ var buildAbsoluteAndroidRelease = async (options) => {
   if (!signed && !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 readFile4(join4(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, sha256] = await Promise.all([
     stat(artifactPath).then(({ size }) => size),
     sha256File(artifactPath)
@@ -1084,32 +1175,314 @@ var buildAbsoluteAndroidRelease = async (options) => {
     runtime: manifest.runtime,
     sha256,
     signed: signed === true,
-    type: "aab"
+    type: "aab",
+    ...versionCode === undefined ? {} : { versionCode }
   };
   return installRelease(artifactPath, metadata, safeOutputDirectory(projectRoot, options.outputDirectory));
 };
-// src/mobile/associationFiles.ts
+// src/mobile/iosRelease.ts
+import { createHash as createHash5 } from "crypto";
 import {
   access as access4,
+  copyFile as copyFile3,
   mkdir as mkdir4,
+  mkdtemp as mkdtemp3,
+  readdir as readdir3,
   readFile as readFile5,
   rename as rename5,
   rm as rm4,
+  stat as stat2,
   writeFile as writeFile5
 } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join5, relative as relative4, resolve as resolve4, sep as sep3 } from "path";
+var ABSOLUTE_IOS_RELEASE_FORMAT = 1;
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var requireManifest2 = (value) => {
+  if (!isRecord2(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
+  };
+};
+var pathExists3 = async (path) => {
+  try {
+    await access4(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var defaultRun = async (command, options = {}) => {
+  const process2 = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  return process2.exited;
+};
+var defaultCapture2 = (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: ""
+    };
+  }
+};
+var ignoredFingerprintDirectories = new Set([
+  "Pods",
+  "DerivedData",
+  "build",
+  "xcuserdata"
+]);
+var fingerprintFiles = async (root, current = root) => {
+  const entries = await readdir3(current, { withFileTypes: true });
+  const nested = await Promise.all(entries.sort((left, right) => left.name.localeCompare(right.name)).map(async (entry) => {
+    const path = join5(current, entry.name);
+    const projectRelative = relative4(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();
+};
+var fingerprintAbsoluteIosNativeProject = async (nativeDirectory) => {
+  const hasher = createHash5("sha256");
+  const files = await fingerprintFiles(nativeDirectory);
+  const contents = await Promise.all(files.map((file) => readFile5(file)));
+  files.forEach((file, index) => {
+    hasher.update(relative4(nativeDirectory, file).replaceAll("\\", "/"));
+    hasher.update("\x00");
+    hasher.update(contents[index] ?? new Uint8Array);
+    hasher.update("\x00");
+  });
+  return hasher.digest("hex");
+};
+var safeOutputDirectory2 = (projectRoot, requested) => {
+  const root = resolve4(projectRoot);
+  const output = resolve4(root, requested ?? ".absolutejs/mobile/releases/ios");
+  const projectRelative = relative4(root, output);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep3}`) || isAbsolute3(projectRelative)) {
+    throw new TypeError("mobile build --outdir must remain inside the project.");
+  }
+  return output;
+};
+var sha256File2 = async (path) => createHash5("sha256").update(await readFile5(path)).digest("hex");
+var findByExtension = async (root, extension) => {
+  if (!await pathExists3(root))
+    return;
+  const entries = await readdir3(root, { withFileTypes: true });
+  const matches = await Promise.all(entries.map(async (entry) => {
+    const path = join5(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);
+};
+var 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>
+`;
+var requireBuildNumber = (value) => {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value < 1))
+    throw new TypeError("iOS build number must be a positive integer.");
+  return value;
+};
+var installRelease2 = async (artifactPath, metadata, outputRoot) => {
+  const releaseRoot = join5(outputRoot, metadata.releaseId);
+  const destination = join5(releaseRoot, "App.ipa");
+  if (await pathExists3(releaseRoot)) {
+    const value = JSON.parse(await readFile5(join5(releaseRoot, "release.json"), "utf8"));
+    if (!isRecord2(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, sha256] = await Promise.all([
+      stat2(destination).then(({ size }) => size),
+      sha256File2(destination)
+    ]);
+    if (bytes !== metadata.bytes || sha256 !== 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 mkdir4(dirname3(releaseRoot), { recursive: true });
+  const staging = await mkdtemp3(join5(dirname3(releaseRoot), ".ios-stage-"));
+  try {
+    await copyFile3(artifactPath, join5(staging, "App.ipa"));
+    const complete = {
+      ...metadata,
+      artifact: "App.ipa"
+    };
+    await writeFile5(join5(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+`, { flag: "wx" });
+    await rename5(staging, releaseRoot);
+    return { artifactPath: destination, metadata: complete, releaseRoot };
+  } finally {
+    await rm4(staging, { force: true, recursive: true }).catch(() => {
+      return;
+    });
+  }
+};
+var 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 readFile5(join5(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 = join5(options.config.nativeProjectDirectory, "ios");
+  let buildNumber = requireBuildNumber(options.buildNumber);
+  if (options.prepareBuildNumber) {
+    const nativeFingerprint = await fingerprintAbsoluteIosNativeProject(nativeDirectory);
+    const buildIdentity = createHash5("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}\x00${marketingVersion}`).digest("hex");
+    buildNumber = requireBuildNumber(await options.prepareBuildNumber(buildIdentity));
+  }
+  const stagingParent = resolve4(options.projectRoot, ".absolutejs/mobile");
+  await mkdir4(stagingParent, { recursive: true });
+  const staging = await mkdtemp3(join5(stagingParent, ".ios-build-"));
+  const archivePath = join5(staging, "App.xcarchive");
+  const exportPath = join5(staging, "export");
+  const exportPlist = join5(staging, "ExportOptions.plist");
+  await mkdir4(exportPath, { recursive: true });
+  await writeFile5(exportPlist, exportOptions());
+  const run = options.run ?? defaultRun;
+  try {
+    const versionArguments = [
+      `MARKETING_VERSION=${marketingVersion}`,
+      ...buildNumber === undefined ? [] : [`CURRENT_PROJECT_VERSION=${buildNumber}`]
+    ];
+    const archiveExit = await run([
+      "xcodebuild",
+      "-workspace",
+      join5(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(join5(archivePath, "Products", "Applications"), ".app");
+    const capture = options.capture ?? defaultCapture2;
+    const signed = archivedApp ? capture([
+      "codesign",
+      "--verify",
+      "--deep",
+      "--strict",
+      archivedApp
+    ]).exitCode === 0 : false;
+    if (!signed && !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, sha256] = await Promise.all([
+      stat2(artifactPath).then(({ size }) => size),
+      sha256File2(artifactPath)
+    ]);
+    const releaseId = `amobile_ios_${sha256}`;
+    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,
+      signed,
+      type: "ipa"
+    }, safeOutputDirectory2(options.projectRoot, options.outputDirectory));
+  } finally {
+    await rm4(staging, { force: true, recursive: true }).catch(() => {
+      return;
+    });
+  }
+};
+// src/mobile/associationFiles.ts
+import {
+  access as access5,
+  mkdir as mkdir5,
+  readFile as readFile6,
+  rename as rename6,
+  rm as rm5,
+  writeFile as writeFile6
+} from "fs/promises";
+import { resolve as resolve6 } from "path";
 import { Elysia } from "elysia";
 
 // src/mobile/config.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 var APP_ID_PATTERN = /^[A-Za-z][\w]*(?:\.[A-Za-z][\w]*)+$/;
 var SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*$/;
 var APPLE_APP_ID_PREFIX_PATTERN = /^[A-Z0-9]{10}$/;
 var CERTIFICATE_FINGERPRINT_PATTERN = /^[0-9A-F]{64}$/;
 var HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/;
 var resolveProjectPath = (projectRoot, value, field) => {
-  const root = resolve4(projectRoot);
-  const path = resolve4(root, value);
+  const root = resolve5(projectRoot);
+  const path = resolve5(root, value);
   if (path !== root && !path.startsWith(`${root}/`)) {
     throw new TypeError(`${field} must remain inside the project root.`);
   }
@@ -1172,6 +1545,15 @@ var normalizeAppleAppIdPrefix = (value) => {
   }
   return normalized;
 };
+var 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;
+};
 var normalizeCertificateFingerprints = (values) => [
   ...new Set((values ?? []).map((value) => requireText(value, "mobile.deepLinks.android.sha256CertificateFingerprints").replaceAll(":", "").toUpperCase()).map((value) => {
     if (!CERTIFICATE_FINGERPRINT_PATTERN.test(value)) {
@@ -1200,6 +1582,7 @@ var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
     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
@@ -1287,7 +1670,7 @@ var createAbsoluteMobileAssociationPlugin = (mobile, projectRoot, options = {})
 var writeAtomic = async (path, source) => {
   let current;
   try {
-    current = await readFile5(path, "utf8");
+    current = await readFile6(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -1296,23 +1679,23 @@ var writeAtomic = async (path, source) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile5(temporary, source, { flag: "wx" });
-  await rename5(temporary, path);
+  await writeFile6(temporary, source, { flag: "wx" });
+  await rename6(temporary, path);
   return true;
 };
 var exists2 = async (path) => {
   try {
-    await access4(path);
+    await access5(path);
     return true;
   } catch {
     return false;
   }
 };
 var assertOwnedOutput = async (root) => {
-  const path = resolve5(root, OWNERSHIP_FILE);
+  const path = resolve6(root, OWNERSHIP_FILE);
   let ownership;
   try {
-    ownership = JSON.parse(await readFile5(path, "utf8"));
+    ownership = JSON.parse(await readFile6(path, "utf8"));
   } catch {
     throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
   }
@@ -1326,22 +1709,22 @@ var publishGeneratedDirectory = async (temporary, root) => {
     await assertOwnedOutput(root);
   const backup = `${root}.${crypto.randomUUID()}.previous`;
   if (hasCurrent)
-    await rename5(root, backup);
+    await rename6(root, backup);
   try {
-    await rename5(temporary, root);
+    await rename6(temporary, root);
   } catch (error) {
     if (hasCurrent)
-      await rename5(backup, root);
+      await rename6(backup, root);
     throw error;
   }
   if (hasCurrent)
-    await rm4(backup, { force: true, recursive: true });
+    await rm5(backup, { force: true, recursive: true });
 };
 var materializeHost = async (root, host, files) => {
-  const directory = resolve5(root, host, ".well-known");
-  await mkdir4(directory, { recursive: true });
+  const directory = resolve6(root, host, ".well-known");
+  await mkdir5(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document]) => {
-    const path = resolve5(directory, name);
+    const path = resolve6(directory, name);
     await writeAtomic(path, `${JSON.stringify(document, null, 2)}
 `);
     return path;
@@ -1366,7 +1749,7 @@ var associationEndpoints = (config, documents) => config.deepLinkHosts.flatMap((
   return endpoints;
 });
 var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
-  const root = resolve5(outputDirectory);
+  const root = resolve6(outputDirectory);
   const temporary = `${root}.${crypto.randomUUID()}.tmp`;
   const documents = createAbsoluteMobileAssociationDocuments(config, {
     requireAll: true
@@ -1377,16 +1760,16 @@ var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory)
   if (documents.apple) {
     files.push(["apple-app-site-association", documents.apple]);
   }
-  await mkdir4(temporary, { recursive: true });
+  await mkdir5(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
-    await writeAtomic(resolve5(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+    await writeAtomic(resolve6(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
 `);
     await publishGeneratedDirectory(temporary, root);
-    const written = temporaryPaths.map((path) => resolve5(root, path.slice(temporary.length + 1)));
+    const written = temporaryPaths.map((path) => resolve6(root, path.slice(temporary.length + 1)));
     return { root, written };
   } catch (error) {
-    await rm4(temporary, { force: true, recursive: true });
+    await rm5(temporary, { force: true, recursive: true });
     throw error;
   }
 };
@@ -1431,10 +1814,10 @@ var frameworks2 = new Set([
   "svelte",
   "vue"
 ]);
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isPageFramework2 = (value) => typeof value === "string" && frameworks2.has(value);
 var parseAbsoluteMobileBuildPageMetadata = (value) => {
-  if (!isRecord2(value))
+  if (!isRecord3(value))
     return;
   if (typeof value.bundleKey !== "string" || typeof value.contract !== "string" || !isPageFramework2(value.framework) || typeof value.pageId !== "string" || typeof value.propsSchemaHash !== "string") {
     return;
@@ -1448,23 +1831,23 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
   };
 };
 // src/mobile/buildPipeline.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join8, resolve as resolve8 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join9, resolve as resolve9 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
-import { createHash as createHash4 } from "crypto";
-import { readFile as readFile6 } from "fs/promises";
-import { join as join5, relative as relative4, resolve as resolve6 } from "path";
-var sha256 = (bytes) => createHash4("sha256").update(bytes).digest("hex");
+import { createHash as createHash6 } from "crypto";
+import { readFile as readFile7 } from "fs/promises";
+import { join as join6, relative as relative5, resolve as resolve7 } from "path";
+var sha256 = (bytes) => createHash6("sha256").update(bytes).digest("hex");
 var readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]);
 var resolveAssetPath = (buildDirectory, assetPath) => {
-  const resolvedBuildDirectory = resolve6(buildDirectory);
-  const resolvedAsset = resolve6(assetPath);
+  const resolvedBuildDirectory = resolve7(buildDirectory);
+  const resolvedAsset = resolve7(assetPath);
   if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
     return resolvedAsset;
   }
-  return join5(buildDirectory, assetPath.replace(/^\/+/, ""));
+  return join6(buildDirectory, assetPath.replace(/^\/+/, ""));
 };
 var pageFor = async (metadata, manifest, buildDirectory) => {
   const assetPath = manifest[metadata.bundleKey];
@@ -1472,8 +1855,8 @@ var pageFor = async (metadata, manifest, buildDirectory) => {
     throw new TypeError(`Mobile page ${metadata.pageId} references missing manifest asset ${metadata.bundleKey}.`);
   }
   const resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
-  const bytes = await readFile6(resolvedAssetPath);
-  const bundlePath = `/${relative4(resolve6(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const bytes = await readFile7(resolvedAssetPath);
+  const bundlePath = `/${relative5(resolve7(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
@@ -1486,7 +1869,7 @@ var pageFor = async (metadata, manifest, buildDirectory) => {
 var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   const [captured, producerBytes] = await Promise.all([
     captureAbsoluteMobileRouteGraph(options.app),
-    readFile6(options.producerPath)
+    readFile7(options.producerPath)
   ]);
   if (captured.length === 0) {
     throw new TypeError("No instrumented AbsoluteJS mobile page routes were found in the finalized Elysia route graph.");
@@ -1566,16 +1949,16 @@ var captureAbsoluteMobileRouteGraph = async (app) => {
 
 // src/mobile/capacitorBundle.ts
 import {
-  copyFile as copyFile3,
-  mkdir as mkdir5,
-  mkdtemp as mkdtemp3,
-  readFile as readFile7,
-  rename as rename6,
-  rm as rm5,
-  writeFile as writeFile6
+  copyFile as copyFile4,
+  mkdir as mkdir6,
+  mkdtemp as mkdtemp4,
+  readFile as readFile8,
+  rename as rename7,
+  rm as rm6,
+  writeFile as writeFile7
 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { basename, dirname as dirname3, extname, join as join6, resolve as resolve7 } from "path";
+import { basename, dirname as dirname4, extname, join as join7, resolve as resolve8 } from "path";
 
 // src/mobile/routeMatcher.ts
 var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
@@ -1731,14 +2114,14 @@ var envelopeResponse = (response, status) => new Response(JSON.stringify({
   protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
   response
 }), { headers: responseHeaders(), status });
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var normalizeJsonValue = (value) => {
   const serialized = JSON.stringify(value);
   if (serialized === undefined) {
     throw new TypeError("Mobile page props must be JSON-serializable.");
   }
   const parsed = JSON.parse(serialized);
-  if (!isRecord3(parsed)) {
+  if (!isRecord4(parsed)) {
     throw new TypeError("Mobile page props must serialize to an object.");
   }
   return parsed;
@@ -1863,14 +2246,14 @@ var upgradeReasons = new Set([
   "protocol",
   "runtime"
 ]);
-var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isFramework = (value) => typeof value === "string" && frameworks4.has(value);
 var isUpgradeReason = (value) => typeof value === "string" && upgradeReasons.has(value);
 var parsePageResult = (value) => {
   if (typeof value.contract !== "string" || !isFramework(value.framework) || typeof value.pageId !== "string" || typeof value.status !== "number") {
     throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The mobile page response is missing required page metadata.");
   }
-  if (!isRecord4(value.props)) {
+  if (!isRecord5(value.props)) {
     throw new AbsoluteMobilePageProtocolError("invalid-props", "The mobile page response must contain an object props value.");
   }
   return {
@@ -1916,7 +2299,7 @@ var activateAbsoluteMobilePage = async (value, options) => {
   };
 };
 var parseAbsoluteMobilePageEnvelope = (value) => {
-  if (!isRecord4(value) || !isRecord4(value.response)) {
+  if (!isRecord5(value) || !isRecord5(value.response)) {
     throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The server did not return an AbsoluteJS mobile page envelope.");
   }
   if (value.protocol !== ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION) {
@@ -2009,7 +2392,7 @@ var INDEX_FILE = "index.html";
 var CLIENT_IMPORT_PATTERN = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s*)["'](\/[^"']+)["']/gu;
 var errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var shellBootstrapModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join6(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
+  const candidate = ["js", "ts"].map((extension) => join7(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
@@ -2030,8 +2413,8 @@ var indexHtml = (appName) => `<!doctype html>
 </html>
 `;
 var sourceAssetPath = (buildDirectory, bundlePath) => {
-  const root = resolve7(buildDirectory);
-  const asset = resolve7(root, bundlePath.replace(/^\/+/, ""));
+  const root = resolve8(buildDirectory);
+  const asset = resolve8(root, bundlePath.replace(/^\/+/, ""));
   if (!asset.startsWith(`${root}/`)) {
     throw new TypeError("Mobile page bundle escaped the build directory.");
   }
@@ -2039,8 +2422,8 @@ var sourceAssetPath = (buildDirectory, bundlePath) => {
 };
 var buildShellBootstrap = async (staging) => {
   const modulePath = shellBootstrapModule();
-  const entryPath = join6(staging, ".absolute-mobile-entry.ts");
-  await writeFile6(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+  const entryPath = join7(staging, ".absolute-mobile-entry.ts");
+  await writeFile7(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
 void startAbsoluteMobileShell();
 `);
   const build = await Bun.build({
@@ -2052,31 +2435,31 @@ void startAbsoluteMobileShell();
   if (!build.success || build.outputs.length !== 1) {
     throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
   }
-  await rename6(build.outputs[0]?.path ?? "", join6(staging, BOOTSTRAP_FILE));
-  await rm5(entryPath, { force: true });
+  await rename7(build.outputs[0]?.path ?? "", join7(staging, BOOTSTRAP_FILE));
+  await rm6(entryPath, { force: true });
 };
 var removePreviousBundle = async (backup, moved) => {
   if (!moved)
     return;
-  await rm5(backup, { force: true, recursive: true });
+  await rm6(backup, { force: true, recursive: true });
 };
 var restorePreviousBundle = async (backup, destination, moved) => {
   if (!moved)
     return;
-  await rename6(backup, destination);
+  await rename7(backup, destination);
 };
 var installBundle = async (staging, destination) => {
   const backup = `${destination}.previous-${crypto.randomUUID()}`;
   let movedPrevious = false;
   try {
-    await rename6(destination, backup);
+    await rename7(destination, backup);
     movedPrevious = true;
   } catch (error) {
     if (!errorHasCode2(error, "ENOENT"))
       throw error;
   }
   try {
-    await rename6(staging, destination);
+    await rename7(staging, destination);
     await removePreviousBundle(backup, movedPrevious);
   } catch (error) {
     await restorePreviousBundle(backup, destination, movedPrevious);
@@ -2090,12 +2473,12 @@ var copyClientPage = async (page, buildDirectory, staging, copiedDependencies) =
   const extension = extname(page.bundlePath) || ".js";
   const localBundlePath = `./pages/${page.bundleHash}${extension}`;
   const source = sourceAssetPath(buildDirectory, page.bundlePath);
-  await copyFile3(source, join6(staging, localBundlePath));
+  await copyFile4(source, join7(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
   return { ...page, localBundlePath };
 };
 var absoluteClientImports = async (sourcePath) => {
-  const source = await readFile7(sourcePath, "utf8");
+  const source = await readFile8(sourcePath, "utf8");
   return [...source.matchAll(CLIENT_IMPORT_PATTERN)].flatMap((match) => {
     const [specifier] = match.slice(1);
     return specifier ? [specifier.split(/[?#]/u, 1)[0] ?? specifier] : [];
@@ -2106,9 +2489,9 @@ var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, co
     return;
   copied.add(specifier);
   const source = sourceAssetPath(buildDirectory, specifier);
-  const destination = join6(staging, specifier.replace(/^\/+/, ""));
-  await mkdir5(dirname3(destination), { recursive: true });
-  await copyFile3(source, destination);
+  const destination = join7(staging, specifier.replace(/^\/+/, ""));
+  await mkdir6(dirname4(destination), { recursive: true });
+  await copyFile4(source, destination);
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
 };
 var copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
@@ -2120,11 +2503,11 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
     throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
   }
   const destination = options.config.bundleDirectory;
-  await mkdir5(dirname3(destination), { recursive: true });
-  const staging = await mkdtemp3(join6(dirname3(destination), `.${basename(destination)}.stage-`));
+  await mkdir6(dirname4(destination), { recursive: true });
+  const staging = await mkdtemp4(join7(dirname4(destination), `.${basename(destination)}.stage-`));
   try {
-    const pageDirectory = join6(staging, "pages");
-    await mkdir5(pageDirectory, { recursive: true });
+    const pageDirectory = join7(staging, "pages");
+    await mkdir6(pageDirectory, { recursive: true });
     const copiedDependencies = new Set;
     const pages = await Promise.all(options.artifact.pages.map((page) => copyClientPage(page, options.buildDirectory, staging, copiedDependencies)));
     const manifest = {
@@ -2141,48 +2524,48 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       runtime: options.artifact.runtime
     };
     await Promise.all([
-      writeFile6(join6(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+      writeFile7(join7(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
-      writeFile6(join6(staging, INDEX_FILE), indexHtml(options.config.appName)),
+      writeFile7(join7(staging, INDEX_FILE), indexHtml(options.config.appName)),
       buildShellBootstrap(staging)
     ]);
     await installBundle(staging, destination);
     return manifest;
   } catch (error) {
-    await rm5(staging, { force: true, recursive: true });
+    await rm6(staging, { force: true, recursive: true });
     throw error;
   }
 };
 
 // src/mobile/materializedBundle.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import {
-  access as access5,
-  mkdir as mkdir6,
-  mkdtemp as mkdtemp4,
-  readFile as readFile8,
-  rename as rename7,
-  rm as rm6,
-  writeFile as writeFile7
+  access as access6,
+  mkdir as mkdir7,
+  mkdtemp as mkdtemp5,
+  readFile as readFile9,
+  rename as rename8,
+  rm as rm7,
+  writeFile as writeFile8
 } from "fs/promises";
-import { dirname as dirname4, join as join7, resolve as resolvePath2 } from "path";
+import { dirname as dirname5, join as join8, resolve as resolvePath2 } from "path";
 import { pathToFileURL } from "url";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1;
 var CURRENT_BUNDLE_FILE = "current.json";
 var BUNDLES_DIRECTORY = "bundles";
 var ARTIFACT_FILE2 = "artifact.json";
 var BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
-var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var errorHasCode3 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var bundleIdFor = (currentReleaseId, releases) => {
   const identity = JSON.stringify({
     currentReleaseId,
     releases: releases.map(({ releaseId }) => releaseId)
   });
-  return `amb_${createHash5("sha256").update(identity).digest("hex")}`;
+  return `amb_${createHash7("sha256").update(identity).digest("hex")}`;
 };
 var parseBundleIndex = (value) => {
-  if (!isRecord5(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
+  if (!isRecord6(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
     throw new TypeError("Invalid materialized mobile compatibility bundle.");
   }
   const releases = value.releases.map(parseAbsoluteMobileCompatibilityArtifact);
@@ -2205,30 +2588,30 @@ var parseBundleIndex = (value) => {
   };
 };
 var writeRelease = async (root, release) => {
-  const directory = join7(root, release.artifact.releaseId);
-  const producerPath = join7(directory, release.artifact.producer.module);
-  await mkdir6(dirname4(producerPath), { recursive: true });
+  const directory = join8(root, release.artifact.releaseId);
+  const producerPath = join8(directory, release.artifact.producer.module);
+  await mkdir7(dirname5(producerPath), { recursive: true });
   await Promise.all([
-    writeFile7(join7(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile8(join8(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
-    writeFile7(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+    writeFile8(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 };
 var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join7(bundlesRoot, bundleId);
+  const destination = join8(bundlesRoot, bundleId);
   try {
-    await access5(destination);
+    await access6(destination);
     return destination;
   } catch (error) {
     if (!errorHasCode3(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp4(join7(bundlesRoot, ".stage-"));
+  const staging = await mkdtemp5(join8(bundlesRoot, ".stage-"));
   try {
     await Promise.all(releases.map((release) => writeRelease(staging, release)));
-    await rename7(staging, destination);
+    await rename8(staging, destination);
   } catch (error) {
-    await rm6(staging, { force: true, recursive: true });
+    await rm7(staging, { force: true, recursive: true });
     if (errorHasCode3(error, "EEXIST") || errorHasCode3(error, "ENOTEMPTY")) {
       return destination;
     }
@@ -2239,7 +2622,7 @@ var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
 var readCompatibilityModule = (modulePath) => import(pathToFileURL(modulePath).href);
 var resolveProducerHandler = (loaded, exportName) => {
   const value = loaded[exportName];
-  if (!isRecord5(value) || typeof value.handle !== "function") {
+  if (!isRecord6(value) || typeof value.handle !== "function") {
     throw new TypeError(`Compatibility producer export ${exportName} must expose handle(request).`);
   }
   const { handle } = value;
@@ -2257,15 +2640,15 @@ var resolveProducerHandler = (loaded, exportName) => {
 };
 var loadAbsoluteMobileMaterializedBundle = async (root) => {
   const resolvedRoot = resolvePath2(root);
-  const serialized = await readFile8(join7(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+  const serialized = await readFile9(join8(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
   const parsed = JSON.parse(serialized);
   const index = parseBundleIndex(parsed);
-  const bundleRoot = join7(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+  const bundleRoot = join8(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
   return {
     artifacts: index.releases,
     currentReleaseId: index.currentReleaseId,
     loadProducer: async (artifact) => {
-      const modulePath = join7(bundleRoot, artifact.releaseId, artifact.producer.module);
+      const modulePath = join8(bundleRoot, artifact.releaseId, artifact.producer.module);
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer: Bun.file(modulePath)
@@ -2292,8 +2675,8 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     return release;
   });
   const root = resolvePath2(input.root);
-  const bundlesRoot = join7(root, BUNDLES_DIRECTORY);
-  await mkdir6(bundlesRoot, { recursive: true });
+  const bundlesRoot = join8(root, BUNDLES_DIRECTORY);
+  await mkdir7(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
   const index = {
@@ -2302,22 +2685,22 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
     releases: artifacts
   };
-  const pointerPath = join7(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join7(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile7(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+  const pointerPath = join8(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join8(root, `.current-${crypto.randomUUID()}.json`);
+  await writeFile8(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
 `, { flag: "wx" });
-  await rename7(temporaryPointerPath, pointerPath);
+  await rename8(temporaryPointerPath, pointerPath);
   return index;
 };
 var readAbsoluteMobileMaterializedReleases = async (root) => {
   const resolvedRoot = resolvePath2(root);
   try {
-    const serialized = await readFile8(join7(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const serialized = await readFile9(join8(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
     const parsed = JSON.parse(serialized);
     const index = parseBundleIndex(parsed);
-    const bundleRoot = join7(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    const bundleRoot = join8(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
     return Promise.all(index.releases.map(async (artifact) => {
-      const producer = Bun.file(join7(bundleRoot, artifact.releaseId, artifact.producer.module));
+      const producer = Bun.file(join8(bundleRoot, artifact.releaseId, artifact.producer.module));
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer
@@ -2366,11 +2749,11 @@ var loadServerApp = async (producerPath) => {
   return { app, exportName };
 };
 var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve8(options.buildDirectory);
+  const buildDirectory = resolve9(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join8(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join9(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile9(join8(buildDirectory, "manifest.json"), "utf8"),
+    readFile10(join9(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -2381,7 +2764,7 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
   let loaded;
   try {
-    loaded = await loadServerApp(resolve8(options.producerPath));
+    loaded = await loadServerApp(resolve9(options.producerPath));
   } finally {
     restoreBuildDirectory(previousBuildDirectory);
   }
@@ -2392,7 +2775,7 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve8(options.producerPath),
+    producerPath: resolve9(options.producerPath),
     runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
   });
   const releasesById = new Map([current, ...previous].map((release) => [
@@ -2486,20 +2869,20 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
   }).as("global");
 };
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile10, rename as rename8, writeFile as writeFile8 } from "fs/promises";
-import { join as join9 } from "path";
+import { readFile as readFile11, rename as rename9, writeFile as writeFile9 } from "fs/promises";
+import { join as join10 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->";
 var END_MARKER = "<!-- absolutejs:deep-links:end -->";
 var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
 var NOT_FOUND = -1;
 var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var writeChangedFile = async (path, source) => {
-  const current = await readFile10(path, "utf8");
+  const current = await readFile11(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile8(temporary, source, { flag: "wx" });
-  await rename8(temporary, path);
+  await writeFile9(temporary, source, { flag: "wx" });
+  await rename9(temporary, path);
   return true;
 };
 var replaceManagedRegion = (source, region, insertAt) => {
@@ -2544,8 +2927,8 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join9(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile10(path, "utf8");
+  const path = join10(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile11(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
     throw new TypeError("Android MainActivity was not found.");
@@ -2570,8 +2953,8 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join9(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile10(path, "utf8");
+  const path = join10(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile11(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
 `;
@@ -2594,10 +2977,10 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join9(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join10(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
-    current = await readFile10(path, "utf8");
+    current = await readFile11(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -2607,13 +2990,13 @@ var configureIosEntitlements = async (config) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile8(temporary, source, { flag: "wx" });
-  await rename8(temporary, path);
+  await writeFile9(temporary, source, { flag: "wx" });
+  await rename9(temporary, path);
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join9(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const source = await readFile10(path, "utf8");
+  const path = join10(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const source = await readFile11(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
   ].map((match) => match[1]);
@@ -2650,15 +3033,113 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
     changed: results.filter(({ didChange }) => didChange).map(({ platform }) => platform)
   };
 };
+// src/mobile/releasePublisher.ts
+import { access as access7 } from "fs/promises";
+import { isAbsolute as isAbsolute4, relative as relative6, resolve as resolve10, sep as sep4 } from "path";
+import { pathToFileURL as pathToFileURL3 } 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;
+};
+var 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;
+};
+var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPublisher = (value) => isRecord7(value) && typeof value.publish === "function";
+var publisherModulePath = (projectRoot, requested) => {
+  const root = resolve10(projectRoot);
+  const path = resolve10(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 access7(modulePath).catch(() => {
+    throw new TypeError(`Native release registry module does not exist: ${modulePath}`);
+  });
+  const loaded = await import(pathToFileURL3(modulePath).href);
+  const publisher = isRecord7(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;
+};
+var 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;
+};
+var 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;
+};
 // src/mobile/routeMetadataTransform.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname5, extname as extname2, relative as relative5, resolve as resolve9 } from "path";
+import { dirname as dirname6, extname as extname2, relative as relative7, resolve as resolve11 } from "path";
 import ts from "typescript";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
 var PAGE_HANDLER = "handleReactPageRequest";
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname5(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname6(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
@@ -2670,7 +3151,7 @@ var createProgram = (entry, projectRoot) => {
       target: ts.ScriptTarget.ESNext
     });
   }
-  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync2(path, "utf8")).config, ts.sys, dirname5(configPath));
+  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync2(path, "utf8")).config, ts.sys, dirname6(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts.createProgram(parsed.fileNames, parsed.options);
@@ -2776,7 +3257,7 @@ var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   const declaration = symbol?.declarations?.[0];
   const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
   const exportedName = symbol?.name ?? expression.getText(sourceFile);
-  const source = posixPath(relative5(projectRoot, file));
+  const source = posixPath(relative7(projectRoot, file));
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
@@ -2883,7 +3364,7 @@ var analyzeProgram = (program, projectRoot) => {
   const checker = program.getTypeChecker();
   const analyzed = new Map;
   for (const sourceFile of program.getSourceFiles()) {
-    const resolvedFile = resolve9(sourceFile.fileName);
+    const resolvedFile = resolve11(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -2966,14 +3447,14 @@ var transformFile = (source, fileName, analysis) => {
 };
 var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
 var createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve9(options.projectRoot ?? process.cwd());
-  const entry = resolve9(options.entry);
+  const projectRoot = resolve11(options.projectRoot ?? process.cwd());
+  const entry = resolve11(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return {
     name: "absolute-mobile-route-metadata",
     setup(build) {
       build.onLoad({ filter: SOURCE_FILTER }, async ({ path }) => {
-        const analysis = analyzed.get(resolve9(path));
+        const analysis = analyzed.get(resolve11(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
@@ -2986,11 +3467,11 @@ var createAbsoluteMobileRouteMetadataPlugin = (options) => {
   };
 };
 var inspectAbsoluteMobileRouteMetadata = (options) => {
-  const projectRoot = resolve9(options.projectRoot ?? process.cwd());
-  const entry = resolve9(options.entry);
+  const projectRoot = resolve11(options.projectRoot ?? process.cwd());
+  const entry = resolve11(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return [...analyzed.entries()].flatMap(([file, analysis]) => [...analysis.byRouteCall.values()].map(({ metadata }) => ({
-    file: posixPath(relative5(projectRoot, file)),
+    file: posixPath(relative7(projectRoot, file)),
     metadata
   })));
 };
@@ -3004,6 +3485,10 @@ export {
   resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
   readAbsoluteMobileMaterializedReleases,
+  publishAbsoluteIosRelease,
+  publishAbsoluteAndroidRelease,
+  prepareAbsoluteIosRelease,
+  prepareAbsoluteAndroidRelease,
   parseAbsoluteMobilePageRequest,
   parseAbsoluteMobilePageEnvelope,
   parseAbsoluteMobileCompatibilityArtifact,
@@ -3014,10 +3499,12 @@ export {
   materializeAbsoluteMobileAssociationFiles,
   materializeAbsoluteCapacitorWebBundle,
   matchesAbsoluteMobileRoutePattern,
+  loadAbsoluteNativeReleasePublisher,
   loadAbsoluteMobileMaterializedBundle,
   inspectAbsoluteMobileRouteMetadata,
   hashAbsoluteMobilePropsSchema,
   getCurrentAbsoluteMobileProducerContext,
+  fingerprintAbsoluteIosNativeProject,
   finalizeAbsoluteMobilePage,
   finalizeAbsoluteMobileCompatibilityBuild,
   fetchAbsoluteMobilePage,
@@ -3035,6 +3522,7 @@ export {
   carryForwardAbsoluteMobileCompatibilityReleases,
   captureAbsoluteMobileRouteGraph,
   buildAbsoluteMobileCompatibilityRelease,
+  buildAbsoluteIosRelease,
   buildAbsoluteAndroidRelease,
   applyAbsoluteNativeDeepLinks,
   activateAbsoluteMobilePage,
@@ -3051,8 +3539,9 @@ export {
   ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
   ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT,
   ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+  ABSOLUTE_IOS_RELEASE_FORMAT,
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=EC6A042BA6D550B864756E2164756E21
+//# debugId=8F6E00755BF98A2E64756E2164756E21
 //# sourceMappingURL=index.js.map