@absolutejs/absolute 0.20.0-beta.59 → 0.20.0-beta.60

package/dist/mobile/index.js

@@ -167,7 +167,8 @@ var init_startupBanner = __esm(() => {
 
 // src/mobile/config.ts
 import { resolve as resolve6 } from "path";
-var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FINGERPRINT_PATTERN, HOSTNAME_PATTERN, EXPO_RESERVED_ROUTE_PREFIXES, resolveProjectPath = (projectRoot, value, field2) => {
+import { createPublicKey } from "crypto";
+var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FINGERPRINT_PATTERN, UPDATE_NAME_PATTERN, UPDATE_PUBLIC_KEY_PATTERN, HOSTNAME_PATTERN, EXPO_RESERVED_ROUTE_PREFIXES, resolveProjectPath = (projectRoot, value, field2) => {
   const root = resolve6(projectRoot);
   const path = resolve6(root, value);
   if (path !== root && !path.startsWith(`${root}/`)) {
@@ -240,7 +241,52 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     }
     return value.match(/.{2}/g)?.join(":") ?? value;
   }))
-].sort(), validateExpoNativeRouteSegment = (path, segment, index, count, parameters) => {
+].sort(), normalizeUpdates = (config, productionOrigin) => {
+  if (!config.updates)
+    return;
+  const channel = requireText(config.updates.channel ?? "production", "mobile.updates.channel");
+  if (!UPDATE_NAME_PATTERN.test(channel))
+    throw new TypeError("mobile.updates.channel contains unsupported characters.");
+  const manifestUrl = new URL(config.updates.manifestUrl ?? `/__absolute/mobile/updates/${encodeURIComponent(channel)}/update.json`, `${productionOrigin}/`);
+  const loopback = manifestUrl.hostname === "localhost" || manifestUrl.hostname === "127.0.0.1" || manifestUrl.hostname === "[::1]";
+  if (manifestUrl.protocol !== "https:" && !loopback)
+    throw new TypeError("mobile.updates.manifestUrl must use HTTPS outside loopback development.");
+  if (manifestUrl.username || manifestUrl.password || manifestUrl.hash)
+    throw new TypeError("mobile.updates.manifestUrl cannot contain credentials or a fragment.");
+  const entries = Object.entries(config.updates.publicKeys).sort(([left], [right]) => left.localeCompare(right));
+  if (entries.length === 0)
+    throw new TypeError("mobile.updates.publicKeys must contain at least one key.");
+  const publicKeys = Object.fromEntries(entries.map(([keyId, key]) => {
+    if (!UPDATE_NAME_PATTERN.test(keyId))
+      throw new TypeError("mobile.updates.publicKeys contains an invalid key ID.");
+    const normalized = requireText(key, `mobile.updates.publicKeys.${keyId}`);
+    if (!UPDATE_PUBLIC_KEY_PATTERN.test(normalized))
+      throw new TypeError(`mobile.updates.publicKeys.${keyId} must be base64-encoded ECDSA P-256 SPKI DER.`);
+    let decoded;
+    try {
+      decoded = Buffer.from(normalized, "base64");
+    } catch {
+      throw new TypeError(`mobile.updates.publicKeys.${keyId} must be canonical base64.`);
+    }
+    let keyType;
+    let namedCurve;
+    try {
+      const publicKey = createPublicKey({
+        format: "der",
+        key: decoded,
+        type: "spki"
+      });
+      keyType = publicKey.asymmetricKeyType;
+      namedCurve = publicKey.asymmetricKeyDetails?.namedCurve;
+    } catch {
+      keyType = undefined;
+    }
+    if (decoded.toString("base64") !== normalized || keyType !== "ec" || namedCurve !== "prime256v1")
+      throw new TypeError(`mobile.updates.publicKeys.${keyId} is not an ECDSA P-256 SPKI public key.`);
+    return [keyId, normalized];
+  }));
+  return { channel, manifestUrl: manifestUrl.href, publicKeys };
+}, validateExpoNativeRouteSegment = (path, segment, index, count, parameters) => {
   if (segment === "*" && (index !== count - 1 || count === 1)) {
     throw new TypeError(`mobile.routes.native route ${path} must use * once, as the final segment after a static or parameterized prefix.`);
   }
@@ -298,6 +344,7 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
   if (deepLinkScheme && !SCHEME_PATTERN.test(deepLinkScheme)) {
     throw new TypeError("mobile.deepLinks.scheme is not a valid URL scheme.");
   }
+  const updates = normalizeUpdates(config, productionOrigin);
   return {
     androidCertificateFingerprints: normalizeCertificateFingerprints(config.deepLinks?.android?.sha256CertificateFingerprints),
     appId,
@@ -314,7 +361,8 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     nativeProjectDirectory: resolveProjectPath(projectRoot, config.nativeProject?.directory ?? (config.engine === "expo" ? ".absolutejs/mobile/expo" : "mobile"), "mobile.nativeProject.directory"),
     platforms: normalizePlatforms(config.platforms),
     productionOrigin,
-    pushAndroidGoogleServicesFile: resolveProjectPath(projectRoot, config.pushNotifications?.android?.googleServicesFile ?? "google-services.json", "mobile.pushNotifications.android.googleServicesFile")
+    pushAndroidGoogleServicesFile: resolveProjectPath(projectRoot, config.pushNotifications?.android?.googleServicesFile ?? "google-services.json", "mobile.pushNotifications.android.googleServicesFile"),
+    ...updates ? { updates } : {}
   };
 };
 var init_config = __esm(() => {
@@ -322,6 +370,8 @@ var init_config = __esm(() => {
   SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*$/;
   APPLE_APP_ID_PREFIX_PATTERN = /^[A-Z0-9]{10}$/;
   CERTIFICATE_FINGERPRINT_PATTERN = /^[0-9A-F]{64}$/;
+  UPDATE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
+  UPDATE_PUBLIC_KEY_PATTERN = /^[A-Za-z0-9+/]+={0,2}$/u;
   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])?))*$/;
   EXPO_RESERVED_ROUTE_PREFIXES = new Set([
     "_expo",
@@ -7497,6 +7547,12 @@ var shellExpoDevicesModule = () => {
     return candidate;
   throw new TypeError("AbsoluteJS Expo device bridge module is missing.");
 };
+var shellUpdateModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellUpdate.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile update shell module is missing.");
+};
 var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 var contentSecurityPolicy = (productionOrigin) => {
   const backend = new URL(productionOrigin);
@@ -7557,7 +7613,7 @@ var resolveProjectImport = async (projectRoot, specifier) => {
     throw new TypeError(`${specifier} has an unsafe import entry.`);
   return resolved;
 };
-var buildShellBootstrap = async (staging, auth, sync, storagePrefix, engine, deviceCapabilities, projectRoot) => {
+var buildShellBootstrap = async (staging, auth, sync, storagePrefix, engine, updates, deviceCapabilities, projectRoot) => {
   const capacitor = engine !== "expo";
   const shellCapabilities = capacitor ? deviceCapabilities.capabilities : [];
   const modulePath = shellBootstrapModule();
@@ -7565,12 +7621,13 @@ var buildShellBootstrap = async (staging, auth, sync, storagePrefix, engine, dev
   const syncFactory = capacitor ? "installAbsoluteMobileShellSync" : "installAbsoluteExpoShellSync";
   const authImport = auth ? `import { ${authFactory} } from ${JSON.stringify(capacitor ? shellAuthModule() : shellExpoAuthModule())};
 ` : "";
-  const options = auth ? `{ createAuth: ${authFactory}${sync ? `, installSync: ${syncFactory}` : ""} }` : "";
   const syncImport = sync ? `import { ${syncFactory} } from ${JSON.stringify(capacitor ? shellSyncModule() : shellExpoSyncModule())};
 ` : "";
   const pushIndex = shellCapabilities.indexOf("pushNotifications");
   const push = pushIndex !== -1;
   const pushImport = push ? `import { createAbsoluteMobileShellPush } from ${JSON.stringify(shellPushModule())};
+` : "";
+  const updateImport = updates ? `import { installAbsoluteMobileShellUpdates } from ${JSON.stringify(shellUpdateModule())};
 ` : "";
   const capabilityImports = (await Promise.all(shellCapabilities.map(async (name, index) => {
     const provider = deviceCapabilities.providers[name];
@@ -7587,15 +7644,21 @@ const absoluteMobilePushCapability = absoluteDeviceCapability${pushIndex}(absolu
   const baseAdapterModule = capacitor ? await resolveProjectImport(projectRoot, "@absolutejs/devices-capacitor") : shellExpoDevicesModule();
   const adapterImport = capacitor ? `import { installCapacitorDeviceAdapterIfNative } from ${JSON.stringify(baseAdapterModule)};` : `import { createAbsoluteExpoBridgeFetch, installAbsoluteExpoWebDeviceAdapter } from ${JSON.stringify(baseAdapterModule)};`;
   const adapterInstall = capacitor ? `installCapacitorDeviceAdapterIfNative({ storagePrefix: ${JSON.stringify(storagePrefix)}${capabilityOptions ? `, ${capabilityOptions}` : ""} });` : `installAbsoluteExpoWebDeviceAdapter(${JSON.stringify(deviceCapabilities.capabilities)});`;
-  let shellOptions = auth ? options : "{ createFetch: createAbsoluteExpoBridgeFetch }";
-  if (capacitor)
-    shellOptions = options;
+  const shellOptionProperties = [];
   if (push) {
-    shellOptions = `{ createAuth: (config, options) => createAbsoluteMobileShellAuth(config, options), beforeSignOut: absoluteMobilePush.beforeSignOut, connectPush: (auth) => absoluteMobilePush.connect(auth, absoluteMobilePushCapability)${sync ? `, installSync: ${syncFactory}` : ""} }`;
-  }
+    shellOptionProperties.push("createAuth: (config, options) => createAbsoluteMobileShellAuth(config, options)", "beforeSignOut: absoluteMobilePush.beforeSignOut", "connectPush: (auth) => absoluteMobilePush.connect(auth, absoluteMobilePushCapability)");
+  } else if (auth)
+    shellOptionProperties.push(`createAuth: ${authFactory}`);
+  else if (!capacitor)
+    shellOptionProperties.push("createFetch: createAbsoluteExpoBridgeFetch");
+  if (sync)
+    shellOptionProperties.push(`installSync: ${syncFactory}`);
+  if (updates)
+    shellOptionProperties.push("installUpdates: installAbsoluteMobileShellUpdates");
+  const shellOptions = `{ ${shellOptionProperties.join(", ")} }`;
   await writeFile10(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
 ${adapterImport}
-${authImport}${syncImport}${pushImport}${capabilityImports}
+${authImport}${syncImport}${pushImport}${updateImport}${capabilityImports}
 ${pushSetup}${adapterInstall}
 void startAbsoluteMobileShell(${shellOptions});
 `);
@@ -7738,10 +7801,12 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       deviceCapabilities: options.deviceCapabilities.capabilities,
       entry: options.config.entry,
       format: ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+      nativeRuntime: options.runtimeFingerprint,
       pages,
       productionOrigin: options.config.productionOrigin,
       routes: options.artifact.routes,
       runtime: options.artifact.runtime,
+      ...options.config.updates ? { updates: options.config.updates } : {},
       ...options.sync ? {
         sync: {
           background: {
@@ -7761,7 +7826,7 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       writeFile10(join9(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
       writeFile10(join9(staging, INDEX_FILE), indexHtml(options.config.appName, options.config.productionOrigin)),
-      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true, `absolutejs.${options.auth?.clientId ?? options.config.appId}.`, options.config.engine, options.deviceCapabilities, options.projectRoot)
+      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true, `absolutejs.${options.auth?.clientId ?? options.config.appId}.`, options.config.engine, options.config.engine === "capacitor" && options.config.updates !== undefined, options.deviceCapabilities, options.projectRoot)
     ]);
     await installBundle(staging, destination);
     return manifest;
@@ -9261,6 +9326,149 @@ var syncAbsoluteExpoWebAssets = async (config) => {
   return { appBuild, assets: assets.length, bundleId, path: destination };
 };
 
+// src/mobile/updateRuntime.ts
+import { createHash as createHash11 } from "crypto";
+
+// src/mobile/updateProtocol.ts
+var ABSOLUTE_MOBILE_UPDATE_FORMAT = 1;
+var ABSOLUTE_MOBILE_UPDATE_MAX_FILE_BYTES = 32 * 1024 * 1024;
+var ABSOLUTE_MOBILE_UPDATE_MAX_FILES = 1e4;
+var ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES = 128 * 1024 * 1024;
+var ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM = "ecdsa-p256-sha256";
+var HASH_PATTERN = /^[a-f0-9]{64}$/u;
+var RELEASE_PATTERN = /^amu_[a-f0-9]{64}$/u;
+var KEY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
+var CHANNEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
+var isClassification = (value) => value === "bug-fix" || value === "content" || value === "security";
+var object3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var canonicalValue = (value) => {
+  if (Array.isArray(value))
+    return value.map(canonicalValue);
+  if (!object3(value))
+    return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalValue(value[key])]));
+};
+var absoluteMobileUpdateSigningPayload = (manifest) => new TextEncoder().encode(canonicalizeAbsoluteMobileUpdate(manifest));
+var canonicalizeAbsoluteMobileUpdate = (value) => JSON.stringify(canonicalValue(value));
+var requireText2 = (value, field2) => {
+  if (typeof value !== "string" || value.length === 0)
+    throw new TypeError(`${field2} must be a non-empty string.`);
+  return value;
+};
+var normalizeAbsoluteMobileUpdatePath = (value) => {
+  const path = requireText2(value, "Update file path").replaceAll("\\", "/");
+  if (path.startsWith("/") || path.includes("\x00") || path.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new TypeError("Update file paths must be normalized relative paths.");
+  }
+  return path;
+};
+var parseFile = (value) => {
+  if (!object3(value))
+    throw new TypeError("Update files must be objects.");
+  const path = normalizeAbsoluteMobileUpdatePath(value.path);
+  if (typeof value.bytes !== "number" || !Number.isSafeInteger(value.bytes) || value.bytes < 0 || value.bytes > ABSOLUTE_MOBILE_UPDATE_MAX_FILE_BYTES) {
+    throw new TypeError(`Update file ${path} has an invalid byte length.`);
+  }
+  if (typeof value.sha256 !== "string" || !HASH_PATTERN.test(value.sha256))
+    throw new TypeError(`Update file ${path} has an invalid SHA-256 digest.`);
+  return { bytes: value.bytes, path, sha256: value.sha256 };
+};
+var parseAbsoluteMobileUnsignedUpdateManifest = (value) => {
+  if (!object3(value) || value.format !== ABSOLUTE_MOBILE_UPDATE_FORMAT)
+    throw new TypeError("Invalid AbsoluteJS mobile update manifest.");
+  const appId = requireText2(value.appId, "Update appId");
+  const channel = requireText2(value.channel, "Update channel");
+  if (!CHANNEL_PATTERN.test(channel))
+    throw new TypeError("Update channel contains unsupported characters.");
+  if (!isClassification(value.classification))
+    throw new TypeError("Update classification is invalid.");
+  const createdAt = requireText2(value.createdAt, "Update createdAt");
+  if (!Number.isFinite(Date.parse(createdAt)) || new Date(createdAt).toISOString() !== createdAt)
+    throw new TypeError("Update createdAt must be a canonical ISO timestamp.");
+  if (!Array.isArray(value.files) || value.files.length === 0)
+    throw new TypeError("An update must contain at least one file.");
+  if (value.files.length > ABSOLUTE_MOBILE_UPDATE_MAX_FILES)
+    throw new TypeError("Update contains too many files.");
+  const files = value.files.map(parseFile);
+  const sorted = [...files].sort((left, right) => left.path.localeCompare(right.path));
+  if (files.some((file, index) => file.path !== sorted[index]?.path))
+    throw new TypeError("Update files must be sorted by path.");
+  if (new Set(files.map(({ path }) => path)).size !== files.length)
+    throw new TypeError("Update file paths must be unique.");
+  if (files.reduce((total, file) => total + file.bytes, 0) > ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES)
+    throw new TypeError("Update exceeds the maximum uncompressed size.");
+  if (typeof value.releaseId !== "string" || !RELEASE_PATTERN.test(value.releaseId))
+    throw new TypeError("Update releaseId is invalid.");
+  if (typeof value.runtimeFingerprint !== "string" || !HASH_PATTERN.test(value.runtimeFingerprint))
+    throw new TypeError("Update runtime fingerprint is invalid.");
+  if (value.withinSubmittedPurpose !== true)
+    throw new TypeError("OTA updates must attest that they remain within the submitted app purpose.");
+  return {
+    appId,
+    channel,
+    classification: value.classification,
+    createdAt,
+    files,
+    format: ABSOLUTE_MOBILE_UPDATE_FORMAT,
+    releaseId: value.releaseId,
+    runtimeFingerprint: value.runtimeFingerprint,
+    withinSubmittedPurpose: true
+  };
+};
+var parseAbsoluteMobileUpdateManifest = (value) => {
+  if (!object3(value))
+    throw new TypeError("Invalid AbsoluteJS mobile update manifest.");
+  const { signature: signatureValue, ...unsignedValue } = value;
+  const unsigned = parseAbsoluteMobileUnsignedUpdateManifest(unsignedValue);
+  if (!object3(signatureValue))
+    throw new TypeError("Update signature is missing.");
+  if (signatureValue.algorithm !== ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM)
+    throw new TypeError("Update signature algorithm is unsupported.");
+  const keyId = requireText2(signatureValue.keyId, "Update signature keyId");
+  if (!KEY_ID_PATTERN.test(keyId))
+    throw new TypeError("Update signature keyId is invalid.");
+  const signature = requireText2(signatureValue.value, "Update signature value");
+  let signatureBytes;
+  try {
+    signatureBytes = Uint8Array.from(atob(signature), (character) => character.charCodeAt(0));
+  } catch {
+    signatureBytes = new Uint8Array;
+  }
+  if (!/^[A-Za-z0-9+/]+={0,2}$/u.test(signature) || signatureBytes.byteLength !== 64 || btoa(String.fromCharCode(...signatureBytes)) !== signature)
+    throw new TypeError("Update signature is not canonical base64.");
+  return {
+    ...unsigned,
+    signature: {
+      algorithm: ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM,
+      keyId,
+      value: signature
+    }
+  };
+};
+var unsignedAbsoluteMobileUpdate = (manifest) => {
+  const { signature: _signature, ...unsigned } = manifest;
+  return unsigned;
+};
+
+// src/mobile/updateRuntime.ts
+var ABSOLUTE_MOBILE_SHELL_ABI = 1;
+var ABSOLUTE_MOBILE_UPDATE_RUNTIME_FORMAT = 1;
+var createAbsoluteMobileUpdateRuntimeDescriptor = (options) => ({
+  appId: options.config.appId,
+  auth: options.auth ?? null,
+  deepLinks: {
+    hosts: options.config.deepLinkHosts,
+    ...options.config.deepLinkScheme ? { scheme: options.config.deepLinkScheme } : {}
+  },
+  deviceCapabilities: options.deviceCapabilities,
+  engine: options.config.engine,
+  format: ABSOLUTE_MOBILE_UPDATE_RUNTIME_FORMAT,
+  shellAbi: ABSOLUTE_MOBILE_SHELL_ABI,
+  syncSchema: options.syncSchema ?? null,
+  updates: options.config.updates ?? null
+});
+var fingerprintAbsoluteMobileUpdateRuntime = (descriptor) => createHash11("sha256").update(canonicalizeAbsoluteMobileUpdate(descriptor)).digest("hex");
+
 // src/mobile/buildPipeline.ts
 var isElysiaApp = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "compile") === "function" && Array.isArray(Reflect.get(value, "routes"));
 var isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
@@ -9336,6 +9544,12 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   const sync = auth !== undefined && projectUsesAbsoluteSync(options.projectRoot);
   const syncSchema = sync ? discoverAbsoluteSyncSchema(options.projectRoot) : undefined;
   const deviceCapabilities = resolveAbsoluteDeviceCapabilityPlan(options.projectRoot, mobile.engine);
+  const runtimeFingerprint = fingerprintAbsoluteMobileUpdateRuntime(createAbsoluteMobileUpdateRuntimeDescriptor({
+    ...auth ? { auth } : {},
+    config: mobile,
+    deviceCapabilities,
+    ...syncSchema ? { syncSchema } : {}
+  }));
   const usesPush = deviceCapabilities.capabilities.includes("pushNotifications");
   if (usesPush && !auth)
     throw new TypeError("Portable push notifications require @absolutejs/auth so provider tokens can be registered without exposing identity controls to page code.");
@@ -9364,6 +9578,7 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     config: mobile,
     deviceCapabilities,
     projectRoot: options.projectRoot,
+    runtimeFingerprint,
     ...sync ? { sync: true } : {},
     ...syncSchema ? { syncSchema: { components: syncSchema.components } } : {}
   });
@@ -11291,6 +11506,65 @@ var applyAbsoluteNativeDeviceCapabilities = async (projectRoot, config, platform
 // src/mobile/index.ts
 init_nativeAuth();
 
+// src/mobile/nativeUpdates.ts
+import { readFile as readFile19, rename as rename14, writeFile as writeFile16 } from "fs/promises";
+import { join as join21 } from "path";
+var START = "// absolutejs:mobile-updates:start";
+var END = "// absolutejs:mobile-updates:end";
+var writeChanged = async (path, source) => {
+  const current = await readFile19(path, "utf8");
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile16(temporary, source, { flag: "wx" });
+  await rename14(temporary, path);
+  return true;
+};
+var replaceRegion = (source, region) => {
+  const start = source.indexOf(START);
+  const end = source.indexOf(END);
+  if (start < 0 !== end < 0 || end < start)
+    throw new TypeError("AbsoluteJS mobile update markers are malformed.");
+  if (start >= 0) {
+    const from = source.lastIndexOf(`
+`, start) + 1;
+    const newline = source.indexOf(`
+`, end + END.length);
+    return `${source.slice(0, from)}${region}${source.slice(newline < 0 ? source.length : newline + 1)}`;
+  }
+  if (!region)
+    return source;
+  const launch = source.indexOf("didFinishLaunchingWithOptions");
+  const brace = launch < 0 ? -1 : source.indexOf("{", launch);
+  const insert = brace < 0 ? -1 : source.indexOf(`
+`, brace) + 1;
+  if (insert <= 0)
+    throw new TypeError("Could not find a safe iOS location for mobile update recovery.");
+  return `${source.slice(0, insert)}${region}${source.slice(insert)}`;
+};
+var iosRecoveryRegion = `        ${START}
+        // A confirmed Capacitor snapshot lives in Library/NoCloud and is not
+        // restored during device migration. Clear only a dangling pointer so
+        // Capacitor falls back to the store-signed embedded bundle.
+        if let persisted = UserDefaults.standard.string(forKey: "serverBasePath"), !persisted.isEmpty,
+           let library = FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).first {
+            let snapshot = library
+                .appendingPathComponent("NoCloud/ionic_built_snapshots", isDirectory: true)
+                .appendingPathComponent(URL(fileURLWithPath: persisted).lastPathComponent, isDirectory: true)
+            if !FileManager.default.fileExists(atPath: snapshot.path) {
+                UserDefaults.standard.removeObject(forKey: "serverBasePath")
+            }
+        }
+        ${END}
+`;
+var applyAbsoluteNativeUpdates = async (config, platforms = config.platforms) => {
+  if (config.engine !== "capacitor" || !platforms.includes("ios"))
+    return { changed: false };
+  const path = join21(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
+  const source = await readFile19(path, "utf8");
+  const updated = replaceRegion(source, config.updates ? iosRecoveryRegion : "");
+  return { changed: await writeChanged(path, updated) };
+};
 // src/mobile/releasePublisher.ts
 import { access as access12 } from "fs/promises";
 import { isAbsolute as isAbsolute6, relative as relative12, resolve as resolve15, sep as sep8 } from "path";
@@ -11468,8 +11742,8 @@ var propertyName = (property) => {
     return property.name.text;
   return;
 };
-var objectPropertyExpression = (object3, name) => {
-  const property = object3.properties.find((candidate) => propertyName(candidate) === name);
+var objectPropertyExpression = (object4, name) => {
+  const property = object4.properties.find((candidate) => propertyName(candidate) === name);
   if (property && ts2.isPropertyAssignment(property)) {
     return property.initializer;
   }
@@ -11665,8 +11939,8 @@ var spreadObject = (expression, checker, bindings) => {
     return;
   return callableObject(expression, checker);
 };
-var objectAssetKey = (object3, name, checker, bindings = new Map) => {
-  for (const property of [...object3.properties].reverse()) {
+var objectAssetKey = (object4, name, checker, bindings = new Map) => {
+  for (const property of [...object4.properties].reverse()) {
     if (propertyName(property) === name && ts2.isShorthandPropertyAssignment(property)) {
       return assetKeyWithBindings(property.name, checker, bindings);
     }
@@ -12380,6 +12654,344 @@ var installAbsoluteMobileUiPrimitives = () => {
     }
   };
 };
+// src/mobile/updateClient.ts
+var exactManifestUrl = (value) => {
+  const url = new URL(value);
+  if (url.protocol !== "https:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1")
+    throw new TypeError("Mobile update manifests require HTTPS outside loopback development.");
+  if (url.username || url.password || url.hash)
+    throw new TypeError("Mobile update manifest URLs cannot contain credentials or fragments.");
+  return url;
+};
+var fileUrl = (manifestUrl, releaseId, path) => {
+  const encodedPath = path.split("/").map(encodeURIComponent).join("/");
+  const base = new URL(`./${encodeURIComponent(releaseId)}/files/`, manifestUrl);
+  const result = new URL(encodedPath, base);
+  if (result.origin !== manifestUrl.origin || !result.pathname.startsWith(base.pathname))
+    throw new TypeError("Mobile update asset escaped its signed release origin.");
+  return result;
+};
+var readChunks = async (reader, maximum2, chunks = [], received = 0) => {
+  const result = await reader.read();
+  if (result.done)
+    return { chunks, received };
+  const total = received + result.value.byteLength;
+  if (total > maximum2)
+    throw new TypeError("Mobile update response exceeds its signed size.");
+  chunks.push(result.value);
+  return readChunks(reader, maximum2, chunks, total);
+};
+var readBounded = async (response, maximum2) => {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maximum2)
+    throw new TypeError("Mobile update response exceeds its signed size.");
+  if (!response.body)
+    return new Uint8Array;
+  const reader = response.body.getReader();
+  let result;
+  try {
+    result = await readChunks(reader, maximum2);
+  } catch (error) {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    throw error;
+  }
+  const contents = new Uint8Array(result.received);
+  let offset = 0;
+  for (const chunk of result.chunks) {
+    contents.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return contents;
+};
+var requestHeaders = (config) => ({
+  "x-absolute-mobile-app": config.appId,
+  "x-absolute-mobile-channel": config.channel,
+  "x-absolute-mobile-installation": config.installationId,
+  "x-absolute-mobile-release": config.currentReleaseId,
+  "x-absolute-mobile-runtime": config.runtimeFingerprint
+});
+var requireCompatible = (manifest, config) => {
+  if (manifest.appId !== config.appId)
+    throw new TypeError("Mobile update belongs to another app.");
+  if (manifest.channel !== config.channel)
+    throw new TypeError("Mobile update belongs to another channel.");
+  if (manifest.runtimeFingerprint !== config.runtimeFingerprint)
+    throw new TypeError("Mobile update requires a different native runtime.");
+};
+var createAbsoluteMobileUpdateClient = (options) => {
+  const manifestUrl = exactManifestUrl(options.config.manifestUrl);
+  const request = options.fetch ?? globalThis.fetch;
+  const downloadFiles = async (manifest, index = 0, received = 0) => {
+    const file = manifest.files[index];
+    if (!file)
+      return received;
+    const asset = await request(fileUrl(manifestUrl, manifest.releaseId, file.path), {
+      cache: "no-store",
+      credentials: "omit",
+      redirect: "error",
+      signal: AbortSignal.timeout(30000)
+    });
+    if (!asset.ok)
+      throw new TypeError(`Mobile update asset ${file.path} failed with HTTP ${asset.status}.`);
+    const contents = await readBounded(asset, file.bytes);
+    const total = received + contents.byteLength;
+    if (contents.byteLength !== file.bytes || total > ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES)
+      throw new TypeError(`Mobile update asset ${file.path} has an invalid size.`);
+    if (await options.verifier.digest(contents) !== file.sha256)
+      throw new TypeError(`Mobile update asset ${file.path} failed integrity verification.`);
+    await options.store.write(file, contents);
+    return downloadFiles(manifest, index + 1, total);
+  };
+  const check = async (download = false) => {
+    const response = await request(manifestUrl, {
+      cache: "no-store",
+      credentials: "omit",
+      headers: requestHeaders(options.config),
+      redirect: "error",
+      signal: AbortSignal.timeout(15000)
+    });
+    if (response.status === 204 || response.status === 304)
+      return { kind: "current" };
+    if (!response.ok)
+      throw new TypeError(`Mobile update check failed with HTTP ${response.status}.`);
+    const manifestBytes = await readBounded(response, 1024 * 1024);
+    let manifestValue;
+    try {
+      manifestValue = JSON.parse(new TextDecoder().decode(manifestBytes));
+    } catch {
+      throw new TypeError("Mobile update manifest is not valid JSON.");
+    }
+    const manifest = parseAbsoluteMobileUpdateManifest(manifestValue);
+    requireCompatible(manifest, options.config);
+    if (!await options.verifier.verify(manifest))
+      throw new TypeError("Mobile update signature verification failed.");
+    if (manifest.releaseId === options.config.currentReleaseId)
+      return { kind: "current" };
+    if (!download)
+      return { kind: "update-available", manifest };
+    await options.store.begin(manifest);
+    try {
+      await downloadFiles(manifest);
+      await options.store.commit(manifest);
+    } catch (error) {
+      await options.store.abort(manifest.releaseId);
+      throw error;
+    }
+    return { kind: "downloaded", manifest };
+  };
+  return {
+    check,
+    activate: (releaseId) => options.store.activate(releaseId),
+    download: () => check(true)
+  };
+};
+// src/mobile/updatePublisher.ts
+import { access as access13 } from "fs/promises";
+import { isAbsolute as isAbsolute7, relative as relative15, resolve as resolve18, sep as sep9 } from "path";
+import { pathToFileURL as pathToFileURL4 } from "url";
+
+// src/mobile/updateSigning.ts
+import { createHash as createHash12, sign, verify } from "crypto";
+import {
+  cp as cp3,
+  mkdir as mkdir13,
+  mkdtemp as mkdtemp8,
+  readdir as readdir5,
+  readFile as readFile20,
+  rename as rename15,
+  rm as rm11,
+  stat as stat4,
+  writeFile as writeFile17
+} from "fs/promises";
+import { dirname as dirname14, join as join22, relative as relative14, resolve as resolve17 } from "path";
+var UPDATE_MANIFEST_FILE = "update.json";
+var UPDATE_FILES_DIRECTORY = "files";
+var sha2562 = (value) => createHash12("sha256").update(value).digest("hex");
+var listFiles = async (root, directory = root) => {
+  const entries = await readdir5(directory, { withFileTypes: true });
+  const paths = await Promise.all(entries.map(async (entry) => {
+    const path = join22(directory, entry.name);
+    if (entry.isDirectory())
+      return listFiles(root, path);
+    if (!entry.isFile())
+      throw new TypeError("Mobile updates cannot contain links or special files.");
+    return [relative14(root, path).replaceAll("\\", "/")];
+  }));
+  return paths.flat().sort();
+};
+var inspectFiles = async (root, paths) => Promise.all(paths.map(async (path) => {
+  const source = join22(root, path);
+  const [metadata, contents] = await Promise.all([
+    stat4(source),
+    readFile20(source)
+  ]);
+  return { bytes: metadata.size, path, sha256: sha2562(contents) };
+}));
+var releaseIdFor = (value) => `amu_${sha2562(canonicalizeAbsoluteMobileUpdate(value))}`;
+var buildAbsoluteMobileUpdate = async (options) => {
+  const bundleDirectory = resolve17(options.bundleDirectory);
+  const outputRoot = resolve17(options.outputDirectory);
+  if (outputRoot === bundleDirectory || outputRoot.startsWith(`${bundleDirectory}/`))
+    throw new TypeError("Mobile update output must be outside the embedded bundle.");
+  const paths = await listFiles(bundleDirectory);
+  const files = await inspectFiles(bundleDirectory, paths);
+  const withoutId = {
+    appId: options.appId,
+    channel: options.channel,
+    classification: options.classification,
+    createdAt: (options.createdAt ?? new Date).toISOString(),
+    files,
+    format: ABSOLUTE_MOBILE_UPDATE_FORMAT,
+    runtimeFingerprint: options.runtimeFingerprint,
+    withinSubmittedPurpose: true
+  };
+  const unsigned = {
+    ...withoutId,
+    releaseId: releaseIdFor(withoutId)
+  };
+  const signature = sign("sha256", absoluteMobileUpdateSigningPayload(unsigned), { dsaEncoding: "ieee-p1363", key: options.privateKey });
+  const manifest = parseAbsoluteMobileUpdateManifest({
+    ...unsigned,
+    signature: {
+      algorithm: "ecdsa-p256-sha256",
+      keyId: options.keyId,
+      value: signature.toString("base64")
+    }
+  });
+  await mkdir13(outputRoot, { recursive: true });
+  const outputDirectory = join22(outputRoot, manifest.releaseId);
+  const staging = await mkdtemp8(join22(outputRoot, ".stage-"));
+  try {
+    await cp3(bundleDirectory, join22(staging, UPDATE_FILES_DIRECTORY), {
+      force: true,
+      recursive: true
+    });
+    await writeFile17(join22(staging, UPDATE_MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+`);
+    await rename15(staging, outputDirectory);
+  } catch (error) {
+    await rm11(staging, { force: true, recursive: true });
+    if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "EEXIST")
+      throw new TypeError(`Mobile update ${manifest.releaseId} already exists.`, { cause: error });
+    throw error;
+  }
+  return {
+    manifest,
+    manifestPath: join22(outputDirectory, UPDATE_MANIFEST_FILE),
+    outputDirectory
+  };
+};
+var copyAbsoluteMobileUpdateFile = async (updateDirectory, path, destination) => {
+  const source = resolve17(updateDirectory, UPDATE_FILES_DIRECTORY, path);
+  const root = resolve17(updateDirectory, UPDATE_FILES_DIRECTORY);
+  if (!source.startsWith(`${root}/`))
+    throw new TypeError("Update file escaped its release.");
+  await mkdir13(dirname14(destination), { recursive: true });
+  await cp3(source, destination, { force: true });
+};
+var readAbsoluteMobileUpdate = async (directory) => parseAbsoluteMobileUpdateManifest(JSON.parse(await readFile20(join22(resolve17(directory), UPDATE_MANIFEST_FILE), "utf8")));
+var verifyAbsoluteMobileUpdateSignature = (manifestValue, publicKey) => {
+  const manifest = parseAbsoluteMobileUpdateManifest(manifestValue);
+  const valid = verify("sha256", absoluteMobileUpdateSigningPayload(unsignedAbsoluteMobileUpdate(manifest)), { dsaEncoding: "ieee-p1363", key: publicKey }, Buffer.from(manifest.signature.value, "base64"));
+  if (!valid)
+    throw new TypeError("Mobile update signature verification failed.");
+  return manifest;
+};
+
+// src/mobile/updatePublisher.ts
+var object4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPublisher2 = (value) => object4(value) && typeof value.publishUpdate === "function" && typeof value.promoteUpdate === "function" && typeof value.rollbackUpdate === "function";
+var projectPath2 = (projectRoot, requested, label) => {
+  const root = resolve18(projectRoot);
+  const path = resolve18(root, requested);
+  const projectRelative = relative15(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep9}`) || isAbsolute7(projectRelative))
+    throw new TypeError(`${label} must remain inside the project.`);
+  return path;
+};
+var loadAbsoluteMobileUpdatePublisher = async (projectRoot, requestedModulePath) => {
+  const modulePath = projectPath2(projectRoot, requestedModulePath, "mobile update registry");
+  await access13(modulePath).catch(() => {
+    throw new TypeError(`Mobile update registry does not exist: ${modulePath}`);
+  });
+  const loaded = await import(pathToFileURL4(modulePath).href);
+  const publisher = object4(loaded) ? loaded.default ?? loaded.registry : undefined;
+  if (!isPublisher2(publisher))
+    throw new TypeError("Mobile update registry must implement publishUpdate, promoteUpdate, and rollbackUpdate.");
+  return publisher;
+};
+var promoteAbsoluteMobileUpdate = async (options) => {
+  const result = await options.publisher.promoteUpdate({
+    appId: options.appId,
+    channel: options.channel,
+    releaseId: options.releaseId,
+    rollout: options.rollout,
+    signal: options.signal
+  });
+  if (result.appId !== options.appId || result.channel !== options.channel || result.releaseId !== options.releaseId || result.rollout !== options.rollout || result.stage !== "promoted")
+    throw new TypeError("Mobile update registry returned a different promotion identity.");
+  return result;
+};
+var publishAbsoluteMobileUpdate = async (options) => {
+  const releaseDirectory = projectPath2(options.projectRoot, options.releaseDirectory, "mobile update release directory");
+  const manifest = await readAbsoluteMobileUpdate(releaseDirectory);
+  const result = await options.publisher.publishUpdate({
+    manifest,
+    releaseDirectory,
+    rollout: options.rollout,
+    signal: options.signal
+  });
+  if (result.appId !== manifest.appId || result.channel !== manifest.channel || result.releaseId !== manifest.releaseId || result.rollout !== options.rollout || result.stage !== "published" || typeof result.reused !== "boolean")
+    throw new TypeError("Mobile update registry returned a different publication identity.");
+  return result;
+};
+var rollbackAbsoluteMobileUpdate = async (options) => {
+  const result = await options.publisher.rollbackUpdate({
+    appId: options.appId,
+    channel: options.channel,
+    ...options.releaseId ? { releaseId: options.releaseId } : {},
+    signal: options.signal
+  });
+  if (result.appId !== options.appId || result.channel !== options.channel || result.releaseId !== options.releaseId || result.stage !== "rolled-back")
+    throw new TypeError("Mobile update registry returned a different rollback identity.");
+  return result;
+};
+// src/mobile/updateRollout.ts
+import { createHash as createHash13 } from "crypto";
+var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-8][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u;
+var requireHeader = (headers, name) => {
+  const value = headers.get(name);
+  if (!value)
+    throw new TypeError(`Mobile update request is missing ${name}.`);
+  return value;
+};
+var isAbsoluteMobileUpdateRolloutMember = (options) => {
+  if (!Number.isFinite(options.rollout) || options.rollout < 0 || options.rollout > 1)
+    throw new TypeError("Mobile update rollout must be between 0 and 1.");
+  if (options.rollout === 0)
+    return false;
+  if (options.rollout === 1)
+    return true;
+  const digest = createHash13("sha256").update(`${options.appId}\x00${options.channel}\x00${options.releaseId}\x00${options.installationId}`).digest();
+  const bucket = digest.readUInt32BE(0) / 4294967296;
+  return bucket < options.rollout;
+};
+var parseAbsoluteMobileUpdateRequest = (request) => {
+  const identity = {
+    appId: requireHeader(request.headers, "x-absolute-mobile-app"),
+    channel: requireHeader(request.headers, "x-absolute-mobile-channel"),
+    currentReleaseId: requireHeader(request.headers, "x-absolute-mobile-release"),
+    installationId: requireHeader(request.headers, "x-absolute-mobile-installation"),
+    runtimeFingerprint: requireHeader(request.headers, "x-absolute-mobile-runtime")
+  };
+  if (!UUID_PATTERN.test(identity.installationId))
+    throw new TypeError("Mobile update installation identity is invalid.");
+  if (!/^[a-f0-9]{64}$/u.test(identity.runtimeFingerprint))
+    throw new TypeError("Mobile update runtime identity is invalid.");
+  return identity;
+};
 export {
   ABSOLUTE_ANDROID_RELEASE_FORMAT,
   ABSOLUTE_AUTH_PACKAGE,
@@ -12403,8 +13015,15 @@ export {
   ABSOLUTE_MOBILE_PREVIEW_PATH,
   ABSOLUTE_MOBILE_RETAINED_GENERATIONS,
   ABSOLUTE_MOBILE_ROUTE_DETAIL,
+  ABSOLUTE_MOBILE_SHELL_ABI,
   ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABILITIES,
   ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL,
+  ABSOLUTE_MOBILE_UPDATE_FORMAT,
+  ABSOLUTE_MOBILE_UPDATE_MAX_FILES,
+  ABSOLUTE_MOBILE_UPDATE_MAX_FILE_BYTES,
+  ABSOLUTE_MOBILE_UPDATE_MAX_TOTAL_BYTES,
+  ABSOLUTE_MOBILE_UPDATE_RUNTIME_FORMAT,
+  ABSOLUTE_MOBILE_UPDATE_SIGNATURE_ALGORITHM,
   ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV,
   ABSOLUTE_NATIVE_AUTH_SCOPES,
   ABSOLUTE_NATIVE_ROUTE_DATA_MEDIA_TYPE,
@@ -12419,6 +13038,7 @@ export {
   absoluteExpoExecutable,
   absoluteIosDeviceAcceptanceCommands,
   absoluteMobilePreviewDocument,
+  absoluteMobileUpdateSigningPayload,
   absoluteRemoteMacSshBase,
   absoluteRemoteProjectSyncCommands,
   absoluteRemoteReleaseInputSyncCommands,
@@ -12428,16 +13048,20 @@ export {
   activateAbsoluteMobilePage,
   applyAbsoluteNativeDeepLinks,
   applyAbsoluteNativeDeviceCapabilities,
+  applyAbsoluteNativeUpdates,
   assertAbsoluteDeviceCapabilityPackages,
   buildAbsoluteAndroidRelease,
   buildAbsoluteIosRelease,
   buildAbsoluteMobileCompatibilityRelease,
+  buildAbsoluteMobileUpdate,
   buildAbsoluteRemoteIosRelease,
+  canonicalizeAbsoluteMobileUpdate,
   captureAbsoluteMobileRouteGraph,
   captureAbsoluteRemoteMacCommand,
   carryForwardAbsoluteMobileCompatibilityReleases,
   cleanAbsoluteRemoteMacWorkspace,
   closeAbsoluteMobileSheet,
+  copyAbsoluteMobileUpdateFile,
   createAbsoluteExpoBridgeError,
   createAbsoluteExpoBridgeResponse,
   createAbsoluteIosNativeWatcher,
@@ -12454,6 +13078,8 @@ export {
   createAbsoluteMobilePageRequest,
   createAbsoluteMobilePreviewPlugin,
   createAbsoluteMobileRouteMetadataPlugin,
+  createAbsoluteMobileUpdateClient,
+  createAbsoluteMobileUpdateRuntimeDescriptor,
   createAbsoluteMobileUpgradeResponse,
   createAbsoluteRemoteExpoIosDevProject,
   createAbsoluteRemoteIosDevProject,
@@ -12466,6 +13092,7 @@ export {
   finalizeAbsoluteMobilePage,
   fingerprintAbsoluteIosDevProject,
   fingerprintAbsoluteIosNativeProject,
+  fingerprintAbsoluteMobileUpdateRuntime,
   getAbsoluteMobileSyncRemediation,
   getAbsoluteRemoteMacProfile,
   getCurrentAbsoluteMobileProducerContext,
@@ -12483,9 +13110,11 @@ export {
   installAbsoluteMobileUiPrimitives,
   installAbsoluteRemoteMacAgent,
   isAbsoluteIosNativeRootInput,
+  isAbsoluteMobileUpdateRolloutMember,
   listAbsoluteRemoteMacProfiles,
   loadAbsoluteDeviceCapabilityProviders,
   loadAbsoluteMobileMaterializedBundle,
+  loadAbsoluteMobileUpdatePublisher,
   loadAbsoluteNativeReleasePublisher,
   matchesAbsoluteMobileRoutePattern,
   materializeAbsoluteCapacitorWebBundle,
@@ -12497,6 +13126,7 @@ export {
   normalizeAbsoluteIosDeviceHost,
   normalizeAbsoluteIosDeviceIdentifier,
   normalizeAbsoluteMobileConfig,
+  normalizeAbsoluteMobileUpdatePath,
   openAbsoluteMobileSheet,
   pairAbsoluteRemoteMac,
   parseAbsoluteAndroidInstalledApp,
@@ -12507,6 +13137,9 @@ export {
   parseAbsoluteMobileCompatibilityArtifact,
   parseAbsoluteMobilePageEnvelope,
   parseAbsoluteMobilePageRequest,
+  parseAbsoluteMobileUnsignedUpdateManifest,
+  parseAbsoluteMobileUpdateManifest,
+  parseAbsoluteMobileUpdateRequest,
   parseIosDeviceTypes,
   parseIosRuntimes,
   parseIosSimulators,
@@ -12517,10 +13150,13 @@ export {
   projectImportsAbsoluteDeviceCapability,
   projectUsesAbsoluteAuth,
   projectUsesAbsoluteSync,
+  promoteAbsoluteMobileUpdate,
   publishAbsoluteAndroidRelease,
   publishAbsoluteIosRelease,
+  publishAbsoluteMobileUpdate,
   readAbsoluteMobileLinkIntent,
   readAbsoluteMobileMaterializedReleases,
+  readAbsoluteMobileUpdate,
   redactAbsoluteIosLog,
   removeAbsoluteRemoteMacProfile,
   repairAbsoluteIosDevSession,
@@ -12534,6 +13170,7 @@ export {
   resolveAbsoluteMobileNavigation,
   resolveAbsoluteMobileRoute,
   retainAbsoluteMobileCompatibilityArtifacts,
+  rollbackAbsoluteMobileUpdate,
   runAbsoluteAndroidUpgradeConformance,
   runWithAbsoluteMobileProducer,
   serializeAbsoluteMobileAuthEnvironment,
@@ -12547,15 +13184,17 @@ export {
   syncAbsoluteRemoteMacProject,
   syncAbsoluteRemoteMacReleaseInputs,
   testAbsoluteIosPhysicalDevice,
+  unsignedAbsoluteMobileUpdate,
   validateAbsoluteRemoteMacProfileName,
   validateAbsoluteSshDestination,
   verifyAbsoluteMobileAssociationFiles,
   verifyAbsoluteMobileCompatibilityProducer,
+  verifyAbsoluteMobileUpdateSignature,
   waitForAbsoluteIosHmrLog,
   writeAbsoluteCapacitorConfig,
   writeAbsoluteExpoProject,
   writeAbsoluteMobileGithubWorkflow
 };
 
-//# debugId=AC4084DD1C6BCD7664756E2164756E21
+//# debugId=FA0645035026C26B64756E2164756E21
 //# sourceMappingURL=index.js.map