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

package/dist/mobile/index.js

@@ -60,6 +60,105 @@ var __legacyMetadataTS = (k, v) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/constants.ts
+var ANGULAR_INIT_TIMEOUT_MS = 500, ANSI_ESCAPE_CODE = 27, ANSI_ESCAPE_LENGTH = 3, ASCII_SPACE = 32, BASE_36_RADIX = 36, BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet", TAILWIND_BUN_CSS_WARNING_PATTERN, BODY_SLICE_LENGTH = 2000, BYTES_PER_KILOBYTE = 1024, CLI_ARGS_OFFSET = 3, CSS_ERROR_RESOLVE_DELAY_MS = 50, CSS_MAX_CHECK_ATTEMPTS = 10, CSS_MAX_PARSE_TIMEOUT_MS = 500, CSS_SHEET_READY_TIMEOUT_MS = 100, DEFAULT_CHUNK_SIZE = 16384, DEFAULT_DEBOUNCE_MS = 15, DEFAULT_PORT = 3000, DEV_SERVER_RESTART_DEBOUNCE_MS = 100, DOM_UPDATE_DELAY_MS = 50, FILE_PROTOCOL_PREFIX_LENGTH = 7, FOCUS_ID_PREFIX_LENGTH = 3, FOCUS_IDX_PREFIX_LENGTH = 4, FOCUS_NAME_PREFIX_LENGTH = 5, ESLINT_STUDIO_DEFAULT_HOST = "eslint.absolute.localhost", ESLINT_STUDIO_DEFAULT_PORT = 4099, CONFIG_DEFAULT_HOST = "config.absolute.localhost", CONFIG_DEFAULT_PORT = 4099, HMR_UPDATE_TIMEOUT_MS = 2000, HOOK_SIGNATURE_LENGTH = 12, EXCLUDE_LAST_OFFSET = -1, HTTP_STATUS_OK = 200, HTTP_STATUS_BAD_REQUEST = 400, HTTP_STATUS_NOT_FOUND = 404, HOURS_IN_DAY = 24, HOURS_IN_HALF_DAY = 12, IMAGE_DEFAULT_DEVICE_SIZES, IMAGE_DEFAULT_IMAGE_SIZES, IMAGE_DEFAULT_QUALITY = 75, IMAGE_GLOB_SUFFIX_LENGTH = 2, INSTANCE_PROBE_TIMEOUT_MS = 250, MAX_ERROR_LENGTH = 200, MAX_RECONNECT_ATTEMPTS = 60, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, OVERLAY_FADE_DURATION_MS = 150, PING_INTERVAL_MS = 30000, LIST_LOG_TAIL_MAX_BYTES = 65536, LIST_TUI_COLUMN_GAP = 2, LIST_TUI_DEFAULT_HEIGHT = 28, LIST_TUI_DEFAULT_WIDTH = 100, LIST_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, LIST_TUI_FOOTER_LINE_COUNT = 2, LIST_TUI_MARKER_WIDTH = 2, LIST_TUI_MIN_LOG_HEIGHT = 3, LIST_TUI_MIN_URL_WIDTH = 16, LIST_TUI_RENDER_DEBOUNCE_MS = 16, LIST_TUI_STATUS_MESSAGE_TIMEOUT_MS = 4000, LIST_WATCH_REFRESH_MS = 1000, RAF_BATCH_COUNT = 3, RANDOM_ID_END_INDEX = 11, REBUILD_BATCH_DELAY_MS = 10, REBUILD_RELOAD_DELAY_MS = 200, RECONNECT_INITIAL_DELAY_MS = 500, RECONNECT_POLL_INTERVAL_MS = 300, REACT_STREAM_SLOT_FAST_DELAY_MS = 5, REACT_STREAM_SLOT_SLOW_DELAY_MS = 20, SIGINT_EXIT_CODE = 130, SIGTERM_EXIT_CODE = 143, SVELTE_CSS_LOAD_TIMEOUT_MS = 500, TIME_PRECISION = 2, TWO_THIRDS, UNFOUND_INDEX = -1, WEBSOCKET_NORMAL_CLOSURE = 1000, DEFAULT_WEBSOCKET_IDLE_TIMEOUT_SECONDS = 240, DEFAULT_HTTP_IDLE_TIMEOUT_SECONDS = 240, MAX_HTTP_IDLE_TIMEOUT_SECONDS = 255, WORKSPACE_COMMAND_ARGS_OFFSET = 3, WORKSPACE_FAILURE_LOG_PRINT_LIMIT = 30, WORKSPACE_FAILURE_RECENT_LOG_LIMIT = 60, WORKSPACE_READY_ATTEMPT_TIMEOUT_MS = 5000, WORKSPACE_READY_PROBE_INTERVAL_MS = 250, WORKSPACE_READY_TIMEOUT_MS = 30000, WORKSPACE_SHUTDOWN_TIMEOUT_MS = 1e4, WORKSPACE_TUI_DEFAULT_HEIGHT = 28, WORKSPACE_TUI_DEFAULT_WIDTH = 100, WORKSPACE_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, WORKSPACE_TUI_FOOTER_LINE_COUNT = 3, WORKSPACE_TUI_MIN_LOG_HEIGHT = 3, WORKSPACE_TUI_MIN_SERVICE_NAME_WIDTH = 7, WORKSPACE_TUI_MIN_TARGET_WIDTH = 8, WORKSPACE_TUI_MIN_WRAP_WIDTH = 12, WORKSPACE_TUI_PROMPT_CURSOR_OFFSET = 3, WORKSPACE_TUI_RECENT_LOG_LIMIT = 40, WORKSPACE_TUI_RENDER_DEBOUNCE_MS = 16, WORKSPACE_TUI_STATUS_WIDTH = 10, WORKSPACE_TUI_TARGET_PADDING_WIDTH = 6, WORKSPACE_TUI_VISIBILITY_WIDTH = 8;
+var init_constants = __esm(() => {
+  TAILWIND_BUN_CSS_WARNING_PATTERN = /invalid @ rule encountered: '@(theme|tailwind|source|utility|variant|custom-variant|apply|reference|plugin|config)'/;
+  IMAGE_DEFAULT_DEVICE_SIZES = [
+    640,
+    750,
+    828,
+    1080,
+    1200,
+    1920,
+    2048,
+    3840
+  ];
+  IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
+  MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+  MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+  TWO_THIRDS = 2 / 3;
+});
+
+// src/utils/getDurationString.ts
+var getDurationString = (duration) => {
+  let durationString;
+  if (duration < MILLISECONDS_IN_A_SECOND) {
+    durationString = `${duration.toFixed(TIME_PRECISION)}ms`;
+  } else if (duration < MILLISECONDS_IN_A_MINUTE) {
+    durationString = `${(duration / MILLISECONDS_IN_A_SECOND).toFixed(TIME_PRECISION)}s`;
+  } else {
+    const totalSeconds = Math.round(duration / MILLISECONDS_IN_A_SECOND);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    durationString = seconds === 0 ? `${minutes}m` : `${minutes}m ${seconds}s`;
+  }
+  return durationString;
+};
+var init_getDurationString = __esm(() => {
+  init_constants();
+});
+
+// src/utils/startupBanner.ts
+var colors, MONTHS, formatTimestamp = () => {
+  const now = new Date;
+  const month = MONTHS[now.getMonth()];
+  const day = now.getDate().toString().padStart(2, "0");
+  let hours = now.getHours();
+  const minutes = now.getMinutes().toString().padStart(2, "0");
+  const seconds = now.getSeconds().toString().padStart(2, "0");
+  const ampm = hours >= HOURS_IN_HALF_DAY ? "PM" : "AM";
+  hours = hours % HOURS_IN_HALF_DAY || HOURS_IN_HALF_DAY;
+  return `${month} ${day} ${hours}:${minutes}:${seconds} ${ampm}`;
+}, startupBanner = (options) => {
+  const {
+    version,
+    readyDuration,
+    buildDuration,
+    port,
+    host,
+    networkUrl,
+    protocol = "http"
+  } = options;
+  const name = `${colors.cyan}${colors.bold}ABSOLUTEJS${colors.reset}`;
+  const ver = `${colors.dim}v${version}${colors.reset}`;
+  const time = `${colors.dim}ready in${colors.reset} ${colors.bold}${getDurationString(readyDuration)}${colors.reset}`;
+  const build = typeof buildDuration === "number" && Number.isFinite(buildDuration) ? ` ${colors.dim}(build ${getDurationString(buildDuration)})${colors.reset}` : "";
+  console.log("");
+  console.log(`  ${name} ${ver}  ${time}${build}`);
+  console.log("");
+  console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Local:${colors.reset}   ${protocol}://${host === "0.0.0.0" ? "localhost" : host}:${port}/`);
+  if (networkUrl) {
+    console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Network:${colors.reset} ${networkUrl}`);
+  }
+  console.log("");
+};
+var init_startupBanner = __esm(() => {
+  init_constants();
+  init_getDurationString();
+  colors = {
+    bold: "\x1B[1m",
+    cyan: "\x1B[36m",
+    dim: "\x1B[2m",
+    green: "\x1B[32m",
+    reset: "\x1B[0m"
+  };
+  MONTHS = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+});
+
 // src/mobile/artifactStore.ts
 import { createHash as createHash2 } from "crypto";
 import {
@@ -152,6 +251,7 @@ var parseCompatibilityPage = (value) => {
   }
   return {
     bundleHash: readString(value.bundleHash, "page.bundleHash"),
+    bundlePath: readString(value.bundlePath, "page.bundlePath"),
     contract: readString(value.contract, "page.contract"),
     framework: value.framework,
     pageId: readString(value.pageId, "page.pageId"),
@@ -189,6 +289,7 @@ var validateProducerModule = (module) => {
 };
 var normalizePage = (page) => ({
   bundleHash: requireNonEmpty(page.bundleHash, "page.bundleHash"),
+  bundlePath: requireNonEmpty(page.bundlePath, "page.bundlePath"),
   contract: requireNonEmpty(page.contract, "page.contract"),
   framework: page.framework,
   pageId: requireNonEmpty(page.pageId, "page.pageId"),
@@ -513,183 +614,1546 @@ var verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes
   }
   return release;
 };
-// src/mobile/producerContextState.ts
-var ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY = Symbol.for("absolutejs.mobileProducerAsyncLocalStorage");
-var frameworks2 = new Set([
-  "angular",
-  "ember",
-  "html",
-  "htmx",
-  "react",
-  "svelte",
-  "vue"
-]);
-var isCompatibilityPage = (value) => typeof value === "object" && value !== null && ("bundleHash" in value) && typeof value.bundleHash === "string" && ("contract" in value) && typeof value.contract === "string" && ("framework" in value) && typeof value.framework === "string" && frameworks2.has(value.framework) && ("pageId" in value) && typeof value.pageId === "string" && ("propsSchemaHash" in value) && typeof value.propsSchemaHash === "string";
-var getCurrentAbsoluteMobileProducerContext = () => {
-  const value = Reflect.get(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY);
-  if (typeof value !== "object" || value === null || !("getStore" in value) || typeof value.getStore !== "function") {
-    return;
+// src/mobile/androidRelease.ts
+import { createHash as createHash4 } from "crypto";
+import {
+  access as access3,
+  copyFile as copyFile2,
+  mkdir as mkdir3,
+  mkdtemp as mkdtemp2,
+  readFile as readFile4,
+  rename as rename4,
+  rm as rm3,
+  stat,
+  writeFile as writeFile4
+} from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, relative as relative3, resolve as resolve3, sep as sep2 } from "path";
+
+// src/mobile/emulatorDoctor.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/cli/utils.ts
+import { existsSync, readFileSync } from "fs";
+init_constants();
+init_startupBanner();
+var isWSLEnvironment = () => {
+  try {
+    const release = readFileSync("/proc/version", "utf-8");
+    return /microsoft|wsl/i.test(release);
+  } catch {
+    return false;
   }
-  const context = value.getStore();
-  if (typeof context !== "object" || context === null || !("page" in context) || !isCompatibilityPage(context.page) || !("releaseId" in context) || typeof context.releaseId !== "string") {
+};
+
+// src/mobile/emulatorDoctor.ts
+var windowsPathToWsl = (path) => {
+  const match = /^([a-z]):[\\/](.*)$/i.exec(path.trim());
+  if (!match)
+    return path.trim().replaceAll("\\", "/");
+  return `/mnt/${match[1]?.toLowerCase()}/${match[2]?.replaceAll("\\", "/")}`;
+};
+var windowsLocalAppDataFromWsl = () => {
+  try {
+    const result = Bun.spawnSync(["cmd.exe", "/d", "/c", "echo", "%LOCALAPPDATA%"], { stderr: "ignore", stdout: "pipe" });
+    if (result.exitCode !== 0)
+      return;
+    const output = result.stdout.toString().trim();
+    if (!output || output === "%LOCALAPPDATA%")
+      return;
+    return windowsPathToWsl(output);
+  } catch {
     return;
   }
-  return { page: context.page, releaseId: context.releaseId };
+};
+var absoluteManagedAndroidSdkRoot = (host, env = process.env) => {
+  if (host === "windows") {
+    return join2(env.LOCALAPPDATA ?? join2(homedir(), "AppData", "Local"), "AbsoluteJS", "Android", "Sdk");
+  }
+  if (host === "wsl") {
+    const localAppData = windowsLocalAppDataFromWsl();
+    if (localAppData) {
+      return join2(localAppData, "AbsoluteJS", "Android", "Sdk");
+    }
+  }
+  return join2(homedir(), ".absolutejs", "android-sdk");
+};
+var detectAbsoluteMobileHost = (platform = process.platform, wsl = isWSLEnvironment()) => {
+  if (platform === "darwin")
+    return "macos";
+  if (platform === "win32")
+    return "windows";
+  if (platform === "linux" && wsl)
+    return "wsl";
+  return "linux";
 };
 
-// src/mobile/pageProtocol.ts
-var ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
-var ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION = 1;
-var BAD_REQUEST_STATUS = 400;
-var OK_STATUS = 200;
-var SERVER_ERROR_STATUS = 500;
-var UPGRADE_REQUIRED_STATUS = 426;
-var MOBILE_PAGE_REQUEST_HEADERS = {
-  appBuild: "x-absolute-mobile-app-build",
-  pageBundle: "x-absolute-mobile-page-bundle",
-  pageContracts: "x-absolute-mobile-page-contracts",
-  pageId: "x-absolute-mobile-page-id",
-  protocol: "x-absolute-mobile-protocol",
-  runtime: "x-absolute-mobile-runtime"
+// src/mobile/androidEmulatorController.ts
+import {
+  access as access2,
+  copyFile,
+  lstat,
+  mkdir as mkdir2,
+  readFile as readFile3,
+  readdir as readdir2,
+  readlink,
+  realpath,
+  rename as rename3,
+  rm as rm2,
+  writeFile as writeFile3
+} from "fs/promises";
+import { createHash as createHash3, randomUUID } from "crypto";
+import {
+  dirname,
+  isAbsolute,
+  join as join3,
+  relative as relative2,
+  resolve as resolve2,
+  sep,
+  win32
+} from "path";
+
+// src/mobile/capacitorProject.ts
+import { access, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { relative, resolve } from "path";
+var CONFIG_FILE = "capacitor.config.ts";
+var portableRelative = (root, path) => relative(root, path).replaceAll("\\", "/");
+var capacitorConfigSource = (config, projectRoot) => `import type { CapacitorConfig } from '@capacitor/cli';
+
+const config: CapacitorConfig = {
+	appId: ${JSON.stringify(config.appId)},
+	appName: ${JSON.stringify(config.appName)},
+	webDir: ${JSON.stringify(portableRelative(projectRoot, config.bundleDirectory))},
+	android: {
+		path: ${JSON.stringify(portableRelative(projectRoot, `${config.nativeProjectDirectory}/android`))}
+	},
+	ios: {
+		path: ${JSON.stringify(portableRelative(projectRoot, `${config.nativeProjectDirectory}/ios`))}
+	}
 };
-var parseMediaType = (value) => value.split(";", 1)[0]?.trim().toLowerCase();
-var acceptsAbsoluteMobilePage = (request) => {
-  if (!request)
+
+export default config;
+`;
+var exists = async (path) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
     return false;
-  return (request.headers.get("accept") ?? "").split(",").some((value) => parseMediaType(value) === ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
+  }
 };
-var readRequiredHeader = (request, name) => {
-  const value = request.headers.get(name)?.trim();
-  return value ? value : undefined;
+var writeAbsoluteCapacitorConfig = async (config, options) => {
+  const projectRoot = resolve(options.projectRoot);
+  const destination = resolve(projectRoot, CONFIG_FILE);
+  const source = capacitorConfigSource(config, projectRoot);
+  if (await exists(destination)) {
+    const current = await readFile2(destination, "utf8");
+    if (current === source)
+      return { changed: false, path: destination };
+    if (!options.force) {
+      throw new TypeError(`${CONFIG_FILE} already exists and differs; rerun with --force only after reviewing it.`);
+    }
+  }
+  const temporary = `${destination}.${crypto.randomUUID()}.tmp`;
+  await writeFile2(temporary, source, { flag: "wx" });
+  await rename2(temporary, destination);
+  return { changed: true, path: destination };
 };
-var parseAbsoluteMobilePageRequest = (request) => {
-  if (!request || !acceptsAbsoluteMobilePage(request)) {
-    return { kind: "not-mobile" };
+
+// 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 {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
   }
-  const protocolValue = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.protocol);
-  const runtime = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.runtime);
-  const appBuild = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.appBuild);
-  const pageBundle = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageBundle);
-  const pageContractsValue = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageContracts);
-  const pageId = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageId);
-  if (!protocolValue || !/^\d+$/.test(protocolValue)) {
+};
+var forwardCommandOutput = (stream, destination) => stream.pipeTo(new WritableStream({
+  write: (chunk) => {
+    destination.write(chunk);
+  }
+}));
+var runCommand = async (command, options = {}) => {
+  const subprocess = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  const [exitCode] = await Promise.all([
+    subprocess.exited,
+    forwardCommandOutput(subprocess.stdout, process.stdout),
+    forwardCommandOutput(subprocess.stderr, process.stderr)
+  ]);
+  return exitCode;
+};
+var captureCommand = (command, options = {}) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      cwd: options.cwd,
+      env: options.env,
+      stderr: "pipe",
+      stdout: "pipe"
+    });
     return {
-      kind: "invalid",
-      message: `Missing or invalid ${MOBILE_PAGE_REQUEST_HEADERS.protocol} header.`
+      exitCode: result.exitCode,
+      stderr: result.stderr.toString(),
+      stdout: result.stdout.toString()
     };
-  }
-  if (!runtime) {
+  } catch (error) {
     return {
-      kind: "invalid",
-      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.runtime} header.`
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : String(error),
+      stdout: ""
     };
   }
-  if (!appBuild) {
-    return {
-      kind: "invalid",
-      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.appBuild} header.`
-    };
+};
+var ASCII_ESCAPE = 27;
+var ANSI_SEQUENCE_PATTERN = new RegExp(`${String.fromCharCode(ASCII_ESCAPE)}(?:\\[[0-?]*[ -/]*[@-~]|[@-_])`, "gu");
+var requireSuccess = async (command, label, run, options) => {
+  const exitCode = await run(command, options);
+  throwIfAborted(options?.signal);
+  if (exitCode !== 0)
+    throw new Error(`${label} failed (exit ${exitCode}).`);
+};
+var throwIfAborted = (signal) => {
+  if (!signal?.aborted)
+    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.");
   }
-  if (!pageBundle) {
+  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()) {
+    throw new Error(`Could not translate WSL path for Windows: ${path}`);
+  }
+  return result.stdout.trim();
+};
+var mirroredCapacitorDependencies = async (project, capture) => {
+  const settingsPath = join3(project.nativeDirectory, "capacitor.settings.gradle");
+  const settings = await readFile3(settingsPath, "utf8");
+  const dependencies = [];
+  const rewrittenSettings = settings.replace(CAPACITOR_PROJECT_DIRECTORY_PATTERN, (_statement, projectName, sourcePath) => {
+    const name = projectName.slice(1).replaceAll(/[^a-zA-Z0-9_.-]/gu, "_");
+    const source = resolve2(project.nativeDirectory, sourcePath);
+    dependencies.push({
+      name,
+      windowsSource: windowsPathFromWsl(source, capture)
+    });
+    return `project('${projectName}').projectDir = new File('./.absolutejs-dependencies/${name}')`;
+  });
+  if (dependencies.length === 0) {
+    throw new Error("Capacitor Android settings did not declare any native dependencies.");
+  }
+  return { dependencies, rewrittenSettings };
+};
+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}'))`,
+    `$directory = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${buildDirectory}'))`,
+    `$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",
+    "& robocopy.exe $source $directory /MIR /XD .gradle build .absolutejs-dependencies /NFL /NDL /NJH /NJS /NP",
+    "$copyExit = $LASTEXITCODE",
+    "if ($copyExit -ge 8) { exit $copyExit }",
+    "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 @gradleArguments ${task}`,
+    "if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }",
+    "exit 0"
+  ].join("; ");
+  return Buffer.from(source, "utf16le").toString("base64");
+};
+var gradleArtifactPath = (nativeDirectory, task, windows = false) => {
+  const pathJoin = windows ? win32.join : join3;
+  if (task === "assembleDebug") {
+    return pathJoin(nativeDirectory, "app", "build", "outputs", "apk", "debug", "app-debug.apk");
+  }
+  if (task === "assembleRelease") {
+    return pathJoin(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release.apk");
+  }
+  return pathJoin(nativeDirectory, "app", "build", "outputs", "bundle", "release", "app-release.aab");
+};
+var resolveGradleArtifactPath = async (nativeDirectory, task) => {
+  const primary = gradleArtifactPath(nativeDirectory, task);
+  if (task !== "assembleRelease" || await pathExists(primary)) {
+    return primary;
+  }
+  return join3(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk");
+};
+var buildAbsoluteAndroidGradleArtifact = async (options) => {
+  const { project, task } = 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);
+    const managedBuildDirectory = resolve2(project.androidRoot, "..", "..", "Builds", `${project.config.appId}-${buildId}`);
+    const windowsDirectory = windowsPathFromWsl(managedBuildDirectory, capture);
+    const windowsAndroidRoot = windowsPathFromWsl(project.androidRoot, capture);
+    const { dependencies, rewrittenSettings } = await mirroredCapacitorDependencies(project, capture);
+    await requireSuccess([
+      "powershell.exe",
+      "-NoProfile",
+      "-EncodedCommand",
+      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");
     return {
-      kind: "invalid",
-      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageBundle} header.`
+      artifactPath: artifactPath2,
+      installPath: unsigned ? win32.join(windowsDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk") : gradleArtifactPath(windowsDirectory, task, true)
     };
   }
-  if (!pageContractsValue) {
+  const wrapper = project.host === "windows" ? "gradlew.bat" : "./gradlew";
+  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 };
+};
+
+// src/mobile/androidRelease.ts
+var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var requireManifest = (value) => {
+  if (!isRecord(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 pathExists2 = async (path) => {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var defaultCapture = (command, options = {}) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      cwd: options.cwd,
+      env: options.env,
+      stderr: "pipe",
+      stdin: "ignore",
+      stdout: "pipe"
+    });
     return {
-      kind: "invalid",
-      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageContracts} header.`
+      exitCode: result.exitCode,
+      stderr: result.stderr.toString(),
+      stdout: result.stdout.toString()
     };
-  }
-  if (!pageId) {
+  } catch (error) {
     return {
-      kind: "invalid",
-      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageId} header.`
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : String(error),
+      stdout: ""
     };
   }
-  const pageContracts = [
-    ...new Set(pageContractsValue.split(",").map((value) => value.trim()).filter(Boolean))
-  ];
-  if (pageContracts.length === 0) {
-    return {
-      kind: "invalid",
-      message: `${MOBILE_PAGE_REQUEST_HEADERS.pageContracts} must contain at least one contract.`
+};
+var verifyAabSignature = (artifactPath, capture, jarsigner) => {
+  const executable = jarsigner === undefined ? Bun.which("jarsigner") : jarsigner;
+  if (!executable)
+    return null;
+  const result = capture([
+    executable,
+    "-J-Duser.language=en",
+    "-J-Duser.country=US",
+    "-verify",
+    artifactPath
+  ]);
+  return result.exitCode === 0 && /jar verified/iu.test(result.stdout);
+};
+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");
+  const projectRelative = relative3(root, output);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep2}`) || isAbsolute2(projectRelative)) {
+    throw new TypeError("mobile build --outdir must remain inside the project.");
+  }
+  return output;
+};
+var installRelease = async (artifactPath, metadata, outputRoot) => {
+  const releaseRoot = join4(outputRoot, metadata.releaseId);
+  const artifactName = "app-release.aab";
+  const destination = join4(releaseRoot, artifactName);
+  if (await pathExists2(releaseRoot)) {
+    const existing = requireManifestIdentity(JSON.parse(await readFile4(join4(releaseRoot, "release.json"), "utf8")), metadata);
+    const [installedBytes, installedSha256] = await Promise.all([
+      stat(destination).then(({ size }) => size),
+      sha256File(destination)
+    ]);
+    if (installedBytes !== metadata.bytes || installedSha256 !== metadata.sha256) {
+      throw new TypeError(`Immutable Android release ${metadata.releaseId} artifact is missing or modified.`);
+    }
+    return { artifactPath: destination, metadata: existing, releaseRoot };
+  }
+  await mkdir3(dirname2(releaseRoot), { recursive: true });
+  const staging = await mkdtemp2(join4(dirname2(releaseRoot), ".android-stage-"));
+  try {
+    await copyFile2(artifactPath, join4(staging, artifactName));
+    const complete = {
+      ...metadata,
+      artifact: artifactName
     };
+    await writeFile4(join4(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+`, { flag: "wx" });
+    await rename4(staging, releaseRoot);
+    return { artifactPath: destination, metadata: complete, releaseRoot };
+  } finally {
+    await rm3(staging, { force: true, recursive: true }).catch(() => {
+      return;
+    });
   }
-  return {
-    client: {
-      appBuild,
-      pageBundle,
-      pageContracts,
-      pageId,
-      protocol: Number(protocolValue),
-      runtime
-    },
-    kind: "mobile"
-  };
 };
-var responseHeaders = () => {
-  const headers = new Headers({
-    "cache-control": "no-store",
-    "content-type": `${ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE}; version=${ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION}`
-  });
-  headerVaryValues.forEach((value) => headers.append("vary", value));
-  return headers;
+var requireManifestIdentity = (value, expected) => {
+  if (!isRecord(value)) {
+    throw new TypeError("Existing Android release metadata is invalid.");
+  }
+  const { artifact } = value;
+  if (artifact !== "app-release.aab" || Object.entries(expected).some(([key, expectedValue]) => Reflect.get(value, key) !== expectedValue)) {
+    throw new TypeError(`Immutable Android release ${expected.releaseId} does not match its content.`);
+  }
+  return { ...expected, artifact };
 };
-var headerVaryValues = [
-  "Accept",
-  MOBILE_PAGE_REQUEST_HEADERS.protocol,
-  MOBILE_PAGE_REQUEST_HEADERS.runtime,
-  MOBILE_PAGE_REQUEST_HEADERS.appBuild,
-  MOBILE_PAGE_REQUEST_HEADERS.pageBundle,
-  MOBILE_PAGE_REQUEST_HEADERS.pageContracts,
-  MOBILE_PAGE_REQUEST_HEADERS.pageId
-];
-var envelopeResponse = (response, status) => new Response(JSON.stringify({
-  protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
-  response
-}), { headers: responseHeaders(), status });
-var isRecord = (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.");
+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,
+      host,
+      nativeDirectory,
+      projectRoot
+    },
+    run: options.run,
+    task: "bundleRelease"
+  });
+  if (!await pathExists2(artifactPath)) {
+    throw new TypeError(`Android Gradle did not produce the expected App Bundle: ${artifactPath}`);
   }
-  const parsed = JSON.parse(serialized);
-  if (!isRecord(parsed)) {
-    throw new TypeError("Mobile page props must serialize to an object.");
+  const capture = options.capture ?? defaultCapture;
+  const signed = verifyAabSignature(artifactPath, capture, options.jarsigner);
+  if (signed === null && !options.allowUnsigned) {
+    throw new TypeError("Could not verify the Android App Bundle signature because jarsigner is unavailable. Install a JDK, or use --unsigned only for a non-publishable build.");
   }
-  return parsed;
+  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 [bytes, sha256] = await Promise.all([
+    stat(artifactPath).then(({ size }) => size),
+    sha256File(artifactPath)
+  ]);
+  const releaseId = `amobile_android_${sha256}`;
+  const metadata = {
+    appBuild: manifest.appBuild,
+    appId: manifest.appId,
+    bytes,
+    engine: "capacitor",
+    format: ABSOLUTE_ANDROID_RELEASE_FORMAT,
+    platform: "android",
+    releaseId,
+    runtime: manifest.runtime,
+    sha256,
+    signed: signed === true,
+    type: "aab",
+    ...versionCode === undefined ? {} : { versionCode }
+  };
+  return installRelease(artifactPath, metadata, safeOutputDirectory(projectRoot, options.outputDirectory));
 };
-var finalizeArchivedMobilePage = (context, input) => {
-  const { page } = context;
-  if (page.pageId !== input.compatibility.pageId || page.framework !== input.compatibility.framework) {
-    return envelopeResponse({
-      kind: "invalid-request",
-      message: "Archived producer page identity does not match its release artifact."
-    }, BAD_REQUEST_STATUS);
+// 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 { 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 {
-    const [currentRepresentation] = input.compatibility.representations;
-    if (!currentRepresentation) {
-      throw new TypeError("Mobile page has no current representation.");
-    }
-    return envelopeResponse({
-      contract: page.contract,
-      framework: page.framework,
-      kind: "page",
-      pageId: page.pageId,
-      props: normalizeJsonValue(currentRepresentation.mapProps(input.props)),
-      status: input.status ?? OK_STATUS
-    }, input.status ?? OK_STATUS);
-  } catch (error) {
-    console.error(`[Mobile] Archived producer ${context.releaseId} failed for ${page.pageId}:`, error);
-    return createAbsoluteMobilePageErrorResponse(page.pageId);
+    await access4(path);
+    return true;
+  } catch {
+    return false;
   }
 };
-var createAbsoluteMobileInvalidRequestResponse = (message) => envelopeResponse({ kind: "invalid-request", message }, BAD_REQUEST_STATUS);
-var createAbsoluteMobilePageErrorResponse = (pageId) => envelopeResponse({
+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 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 = resolve5(projectRoot);
+  const path = resolve5(root, value);
+  if (path !== root && !path.startsWith(`${root}/`)) {
+    throw new TypeError(`${field} must remain inside the project root.`);
+  }
+  return path;
+};
+var requireText = (value, field) => {
+  const normalized = value.trim();
+  if (!normalized)
+    throw new TypeError(`${field} must not be empty.`);
+  return normalized;
+};
+var normalizeEntry = (entry) => {
+  const normalized = requireText(entry ?? "/", "mobile.entry");
+  if (!normalized.startsWith("/") || normalized.startsWith("//")) {
+    throw new TypeError("mobile.entry must be an absolute application path.");
+  }
+  return normalized;
+};
+var normalizeProductionOrigin = (value) => {
+  const parsed = new URL(requireText(value, "mobile.server.productionOrigin"));
+  if (parsed.protocol !== "https:") {
+    throw new TypeError("mobile.server.productionOrigin must use HTTPS in production.");
+  }
+  if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+    throw new TypeError("mobile.server.productionOrigin must be an origin without credentials, path, query, or hash.");
+  }
+  return parsed.origin;
+};
+var normalizePlatforms = (platforms) => {
+  const normalized = [
+    ...new Set(platforms ?? ["ios", "android"])
+  ];
+  if (normalized.length === 0) {
+    throw new TypeError("mobile.platforms must contain at least one platform.");
+  }
+  return normalized;
+};
+var normalizeHosts = (hosts, productionOrigin) => {
+  const normalizeHostname = (host) => {
+    const value = requireText(host, "mobile.deepLinks.hosts").toLowerCase();
+    if (!HOSTNAME_PATTERN.test(value)) {
+      throw new TypeError("mobile.deepLinks.hosts entries must be valid hostnames without ports, wildcards, or paths.");
+    }
+    return value;
+  };
+  const normalized = new Set([
+    normalizeHostname(new URL(productionOrigin).hostname)
+  ]);
+  for (const host of hosts ?? []) {
+    normalized.add(normalizeHostname(host));
+  }
+  return [...normalized].sort();
+};
+var normalizeAppleAppIdPrefix = (value) => {
+  if (value === undefined)
+    return;
+  const normalized = requireText(value, "mobile.deepLinks.apple.appIdPrefix").toUpperCase();
+  if (!APPLE_APP_ID_PREFIX_PATTERN.test(normalized)) {
+    throw new TypeError("mobile.deepLinks.apple.appIdPrefix must contain ten letters or digits.");
+  }
+  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)) {
+      throw new TypeError("mobile.deepLinks.android.sha256CertificateFingerprints entries must be SHA-256 certificate fingerprints.");
+    }
+    return value.match(/.{2}/g)?.join(":") ?? value;
+  }))
+].sort();
+var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
+  const appId = requireText(config.appId, "mobile.appId");
+  if (!APP_ID_PATTERN.test(appId)) {
+    throw new TypeError("mobile.appId must use reverse-domain notation, for example com.example.app.");
+  }
+  const productionOrigin = normalizeProductionOrigin(config.server.productionOrigin);
+  const deepLinkScheme = config.deepLinks?.scheme?.trim().toLowerCase();
+  if (deepLinkScheme && !SCHEME_PATTERN.test(deepLinkScheme)) {
+    throw new TypeError("mobile.deepLinks.scheme is not a valid URL scheme.");
+  }
+  return {
+    androidCertificateFingerprints: normalizeCertificateFingerprints(config.deepLinks?.android?.sha256CertificateFingerprints),
+    appId,
+    appleAppIdPrefix: normalizeAppleAppIdPrefix(config.deepLinks?.apple?.appIdPrefix),
+    appName: requireText(config.appName, "mobile.appName"),
+    bundleDirectory: resolveProjectPath(projectRoot, config.bundleDirectory ?? ".absolutejs/mobile/web", "mobile.bundleDirectory"),
+    deepLinkHosts: normalizeHosts(config.deepLinks?.hosts, productionOrigin),
+    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
+  };
+};
+
+// src/mobile/associationFiles.ts
+var JSON_HEADERS = {
+  "cache-control": "public, max-age=300, must-revalidate",
+  "content-type": "application/json; charset=utf-8"
+};
+var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json";
+var HTTP_OK = 200;
+var VERIFY_TIMEOUT_MS = 1e4;
+var ANDROID_ASSOCIATION_PATH = "/.well-known/assetlinks.json";
+var APPLE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association";
+var missingIdentity = (field, platform) => new TypeError(`${field} is required to publish ${platform} deep-link association files.`);
+var createAppleDocument = (config, requireAll) => {
+  if (!config.platforms.includes("ios"))
+    return;
+  if (!config.appleAppIdPrefix && requireAll) {
+    throw missingIdentity("mobile.deepLinks.apple.appIdPrefix", "iOS");
+  }
+  if (!config.appleAppIdPrefix)
+    return;
+  return {
+    applinks: {
+      details: [
+        {
+          appIDs: [
+            `${config.appleAppIdPrefix}.${config.appId}`
+          ],
+          components: [{ "/": "/*" }]
+        }
+      ]
+    }
+  };
+};
+var createAndroidDocument = (config, requireAll) => {
+  if (!config.platforms.includes("android"))
+    return;
+  if (config.androidCertificateFingerprints.length === 0 && requireAll) {
+    throw missingIdentity("mobile.deepLinks.android.sha256CertificateFingerprints", "Android");
+  }
+  if (config.androidCertificateFingerprints.length === 0)
+    return;
+  return [
+    {
+      relation: ["delegate_permission/common.handle_all_urls"],
+      target: {
+        namespace: "android_app",
+        package_name: config.appId,
+        sha256_cert_fingerprints: config.androidCertificateFingerprints
+      }
+    }
+  ];
+};
+var createAbsoluteMobileAssociationDocuments = (config, options = {}) => {
+  const documents = {};
+  const requireAll = options.requireAll === true;
+  const android = createAndroidDocument(config, requireAll);
+  const apple = createAppleDocument(config, requireAll);
+  if (android)
+    documents.android = android;
+  if (apple)
+    documents.apple = apple;
+  return documents;
+};
+var jsonResponse = (value) => new Response(`${JSON.stringify(value)}
+`, { headers: JSON_HEADERS });
+var createAbsoluteMobileAssociationPlugin = (mobile, projectRoot, options = {}) => {
+  const plugin = new Elysia({ name: "absolutejs-mobile-associations" });
+  if (!mobile)
+    return plugin;
+  const config = normalizeAbsoluteMobileConfig(mobile, projectRoot);
+  const documents = createAbsoluteMobileAssociationDocuments(config, options);
+  if (documents.apple) {
+    plugin.get(APPLE_ASSOCIATION_PATH, () => jsonResponse(documents.apple));
+  }
+  if (documents.android) {
+    plugin.get(ANDROID_ASSOCIATION_PATH, () => jsonResponse(documents.android));
+  }
+  return plugin;
+};
+var writeAtomic = async (path, source) => {
+  let current;
+  try {
+    current = await readFile6(path, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile6(temporary, source, { flag: "wx" });
+  await rename6(temporary, path);
+  return true;
+};
+var exists2 = async (path) => {
+  try {
+    await access5(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var assertOwnedOutput = async (root) => {
+  const path = resolve6(root, OWNERSHIP_FILE);
+  let ownership;
+  try {
+    ownership = JSON.parse(await readFile6(path, "utf8"));
+  } catch {
+    throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
+  }
+  if (typeof ownership !== "object" || ownership === null || Reflect.get(ownership, "format") !== 1) {
+    throw new TypeError(`Association output ${root} has an unsupported ownership manifest.`);
+  }
+};
+var publishGeneratedDirectory = async (temporary, root) => {
+  const hasCurrent = await exists2(root);
+  if (hasCurrent)
+    await assertOwnedOutput(root);
+  const backup = `${root}.${crypto.randomUUID()}.previous`;
+  if (hasCurrent)
+    await rename6(root, backup);
+  try {
+    await rename6(temporary, root);
+  } catch (error) {
+    if (hasCurrent)
+      await rename6(backup, root);
+    throw error;
+  }
+  if (hasCurrent)
+    await rm5(backup, { force: true, recursive: true });
+};
+var materializeHost = async (root, host, files) => {
+  const directory = resolve6(root, host, ".well-known");
+  await mkdir5(directory, { recursive: true });
+  return Promise.all(files.map(async ([name, document]) => {
+    const path = resolve6(directory, name);
+    await writeAtomic(path, `${JSON.stringify(document, null, 2)}
+`);
+    return path;
+  }));
+};
+var associationEndpoints = (config, documents) => config.deepLinkHosts.flatMap((host) => {
+  const endpoints = [];
+  if (documents.android)
+    endpoints.push({
+      document: documents.android,
+      host,
+      path: ANDROID_ASSOCIATION_PATH,
+      platform: "Android"
+    });
+  if (documents.apple)
+    endpoints.push({
+      document: documents.apple,
+      host,
+      path: APPLE_ASSOCIATION_PATH,
+      platform: "Apple"
+    });
+  return endpoints;
+});
+var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
+  const root = resolve6(outputDirectory);
+  const temporary = `${root}.${crypto.randomUUID()}.tmp`;
+  const documents = createAbsoluteMobileAssociationDocuments(config, {
+    requireAll: true
+  });
+  const files = [];
+  if (documents.android)
+    files.push(["assetlinks.json", documents.android]);
+  if (documents.apple) {
+    files.push(["apple-app-site-association", documents.apple]);
+  }
+  await mkdir5(temporary, { recursive: true });
+  try {
+    const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
+    await writeAtomic(resolve6(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+`);
+    await publishGeneratedDirectory(temporary, root);
+    const written = temporaryPaths.map((path) => resolve6(root, path.slice(temporary.length + 1)));
+    return { root, written };
+  } catch (error) {
+    await rm5(temporary, { force: true, recursive: true });
+    throw error;
+  }
+};
+var verifyAbsoluteMobileAssociationFiles = async (config, request = globalThis.fetch) => {
+  const documents = createAbsoluteMobileAssociationDocuments(config, {
+    requireAll: true
+  });
+  const results = await Promise.all(associationEndpoints(config, documents).map(async (endpoint) => {
+    const url = `https://${endpoint.host}${endpoint.path}`;
+    const response = await request(url, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(VERIFY_TIMEOUT_MS)
+    });
+    if (response.status !== HTTP_OK) {
+      throw new TypeError(`${endpoint.platform} association verification failed for ${url}: HTTP ${response.status}; redirects are not allowed.`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().startsWith("application/json")) {
+      throw new TypeError(`${endpoint.platform} association verification failed for ${url}: expected application/json.`);
+    }
+    let document;
+    try {
+      document = await response.json();
+    } catch {
+      throw new TypeError(`${endpoint.platform} association verification failed for ${url}: invalid JSON.`);
+    }
+    if (JSON.stringify(document) !== JSON.stringify(endpoint.document)) {
+      throw new TypeError(`${endpoint.platform} association verification failed for ${url}: the hosted identity does not match mobile config.`);
+    }
+    return { platform: endpoint.platform, url };
+  }));
+  return { results };
+};
+// src/mobile/buildMetadata.ts
+var ABSOLUTE_MOBILE_ROUTE_DETAIL = "x-absolute-mobile";
+var frameworks2 = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPageFramework2 = (value) => typeof value === "string" && frameworks2.has(value);
+var parseAbsoluteMobileBuildPageMetadata = (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;
+  }
+  return {
+    bundleKey: value.bundleKey,
+    contract: value.contract,
+    framework: value.framework,
+    pageId: value.pageId,
+    propsSchemaHash: value.propsSchemaHash
+  };
+};
+// src/mobile/buildPipeline.ts
+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 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 = resolve7(buildDirectory);
+  const resolvedAsset = resolve7(assetPath);
+  if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
+    return resolvedAsset;
+  }
+  return join6(buildDirectory, assetPath.replace(/^\/+/, ""));
+};
+var pageFor = async (metadata, manifest, buildDirectory) => {
+  const assetPath = manifest[metadata.bundleKey];
+  if (!assetPath) {
+    throw new TypeError(`Mobile page ${metadata.pageId} references missing manifest asset ${metadata.bundleKey}.`);
+  }
+  const resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
+  const bytes = await readFile7(resolvedAssetPath);
+  const bundlePath = `/${relative5(resolve7(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  return {
+    bundleHash: sha256(bytes),
+    bundlePath,
+    contract: metadata.contract,
+    framework: metadata.framework,
+    pageId: metadata.pageId,
+    propsSchemaHash: metadata.propsSchemaHash
+  };
+};
+var buildAbsoluteMobileCompatibilityRelease = async (options) => {
+  const [captured, producerBytes] = await Promise.all([
+    captureAbsoluteMobileRouteGraph(options.app),
+    readFile7(options.producerPath)
+  ]);
+  if (captured.length === 0) {
+    throw new TypeError("No instrumented AbsoluteJS mobile page routes were found in the finalized Elysia route graph.");
+  }
+  const metadataByPage = new Map;
+  for (const { metadata } of captured) {
+    const prior = metadataByPage.get(metadata.pageId);
+    if (prior && JSON.stringify(prior) !== JSON.stringify(metadata)) {
+      throw new TypeError(`Mobile page ${metadata.pageId} has inconsistent generated contracts.`);
+    }
+    metadataByPage.set(metadata.pageId, metadata);
+  }
+  const pages = await Promise.all([...metadataByPage.values()].map((metadata) => pageFor(metadata, options.manifest, options.buildDirectory)));
+  const producerHash = sha256(producerBytes);
+  const appBuild = `ambuild_${sha256(new TextEncoder().encode(JSON.stringify({
+    pages: pages.map(({ bundleHash, bundlePath, contract, pageId }) => ({
+      bundleHash,
+      bundlePath,
+      contract,
+      pageId
+    })),
+    producerHash,
+    runtime: options.runtime
+  })))}`;
+  const priorAppIds = new Set((options.previousArtifacts ?? []).map(({ appId }) => appId));
+  if (priorAppIds.size > 1 || priorAppIds.size === 1 && !priorAppIds.has(options.appId)) {
+    throw new TypeError("Previous mobile compatibility artifacts belong to another app.");
+  }
+  const unchanged = options.previousArtifacts?.find((artifact2) => artifact2.appBuild === appBuild && artifact2.runtime === options.runtime);
+  const generation = unchanged?.generation ?? Math.max(0, ...(options.previousArtifacts ?? []).map((artifact2) => artifact2.generation)) + 1;
+  const artifact = createAbsoluteMobileCompatibilityArtifact({
+    appBuild,
+    appId: options.appId,
+    generation,
+    pages,
+    producer: {
+      bundleHash: producerHash,
+      bytes: producerBytes.byteLength,
+      exportName: options.producerExport ?? "server",
+      module: options.producerModule ?? "producer.js"
+    },
+    routes: captured.map(({ route }) => route),
+    runtime: options.runtime
+  });
+  return { artifact, producer: new Blob([producerBytes]) };
+};
+var captureAbsoluteMobileRouteGraph = async (app) => {
+  if (app.modules)
+    await app.modules;
+  app.compile();
+  const captured = app.routes.flatMap((route) => {
+    const metadata = readPageMetadata(route);
+    if (!metadata || route.method !== "GET" && route.method !== "HEAD") {
+      return [];
+    }
+    return [
+      {
+        metadata,
+        route: {
+          method: route.method === "GET" ? "GET" : "HEAD",
+          pageId: metadata.pageId,
+          pattern: route.path
+        }
+      }
+    ];
+  });
+  const identities = new Map;
+  for (const { metadata, route } of captured) {
+    const prior = identities.get(`${route.method}:${route.pattern}`);
+    if (prior && prior !== metadata.pageId) {
+      throw new TypeError(`Mobile route ${route.method} ${route.pattern} resolves to multiple pages.`);
+    }
+    identities.set(`${route.method}:${route.pattern}`, metadata.pageId);
+  }
+  return captured;
+};
+
+// src/mobile/capacitorBundle.ts
+import {
+  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 dirname4, extname, join as join7, resolve as resolve8 } from "path";
+
+// src/mobile/routeMatcher.ts
+var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
+var routeSegmentPattern = (segment) => {
+  if (segment === "*")
+    return ".*";
+  if (segment.startsWith(":") && segment.endsWith("?"))
+    return "[^/]*";
+  if (segment.startsWith(":"))
+    return "[^/]+";
+  return segment.replace(REGEXP_SPECIAL_CHARACTERS, "\\$&");
+};
+var matchesAbsoluteMobileRoutePattern = (pattern, pathname) => {
+  const expression = pattern.split("/").map(routeSegmentPattern).join("/");
+  return new RegExp(`^${expression}/?$`).test(pathname);
+};
+var resolveAbsoluteMobileRoute = (routes, pathname, method = "GET") => routes.find((route) => route.method === method && matchesAbsoluteMobileRoutePattern(route.pattern, pathname));
+
+// src/mobile/producerContextState.ts
+var ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY = Symbol.for("absolutejs.mobileProducerAsyncLocalStorage");
+var frameworks3 = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var isCompatibilityPage = (value) => typeof value === "object" && value !== null && ("bundleHash" in value) && typeof value.bundleHash === "string" && ("contract" in value) && typeof value.contract === "string" && ("framework" in value) && typeof value.framework === "string" && frameworks3.has(value.framework) && ("pageId" in value) && typeof value.pageId === "string" && ("propsSchemaHash" in value) && typeof value.propsSchemaHash === "string";
+var getCurrentAbsoluteMobileProducerContext = () => {
+  const value = Reflect.get(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY);
+  if (typeof value !== "object" || value === null || !("getStore" in value) || typeof value.getStore !== "function") {
+    return;
+  }
+  const context = value.getStore();
+  if (typeof context !== "object" || context === null || !("page" in context) || !isCompatibilityPage(context.page) || !("releaseId" in context) || typeof context.releaseId !== "string") {
+    return;
+  }
+  return { page: context.page, releaseId: context.releaseId };
+};
+
+// src/mobile/pageProtocol.ts
+var ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
+var ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION = 1;
+var BAD_REQUEST_STATUS = 400;
+var OK_STATUS = 200;
+var SERVER_ERROR_STATUS = 500;
+var UPGRADE_REQUIRED_STATUS = 426;
+var MOBILE_PAGE_REQUEST_HEADERS = {
+  appBuild: "x-absolute-mobile-app-build",
+  pageBundle: "x-absolute-mobile-page-bundle",
+  pageContracts: "x-absolute-mobile-page-contracts",
+  pageId: "x-absolute-mobile-page-id",
+  protocol: "x-absolute-mobile-protocol",
+  runtime: "x-absolute-mobile-runtime"
+};
+var parseMediaType = (value) => value.split(";", 1)[0]?.trim().toLowerCase();
+var acceptsAbsoluteMobilePage = (request) => {
+  if (!request)
+    return false;
+  return (request.headers.get("accept") ?? "").split(",").some((value) => parseMediaType(value) === ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
+};
+var readRequiredHeader = (request, name) => {
+  const value = request.headers.get(name)?.trim();
+  return value ? value : undefined;
+};
+var parseAbsoluteMobilePageRequest = (request) => {
+  if (!request || !acceptsAbsoluteMobilePage(request)) {
+    return { kind: "not-mobile" };
+  }
+  const protocolValue = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.protocol);
+  const runtime = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.runtime);
+  const appBuild = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.appBuild);
+  const pageBundle = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageBundle);
+  const pageContractsValue = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageContracts);
+  const pageId = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageId);
+  if (!protocolValue || !/^\d+$/.test(protocolValue)) {
+    return {
+      kind: "invalid",
+      message: `Missing or invalid ${MOBILE_PAGE_REQUEST_HEADERS.protocol} header.`
+    };
+  }
+  if (!runtime) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.runtime} header.`
+    };
+  }
+  if (!appBuild) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.appBuild} header.`
+    };
+  }
+  if (!pageBundle) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageBundle} header.`
+    };
+  }
+  if (!pageContractsValue) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageContracts} header.`
+    };
+  }
+  if (!pageId) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageId} header.`
+    };
+  }
+  const pageContracts = [
+    ...new Set(pageContractsValue.split(",").map((value) => value.trim()).filter(Boolean))
+  ];
+  if (pageContracts.length === 0) {
+    return {
+      kind: "invalid",
+      message: `${MOBILE_PAGE_REQUEST_HEADERS.pageContracts} must contain at least one contract.`
+    };
+  }
+  return {
+    client: {
+      appBuild,
+      pageBundle,
+      pageContracts,
+      pageId,
+      protocol: Number(protocolValue),
+      runtime
+    },
+    kind: "mobile"
+  };
+};
+var responseHeaders = () => {
+  const headers = new Headers({
+    "cache-control": "no-store",
+    "content-type": `${ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE}; version=${ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION}`
+  });
+  headerVaryValues.forEach((value) => headers.append("vary", value));
+  return headers;
+};
+var headerVaryValues = [
+  "Accept",
+  MOBILE_PAGE_REQUEST_HEADERS.protocol,
+  MOBILE_PAGE_REQUEST_HEADERS.runtime,
+  MOBILE_PAGE_REQUEST_HEADERS.appBuild,
+  MOBILE_PAGE_REQUEST_HEADERS.pageBundle,
+  MOBILE_PAGE_REQUEST_HEADERS.pageContracts,
+  MOBILE_PAGE_REQUEST_HEADERS.pageId
+];
+var envelopeResponse = (response, status) => new Response(JSON.stringify({
+  protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+  response
+}), { headers: responseHeaders(), status });
+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 (!isRecord4(parsed)) {
+    throw new TypeError("Mobile page props must serialize to an object.");
+  }
+  return parsed;
+};
+var finalizeArchivedMobilePage = (context, input) => {
+  const { page } = context;
+  if (page.pageId !== input.compatibility.pageId || page.framework !== input.compatibility.framework) {
+    return envelopeResponse({
+      kind: "invalid-request",
+      message: "Archived producer page identity does not match its release artifact."
+    }, BAD_REQUEST_STATUS);
+  }
+  try {
+    const [currentRepresentation] = input.compatibility.representations;
+    if (!currentRepresentation) {
+      throw new TypeError("Mobile page has no current representation.");
+    }
+    return envelopeResponse({
+      contract: page.contract,
+      framework: page.framework,
+      kind: "page",
+      pageId: page.pageId,
+      props: normalizeJsonValue(currentRepresentation.mapProps(input.props)),
+      status: input.status ?? OK_STATUS
+    }, input.status ?? OK_STATUS);
+  } catch (error) {
+    console.error(`[Mobile] Archived producer ${context.releaseId} failed for ${page.pageId}:`, error);
+    return createAbsoluteMobilePageErrorResponse(page.pageId);
+  }
+};
+var createAbsoluteMobileInvalidRequestResponse = (message) => envelopeResponse({ kind: "invalid-request", message }, BAD_REQUEST_STATUS);
+var createAbsoluteMobilePageErrorResponse = (pageId) => envelopeResponse({
   code: "representation-failed",
   kind: "error",
   pageId,
@@ -767,7 +2231,7 @@ class AbsoluteMobilePageProtocolError extends Error {
     this.code = code;
   }
 }
-var frameworks3 = new Set([
+var frameworks4 = new Set([
   "angular",
   "ember",
   "html",
@@ -782,14 +2246,14 @@ var upgradeReasons = new Set([
   "protocol",
   "runtime"
 ]);
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isFramework = (value) => typeof value === "string" && frameworks3.has(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 (!isRecord2(value.props)) {
+  if (!isRecord5(value.props)) {
     throw new AbsoluteMobilePageProtocolError("invalid-props", "The mobile page response must contain an object props value.");
   }
   return {
@@ -835,7 +2299,7 @@ var activateAbsoluteMobilePage = async (value, options) => {
   };
 };
 var parseAbsoluteMobilePageEnvelope = (value) => {
-  if (!isRecord2(value) || !isRecord2(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) {
@@ -862,122 +2326,246 @@ var parseAbsoluteMobilePageEnvelope = (value) => {
   }
   throw new AbsoluteMobilePageProtocolError("invalid-envelope", `Unknown mobile page response kind ${String(kind)}.`);
 };
-// src/mobile/compatibilityDispatcher.ts
-import { Elysia } from "elysia";
 
-// src/mobile/producerContext.ts
-import { AsyncLocalStorage } from "async_hooks";
-var isProducerStorage = (value) => typeof value === "object" && value !== null && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
-var getProducerStorage = () => {
-  const value = Reflect.get(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY);
-  return isProducerStorage(value) ? value : undefined;
+// src/mobile/transport.ts
+var ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT = 1;
+var pageForPathname = (manifest, pathname) => {
+  const route = resolveAbsoluteMobileRoute(manifest.routes, pathname);
+  if (!route) {
+    throw new TypeError(`No embedded mobile page owns ${pathname}.`);
+  }
+  const page = manifest.pages.find((candidate) => candidate.pageId === route.pageId);
+  if (!page) {
+    throw new TypeError(`Mobile route ${route.pattern} references missing page ${route.pageId}.`);
+  }
+  return page;
 };
-var ensureProducerStorage = () => {
-  const existing = getProducerStorage();
-  if (existing)
-    return existing;
-  const storage = new AsyncLocalStorage;
-  Reflect.set(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY, storage);
-  return storage;
+var canonicalBackendUrl = (manifest, path) => {
+  const origin = new URL(manifest.productionOrigin);
+  const url = new URL(path, `${origin.origin}/`);
+  if (url.origin !== origin.origin) {
+    throw new TypeError("Mobile transport cannot leave productionOrigin.");
+  }
+  url.hash = "";
+  return url;
+};
+var createAbsoluteMobilePageRequest = (manifest, path, options = {}) => {
+  const url = canonicalBackendUrl(manifest, path);
+  const page = pageForPathname(manifest, url.pathname);
+  const headers = new Headers(options.headers);
+  headers.set("accept", ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.appBuild, manifest.appBuild);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageBundle, page.bundleHash);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageContracts, page.contract);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageId, page.pageId);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.protocol, String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION));
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.runtime, manifest.runtime);
+  return new Request(url, { headers, method: "GET" });
+};
+var fetchAbsoluteMobilePage = async (manifest, path, options = {}) => {
+  const request = createAbsoluteMobilePageRequest(manifest, path, options);
+  const response = await (options.fetch ?? globalThis.fetch)(request);
+  const value = await response.json();
+  return value;
+};
+var navigateAbsoluteMobilePage = async (manifest, path, options) => {
+  const envelope = await fetchAbsoluteMobilePage(manifest, path, options);
+  return activateAbsoluteMobilePage(envelope, options);
+};
+var resolveAbsoluteMobileDeepLink = (manifest, value) => {
+  const url = new URL(value);
+  if (url.username || url.password) {
+    throw new TypeError("Mobile deep links cannot contain credentials.");
+  }
+  const isHttpsHost = url.protocol === "https:" && manifest.deepLinkHosts.includes(url.hostname.toLowerCase());
+  const isCustomScheme = manifest.deepLinkScheme !== undefined && url.protocol === `${manifest.deepLinkScheme}:`;
+  if (!isHttpsHost && !isCustomScheme) {
+    throw new TypeError("Mobile deep link is outside the configured app URLs.");
+  }
+  return `${url.pathname || "/"}${url.search}${url.hash}`;
 };
-var runWithAbsoluteMobileProducer = (context, callback) => ensureProducerStorage().run(context, callback);
 
-// src/mobile/compatibilityDispatcher.ts
-var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
-var routeSegmentPattern = (segment) => {
-  if (segment === "*")
-    return ".*";
-  if (segment.startsWith(":") && segment.endsWith("?"))
-    return "[^/]*";
-  if (segment.startsWith(":"))
-    return "[^/]+";
-  return segment.replace(REGEXP_SPECIAL_CHARACTERS, "\\$&");
+// src/mobile/capacitorBundle.ts
+var MANIFEST_FILE = "absolute-mobile-manifest.json";
+var BOOTSTRAP_FILE = "absolute-mobile-bootstrap.js";
+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) => join7(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
 };
-var matchesRoutePattern = (pattern, pathname) => {
-  const expression = pattern.split("/").map(routeSegmentPattern).join("/");
-  return new RegExp(`^${expression}/?$`).test(pathname);
+var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var indexHtml = (appName) => `<!doctype html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
+		<meta name="color-scheme" content="light dark">
+		<title>${escapeHtml(appName)}</title>
+	</head>
+	<body>
+		<main id="absolute-mobile-status" role="status">Starting\u2026</main>
+		<script type="module" src="./${BOOTSTRAP_FILE}"></script>
+	</body>
+</html>
+`;
+var sourceAssetPath = (buildDirectory, bundlePath) => {
+  const root = resolve8(buildDirectory);
+  const asset = resolve8(root, bundlePath.replace(/^\/+/, ""));
+  if (!asset.startsWith(`${root}/`)) {
+    throw new TypeError("Mobile page bundle escaped the build directory.");
+  }
+  return asset;
 };
-var artifactOwnsRequest = (artifact, pageId, request) => {
-  const { pathname } = new URL(request.url);
-  return artifact.routes.some((route) => route.pageId === pageId && route.method === request.method && matchesRoutePattern(route.pattern, pathname));
+var buildShellBootstrap = async (staging) => {
+  const modulePath = shellBootstrapModule();
+  const entryPath = join7(staging, ".absolute-mobile-entry.ts");
+  await writeFile7(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+void startAbsoluteMobileShell();
+`);
+  const build = await Bun.build({
+    entrypoints: [entryPath],
+    minify: true,
+    outdir: staging,
+    target: "browser"
+  });
+  if (!build.success || build.outputs.length !== 1) {
+    throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
+  }
+  await rename7(build.outputs[0]?.path ?? "", join7(staging, BOOTSTRAP_FILE));
+  await rm6(entryPath, { force: true });
 };
-var createProducerResolver = (loadProducer) => {
-  const producers = new Map;
-  return (artifact) => {
-    const cached = producers.get(artifact.releaseId);
-    if (cached)
-      return cached;
-    const loading = loadProducer(artifact).catch((error) => {
-      producers.delete(artifact.releaseId);
+var removePreviousBundle = async (backup, moved) => {
+  if (!moved)
+    return;
+  await rm6(backup, { force: true, recursive: true });
+};
+var restorePreviousBundle = async (backup, destination, moved) => {
+  if (!moved)
+    return;
+  await rename7(backup, destination);
+};
+var installBundle = async (staging, destination) => {
+  const backup = `${destination}.previous-${crypto.randomUUID()}`;
+  let movedPrevious = false;
+  try {
+    await rename7(destination, backup);
+    movedPrevious = true;
+  } catch (error) {
+    if (!errorHasCode2(error, "ENOENT"))
       throw error;
-    });
-    producers.set(artifact.releaseId, loading);
-    return loading;
-  };
+  }
+  try {
+    await rename7(staging, destination);
+    await removePreviousBundle(backup, movedPrevious);
+  } catch (error) {
+    await restorePreviousBundle(backup, destination, movedPrevious);
+    throw error;
+  }
 };
-var createAbsoluteMobileCompatibilityDispatcher = (options) => {
-  const artifacts = retainAbsoluteMobileCompatibilityArtifacts(options.artifacts);
-  if (!artifacts.some(({ releaseId }) => releaseId === options.currentReleaseId)) {
-    throw new TypeError("currentReleaseId must identify a retained compatibility artifact.");
+var copyClientPage = async (page, buildDirectory, staging, copiedDependencies) => {
+  if (page.framework !== "react") {
+    throw new TypeError(`Capacitor spike currently supports React pages; ${page.pageId} is ${page.framework}.`);
+  }
+  const extension = extname(page.bundlePath) || ".js";
+  const localBundlePath = `./pages/${page.bundleHash}${extension}`;
+  const source = sourceAssetPath(buildDirectory, page.bundlePath);
+  await copyFile4(source, join7(staging, localBundlePath));
+  await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
+  return { ...page, localBundlePath };
+};
+var absoluteClientImports = async (sourcePath) => {
+  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] : [];
+  });
+};
+var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, copied) => {
+  if (copied.has(specifier))
+    return;
+  copied.add(specifier);
+  const source = sourceAssetPath(buildDirectory, specifier);
+  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) => {
+  const dependencies = await absoluteClientImports(sourcePath);
+  await Promise.all(dependencies.map((specifier) => copyAbsoluteClientDependency(specifier, buildDirectory, staging, copied)));
+};
+var materializeAbsoluteCapacitorWebBundle = async (options) => {
+  if (!resolveAbsoluteMobileRoute(options.artifact.routes, new URL(options.config.entry, "https://absolute.invalid").pathname)) {
+    throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
+  }
+  const destination = options.config.bundleDirectory;
+  await mkdir6(dirname4(destination), { recursive: true });
+  const staging = await mkdtemp4(join7(dirname4(destination), `.${basename(destination)}.stage-`));
+  try {
+    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 = {
+      appBuild: options.artifact.appBuild,
+      appId: options.config.appId,
+      appName: options.config.appName,
+      deepLinkHosts: options.config.deepLinkHosts,
+      deepLinkScheme: options.config.deepLinkScheme,
+      entry: options.config.entry,
+      format: ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+      pages,
+      productionOrigin: options.config.productionOrigin,
+      routes: options.artifact.routes,
+      runtime: options.artifact.runtime
+    };
+    await Promise.all([
+      writeFile7(join7(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+`),
+      writeFile7(join7(staging, INDEX_FILE), indexHtml(options.config.appName)),
+      buildShellBootstrap(staging)
+    ]);
+    await installBundle(staging, destination);
+    return manifest;
+  } catch (error) {
+    await rm6(staging, { force: true, recursive: true });
+    throw error;
   }
-  const resolveProducer = createProducerResolver(options.loadProducer);
-  return new Elysia({ name: "absolutejs-mobile-compatibility-dispatcher" }).request(async ({ request }) => {
-    if (getCurrentAbsoluteMobileProducerContext())
-      return;
-    const parsed = parseAbsoluteMobilePageRequest(request);
-    if (parsed.kind !== "mobile")
-      return;
-    const resolved = resolveAbsoluteMobileCompatibilityRelease(parsed.client, artifacts);
-    if (resolved.kind === "upgrade-required") {
-      return createAbsoluteMobileUpgradeResponse(resolved.result);
-    }
-    if (!artifactOwnsRequest(resolved.artifact, parsed.client.pageId, request)) {
-      return createAbsoluteMobileInvalidRequestResponse("The requested URL is not assigned to this mobile page.");
-    }
-    if (resolved.artifact.releaseId === options.currentReleaseId) {
-      return;
-    }
-    try {
-      const producer = await resolveProducer(resolved.artifact);
-      return runWithAbsoluteMobileProducer({
-        page: resolved.page,
-        releaseId: resolved.artifact.releaseId
-      }, () => producer.handle(request));
-    } catch (error) {
-      console.error(`[Mobile] Failed to load retained producer ${resolved.artifact.releaseId}:`, error);
-      return createAbsoluteMobilePageErrorResponse(parsed.client.pageId);
-    }
-  }).as("global");
 };
+
 // src/mobile/materializedBundle.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import {
-  access,
-  mkdir as mkdir2,
-  mkdtemp as mkdtemp2,
-  readFile as readFile2,
-  rename as rename2,
-  rm as rm2,
-  writeFile as writeFile2
+  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, join as join2, 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 isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
+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_${createHash3("sha256").update(identity).digest("hex")}`;
+  return `amb_${createHash7("sha256").update(identity).digest("hex")}`;
 };
 var parseBundleIndex = (value) => {
-  if (!isRecord3(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);
@@ -1000,31 +2588,31 @@ var parseBundleIndex = (value) => {
   };
 };
 var writeRelease = async (root, release) => {
-  const directory = join2(root, release.artifact.releaseId);
-  const producerPath = join2(directory, release.artifact.producer.module);
-  await mkdir2(dirname(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([
-    writeFile2(join2(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile8(join8(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
-    writeFile2(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+    writeFile8(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 };
 var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join2(bundlesRoot, bundleId);
+  const destination = join8(bundlesRoot, bundleId);
   try {
-    await access(destination);
+    await access6(destination);
     return destination;
   } catch (error) {
-    if (!errorHasCode2(error, "ENOENT"))
+    if (!errorHasCode3(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp2(join2(bundlesRoot, ".stage-"));
+  const staging = await mkdtemp5(join8(bundlesRoot, ".stage-"));
   try {
     await Promise.all(releases.map((release) => writeRelease(staging, release)));
-    await rename2(staging, destination);
+    await rename8(staging, destination);
   } catch (error) {
-    await rm2(staging, { force: true, recursive: true });
-    if (errorHasCode2(error, "EEXIST") || errorHasCode2(error, "ENOTEMPTY")) {
+    await rm7(staging, { force: true, recursive: true });
+    if (errorHasCode3(error, "EEXIST") || errorHasCode3(error, "ENOTEMPTY")) {
       return destination;
     }
     throw error;
@@ -1034,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 (!isRecord3(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;
@@ -1052,15 +2640,15 @@ var resolveProducerHandler = (loaded, exportName) => {
 };
 var loadAbsoluteMobileMaterializedBundle = async (root) => {
   const resolvedRoot = resolvePath2(root);
-  const serialized = await readFile2(join2(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 = join2(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 = join2(bundleRoot, artifact.releaseId, artifact.producer.module);
+      const modulePath = join8(bundleRoot, artifact.releaseId, artifact.producer.module);
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer: Bun.file(modulePath)
@@ -1087,8 +2675,8 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     return release;
   });
   const root = resolvePath2(input.root);
-  const bundlesRoot = join2(root, BUNDLES_DIRECTORY);
-  await mkdir2(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 = {
@@ -1097,44 +2685,863 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
     releases: artifacts
   };
-  const pointerPath = join2(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join2(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile2(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 rename2(temporaryPointerPath, pointerPath);
+  await rename8(temporaryPointerPath, pointerPath);
   return index;
 };
+var readAbsoluteMobileMaterializedReleases = async (root) => {
+  const resolvedRoot = resolvePath2(root);
+  try {
+    const serialized = await readFile9(join8(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const parsed = JSON.parse(serialized);
+    const index = parseBundleIndex(parsed);
+    const bundleRoot = join8(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    return Promise.all(index.releases.map(async (artifact) => {
+      const producer = Bun.file(join8(bundleRoot, artifact.releaseId, artifact.producer.module));
+      await verifyAbsoluteMobileCompatibilityProducer({
+        artifact,
+        producer
+      });
+      return { artifact, producer };
+    }));
+  } catch (error) {
+    if (errorHasCode3(error, "ENOENT"))
+      return [];
+    throw error;
+  }
+};
+
+// 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");
+var serverExportName = (loaded, app) => {
+  if (loaded.server === app)
+    return "server";
+  if (loaded.app === app)
+    return "app";
+  return "default";
+};
+var restoreBuildDirectory = (previous) => {
+  if (previous !== undefined) {
+    process.env.ABSOLUTE_BUILD_DIR = previous;
+    return;
+  }
+  delete process.env.ABSOLUTE_BUILD_DIR;
+};
+var requireRelease = (releases, releaseId) => {
+  const release = releases.get(releaseId);
+  if (!release) {
+    throw new TypeError(`Missing retained mobile release ${releaseId}.`);
+  }
+  return release;
+};
+var loadServerApp = async (producerPath) => {
+  const loaded = await import(`${pathToFileURL2(producerPath).href}?absolute-mobile-capture=${crypto.randomUUID()}`);
+  const candidates = [loaded.server, loaded.app, loaded.default];
+  const app = candidates.find(isElysiaApp);
+  if (!app) {
+    throw new TypeError("Mobile builds require the server entry to export its Elysia app as server, app, or default.");
+  }
+  const exportName = serverExportName(loaded, app);
+  return { app, exportName };
+};
+var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
+  const buildDirectory = resolve9(options.buildDirectory);
+  const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
+  const root = join9(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const [manifestSource, previous] = await Promise.all([
+    readFile10(join9(buildDirectory, "manifest.json"), "utf8"),
+    readAbsoluteMobileMaterializedReleases(root)
+  ]);
+  const manifest = JSON.parse(manifestSource);
+  if (!isStringRecord(manifest)) {
+    throw new TypeError("Invalid AbsoluteJS build manifest for mobile capture.");
+  }
+  const previousBuildDirectory = process.env.ABSOLUTE_BUILD_DIR;
+  process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
+  let loaded;
+  try {
+    loaded = await loadServerApp(resolve9(options.producerPath));
+  } finally {
+    restoreBuildDirectory(previousBuildDirectory);
+  }
+  const current = await buildAbsoluteMobileCompatibilityRelease({
+    app: loaded.app,
+    appId: mobile.appId,
+    buildDirectory,
+    manifest,
+    previousArtifacts: previous.map(({ artifact }) => artifact),
+    producerExport: loaded.exportName,
+    producerPath: resolve9(options.producerPath),
+    runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
+  });
+  const releasesById = new Map([current, ...previous].map((release) => [
+    release.artifact.releaseId,
+    release
+  ]));
+  const retained = retainAbsoluteMobileCompatibilityArtifacts([...releasesById.values()].map(({ artifact }) => artifact));
+  await materializeAbsoluteMobileCompatibilityBundle({
+    currentReleaseId: current.artifact.releaseId,
+    releases: retained.map((artifact) => requireRelease(releasesById, artifact.releaseId)),
+    root
+  });
+  await materializeAbsoluteCapacitorWebBundle({
+    artifact: current.artifact,
+    buildDirectory,
+    config: mobile
+  });
+  return current.artifact;
+};
+// src/mobile/compatibilityDispatcher.ts
+import { Elysia as Elysia2 } from "elysia";
+
+// src/mobile/producerContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+var isProducerStorage = (value) => typeof value === "object" && value !== null && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
+var getProducerStorage = () => {
+  const value = Reflect.get(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY);
+  return isProducerStorage(value) ? value : undefined;
+};
+var ensureProducerStorage = () => {
+  const existing = getProducerStorage();
+  if (existing)
+    return existing;
+  const storage = new AsyncLocalStorage;
+  Reflect.set(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY, storage);
+  return storage;
+};
+var runWithAbsoluteMobileProducer = (context, callback) => ensureProducerStorage().run(context, callback);
+
+// src/mobile/compatibilityDispatcher.ts
+var artifactOwnsRequest = (artifact, pageId, request) => {
+  const { pathname } = new URL(request.url);
+  return artifact.routes.some((route) => route.pageId === pageId && route.method === request.method && matchesAbsoluteMobileRoutePattern(route.pattern, pathname));
+};
+var createProducerResolver = (loadProducer) => {
+  const producers = new Map;
+  return (artifact) => {
+    const cached = producers.get(artifact.releaseId);
+    if (cached)
+      return cached;
+    const loading = loadProducer(artifact).catch((error) => {
+      producers.delete(artifact.releaseId);
+      throw error;
+    });
+    producers.set(artifact.releaseId, loading);
+    return loading;
+  };
+};
+var createAbsoluteMobileCompatibilityDispatcher = (options) => {
+  const artifacts = retainAbsoluteMobileCompatibilityArtifacts(options.artifacts);
+  if (!artifacts.some(({ releaseId }) => releaseId === options.currentReleaseId)) {
+    throw new TypeError("currentReleaseId must identify a retained compatibility artifact.");
+  }
+  const resolveProducer = createProducerResolver(options.loadProducer);
+  return new Elysia2({ name: "absolutejs-mobile-compatibility-dispatcher" }).request(async ({ request }) => {
+    if (getCurrentAbsoluteMobileProducerContext())
+      return;
+    const parsed = parseAbsoluteMobilePageRequest(request);
+    if (parsed.kind !== "mobile")
+      return;
+    const resolved = resolveAbsoluteMobileCompatibilityRelease(parsed.client, artifacts);
+    if (resolved.kind === "upgrade-required") {
+      return createAbsoluteMobileUpgradeResponse(resolved.result);
+    }
+    if (!artifactOwnsRequest(resolved.artifact, parsed.client.pageId, request)) {
+      return createAbsoluteMobileInvalidRequestResponse("The requested URL is not assigned to this mobile page.");
+    }
+    if (resolved.artifact.releaseId === options.currentReleaseId) {
+      return;
+    }
+    try {
+      const producer = await resolveProducer(resolved.artifact);
+      return runWithAbsoluteMobileProducer({
+        page: resolved.page,
+        releaseId: resolved.artifact.releaseId
+      }, () => producer.handle(request));
+    } catch (error) {
+      console.error(`[Mobile] Failed to load retained producer ${resolved.artifact.releaseId}:`, error);
+      return createAbsoluteMobilePageErrorResponse(parsed.client.pageId);
+    }
+  }).as("global");
+};
+// src/mobile/nativeDeepLinks.ts
+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 readFile11(path, "utf8");
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile9(temporary, source, { flag: "wx" });
+  await rename9(temporary, path);
+  return true;
+};
+var replaceManagedRegion = (source, region, insertAt) => {
+  const start = source.indexOf(START_MARKER);
+  const end = source.indexOf(END_MARKER);
+  if (start === NOT_FOUND !== (end === NOT_FOUND) || start !== NOT_FOUND && end < start) {
+    throw new TypeError("AbsoluteJS deep-link ownership markers are malformed.");
+  }
+  if (start !== NOT_FOUND) {
+    const lineStart = source.lastIndexOf(`
+`, start) + 1;
+    const nextLine = source.indexOf(`
+`, end + END_MARKER.length);
+    const lineEnd = nextLine === NOT_FOUND ? source.length : nextLine + 1;
+    return `${source.slice(0, lineStart)}${region}${source.slice(lineEnd)}`;
+  }
+  const index = insertAt();
+  if (index === NOT_FOUND) {
+    throw new TypeError("Could not find a safe native project location for deep-link configuration.");
+  }
+  return `${source.slice(0, index)}${region}${source.slice(index)}`;
+};
+var androidRegion = (config) => {
+  const hosts = config.deepLinkHosts.map((host) => `                <data android:scheme="https" android:host="${escapeXml(host)}" />`).join(`
+`);
+  const customScheme = config.deepLinkScheme ? `
+
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="${escapeXml(config.deepLinkScheme)}" />
+            </intent-filter>` : "";
+  return `            ${START_MARKER}
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+${hosts}
+            </intent-filter>${customScheme}
+            ${END_MARKER}
+`;
+};
+var configureAndroid = async (config) => {
+  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.");
+  }
+  const activityEnd = source.indexOf("</activity>", mainActivity);
+  const updated = replaceManagedRegion(source, androidRegion(config), () => activityEnd === NOT_FOUND ? NOT_FOUND : source.lastIndexOf(`
+`, activityEnd) + 1);
+  return writeChangedFile(path, updated);
+};
+var iosSchemeRegion = (scheme) => `	${START_MARKER}
+	<key>CFBundleURLTypes</key>
+	<array>
+		<dict>
+			<key>CFBundleURLName</key>
+			<string>absolutejs</string>
+			<key>CFBundleURLSchemes</key>
+			<array>
+				<string>${escapeXml(scheme)}</string>
+			</array>
+		</dict>
+	</array>
+	${END_MARKER}
+`;
+var configureIosInfo = async (config) => {
+  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}
+`;
+  const updated = replaceManagedRegion(source, region, () => source.lastIndexOf("</dict>"));
+  return writeChangedFile(path, updated);
+};
+var iosEntitlementsSource = (config) => {
+  const domains = config.deepLinkHosts.map((host) => `		<string>applinks:${escapeXml(host)}</string>`).join(`
+`);
+  return `<?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>com.apple.developer.associated-domains</key>
+	<array>
+${domains}
+	</array>
+</dict>
+</plist>
+`;
+};
+var configureIosEntitlements = async (config) => {
+  const path = join10(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  let current = "";
+  try {
+    current = await readFile11(path, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const source = iosEntitlementsSource(config);
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile9(temporary, source, { flag: "wx" });
+  await rename9(temporary, path);
+  return true;
+};
+var configureIosProject = async (config) => {
+  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]);
+  if (declarations.some((value) => value !== IOS_ENTITLEMENTS)) {
+    throw new TypeError("The iOS target already uses a different entitlements file; merge associated domains there before continuing.");
+  }
+  if (declarations.length > 0)
+    return false;
+  let count = 0;
+  const updated = source.replaceAll("INFOPLIST_FILE = App/Info.plist;", () => {
+    count += 1;
+    return `CODE_SIGN_ENTITLEMENTS = ${IOS_ENTITLEMENTS};
+				INFOPLIST_FILE = App/Info.plist;`;
+  });
+  if (count === 0) {
+    throw new TypeError("The iOS application target build settings were not found.");
+  }
+  return writeChangedFile(path, updated);
+};
+var configureIos = async (config) => {
+  const changed = await Promise.all([
+    configureIosInfo(config),
+    configureIosEntitlements(config),
+    configureIosProject(config)
+  ]);
+  return changed.some(Boolean);
+};
+var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms) => {
+  const results = await Promise.all(platforms.map(async (platform) => {
+    const didChange = platform === "android" ? await configureAndroid(config) : await configureIos(config);
+    return { didChange, platform };
+  }));
+  return {
+    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 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(dirname6(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var createProgram = (entry, projectRoot) => {
+  const configPath = findTsconfig(entry, projectRoot);
+  if (!configPath) {
+    return ts.createProgram([entry], {
+      allowJs: true,
+      jsx: ts.JsxEmit.ReactJSX,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      target: ts.ScriptTarget.ESNext
+    });
+  }
+  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);
+};
+var propertyName = (property) => {
+  if (!("name" in property) || !property.name)
+    return;
+  if (ts.isIdentifier(property.name))
+    return property.name.text;
+  if (ts.isStringLiteralLike(property.name))
+    return property.name.text;
+  return;
+};
+var objectPropertyExpression = (object, name) => {
+  const property = object.properties.find((candidate) => propertyName(candidate) === name);
+  if (property && ts.isPropertyAssignment(property)) {
+    return property.initializer;
+  }
+  if (property && ts.isShorthandPropertyAssignment(property)) {
+    return property.name;
+  }
+  return;
+};
+var serializeType = (type, checker, ancestors = new Set) => {
+  if (type.flags & ts.TypeFlags.Any)
+    return { type: "any" };
+  if (type.flags & ts.TypeFlags.Unknown)
+    return { type: "unknown" };
+  if (type.flags & ts.TypeFlags.Never)
+    return { type: "never" };
+  if (type.flags & ts.TypeFlags.StringLike)
+    return { type: "string" };
+  if (type.flags & ts.TypeFlags.NumberLike)
+    return { type: "number" };
+  if (type.flags & ts.TypeFlags.BooleanLike)
+    return { type: "boolean" };
+  if (type.flags & ts.TypeFlags.BigIntLike)
+    return { type: "bigint" };
+  if (type.flags & ts.TypeFlags.Null)
+    return { type: "null" };
+  if (type.flags & ts.TypeFlags.Undefined)
+    return { type: "undefined" };
+  if (type.isUnion()) {
+    return {
+      anyOf: type.types.map((member) => serializeType(member, checker, ancestors)).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))
+    };
+  }
+  if (type.isIntersection()) {
+    return {
+      allOf: type.types.map((member) => serializeType(member, checker, ancestors)).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))
+    };
+  }
+  if (ancestors.has(type)) {
+    return {
+      ref: checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)
+    };
+  }
+  ancestors.add(type);
+  const arrayElement = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+  const properties = checker.getPropertiesOfType(type);
+  let schema;
+  if (arrayElement && properties.some(({ name }) => name === "length")) {
+    schema = {
+      items: serializeType(arrayElement, checker, ancestors),
+      type: "array"
+    };
+  } else if (properties.length > 0) {
+    const entries = properties.filter(({ name }) => !name.startsWith("__")).map((property) => {
+      const declaration = property.valueDeclaration ?? property.declarations?.[0];
+      const propertyType = declaration ? checker.getTypeOfSymbolAtLocation(property, declaration) : checker.getDeclaredTypeOfSymbol(property);
+      return [
+        property.name,
+        {
+          optional: Boolean(property.flags & ts.SymbolFlags.Optional),
+          schema: serializeType(propertyType, checker, ancestors)
+        }
+      ];
+    }).sort(([left], [right]) => left.localeCompare(right));
+    schema = { properties: Object.fromEntries(entries), type: "object" };
+  } else {
+    schema = {
+      type: checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)
+    };
+  }
+  ancestors.delete(type);
+  return schema;
+};
+var pagePropsType = (pageExpression, propsExpression, checker) => {
+  const pageType = checker.getTypeAtLocation(pageExpression);
+  const [signature] = pageType.getCallSignatures();
+  const [parameter] = signature?.parameters ?? [];
+  const declaration = parameter?.valueDeclaration ?? parameter?.declarations?.[0];
+  if (parameter && declaration) {
+    return checker.getTypeOfSymbolAtLocation(parameter, declaration);
+  }
+  return propsExpression ? checker.getTypeAtLocation(propsExpression) : checker.getTypeAtLocation(pageExpression);
+};
+var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
+  let symbol = checker.getSymbolAtLocation(expression);
+  if (symbol?.flags && symbol.flags & ts.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
+  }
+  const declaration = symbol?.declarations?.[0];
+  const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
+  const exportedName = symbol?.name ?? expression.getText(sourceFile);
+  const source = posixPath(relative7(projectRoot, file));
+  return `${source}#${exportedName}`;
+};
+var resolveAlias = (symbol, checker) => {
+  if (!(symbol.flags & ts.SymbolFlags.Alias))
+    return symbol;
+  return checker.getAliasedSymbol(symbol);
+};
+var assetKey = (expression, checker, seen = new Set) => {
+  if (!expression)
+    return;
+  if (ts.isIdentifier(expression)) {
+    const unresolved = ts.isShorthandPropertyAssignment(expression.parent) ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
+    if (!unresolved)
+      return;
+    const symbol = resolveAlias(unresolved, checker);
+    if (seen.has(symbol))
+      return;
+    seen.add(symbol);
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    if (!declaration || !ts.isVariableDeclaration(declaration))
+      return;
+    return assetKey(declaration.initializer, checker, seen);
+  }
+  if (!ts.isCallExpression(expression))
+    return;
+  if (!ts.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
+    return;
+  }
+  const [, key] = expression.arguments;
+  return key && ts.isStringLiteralLike(key) ? key.text : undefined;
+};
+var findPageCall = (nodes) => {
+  let found;
+  const visit = (candidate) => {
+    if (found)
+      return;
+    if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && candidate.expression.text === PAGE_HANDLER) {
+      found = candidate;
+      return;
+    }
+    ts.forEachChild(candidate, visit);
+  };
+  for (const node of nodes)
+    visit(node);
+  return found;
+};
+var isProjectSource = (sourceFile, resolvedFile, projectRoot) => !sourceFile.isDeclarationFile && !resolvedFile.includes("/node_modules/") && resolvedFile.startsWith(`${projectRoot}/`);
+var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
+  const callee = node.expression;
+  if (!ts.isPropertyAccessExpression(callee))
+    return;
+  if (!ROUTE_METHODS.has(callee.name.text))
+    return;
+  const [routePath] = node.arguments;
+  if (!routePath || !ts.isStringLiteralLike(routePath))
+    return;
+  const pageCall = findPageCall(node.arguments.slice(1));
+  const [input] = pageCall?.arguments ?? [];
+  if (!pageCall || !input || !ts.isObjectLiteralExpression(input)) {
+    return;
+  }
+  const page = objectPropertyExpression(input, "Page");
+  if (!page)
+    return;
+  const props = objectPropertyExpression(input, "props");
+  const index = objectPropertyExpression(input, "index");
+  const bundleKey = assetKey(index, checker);
+  if (!bundleKey)
+    return;
+  const pageId = resolvePageIdentity(page, sourceFile, checker, projectRoot);
+  const schema = serializeType(pagePropsType(page, props, checker), checker);
+  const propsSchemaHash = hashAbsoluteMobilePropsSchema(schema);
+  const metadata = {
+    bundleKey,
+    contract: `react:${pageId}:${propsSchemaHash}`,
+    framework: "react",
+    pageId,
+    propsSchemaHash
+  };
+  const result = {
+    metadata,
+    pageCallStart: pageCall.getStart(sourceFile),
+    routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
+  };
+  return result;
+};
+var analyzeSourceFile = (sourceFile, checker, projectRoot) => {
+  const analysis = {
+    byPageCall: new Map,
+    byRouteCall: new Map
+  };
+  const visit = (node) => {
+    const result = ts.isCallExpression(node) ? analyzeRouteCall(node, sourceFile, checker, projectRoot) : undefined;
+    if (result) {
+      analysis.byPageCall.set(result.pageCallStart, result);
+      analysis.byRouteCall.set(result.routeCallSpan, result);
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(sourceFile, visit);
+  return analysis;
+};
+var analyzeProgram = (program, projectRoot) => {
+  const checker = program.getTypeChecker();
+  const analyzed = new Map;
+  for (const sourceFile of program.getSourceFiles()) {
+    const resolvedFile = resolve11(sourceFile.fileName);
+    if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
+      continue;
+    const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
+    if (analysis.byPageCall.size > 0)
+      analyzed.set(resolvedFile, analysis);
+  }
+  return analyzed;
+};
+var metadataExpression = (metadata) => ts.factory.createObjectLiteralExpression(Object.entries(metadata).map(([key, item]) => ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(key), ts.factory.createStringLiteral(item))), false);
+var routeOptions = (existing, metadata) => {
+  const detail = ts.factory.createObjectLiteralExpression([
+    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
+  ]);
+  if (!existing) {
+    return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("detail", detail)
+    ]);
+  }
+  return ts.factory.createObjectLiteralExpression([
+    ts.factory.createSpreadAssignment(existing),
+    ts.factory.createPropertyAssignment("detail", ts.factory.createObjectLiteralExpression([
+      ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(existing, "detail")),
+      ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
+    ]))
+  ]);
+};
+var transformPageCall = (node, page) => {
+  if (!page)
+    return;
+  const [input] = node.arguments;
+  if (!input || !ts.isObjectLiteralExpression(input))
+    return;
+  return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+    ts.factory.updateObjectLiteralExpression(input, [
+      ...input.properties,
+      ts.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+    ]),
+    ...node.arguments.slice(1)
+  ]);
+};
+var transformRouteCall = (node, route) => {
+  if (!route)
+    return;
+  const [path, maybeOptions, maybeHandler, ...rest] = node.arguments;
+  if (!path || !maybeOptions)
+    return;
+  const options = maybeHandler ? maybeOptions : undefined;
+  const handler = maybeHandler ?? maybeOptions;
+  return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [path, routeOptions(options, route.metadata), handler, ...rest]);
+};
+var transformFile = (source, fileName, analysis) => {
+  const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const transformer = (context) => {
+    const visit = (node) => {
+      if (!ts.isCallExpression(node)) {
+        return ts.visitEachChild(node, visit, context);
+      }
+      const transformedChildren = ts.visitEachChild(node, visit, context);
+      const page = analysis.byPageCall.get(node.getStart(sourceFile));
+      const transformedPage = transformPageCall(transformedChildren, page);
+      if (transformedPage)
+        return transformedPage;
+      const route = analysis.byRouteCall.get(`${node.getStart(sourceFile)}:${node.end}`);
+      const transformedRoute = transformRouteCall(transformedChildren, route);
+      if (transformedRoute)
+        return transformedRoute;
+      return transformedChildren;
+    };
+    return (node) => ts.visitNode(node, visit, ts.isSourceFile) ?? node;
+  };
+  const result = ts.transform(sourceFile, [transformer]);
+  try {
+    const [transformed] = result.transformed;
+    if (!transformed)
+      throw new TypeError("Mobile route transform failed.");
+    return ts.createPrinter().printFile(transformed);
+  } finally {
+    result.dispose();
+  }
+};
+var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
+var createAbsoluteMobileRouteMetadataPlugin = (options) => {
+  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(resolve11(path));
+        if (!analysis)
+          return;
+        const source = await Bun.file(path).text();
+        return {
+          contents: transformFile(source, path, analysis),
+          loader: extname2(path).endsWith("x") ? "tsx" : "ts"
+        };
+      });
+    }
+  };
+};
+var inspectAbsoluteMobileRouteMetadata = (options) => {
+  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(relative7(projectRoot, file)),
+    metadata
+  })));
+};
 export {
+  writeAbsoluteCapacitorConfig,
   verifyAbsoluteMobileCompatibilityProducer,
+  verifyAbsoluteMobileAssociationFiles,
   runWithAbsoluteMobileProducer,
   retainAbsoluteMobileCompatibilityArtifacts,
+  resolveAbsoluteMobileRoute,
+  resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
+  readAbsoluteMobileMaterializedReleases,
+  publishAbsoluteIosRelease,
+  publishAbsoluteAndroidRelease,
+  prepareAbsoluteIosRelease,
+  prepareAbsoluteAndroidRelease,
   parseAbsoluteMobilePageRequest,
   parseAbsoluteMobilePageEnvelope,
   parseAbsoluteMobileCompatibilityArtifact,
+  parseAbsoluteMobileBuildPageMetadata,
+  normalizeAbsoluteMobileConfig,
+  navigateAbsoluteMobilePage,
   materializeAbsoluteMobileCompatibilityBundle,
+  materializeAbsoluteMobileAssociationFiles,
+  materializeAbsoluteCapacitorWebBundle,
+  matchesAbsoluteMobileRoutePattern,
+  loadAbsoluteNativeReleasePublisher,
   loadAbsoluteMobileMaterializedBundle,
+  inspectAbsoluteMobileRouteMetadata,
   hashAbsoluteMobilePropsSchema,
   getCurrentAbsoluteMobileProducerContext,
+  fingerprintAbsoluteIosNativeProject,
   finalizeAbsoluteMobilePage,
+  finalizeAbsoluteMobileCompatibilityBuild,
+  fetchAbsoluteMobilePage,
   createAbsoluteMobileUpgradeResponse,
+  createAbsoluteMobileRouteMetadataPlugin,
+  createAbsoluteMobilePageRequest,
   createAbsoluteMobilePageErrorResponse,
   createAbsoluteMobileInvalidRequestResponse,
   createAbsoluteMobileFileArtifactStore,
   createAbsoluteMobileCompatibilityDispatcher,
   createAbsoluteMobileCompatibilityArtifact,
   createAbsoluteMobileBlobArtifactStore,
+  createAbsoluteMobileAssociationPlugin,
+  createAbsoluteMobileAssociationDocuments,
   carryForwardAbsoluteMobileCompatibilityReleases,
+  captureAbsoluteMobileRouteGraph,
+  buildAbsoluteMobileCompatibilityRelease,
+  buildAbsoluteIosRelease,
+  buildAbsoluteAndroidRelease,
+  applyAbsoluteNativeDeepLinks,
   activateAbsoluteMobilePage,
   acceptsAbsoluteMobilePage,
   MOBILE_PAGE_REQUEST_HEADERS,
   AbsoluteMobilePageProtocolError,
+  APPLE_ASSOCIATION_PATH,
+  ANDROID_ASSOCIATION_PATH,
+  ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL,
+  ABSOLUTE_MOBILE_ROUTE_DETAIL,
   ABSOLUTE_MOBILE_RETAINED_GENERATIONS,
   ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
   ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE,
   ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
-  ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT
+  ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT,
+  ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+  ABSOLUTE_IOS_RELEASE_FORMAT,
+  ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=AF97492DC1F47D7364756E2164756E21
+//# debugId=8F6E00755BF98A2E64756E2164756E21
 //# sourceMappingURL=index.js.map