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

package/dist/mobile/index.js

@@ -159,6 +159,14 @@ var init_startupBanner = __esm(() => {
   ];
 });
 
+// src/utils/stringModifiers.ts
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+};
+
 // src/mobile/artifactStore.ts
 import { createHash as createHash2 } from "crypto";
 import {
@@ -249,13 +257,19 @@ var parseCompatibilityPage = (value) => {
   if (!isCanonicalRecord(value) || !isPageFramework(value.framework)) {
     throw new TypeError("Compatibility artifact contains an invalid page.");
   }
+  const styleBundleHash = typeof value.styleBundleHash === "string" ? value.styleBundleHash : undefined;
+  const styleBundlePath = typeof value.styleBundlePath === "string" ? value.styleBundlePath : undefined;
+  if (Boolean(styleBundleHash) !== Boolean(styleBundlePath)) {
+    throw new TypeError("Compatibility page style hash and path must be provided together.");
+  }
   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"),
-    propsSchemaHash: readString(value.propsSchemaHash, "page.propsSchemaHash")
+    propsSchemaHash: readString(value.propsSchemaHash, "page.propsSchemaHash"),
+    ...styleBundleHash && styleBundlePath ? { styleBundleHash, styleBundlePath } : {}
   };
 };
 var parseCompatibilityRoute = (value) => {
@@ -287,14 +301,23 @@ var validateProducerModule = (module) => {
   }
   return 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"),
-  propsSchemaHash: requireNonEmpty(page.propsSchemaHash, "page.propsSchemaHash")
-});
+var normalizePage = (page) => {
+  if (Boolean(page.styleBundleHash) !== Boolean(page.styleBundlePath)) {
+    throw new TypeError("Compatibility page style hash and path must be provided together.");
+  }
+  return {
+    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"),
+    propsSchemaHash: requireNonEmpty(page.propsSchemaHash, "page.propsSchemaHash"),
+    ...page.styleBundleHash && page.styleBundlePath ? {
+      styleBundleHash: requireNonEmpty(page.styleBundleHash, "page.styleBundleHash"),
+      styleBundlePath: requireNonEmpty(page.styleBundlePath, "page.styleBundlePath")
+    } : {}
+  };
+};
 var normalizeRoute = (route) => {
   if (!route.pattern.startsWith("/")) {
     throw new TypeError("route.pattern must start with /.");
@@ -615,9 +638,9 @@ var verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes
   return release;
 };
 // src/mobile/androidRelease.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import {
-  access as access3,
+  access as access4,
   copyFile as copyFile2,
   mkdir as mkdir3,
   mkdtemp as mkdtemp2,
@@ -630,6 +653,7 @@ import {
 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 { access } from "fs/promises";
 import { homedir } from "os";
 import { join as join2 } from "path";
 
@@ -647,6 +671,34 @@ var isWSLEnvironment = () => {
 };
 
 // src/mobile/emulatorDoctor.ts
+var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36";
+var captureCommand = (command) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      stderr: "ignore",
+      stdout: "pipe"
+    });
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout.toString()
+    };
+  } catch {
+    return { exitCode: 1, stdout: "" };
+  }
+};
+var hasAvailableIosRuntime = (output) => {
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed !== "object" || parsed === null)
+      return false;
+    const runtimes = Reflect.get(parsed, "runtimes");
+    if (!Array.isArray(runtimes))
+      return false;
+    return runtimes.some((runtime) => typeof runtime === "object" && runtime !== null && Reflect.get(runtime, "isAvailable") === true && typeof Reflect.get(runtime, "identifier") === "string" && String(Reflect.get(runtime, "identifier")).includes("iOS"));
+  } catch {
+    return false;
+  }
+};
 var windowsPathToWsl = (path) => {
   const match = /^([a-z]):[\\/](.*)$/i.exec(path.trim());
   if (!match)
@@ -678,6 +730,14 @@ var absoluteManagedAndroidSdkRoot = (host, env = process.env) => {
   }
   return join2(homedir(), ".absolutejs", "android-sdk");
 };
+var pathExists = async (path) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
 var detectAbsoluteMobileHost = (platform = process.platform, wsl = isWSLEnvironment()) => {
   if (platform === "darwin")
     return "macos";
@@ -687,10 +747,151 @@ var detectAbsoluteMobileHost = (platform = process.platform, wsl = isWSLEnvironm
     return "wsl";
   return "linux";
 };
+var executableNames = (host, name) => {
+  if (host === "wsl")
+    return [`${name}.exe`, `${name}.bat`, name];
+  if (host === "windows")
+    return [name, `${name}.exe`, `${name}.bat`];
+  return [name];
+};
+var findExecutable = async (name, paths, options, host) => {
+  const existing = await Promise.all(paths.map(async (path) => await options.exists(path) ? path : undefined));
+  const configured = existing.find((path) => path !== undefined);
+  if (configured)
+    return configured;
+  for (const candidate of executableNames(host, name)) {
+    const path = options.which(candidate);
+    if (path)
+      return path;
+  }
+  return;
+};
+var toolCheck = (id, label, platform, path, remediation) => path ? {
+  id,
+  label,
+  path,
+  platform,
+  status: "pass"
+} : {
+  id,
+  label,
+  platform,
+  remediation,
+  status: "fail"
+};
+var inspectAbsoluteMobileToolchain = async (input = {}) => {
+  const env = input.env ?? process.env;
+  const host = input.host ?? detectAbsoluteMobileHost();
+  const exists = input.exists ?? pathExists;
+  const which = input.which ?? ((command) => Bun.which(command));
+  const capture = input.capture ?? captureCommand;
+  const androidRoot = input.androidRoot === null ? undefined : input.androidRoot ?? env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host, env);
+  const windowsAndroidTools = host === "windows" || host === "wsl";
+  const android = (segments) => androidRoot ? join2(androidRoot, ...segments) : undefined;
+  const paths = (values) => values.filter((value) => Boolean(value));
+  const adb = await findExecutable("adb", paths([
+    android(["platform-tools", windowsAndroidTools ? "adb.exe" : "adb"])
+  ]), { exists, which }, host);
+  const emulator = await findExecutable("emulator", paths([
+    android([
+      "emulator",
+      windowsAndroidTools ? "emulator.exe" : "emulator"
+    ])
+  ]), { exists, which }, host);
+  const sdkmanager = await findExecutable("sdkmanager", paths([
+    android([
+      "cmdline-tools",
+      "latest",
+      "bin",
+      windowsAndroidTools ? "sdkmanager.bat" : "sdkmanager"
+    ])
+  ]), { exists, which }, host);
+  const avdmanager = await findExecutable("avdmanager", paths([
+    android([
+      "cmdline-tools",
+      "latest",
+      "bin",
+      windowsAndroidTools ? "avdmanager.bat" : "avdmanager"
+    ])
+  ]), { exists, which }, host);
+  const java = await findExecutable("java", [], { exists, which }, host);
+  const checks = [
+    {
+      id: "host",
+      label: `Development host: ${host}`,
+      platform: "host",
+      status: "pass"
+    },
+    toolCheck("android.adb", "Android Debug Bridge", "android", adb, "Install Android SDK Platform Tools or expose adb on PATH."),
+    toolCheck("android.emulator", "Android Emulator", "android", emulator, "Install the Android Emulator from Android Studio SDK Manager."),
+    toolCheck("android.sdkmanager", "Android SDK Manager", "android", sdkmanager, "Install Android SDK Command-line Tools (latest)."),
+    toolCheck("android.avdmanager", "Android Virtual Device Manager", "android", avdmanager, "Install Android SDK Command-line Tools (latest)."),
+    toolCheck("android.java", "Java runtime", "android", java, "Install the JDK required by the configured Android Gradle plugin.")
+  ];
+  if (emulator) {
+    const avds = capture([emulator, "-list-avds"]);
+    const hasManagedAvd = avds.exitCode === 0 && avds.stdout.split(/\r?\n/).includes(ABSOLUTE_ANDROID_AVD_NAME);
+    checks.push({
+      id: "android.avd",
+      label: `AbsoluteJS Android emulator (${ABSOLUTE_ANDROID_AVD_NAME})`,
+      platform: "android",
+      remediation: hasManagedAvd ? undefined : "Run absolute mobile doctor android --fix to provision the managed emulator.",
+      status: hasManagedAvd ? "pass" : "fail"
+    });
+  }
+  if (host === "wsl") {
+    checks.push({
+      id: "android.virtualization",
+      label: adb?.endsWith(".exe") ? "Windows-host Android bridge available to WSL" : "WSL requires a Windows-host emulator bridge or Linux KVM",
+      platform: "android",
+      remediation: adb?.endsWith(".exe") ? undefined : "Expose the Windows Android SDK adb.exe to WSL, or enable /dev/kvm for a Linux SDK.",
+      status: adb?.endsWith(".exe") ? "pass" : "warn"
+    });
+  } else if (host === "linux") {
+    const hasKvm = await exists("/dev/kvm");
+    checks.push({
+      id: "android.virtualization",
+      label: "Linux KVM acceleration",
+      platform: "android",
+      remediation: hasKvm ? undefined : "Enable KVM and grant the current user access to /dev/kvm.",
+      status: hasKvm ? "pass" : "warn"
+    });
+  }
+  if (host !== "macos") {
+    checks.push({
+      id: "ios.simulator",
+      label: "iOS Simulator requires macOS and Xcode",
+      platform: "ios",
+      status: "skip"
+    });
+    return checks;
+  }
+  const xcrun = await findExecutable("xcrun", [], { exists, which }, host);
+  const xcodebuild = await findExecutable("xcodebuild", [], { exists, which }, host);
+  checks.push(toolCheck("ios.xcrun", "Xcode command runner", "ios", xcrun, "Install Xcode and select it with xcode-select."), toolCheck("ios.xcodebuild", "Xcode build system", "ios", xcodebuild, "Install Xcode and select it with xcode-select."));
+  if (xcrun) {
+    const runtimes = capture([
+      xcrun,
+      "simctl",
+      "list",
+      "runtimes",
+      "--json"
+    ]);
+    const hasRuntime = runtimes.exitCode === 0 && hasAvailableIosRuntime(runtimes.stdout);
+    checks.push({
+      id: "ios.runtime",
+      label: "iOS Simulator runtime",
+      platform: "ios",
+      remediation: hasRuntime ? undefined : "Run absolute mobile doctor ios --fix to download an iOS Simulator runtime.",
+      status: hasRuntime ? "pass" : "fail"
+    });
+  }
+  return checks;
+};
 
 // src/mobile/androidEmulatorController.ts
 import {
-  access as access2,
+  access as access3,
   copyFile,
   lstat,
   mkdir as mkdir2,
@@ -702,6 +903,7 @@ import {
   rm as rm2,
   writeFile as writeFile3
 } from "fs/promises";
+import { createHash as createHash3, randomUUID } from "crypto";
 import {
   dirname,
   isAbsolute,
@@ -713,7 +915,7 @@ import {
 } from "path";
 
 // src/mobile/capacitorProject.ts
-import { access, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { access as access2, 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("\\", "/");
@@ -735,7 +937,7 @@ export default config;
 `;
 var exists = async (path) => {
   try {
-    await access(path);
+    await access2(path);
     return true;
   } catch {
     return false;
@@ -762,10 +964,12 @@ var writeAbsoluteCapacitorConfig = async (config, options) => {
 // src/mobile/androidEmulatorController.ts
 init_getDurationString();
 var HASH_RADIX = 16;
+var EXECUTABLE_MODE_MASK = 73;
+var NATIVE_PUBLIC_PATH_SEGMENTS = 5;
 var CAPACITOR_PROJECT_DIRECTORY_PATTERN = /project\(['"](:[^'"]+)['"]\)\.projectDir\s*=\s*new File\(['"]([^'"]+)['"]\)/gu;
-var pathExists = async (path) => {
+var pathExists2 = async (path) => {
   try {
-    await access2(path);
+    await access3(path);
     return true;
   } catch {
     return false;
@@ -792,7 +996,7 @@ var runCommand = async (command, options = {}) => {
   ]);
   return exitCode;
 };
-var captureCommand = (command, options = {}) => {
+var captureCommand2 = (command, options = {}) => {
   try {
     const result = Bun.spawnSync(command, {
       cwd: options.cwd,
@@ -826,6 +1030,75 @@ var throwIfAborted = (signal) => {
     return;
   throw new DOMException("Android development startup was cancelled.", "AbortError");
 };
+var nativeDependencySources = async (nativeDirectory) => {
+  const settings = await readFile3(join3(nativeDirectory, "capacitor.settings.gradle"), "utf8");
+  const pattern = new RegExp(CAPACITOR_PROJECT_DIRECTORY_PATTERN.source, CAPACITOR_PROJECT_DIRECTORY_PATTERN.flags);
+  const dependencies = [...settings.matchAll(pattern)].map((match) => ({
+    name: (match[1] ?? "").slice(1).replaceAll(/[^a-zA-Z0-9_.-]/gu, "_"),
+    source: resolve2(nativeDirectory, match[2] ?? "")
+  }));
+  if (dependencies.length === 0) {
+    throw new Error("Capacitor Android settings did not declare any native dependencies.");
+  }
+  return { dependencies, settings };
+};
+var shouldIgnoreNativePath = (relativePath, ignorePublicBundle) => {
+  const parts = relativePath.split(sep);
+  if (parts.includes(".gradle") || parts.includes("build") || parts.includes(".absolutejs-dependencies")) {
+    return true;
+  }
+  return ignorePublicBundle && parts.slice(0, NATIVE_PUBLIC_PATH_SEGMENTS).join("/") === "app/src/main/assets/public";
+};
+var collectNativePath = async (root, label, path, isDirectory, isFile, isSymbolicLink, ignorePublicBundle) => {
+  const relativePath = relative2(root, path);
+  if (shouldIgnoreNativePath(relativePath, ignorePublicBundle))
+    return [];
+  const identity = `${label}:${relativePath.split(sep).join("/")}\x00`;
+  if (isDirectory) {
+    return collectNativeDirectory(root, label, path, ignorePublicBundle);
+  }
+  if (isSymbolicLink) {
+    return [`link\x00${identity}${await readlink(path)}\x00`];
+  }
+  if (!isFile)
+    return [];
+  const [metadata, contents] = await Promise.all([
+    lstat(path),
+    readFile3(path)
+  ]);
+  const contentDigest = createHash3("sha256").update(contents).digest("hex");
+  return [
+    `file\x00${identity}${metadata.mode & EXECUTABLE_MODE_MASK}\x00${contentDigest}\x00`
+  ];
+};
+var collectNativeDirectory = async (root, label, directory, ignorePublicBundle) => {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  entries.sort((left, right) => left.name.localeCompare(right.name));
+  const records = await Promise.all(entries.map((entry) => collectNativePath(root, label, join3(directory, entry.name), entry.isDirectory(), entry.isFile(), entry.isSymbolicLink(), ignorePublicBundle)));
+  return records.flat();
+};
+var hashNativeTree = async (root, label, ignorePublicBundle) => {
+  const resolvedRoot = await realpath(root);
+  const records = await collectNativeDirectory(resolvedRoot, label, resolvedRoot, ignorePublicBundle);
+  return createHash3("sha256").update(records.join("")).digest("hex");
+};
+var fingerprintAbsoluteAndroidNativeProject = async (project, options = {}) => {
+  const { dependencies } = await nativeDependencySources(project.nativeDirectory);
+  const roots = [
+    {
+      ignorePublicBundle: options.includePublicBundle !== true,
+      label: "android",
+      source: project.nativeDirectory
+    },
+    ...dependencies.sort((left, right) => left.name.localeCompare(right.name)).map((dependency) => ({
+      ignorePublicBundle: false,
+      label: `dependency:${dependency.name}`,
+      source: dependency.source
+    }))
+  ];
+  const treeDigests = await Promise.all(roots.map((root) => hashNativeTree(root.source, root.label, root.ignorePublicBundle)));
+  return createHash3("sha256").update(treeDigests.join("\x00")).digest("hex");
+};
 var windowsPathFromWsl = (path, capture) => {
   const result = capture(["wslpath", "-w", path]);
   if (result.exitCode !== 0 || !result.stdout.trim()) {
@@ -851,12 +1124,13 @@ var mirroredCapacitorDependencies = async (project, capture) => {
   }
   return { dependencies, rewrittenSettings };
 };
-var encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task) => {
+var encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task, gradleArguments) => {
   const sourceDirectory = Buffer.from(windowsSource, "utf8").toString("base64");
   const buildDirectory = Buffer.from(windowsDirectory, "utf8").toString("base64");
   const androidRoot = Buffer.from(windowsAndroidRoot, "utf8").toString("base64");
   const dependencyData = Buffer.from(JSON.stringify(dependencies), "utf8").toString("base64");
   const settingsData = Buffer.from(rewrittenSettings, "utf8").toString("base64");
+  const argumentsData = Buffer.from(JSON.stringify(gradleArguments), "utf8").toString("base64");
   const source = [
     "$ErrorActionPreference = 'Stop'",
     `$source = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${sourceDirectory}'))`,
@@ -864,6 +1138,7 @@ var encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndro
     `$androidHome = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${androidRoot}'))`,
     `$dependencies = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${dependencyData}')) | ConvertFrom-Json`,
     `$settings = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${settingsData}'))`,
+    `$gradleArguments = @([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${argumentsData}')) | ConvertFrom-Json)`,
     "$env:ANDROID_HOME = $androidHome",
     "$env:ANDROID_SDK_ROOT = $androidHome",
     "New-Item -ItemType Directory -Force -Path $directory | Out-Null",
@@ -873,7 +1148,7 @@ var encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndro
     "foreach ($dependency in @($dependencies)) { $target = Join-Path $directory ('.absolutejs-dependencies\\' + $dependency.name); New-Item -ItemType Directory -Force -Path $target | Out-Null; & robocopy.exe $dependency.windowsSource $target /MIR /XD .gradle build /NFL /NDL /NJH /NJS /NP; if ($LASTEXITCODE -ge 8) { exit $LASTEXITCODE } }",
     "[IO.File]::WriteAllText((Join-Path $directory 'capacitor.settings.gradle'), $settings)",
     "$wrapper = Join-Path $directory 'gradlew.bat'",
-    `& $wrapper --no-daemon --console=plain -p $directory ${task}`,
+    `& $wrapper --no-daemon --console=plain -p $directory @gradleArguments ${task}`,
     "if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }",
     "exit 0"
   ].join("; ");
@@ -891,16 +1166,17 @@ var gradleArtifactPath = (nativeDirectory, task, windows = false) => {
 };
 var resolveGradleArtifactPath = async (nativeDirectory, task) => {
   const primary = gradleArtifactPath(nativeDirectory, task);
-  if (task !== "assembleRelease" || await pathExists(primary)) {
+  if (task !== "assembleRelease" || await pathExists2(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 capture = options.capture ?? captureCommand2;
   const run = options.run ?? runCommand;
   const env = options.env ?? process.env;
+  const gradleArguments = options.gradleArguments ?? [];
   if (project.host === "wsl") {
     const windowsSource = windowsPathFromWsl(project.nativeDirectory, capture);
     const buildId = Bun.hash(project.projectRoot).toString(HASH_RADIX);
@@ -912,7 +1188,7 @@ var buildAbsoluteAndroidGradleArtifact = async (options) => {
       "powershell.exe",
       "-NoProfile",
       "-EncodedCommand",
-      encodedWindowsGradleCommand(windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task)
+      encodedWindowsGradleCommand(windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task, gradleArguments)
     ], "Android Gradle build", run, { env, signal: options.signal });
     const artifactPath2 = await resolveGradleArtifactPath(managedBuildDirectory, task);
     const unsigned = artifactPath2.endsWith("-unsigned.apk");
@@ -922,7 +1198,7 @@ var buildAbsoluteAndroidGradleArtifact = async (options) => {
     };
   }
   const wrapper = project.host === "windows" ? "gradlew.bat" : "./gradlew";
-  await requireSuccess([wrapper, "--no-daemon", "--console=plain", task], "Android Gradle build", run, { cwd: project.nativeDirectory, env, signal: options.signal });
+  await requireSuccess([wrapper, "--no-daemon", "--console=plain", ...gradleArguments, task], "Android Gradle build", run, { cwd: project.nativeDirectory, env, signal: options.signal });
   const artifactPath = await resolveGradleArtifactPath(project.nativeDirectory, task);
   return { artifactPath, installPath: artifactPath };
 };
@@ -940,9 +1216,9 @@ var requireManifest = (value) => {
     runtime: value.runtime
   };
 };
-var pathExists2 = async (path) => {
+var pathExists3 = async (path) => {
   try {
-    await access3(path);
+    await access4(path);
     return true;
   } catch {
     return false;
@@ -983,7 +1259,7 @@ var verifyAabSignature = (artifactPath, capture, jarsigner) => {
   ]);
   return result.exitCode === 0 && /jar verified/iu.test(result.stdout);
 };
-var sha256File = async (path) => createHash3("sha256").update(await readFile4(path)).digest("hex");
+var sha256File = async (path) => createHash4("sha256").update(await readFile4(path)).digest("hex");
 var safeOutputDirectory = (projectRoot, requested) => {
   const root = resolve3(projectRoot);
   const output = resolve3(root, requested ?? ".absolutejs/mobile/releases/android");
@@ -997,7 +1273,7 @@ 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)) {
+  if (await pathExists3(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),
@@ -1037,12 +1313,32 @@ var requireManifestIdentity = (value, expected) => {
   return { ...expected, artifact };
 };
 var buildAbsoluteAndroidRelease = async (options) => {
+  if (options.versionCode !== undefined && options.prepareVersionCode) {
+    throw new TypeError("Android release versionCode and prepareVersionCode cannot be combined.");
+  }
+  if (options.versionCode !== undefined && (!Number.isSafeInteger(options.versionCode) || options.versionCode < 1 || options.versionCode > 2100000000)) {
+    throw new TypeError("Android versionCode must be an integer from 1 through 2100000000.");
+  }
   const projectRoot = resolve3(options.projectRoot);
   const host = options.host ?? detectAbsoluteMobileHost();
   const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host);
   const nativeDirectory = join4(options.config.nativeProjectDirectory, "android");
+  const manifest = requireManifest(JSON.parse(await readFile4(join4(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  if (manifest.appId !== options.config.appId) {
+    throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
+  }
+  let { versionCode } = options;
+  if (options.prepareVersionCode) {
+    const nativeFingerprint = await fingerprintAbsoluteAndroidNativeProject({ nativeDirectory });
+    const buildIdentity = createHash4("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}`).digest("hex");
+    versionCode = await options.prepareVersionCode(buildIdentity);
+  }
+  if (versionCode !== undefined && (!Number.isSafeInteger(versionCode) || versionCode < 1 || versionCode > 2100000000)) {
+    throw new TypeError("Android versionCode must be an integer from 1 through 2100000000.");
+  }
   const { artifactPath } = await buildAbsoluteAndroidGradleArtifact({
     capture: options.capture,
+    gradleArguments: versionCode === undefined ? [] : [`-Pandroid.injected.version.code=${versionCode}`],
     project: {
       androidRoot,
       config: options.config,
@@ -1053,7 +1349,7 @@ var buildAbsoluteAndroidRelease = async (options) => {
     run: options.run,
     task: "bundleRelease"
   });
-  if (!await pathExists2(artifactPath)) {
+  if (!await pathExists3(artifactPath)) {
     throw new TypeError(`Android Gradle did not produce the expected App Bundle: ${artifactPath}`);
   }
   const capture = options.capture ?? defaultCapture;
@@ -1064,52 +1360,1792 @@ var buildAbsoluteAndroidRelease = async (options) => {
   if (!signed && !options.allowUnsigned) {
     throw new TypeError("Android Gradle produced an unsigned App Bundle. Configure the release signingConfig in the source-owned Android project (prefer external Gradle properties), or pass --unsigned only for a non-publishable build.");
   }
-  const manifest = requireManifest(JSON.parse(await readFile4(join4(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
-  if (manifest.appId !== options.config.appId) {
-    throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
+  const [bytes, sha256] = await Promise.all([
+    stat(artifactPath).then(({ size }) => size),
+    sha256File(artifactPath)
+  ]);
+  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));
+};
+// src/mobile/iosRelease.ts
+import { createHash as createHash5 } from "crypto";
+import {
+  access as access5,
+  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 pathExists4 = async (path) => {
+  try {
+    await access5(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var defaultRun = async (command, options = {}) => {
+  const process2 = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  return process2.exited;
+};
+var defaultCapture2 = (command, options = {}) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      cwd: options.cwd,
+      env: options.env,
+      stderr: "pipe",
+      stdin: "ignore",
+      stdout: "pipe"
+    });
+    return {
+      exitCode: result.exitCode,
+      stderr: result.stderr.toString(),
+      stdout: result.stdout.toString()
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : String(error),
+      stdout: ""
+    };
+  }
+};
+var ignoredFingerprintDirectories = new Set([
+  "Pods",
+  "DerivedData",
+  "build",
+  "xcuserdata"
+]);
+var fingerprintFiles = async (root, current = root) => {
+  const entries = await readdir3(current, { withFileTypes: true });
+  const nested = await Promise.all(entries.sort((left, right) => left.name.localeCompare(right.name)).map(async (entry) => {
+    const path = join5(current, entry.name);
+    const projectRelative = relative4(root, path).replaceAll("\\", "/");
+    const ignored = entry.isDirectory() && (ignoredFingerprintDirectories.has(entry.name) || projectRelative === "App/App/public");
+    if (ignored)
+      return [];
+    if (entry.isDirectory())
+      return fingerprintFiles(root, path);
+    return entry.isFile() ? [path] : [];
+  }));
+  return nested.flat();
+};
+var fingerprintAbsoluteIosNativeProject = async (nativeDirectory) => {
+  const hasher = createHash5("sha256");
+  const files = await fingerprintFiles(nativeDirectory);
+  const contents = await Promise.all(files.map((file) => readFile5(file)));
+  files.forEach((file, index) => {
+    hasher.update(relative4(nativeDirectory, file).replaceAll("\\", "/"));
+    hasher.update("\x00");
+    hasher.update(contents[index] ?? new Uint8Array);
+    hasher.update("\x00");
+  });
+  return hasher.digest("hex");
+};
+var safeOutputDirectory2 = (projectRoot, requested) => {
+  const root = resolve4(projectRoot);
+  const output = resolve4(root, requested ?? ".absolutejs/mobile/releases/ios");
+  const projectRelative = relative4(root, output);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep3}`) || isAbsolute3(projectRelative)) {
+    throw new TypeError("mobile build --outdir must remain inside the project.");
+  }
+  return output;
+};
+var sha256File2 = async (path) => createHash5("sha256").update(await readFile5(path)).digest("hex");
+var findByExtension = async (root, extension) => {
+  if (!await pathExists4(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 pathExists4(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/iosConformance.ts
+import { readFile as readFile6, stat as stat3 } from "fs/promises";
+var HMR_LINE = new RegExp(String.raw`\[hmr:ios\]\s+([^\n]*?)\s+(applied in|falling back to reload after|failed after)\s+(\d+)ms(?:; server\s+(\d+)ms, client\s+(\d+)ms)?`, "u");
+var parseAbsoluteIosHmrLog = (line) => {
+  const match = HMR_LINE.exec(line);
+  if (!match)
+    return null;
+  const [, , action, durationValue, serverValue, clientValue] = match;
+  let outcome = "reloaded";
+  if (action === "applied in")
+    outcome = "applied";
+  if (action === "failed after")
+    outcome = "failed";
+  const serverMs = serverValue === undefined ? undefined : Number(serverValue);
+  const clientMs = clientValue === undefined ? undefined : Number(clientValue);
+  return {
+    ...clientMs === undefined ? {} : { clientMs },
+    duration: Number(durationValue),
+    line: match[0],
+    outcome,
+    ...serverMs === undefined ? {} : { serverMs }
+  };
+};
+var findHmrApply = (lines) => {
+  const apply = lines.map((line) => parseAbsoluteIosHmrLog(line)).find((candidate) => candidate !== null);
+  if (apply?.outcome === "failed")
+    throw new Error(`iOS HMR client reported a failed apply: ${apply.line}`);
+  return apply;
+};
+var waitForAbsoluteIosHmrLog = async (options) => {
+  const sleep = options.sleep ?? Bun.sleep;
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const deadline = Date.now() + timeoutMs;
+  let offset = options.startOffset ?? await stat3(options.logPath).then(({ size }) => size).catch(() => 0);
+  let buffered = "";
+  const poll = async () => {
+    if (Date.now() > deadline)
+      throw new Error(`No iOS native HMR acknowledgement was observed within ${timeoutMs}ms.`);
+    options.signal?.throwIfAborted();
+    const contents = await readFile6(options.logPath).catch(() => Buffer.alloc(0));
+    if (contents.byteLength < offset) {
+      offset = 0;
+      buffered = "";
+    }
+    if (contents.byteLength > offset) {
+      buffered += contents.subarray(offset).toString("utf8");
+      offset = contents.byteLength;
+      const lines = buffered.split(/\r?\n/u);
+      buffered = lines.pop() ?? "";
+      const apply = findHmrApply(lines);
+      if (apply)
+        return apply;
+    }
+    await sleep(100);
+    return poll();
+  };
+  return poll();
+};
+// src/mobile/iosSimulatorController.ts
+import { createHash as createHash6, randomUUID as randomUUID2 } from "crypto";
+import {
+  access as access6,
+  copyFile as copyFile4,
+  mkdir as mkdir5,
+  readFile as readFile7,
+  rename as rename6,
+  rm as rm5,
+  writeFile as writeFile6
+} from "fs/promises";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join6, relative as relative5, resolve as resolve5, sep as sep4 } from "path";
+init_getDurationString();
+var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone";
+var BOOT_TIMEOUT_MS = 180000;
+var BOOT_POLL_MS = 1000;
+var DEV_JOURNAL_FORMAT = 1;
+var NATIVE_CACHE_FORMAT = 1;
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pathExists5 = async (path) => {
+  try {
+    await access6(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var throwIfAborted2 = (signal) => signal?.throwIfAborted();
+var defaultCapture3 = (command, options = {}) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      cwd: options.cwd,
+      env: options.env,
+      stderr: "pipe",
+      stdin: "ignore",
+      stdout: "pipe"
+    });
+    return {
+      exitCode: result.exitCode,
+      stderr: result.stderr.toString(),
+      stdout: result.stdout.toString()
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : String(error),
+      stdout: ""
+    };
+  }
+};
+var defaultRun2 = async (command, options = {}) => {
+  const process2 = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  return process2.exited;
+};
+var defaultSpawn = (command, options = {}) => {
+  Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+    stderr: "ignore",
+    stdin: "ignore",
+    stdout: "ignore"
+  });
+};
+var consumeLines = async (stream, onLine) => {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  const pump = async () => {
+    const { done, value } = await reader.read();
+    if (done)
+      return;
+    buffered += decoder.decode(value, { stream: true });
+    const lines = buffered.split(/\r?\n/u);
+    buffered = lines.pop() ?? "";
+    lines.forEach(onLine);
+    await pump();
+  };
+  try {
+    await pump();
+    buffered += decoder.decode();
+    if (buffered)
+      onLine(buffered);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var defaultStartNativeLogs = (command, options, onLine) => {
+  const process2 = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  consumeLines(process2.stdout, onLine);
+  consumeLines(process2.stderr, onLine);
+  return {
+    close: async () => {
+      try {
+        process2.kill();
+      } catch {}
+      await process2.exited.catch(() => {
+        return;
+      });
+    }
+  };
+};
+var requireSuccess2 = async (command, label, run, options) => {
+  const exitCode = await run(command, options);
+  if (exitCode !== 0)
+    throw new Error(`${label} failed with status ${exitCode}.`);
+};
+var requireCapturedSuccess = (result, label) => {
+  if (result.exitCode !== 0) {
+    throw new Error(`${label} failed: ${result.stderr.trim() || result.stdout.trim() || `status ${result.exitCode}`}`);
+  }
+  return result.stdout.trim();
+};
+var parseJson = (source, label) => {
+  try {
+    const parsed = JSON.parse(source);
+    if (isRecord3(parsed))
+      return parsed;
+  } catch {}
+  throw new Error(`Invalid ${label} JSON from simctl.`);
+};
+var parseIosDeviceTypes = (source) => {
+  const parsed = parseJson(source, "device type");
+  const types = parsed.devicetypes;
+  if (!Array.isArray(types))
+    return [];
+  return types.flatMap((type) => {
+    if (!isRecord3(type))
+      return [];
+    const { identifier } = type;
+    const { name } = type;
+    return typeof identifier === "string" && typeof name === "string" ? [{ identifier, name }] : [];
+  });
+};
+var parseIosRuntimes = (source) => {
+  const parsed = parseJson(source, "runtime");
+  const { runtimes } = parsed;
+  if (!Array.isArray(runtimes))
+    return [];
+  return runtimes.flatMap((runtime) => {
+    if (!isRecord3(runtime))
+      return [];
+    const { identifier } = runtime;
+    const { name } = runtime;
+    const { version } = runtime;
+    if (typeof identifier !== "string" || typeof name !== "string" || typeof version !== "string")
+      return [];
+    return [
+      {
+        identifier,
+        isAvailable: runtime.isAvailable !== false,
+        name,
+        version
+      }
+    ];
+  });
+};
+var parseIosSimulators = (source) => {
+  const parsed = parseJson(source, "device");
+  const { devices } = parsed;
+  if (!isRecord3(devices))
+    return [];
+  return Object.entries(devices).flatMap(([runtime, values]) => {
+    if (!Array.isArray(values))
+      return [];
+    return values.flatMap((device) => {
+      if (!isRecord3(device))
+        return [];
+      const { name } = device;
+      const { state } = device;
+      const { udid } = device;
+      if (typeof name !== "string" || typeof state !== "string" || typeof udid !== "string")
+        return [];
+      return [
+        {
+          isAvailable: device.isAvailable !== false,
+          name,
+          runtime,
+          state,
+          udid
+        }
+      ];
+    });
+  });
+};
+var versionParts = (version) => version.split(".").map((part) => Number(part));
+var compareVersions = (left, right) => {
+  const leftParts = versionParts(left);
+  const rightParts = versionParts(right);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0;index < length; index++) {
+    const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (difference !== 0)
+      return difference;
+  }
+  return 0;
+};
+var latestIosRuntime = (runtimes) => runtimes.filter((runtime) => runtime.isAvailable && runtime.identifier.includes("SimRuntime.iOS-")).sort((left, right) => compareVersions(right.version, left.version))[0];
+var iphoneGeneration = (name) => Number(/iPhone\s+(\d+)/u.exec(name)?.[1] ?? 0);
+var preferredIphoneType = (types) => types.filter((type) => type.name.startsWith("iPhone")).sort((left, right) => {
+  const generation = iphoneGeneration(right.name) - iphoneGeneration(left.name);
+  if (generation !== 0)
+    return generation;
+  const rightPro = right.name.includes("Pro") ? 1 : 0;
+  const leftPro = left.name.includes("Pro") ? 1 : 0;
+  return rightPro - leftPro;
+})[0];
+var journalPaths = (projectRoot) => {
+  const root = join6(projectRoot, ".absolutejs", "mobile", "ios-dev-session");
+  return {
+    configBackup: join6(root, "capacitor-config.backup"),
+    infoBackup: join6(root, "Info.plist.backup"),
+    journal: join6(root, "journal.json"),
+    root
+  };
+};
+var nativeCachePath = (projectRoot) => join6(projectRoot, ".absolutejs", "mobile", "ios-native-cache.json");
+var isInside = (root, path) => {
+  const value = relative5(resolve5(root), resolve5(path));
+  return value === "" || !value.startsWith(`..${sep4}`) && value !== ".." && !isAbsolute4(value);
+};
+var parseJournal = (value) => {
+  if (!isRecord3(value) || value.format !== DEV_JOURNAL_FORMAT)
+    return null;
+  const { configBackupPath } = value;
+  const { infoBackupPath } = value;
+  const { infoPath } = value;
+  const { nativeConfigPath } = value;
+  if (typeof configBackupPath !== "string" || typeof infoBackupPath !== "string" || typeof infoPath !== "string" || typeof nativeConfigPath !== "string")
+    return null;
+  return {
+    configBackupPath,
+    format: DEV_JOURNAL_FORMAT,
+    infoBackupPath,
+    infoPath,
+    nativeConfigPath
+  };
+};
+var repairAbsoluteIosDevSession = async (projectRoot) => {
+  const paths = journalPaths(projectRoot);
+  if (!await pathExists5(paths.journal)) {
+    await rm5(paths.root, { force: true, recursive: true });
+    return false;
+  }
+  const journal = await readFile7(paths.journal, "utf8").then((source) => parseJournal(JSON.parse(source))).catch(() => null);
+  if (!journal || !isInside(projectRoot, journal.nativeConfigPath) || !isInside(projectRoot, journal.infoPath) || !isInside(paths.root, journal.configBackupPath) || !isInside(paths.root, journal.infoBackupPath)) {
+    throw new Error(`Refusing unsafe or invalid iOS dev journal at ${paths.journal}.`);
+  }
+  if (await pathExists5(journal.configBackupPath))
+    await copyFile4(journal.configBackupPath, journal.nativeConfigPath);
+  if (await pathExists5(journal.infoBackupPath))
+    await copyFile4(journal.infoBackupPath, journal.infoPath);
+  await rm5(paths.root, { force: true, recursive: true });
+  return true;
+};
+var iosDevelopmentInfoPlist = (source, cleartext) => {
+  if (!cleartext)
+    return source;
+  const arbitraryLoads = /(<key>NSAllowsArbitraryLoads<\/key>\s*)<false\s*\/>/u;
+  if (arbitraryLoads.test(source))
+    return source.replace(arbitraryLoads, "$1<true/>");
+  if (/<key>NSAllowsArbitraryLoads<\/key>\s*<true\s*\/>/u.test(source))
+    return source;
+  const transport = /(<key>NSAppTransportSecurity<\/key>\s*<dict>)/u;
+  if (transport.test(source))
+    return source.replace(transport, `$1
+		<key>NSAllowsArbitraryLoads</key>
+		<true/>`);
+  return source.replace(/<dict>/u, `<dict>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsArbitraryLoads</key>
+		<true/>
+	</dict>`);
+};
+var writeDevProjection = async (project, port, https) => {
+  const paths = journalPaths(project.projectRoot);
+  await repairAbsoluteIosDevSession(project.projectRoot);
+  const nativeConfigPath = join6(project.nativeDirectory, "App", "App", "capacitor.config.json");
+  const infoPath = join6(project.nativeDirectory, "App", "App", "Info.plist");
+  const [configSource, infoSource] = await Promise.all([
+    readFile7(nativeConfigPath, "utf8"),
+    readFile7(infoPath, "utf8")
+  ]);
+  const parsed = JSON.parse(configSource);
+  if (!isRecord3(parsed))
+    throw new Error(`Invalid Capacitor native config at ${nativeConfigPath}.`);
+  await mkdir5(paths.root, { recursive: true });
+  await Promise.all([
+    writeFile6(paths.configBackup, configSource, { flag: "wx" }),
+    writeFile6(paths.infoBackup, infoSource, { flag: "wx" })
+  ]);
+  const journal = {
+    configBackupPath: paths.configBackup,
+    format: DEV_JOURNAL_FORMAT,
+    infoBackupPath: paths.infoBackup,
+    infoPath,
+    nativeConfigPath
+  };
+  await writeFile6(paths.journal, `${JSON.stringify(journal, null, "\t")}
+`, {
+    flag: "wx"
+  });
+  const developmentUrl = new URL(`${https ? "https" : "http"}://localhost:${port}${project.config.entry}`);
+  developmentUrl.searchParams.set("__absolute_target", "capacitor-ios");
+  const existingServer = parsed.server;
+  parsed.server = {
+    ...isRecord3(existingServer) ? existingServer : {},
+    cleartext: !https,
+    url: developmentUrl.href
+  };
+  await Promise.all([
+    writeFile6(nativeConfigPath, `${JSON.stringify(parsed, null, "\t")}
+`),
+    writeFile6(infoPath, iosDevelopmentInfoPlist(infoSource, !https))
+  ]);
+};
+var parseNativeCache = (value) => {
+  if (!isRecord3(value))
+    return null;
+  const { appId, fingerprint, format, installations } = value;
+  if (format !== NATIVE_CACHE_FORMAT || typeof appId !== "string" || typeof fingerprint !== "string" || !isRecord3(installations) || !Object.values(installations).every((identity) => typeof identity === "string"))
+    return null;
+  return {
+    appId,
+    fingerprint,
+    format,
+    installations: Object.fromEntries(Object.entries(installations).map(([udid, identity]) => [
+      udid,
+      String(identity)
+    ]))
+  };
+};
+var readNativeCache = (projectRoot) => readFile7(nativeCachePath(projectRoot), "utf8").then((source) => parseNativeCache(JSON.parse(source))).catch(() => null);
+var writeNativeCache = async (projectRoot, cache) => {
+  const destination = nativeCachePath(projectRoot);
+  const temporary = `${destination}.${process.pid}.${randomUUID2()}.tmp`;
+  await mkdir5(dirname4(destination), { recursive: true });
+  try {
+    await writeFile6(temporary, `${JSON.stringify(cache, null, "\t")}
+`, {
+      flag: "wx"
+    });
+    await rename6(temporary, destination);
+  } finally {
+    await rm5(temporary, { force: true }).catch(() => {
+      return;
+    });
+  }
+};
+var fingerprintAbsoluteIosDevProject = async (project) => fingerprintAbsoluteIosNativeProject(project.nativeDirectory);
+var simulatorInventory = (xcrun, capture) => {
+  const result = capture([
+    xcrun,
+    "simctl",
+    "list",
+    "devices",
+    "available",
+    "-j"
+  ]);
+  return parseIosSimulators(requireCapturedSuccess(result, "iOS simulator discovery"));
+};
+var ensureManagedSimulator = async (project, capture) => {
+  const runtimes = parseIosRuntimes(requireCapturedSuccess(capture([project.xcrun, "simctl", "list", "runtimes", "-j"]), "iOS runtime discovery"));
+  const runtime = latestIosRuntime(runtimes);
+  if (!runtime)
+    throw new Error("No available iOS Simulator runtime. Run absolute mobile doctor ios --fix.");
+  const [existing] = simulatorInventory(project.xcrun, capture).filter((device) => device.isAvailable && device.name === ABSOLUTE_IOS_SIMULATOR_NAME && device.runtime === runtime.identifier).sort((left, right) => Number(right.state === "Booted") - Number(left.state === "Booted"));
+  if (existing)
+    return { created: false, device: existing };
+  const types = parseIosDeviceTypes(requireCapturedSuccess(capture([project.xcrun, "simctl", "list", "devicetypes", "-j"]), "iOS device-type discovery"));
+  const type = preferredIphoneType(types);
+  if (!type)
+    throw new Error("Xcode did not report an iPhone simulator type.");
+  const [udid] = requireCapturedSuccess(capture([
+    project.xcrun,
+    "simctl",
+    "create",
+    ABSOLUTE_IOS_SIMULATOR_NAME,
+    type.identifier,
+    runtime.identifier
+  ]), "iOS simulator creation").split(/\s/u);
+  if (!udid)
+    throw new Error("simctl did not return the created simulator UDID.");
+  return {
+    created: true,
+    device: {
+      isAvailable: true,
+      name: ABSOLUTE_IOS_SIMULATOR_NAME,
+      runtime: runtime.identifier,
+      state: "Shutdown",
+      udid
+    }
+  };
+};
+var waitForBootedSimulator = async (project, udid, capture, sleep, signal) => {
+  const deadline = Date.now() + BOOT_TIMEOUT_MS;
+  const poll = async () => {
+    throwIfAborted2(signal);
+    const device = simulatorInventory(project.xcrun, capture).find((candidate) => candidate.udid === udid);
+    if (device?.state === "Booted")
+      return;
+    if (Date.now() > deadline)
+      throw new Error(`iOS simulator ${udid} did not finish booting within ${BOOT_TIMEOUT_MS / 1000}s.`);
+    await sleep(BOOT_POLL_MS);
+    await poll();
+  };
+  return poll();
+};
+var bootSimulator = (project, device, capture) => {
+  if (device.state === "Booted")
+    return;
+  requireCapturedSuccess(capture([project.xcrun, "simctl", "boot", device.udid]), "iOS simulator boot");
+};
+var installedAppIdentity = (project, udid, capture) => {
+  const result = capture([
+    project.xcrun,
+    "simctl",
+    "get_app_container",
+    udid,
+    project.config.appId,
+    "app"
+  ]);
+  return result.exitCode === 0 && result.stdout.trim() ? result.stdout.trim() : undefined;
+};
+var buildIosDebugApp = async (project, udid, fingerprint, run, signal) => {
+  const derivedDataPath = join6(project.projectRoot, ".absolutejs", "mobile", "ios-derived-data", createHash6("sha256").update(project.config.appId).digest("hex").slice(0, 16));
+  await mkdir5(derivedDataPath, { recursive: true });
+  await requireSuccess2([
+    project.xcodebuild,
+    "-workspace",
+    join6(project.nativeDirectory, "App", "App.xcworkspace"),
+    "-scheme",
+    "App",
+    "-configuration",
+    "Debug",
+    "-destination",
+    `platform=iOS Simulator,id=${udid}`,
+    "-derivedDataPath",
+    derivedDataPath,
+    "build"
+  ], "iOS simulator build", run, { cwd: project.nativeDirectory, signal });
+  const appPath = join6(derivedDataPath, "Build", "Products", "Debug-iphonesimulator", "App.app");
+  if (!await pathExists5(appPath))
+    throw new Error(`Xcode did not produce the simulator app at ${appPath}.`);
+  return appPath;
+};
+var ensureIosDebugApp = async (options) => {
+  const installed = installedAppIdentity(options.project, options.udid, options.capture);
+  const cacheHit = options.cache?.appId === options.project.config.appId && options.cache.fingerprint === options.fingerprint && installed !== undefined && options.cache.installations[options.udid] === installed;
+  if (cacheHit) {
+    options.log(`iOS native app is unchanged on ${options.udid}; skipped Xcode build and install.`);
+    return true;
+  }
+  options.log("iOS native inputs changed or the installed app is stale; rebuilding.");
+  options.transition("building");
+  const appPath = await buildIosDebugApp(options.project, options.udid, options.fingerprint, options.run, options.signal);
+  throwIfAborted2(options.signal);
+  options.transition("installing");
+  await requireSuccess2([options.project.xcrun, "simctl", "install", options.udid, appPath], "iOS simulator app installation", options.run, { signal: options.signal });
+  const updated = installedAppIdentity(options.project, options.udid, options.capture);
+  if (updated) {
+    await writeNativeCache(options.project.projectRoot, {
+      appId: options.project.config.appId,
+      fingerprint: options.fingerprint,
+      format: NATIVE_CACHE_FORMAT,
+      installations: { [options.udid]: updated }
+    }).catch((error) => options.log(`iOS native cache could not be saved: ${error instanceof Error ? error.message : String(error)}`));
+  }
+  return false;
+};
+var SECRET_VALUE = /((?:authorization|cookie|password|secret|token|oauth[_-]?code)\s*[:=]\s*)([^\s,;]+)/giu;
+var BEARER_VALUE = new RegExp(String.raw`\bBearer\s+[A-Za-z0-9._~+/-]+=*`, "giu");
+var JWT_VALUE = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu;
+var IOS_LOG_PATTERN = new RegExp(String.raw`\s(Debug|Info|Notice|Error|Fault)\s+.*?\[[^\]]+\]\s+\[([^\]]+)\]\s*(.*)$`, "iu");
+var parseAbsoluteIosLogLine = (line) => {
+  const sanitized = redactAbsoluteIosLog(line).trim();
+  if (!sanitized)
+    return null;
+  const match = IOS_LOG_PATTERN.exec(sanitized);
+  const candidate = match?.[1]?.toLowerCase();
+  const level = candidate === "debug" || candidate === "error" || candidate === "fault" || candidate === "notice" ? candidate : "info";
+  return {
+    level,
+    message: match?.[3]?.trim() || sanitized,
+    tag: match?.[2]?.trim() || "App"
+  };
+};
+var redactAbsoluteIosLog = (value) => value.replaceAll(BEARER_VALUE, "Bearer [REDACTED]").replaceAll(JWT_VALUE, "[REDACTED_JWT]").replaceAll(SECRET_VALUE, "$1[REDACTED]").replaceAll(/\p{C}/gu, "");
+var attachNativeLogs = (project, udid, options) => {
+  if (!options.nativeLog)
+    return null;
+  const start = options.startNativeLogs ?? defaultStartNativeLogs;
+  return start([
+    project.xcrun,
+    "simctl",
+    "spawn",
+    udid,
+    "log",
+    "stream",
+    "--style",
+    "compact",
+    "--level",
+    "debug",
+    "--predicate",
+    'process == "App"'
+  ], { signal: options.signal }, (line) => {
+    const entry = parseAbsoluteIosLogLine(line);
+    if (entry)
+      options.nativeLog?.(entry);
+  });
+};
+var IOS_TIMING_PHASES = [
+  ["syncing", "Capacitor sync"],
+  ["configuring", "dev config"],
+  ["fingerprinting", "fingerprint"],
+  ["booting", "simulator"],
+  ["connecting", "device ready"],
+  ["checking-native", "app check"],
+  ["building", "Xcode"],
+  ["installing", "install"],
+  ["launching", "launch"],
+  ["streaming-logs", "logs"]
+];
+var timingSummary = (timings) => IOS_TIMING_PHASES.map(([phase, label]) => {
+  const duration = timings[phase];
+  return duration === undefined ? null : `${label} ${getDurationString(duration)}`;
+}).filter((value) => value !== null).join(", ");
+var prepareAbsoluteIosDevProject = async (config, options) => {
+  if (detectAbsoluteMobileHost() !== "macos")
+    throw new Error("iOS simulation requires macOS and Xcode.");
+  const projectRoot = resolve5(options.projectRoot);
+  const checks = await inspectAbsoluteMobileToolchain({ host: "macos" });
+  const failed = checks.filter((check) => check.platform === "ios" && (check.status === "fail" || check.status === "warn"));
+  if (failed.length > 0)
+    throw new Error(`iOS simulation is not ready: ${failed.map(({ label }) => label).join(", ")}.`);
+  const xcrun = checks.find((check) => check.id === "ios.xcrun")?.path;
+  const xcodebuild = checks.find((check) => check.id === "ios.xcodebuild")?.path;
+  if (!xcrun || !xcodebuild)
+    throw new Error("Xcode tools disappeared after readiness checks.");
+  const cap = join6(projectRoot, "node_modules", ".bin", "cap");
+  if (!await pathExists5(cap))
+    throw new Error("Capacitor CLI is not installed. Run absolute mobile init first.");
+  await writeAbsoluteCapacitorConfig(config, { projectRoot });
+  await mkdir5(config.bundleDirectory, { recursive: true });
+  const placeholder = join6(config.bundleDirectory, "index.html");
+  if (!await pathExists5(placeholder))
+    await writeFile6(placeholder, `<!doctype html><title>AbsoluteJS mobile development</title>
+`);
+  const nativeDirectory = join6(config.nativeProjectDirectory, "ios");
+  if (!await pathExists5(nativeDirectory)) {
+    if (!options.createNativeProject)
+      throw new Error("iOS native project has not been created.");
+    const run = options.run ?? defaultRun2;
+    if (await run([cap, "add", "ios"], { cwd: projectRoot }) !== 0)
+      throw new Error("Capacitor iOS project creation failed.");
+  }
+  return {
+    cap,
+    config,
+    nativeDirectory,
+    projectRoot,
+    xcodebuild,
+    xcrun
+  };
+};
+var startAbsoluteIosDevSession = async (options) => {
+  const { project } = options;
+  const capture = options.capture ?? defaultCapture3;
+  const run = options.run ?? defaultRun2;
+  const sleep = options.sleep ?? Bun.sleep;
+  const spawn = options.spawn ?? defaultSpawn;
+  const log = options.log ?? console.log;
+  const startedAt = performance.now();
+  let phaseStartedAt = performance.now();
+  const timings = {};
+  let state = "syncing";
+  const transition = (next) => {
+    if (next === state) {
+      options.onStateChange?.(next);
+      return;
+    }
+    const now = performance.now();
+    const durationMs = now - phaseStartedAt;
+    timings[state] = (timings[state] ?? 0) + durationMs;
+    options.onPhaseTiming?.({
+      durationMs,
+      phase: state,
+      totalMs: now - startedAt
+    });
+    state = next;
+    phaseStartedAt = now;
+    options.onStateChange?.(next);
+  };
+  let nativeLogs = null;
+  const closeLogs = async () => {
+    const stream = nativeLogs;
+    nativeLogs = null;
+    await stream?.close().catch(() => {
+      return;
+    });
+  };
+  try {
+    await repairAbsoluteIosDevSession(project.projectRoot);
+    throwIfAborted2(options.signal);
+    transition("syncing");
+    await requireSuccess2([project.cap, "sync", "ios"], "Capacitor iOS synchronization", run, { cwd: project.projectRoot, signal: options.signal });
+    transition("configuring");
+    await writeDevProjection(project, options.port, options.https === true);
+    throwIfAborted2(options.signal);
+    const fingerprintStartedAt = performance.now();
+    const fingerprintPromise = fingerprintAbsoluteIosDevProject(project).then((fingerprint2) => {
+      timings.fingerprinting = performance.now() - fingerprintStartedAt;
+      return fingerprint2;
+    });
+    transition("booting");
+    const { created, device } = await ensureManagedSimulator(project, capture);
+    const startedSimulator = created || device.state !== "Booted";
+    bootSimulator(project, device, capture);
+    spawn([
+      "open",
+      "-a",
+      "Simulator",
+      "--args",
+      "-CurrentDeviceUDID",
+      device.udid
+    ]);
+    transition("connecting");
+    await waitForBootedSimulator(project, device.udid, capture, sleep, options.signal);
+    await requireSuccess2([project.xcrun, "simctl", "bootstatus", device.udid, "-b"], "iOS simulator boot readiness", run, { signal: options.signal });
+    const fingerprint = await fingerprintPromise;
+    transition("checking-native");
+    const nativeCacheHit = await ensureIosDebugApp({
+      cache: await readNativeCache(project.projectRoot),
+      capture,
+      fingerprint,
+      log,
+      project,
+      run,
+      signal: options.signal,
+      transition,
+      udid: device.udid
+    });
+    throwIfAborted2(options.signal);
+    if (options.nativeLog)
+      transition("streaming-logs");
+    nativeLogs = attachNativeLogs(project, device.udid, options);
+    transition("launching");
+    await requireSuccess2([
+      project.xcrun,
+      "simctl",
+      "launch",
+      "--terminate-running-process",
+      device.udid,
+      project.config.appId
+    ], "iOS app launch", run, { signal: options.signal });
+    transition("ready");
+    timings.total = performance.now() - startedAt;
+    log(`iOS simulator connected (${device.udid}) with HMR on port ${options.port} in ${getDurationString(timings.total)} (${nativeCacheHit ? "native cache hit" : "native build installed"}).`);
+    log(`iOS startup: ${timingSummary(timings)}.`);
+    let closed = false;
+    const close = async () => {
+      if (closed)
+        return;
+      closed = true;
+      transition("closing");
+      await closeLogs();
+      await repairAbsoluteIosDevSession(project.projectRoot);
+      transition("closed");
+    };
+    return {
+      close,
+      nativeCacheHit,
+      startedSimulator,
+      timings: { ...timings },
+      udid: device.udid,
+      rebuild: async () => {
+        if (closed)
+          throw new Error("iOS development session is closed.");
+        log("iOS native inputs changed; rebuilding without restarting the dev server.");
+        await close();
+        return startAbsoluteIosDevSession(options);
+      },
+      relaunch: async () => {
+        if (closed)
+          throw new Error("iOS development session is closed.");
+        transition("launching");
+        try {
+          await requireSuccess2([
+            project.xcrun,
+            "simctl",
+            "launch",
+            "--terminate-running-process",
+            device.udid,
+            project.config.appId
+          ], "iOS app relaunch", run, { signal: options.signal });
+          transition("ready");
+          log(`iOS app relaunched on ${device.udid}.`);
+        } catch (error) {
+          transition("failed");
+          throw error;
+        }
+      },
+      screenshot: async (destination) => {
+        const resolved = resolve5(project.projectRoot, destination);
+        if (!isInside(project.projectRoot, resolved))
+          throw new Error("iOS screenshot destination must remain inside the project.");
+        await mkdir5(dirname4(resolved), { recursive: true });
+        await requireSuccess2([
+          project.xcrun,
+          "simctl",
+          "io",
+          device.udid,
+          "screenshot",
+          resolved
+        ], "iOS simulator screenshot", run, { signal: options.signal });
+        return resolved;
+      },
+      get state() {
+        return state;
+      }
+    };
+  } catch (error) {
+    transition("failed");
+    await closeLogs();
+    await repairAbsoluteIosDevSession(project.projectRoot);
+    throw error;
+  }
+};
+// src/mobile/iosNativeWatcher.ts
+import { watch } from "fs";
+import { basename } from "path";
+var NATIVE_CHANGE_DEBOUNCE_MS = 500;
+var ROOT_NATIVE_INPUTS = new Set([
+  "absolute.config.js",
+  "absolute.config.mjs",
+  "absolute.config.ts",
+  "absolutejs.config.js",
+  "absolutejs.config.mjs",
+  "absolutejs.config.ts",
+  "bun.lock",
+  "bun.lockb",
+  "capacitor.config.js",
+  "capacitor.config.ts",
+  "package.json"
+]);
+var createAbsoluteIosNativeWatcher = async (options) => {
+  let fingerprint = await fingerprintAbsoluteIosDevProject(options.project);
+  let closed = false;
+  let running = false;
+  let timer;
+  let rootInputChanged = false;
+  const changedPaths = new Set;
+  const watchers = [];
+  const debounceMs = options.debounceMs ?? NATIVE_CHANGE_DEBOUNCE_MS;
+  const close = () => {
+    if (closed)
+      return;
+    closed = true;
+    if (timer)
+      clearTimeout(timer);
+    watchers.forEach((watcher) => watcher.close());
+    options.signal?.removeEventListener("abort", close);
+  };
+  const schedule = () => {
+    if (closed || running)
+      return;
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(() => void flush(), debounceMs);
+  };
+  const flush = async () => {
+    timer = undefined;
+    if (closed || running || changedPaths.size === 0)
+      return;
+    running = true;
+    const paths = [...changedPaths].sort();
+    const forced = rootInputChanged;
+    changedPaths.clear();
+    rootInputChanged = false;
+    try {
+      const next = await fingerprintAbsoluteIosDevProject(options.project);
+      if (!forced && next === fingerprint)
+        return;
+      await options.onChange({
+        afterFingerprint: next,
+        beforeFingerprint: fingerprint,
+        paths,
+        rootInputChanged: forced
+      });
+      fingerprint = await fingerprintAbsoluteIosDevProject(options.project);
+    } catch (error) {
+      options.onError?.(error);
+    } finally {
+      running = false;
+      if (changedPaths.size > 0)
+        schedule();
+    }
+  };
+  const record = (path, force) => {
+    if (closed)
+      return;
+    changedPaths.add(path);
+    rootInputChanged ||= force;
+    schedule();
+  };
+  watchers.push(watch(options.project.nativeDirectory, { recursive: true }, (_event, filename) => {
+    if (filename)
+      record(String(filename), false);
+  }));
+  watchers.push(watch(options.project.projectRoot, (_event, filename) => {
+    if (!filename)
+      return;
+    const path = String(filename);
+    if (isAbsoluteIosNativeRootInput(path))
+      record(path, true);
+  }));
+  watchers.forEach((watcher) => watcher.on("error", (error) => options.onError?.(error)));
+  options.signal?.addEventListener("abort", close, { once: true });
+  return { close };
+};
+var isAbsoluteIosNativeRootInput = (path) => ROOT_NATIVE_INPUTS.has(basename(path));
+// src/mobile/remoteMacProtocol.ts
+import { createHash as createHash7, randomUUID as randomUUID3 } from "crypto";
+import { chmod, mkdir as mkdir6, readFile as readFile8, rename as rename7, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import {
+  dirname as dirname5,
+  isAbsolute as isAbsolute5,
+  join as join7,
+  posix,
+  relative as relative6,
+  resolve as resolvePath2,
+  sep as sep5
+} from "path";
+
+// src/mobile/remoteMacWire.ts
+var ABSOLUTE_REMOTE_MAC_EVENT_PREFIX = "ABSOLUTE_REMOTE_MAC\t";
+var ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION = 1;
+
+// src/mobile/remoteMacProtocol.ts
+var PROFILE_FORMAT = 1;
+var PROFILE_NAME = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/u;
+var SSH_DESTINATION = /^(?:[A-Za-z0-9._-]+@)?[A-Za-z0-9._:-]+$/u;
+var defaultProfilePath = () => join7(homedir2(), ".absolutejs", "mobile", "remote-macs.json");
+var emptyStore = () => ({
+  format: PROFILE_FORMAT,
+  profiles: {}
+});
+var loadStore = async (path = defaultProfilePath()) => {
+  try {
+    const parsed = JSON.parse(await readFile8(path, "utf8"));
+    if (parsed.format !== PROFILE_FORMAT || typeof parsed.profiles !== "object" || parsed.profiles === null || Array.isArray(parsed.profiles))
+      throw new Error("Unsupported remote Mac profile format.");
+    for (const [key, profile] of Object.entries(parsed.profiles)) {
+      if (typeof profile !== "object" || profile === null || validateAbsoluteRemoteMacProfileName(key) !== key || profile.name !== key || validateAbsoluteSshDestination(profile.destination) !== profile.destination || validatePort(profile.port) !== profile.port || typeof profile.createdAt !== "string" || !profile.createdAt || typeof profile.bunPath !== "string" || !profile.bunPath.startsWith("/") || /[\r\n\0]/u.test(profile.bunPath) || typeof profile.workspaceRoot !== "string" || !profile.workspaceRoot.startsWith("/") || profile.workspaceRoot === "/" || /[\r\n\0]/u.test(profile.workspaceRoot) || typeof profile.xcodeVersion !== "string" || !profile.xcodeVersion.startsWith("Xcode "))
+        throw new Error(`Remote Mac profile ${JSON.stringify(key)} is invalid.`);
+    }
+    if (parsed.defaultProfile !== undefined && !parsed.profiles[parsed.defaultProfile])
+      throw new Error("The default remote Mac profile does not exist.");
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return emptyStore();
+    throw error;
+  }
+};
+var saveStore = async (store, path = defaultProfilePath()) => {
+  await mkdir6(dirname5(path), { recursive: true });
+  const temporary = `${path}.${randomUUID3()}.tmp`;
+  await writeFile7(temporary, `${JSON.stringify(store, null, 2)}
+`, {
+    mode: 384
+  });
+  await rename7(temporary, path);
+  await chmod(path, 384);
+};
+var validateAbsoluteRemoteMacProfileName = (name) => {
+  const normalized = name.trim().toLowerCase();
+  if (!PROFILE_NAME.test(normalized))
+    throw new TypeError("Remote Mac profile names must use 1-64 lowercase letters, digits, dots, dashes, or underscores.");
+  return normalized;
+};
+var validateAbsoluteSshDestination = (destination) => {
+  const normalized = destination.trim();
+  if (!SSH_DESTINATION.test(normalized) || normalized.startsWith("-"))
+    throw new TypeError("Remote Mac SSH destination must be a host, SSH alias, or user@host without command-line options.");
+  return normalized;
+};
+var validatePort = (port) => {
+  if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
+    throw new TypeError("Remote Mac SSH port must be between 1 and 65535.");
+  return port;
+};
+var shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+var absoluteRemoteMacSshBase = (profile, options = {}) => [
+  "ssh",
+  "-o",
+  "BatchMode=yes",
+  "-o",
+  "ConnectTimeout=10",
+  "-o",
+  "ServerAliveInterval=15",
+  "-o",
+  "ServerAliveCountMax=3",
+  "-o",
+  `StrictHostKeyChecking=${options.acceptNew ? "accept-new" : "yes"}`,
+  ...profile.port ? ["-p", String(profile.port)] : [],
+  profile.destination
+];
+var localCapture = async (command) => {
+  const process2 = Bun.spawn(command, {
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    process2.exited,
+    new Response(process2.stdout).text(),
+    new Response(process2.stderr).text()
+  ]);
+  return { exitCode, stderr, stdout };
+};
+var defaultTransport = {
+  capture: localCapture,
+  spawn: (command, options) => Bun.spawn(command, {
+    signal: options.signal,
+    stderr: "pipe",
+    stdin: "pipe",
+    stdout: "pipe"
+  })
+};
+var requireRemoteSuccess = (result, label) => {
+  if (result.exitCode !== 0)
+    throw new Error(`${label} failed: ${(result.stderr || result.stdout).trim() || `status ${result.exitCode}`}`);
+  return result.stdout.trim();
+};
+var getAbsoluteRemoteMacProfile = async (name, profilePath) => {
+  const store = await loadStore(profilePath);
+  const selected = name ?? process.env.ABSOLUTE_IOS_REMOTE ?? store.defaultProfile;
+  if (!selected)
+    return;
+  const profile = store.profiles[selected];
+  if (!profile)
+    throw new Error(`Remote Mac profile ${JSON.stringify(selected)} was not found.`);
+  return profile;
+};
+var inspectAbsoluteRemoteMac = async (destination, options = {}) => {
+  const profile = {
+    destination: validateAbsoluteSshDestination(destination),
+    port: validatePort(options.port)
+  };
+  const capture = options.transport?.capture ?? defaultTransport.capture;
+  const command = [
+    ...absoluteRemoteMacSshBase(profile, {
+      acceptNew: options.acceptNew === true
+    }),
+    "/bin/sh -lc",
+    shellQuote(`bun_path="$(command -v bun || true)"; if [ -z "$bun_path" ] && [ -x "$HOME/.bun/bin/bun" ]; then bun_path="$HOME/.bun/bin/bun"; fi; printf '%s\\n' "$(uname -s)" "$HOME" "$bun_path" "$(/usr/bin/xcodebuild -version 2>/dev/null | tr '\\n' ' ' || true)"`)
+  ];
+  const lines = requireRemoteSuccess(await capture(command), "Remote Mac handshake").split(/\r?\n/u);
+  const [operatingSystem, home, bunPath, xcodeVersion] = lines;
+  if (operatingSystem !== "Darwin")
+    throw new Error("The SSH target is not a Mac.");
+  if (!home?.startsWith("/") || !bunPath?.startsWith("/"))
+    throw new Error("The remote Mac must have Bun installed and available to SSH.");
+  if (!xcodeVersion?.startsWith("Xcode "))
+    throw new Error("The remote Mac must have full Xcode installed and selected.");
+  return { bunPath, home, os: operatingSystem, xcodeVersion };
+};
+var listAbsoluteRemoteMacProfiles = async (profilePath) => {
+  const store = await loadStore(profilePath);
+  return {
+    defaultProfile: store.defaultProfile,
+    profiles: Object.values(store.profiles).sort((left, right) => left.name.localeCompare(right.name))
+  };
+};
+var pairAbsoluteRemoteMac = async (options) => {
+  const name = validateAbsoluteRemoteMacProfileName(options.name);
+  const destination = validateAbsoluteSshDestination(options.destination);
+  const port = validatePort(options.port);
+  const inspection = await inspectAbsoluteRemoteMac(destination, {
+    acceptNew: true,
+    port,
+    transport: options.transport
+  });
+  const workspaceRoot = options.workspaceRoot ? options.workspaceRoot.trim() : posix.join(inspection.home, ".absolutejs", "remote-ios");
+  if (!workspaceRoot.startsWith("/") || workspaceRoot === "/" || /[\r\n\0]/u.test(workspaceRoot))
+    throw new TypeError("Remote Mac workspace must be an absolute macOS path.");
+  const profile = {
+    bunPath: inspection.bunPath,
+    createdAt: new Date().toISOString(),
+    destination,
+    name,
+    ...port ? { port } : {},
+    workspaceRoot,
+    xcodeVersion: inspection.xcodeVersion
+  };
+  const store = await loadStore(options.profilePath);
+  store.profiles[name] = profile;
+  store.defaultProfile = name;
+  await saveStore(store, options.profilePath);
+  return profile;
+};
+var removeAbsoluteRemoteMacProfile = async (name, profilePath) => {
+  const normalized = validateAbsoluteRemoteMacProfileName(name);
+  const store = await loadStore(profilePath);
+  if (!store.profiles[normalized])
+    return false;
+  delete store.profiles[normalized];
+  if (store.defaultProfile === normalized) {
+    const [nextDefault] = Object.keys(store.profiles).sort();
+    store.defaultProfile = nextDefault;
+  }
+  await saveStore(store, profilePath);
+  return true;
+};
+var projectIdentity = (projectRoot, appId) => createHash7("sha256").update(`${resolvePath2(projectRoot)}\x00${appId}`).digest("hex").slice(0, 20);
+var createAbsoluteRemoteIosDevProject = (config, projectRoot, profile) => ({
+  cap: join7(resolvePath2(projectRoot), "node_modules", ".bin", "cap"),
+  config,
+  nativeDirectory: join7(config.nativeProjectDirectory, "ios"),
+  profile,
+  projectRoot: resolvePath2(projectRoot),
+  remote: true,
+  remoteProjectRoot: posix.join(profile.workspaceRoot, "projects", projectIdentity(projectRoot, config.appId), "current"),
+  xcodebuild: "remote:xcodebuild",
+  xcrun: "remote:xcrun"
+});
+var installAbsoluteRemoteMacAgent = async (project) => {
+  const artifact = await materializeAbsoluteRemoteMacAgent(project.projectRoot);
+  const directory = posix.join(project.profile.workspaceRoot, "agents", `protocol-${ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION}`, artifact.sha256);
+  const remotePath = posix.join(directory, "agent.js");
+  const verifyScript = `test -f ${shellQuote(remotePath)} && ` + `test "$(shasum -a 256 ${shellQuote(remotePath)} | awk '{print $1}')" = ${shellQuote(artifact.sha256)}`;
+  const verified = await defaultTransport.capture([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(verifyScript)
+  ]);
+  if (verified.exitCode === 0)
+    return { ...artifact, remotePath, uploaded: false };
+  const temporary = posix.join(directory, `.agent-${randomUUID3()}.tmp`);
+  const installScript = [
+    "set -eu",
+    "umask 077",
+    `mkdir -p ${shellQuote(directory)}`,
+    `cat > ${shellQuote(temporary)}`,
+    `test "$(shasum -a 256 ${shellQuote(temporary)} | awk '{print $1}')" = ${shellQuote(artifact.sha256)}`,
+    `chmod 600 ${shellQuote(temporary)}`,
+    `mv ${shellQuote(temporary)} ${shellQuote(remotePath)}`
+  ].join("; ");
+  const upload = Bun.spawn([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(installScript)
+  ], {
+    stderr: "pipe",
+    stdin: Bun.file(artifact.path),
+    stdout: "pipe"
+  });
+  const [exitCode, stderr] = await Promise.all([
+    upload.exited,
+    new Response(upload.stderr).text()
+  ]);
+  if (exitCode !== 0)
+    throw new Error(`Remote Mac agent installation failed: ${stderr.trim() || `status ${exitCode}`}`);
+  return { ...artifact, remotePath, uploaded: true };
+};
+var materializeAbsoluteRemoteMacAgent = async (projectRoot) => {
+  const shippedCandidates = [
+    join7(import.meta.dir, "remoteMacAgentEntry.js"),
+    join7(import.meta.dir, "..", "mobile", "remoteMacAgentEntry.js")
+  ];
+  let path;
+  for (const candidate of shippedCandidates) {
+    if (await Bun.file(candidate).exists()) {
+      path = candidate;
+      break;
+    }
   }
-  const [bytes, sha256] = await Promise.all([
-    stat(artifactPath).then(({ size }) => size),
-    sha256File(artifactPath)
+  if (!path) {
+    const sourceCandidates = [
+      join7(import.meta.dir, "remoteMacAgentEntry.ts"),
+      join7(import.meta.dir, "..", "..", "src", "mobile", "remoteMacAgentEntry.ts")
+    ];
+    const source = await sourceCandidates.reduce(async (found, candidate) => await found ?? (await Bun.file(candidate).exists() ? candidate : undefined), Promise.resolve(undefined));
+    if (!source)
+      throw new Error("The AbsoluteJS installation does not contain its remote Mac agent artifact.");
+    const outdir = join7(resolvePath2(projectRoot), ".absolutejs", "mobile", "remote-agent");
+    await mkdir6(outdir, { recursive: true });
+    const result = await Bun.build({
+      entrypoints: [source],
+      minify: true,
+      outdir,
+      target: "bun"
+    });
+    if (!result.success)
+      throw new AggregateError(result.logs, "Failed to build the AbsoluteJS remote Mac agent.");
+    path = join7(outdir, "remoteMacAgentEntry.js");
+  }
+  const bytes = await Bun.file(path).arrayBuffer();
+  const sha256 = createHash7("sha256").update(new Uint8Array(bytes)).digest("hex");
+  return { bytes: bytes.byteLength, path, sha256 };
+};
+var portableRelativePath = (root, path) => relative6(root, path).split(sep5).join(posix.sep);
+var portableMobileConfig = (project) => ({
+  appId: project.config.appId,
+  appName: project.config.appName,
+  bundleDirectory: portableRelativePath(project.projectRoot, project.config.bundleDirectory),
+  ...project.config.deepLinkScheme || project.config.deepLinkHosts.length > 1 || project.config.appleAppIdPrefix ? {
+    deepLinks: {
+      ...project.config.deepLinkScheme ? { scheme: project.config.deepLinkScheme } : {},
+      hosts: project.config.deepLinkHosts,
+      ...project.config.appleAppIdPrefix ? {
+        apple: {
+          appIdPrefix: project.config.appleAppIdPrefix
+        }
+      } : {}
+    }
+  } : {},
+  entry: project.config.entry,
+  ...project.config.iosVersion ? { ios: { version: project.config.iosVersion } } : {},
+  nativeProject: {
+    directory: portableRelativePath(project.projectRoot, project.config.nativeProjectDirectory),
+    mode: "source"
+  },
+  platforms: ["ios"],
+  server: { productionOrigin: project.config.productionOrigin }
+});
+var absoluteRemoteProjectSyncCommands = (project) => {
+  const current = project.remoteProjectRoot;
+  const parent = posix.dirname(current);
+  const staging = posix.join(parent, `.incoming-${randomUUID3()}`);
+  const previous = posix.join(parent, ".previous");
+  const script = [
+    "set -eu",
+    `mkdir -p ${shellQuote(staging)}`,
+    `tar -xf - -C ${shellQuote(staging)}`,
+    `if [ -d ${shellQuote(posix.join(current, "node_modules"))} ]; then mv ${shellQuote(posix.join(current, "node_modules"))} ${shellQuote(posix.join(staging, "node_modules"))}; fi`,
+    `if [ -d ${shellQuote(posix.join(current, ".absolutejs"))} ]; then mv ${shellQuote(posix.join(current, ".absolutejs"))} ${shellQuote(posix.join(staging, ".absolutejs"))}; fi`,
+    `rm -rf ${shellQuote(previous)}`,
+    `if [ -d ${shellQuote(current)} ]; then mv ${shellQuote(current)} ${shellQuote(previous)}; fi`,
+    `mv ${shellQuote(staging)} ${shellQuote(current)}`,
+    `rm -rf ${shellQuote(previous)}`
+  ].join("; ");
+  return {
+    remote: [
+      ...absoluteRemoteMacSshBase(project.profile),
+      "/bin/sh -lc",
+      shellQuote(script)
+    ],
+    tar: [
+      "tar",
+      "--exclude=.git",
+      "--exclude=node_modules",
+      "--exclude=build",
+      "--exclude=.absolutejs",
+      "-cf",
+      "-",
+      "-C",
+      project.projectRoot,
+      "."
+    ]
+  };
+};
+var syncAbsoluteRemoteMacProject = async (project) => {
+  const commands = absoluteRemoteProjectSyncCommands(project);
+  const archive = Bun.spawn(commands.tar, {
+    stderr: "pipe",
+    stdout: "pipe"
+  });
+  const upload = Bun.spawn(commands.remote, {
+    stderr: "pipe",
+    stdin: archive.stdout,
+    stdout: "pipe"
+  });
+  const [archiveExit, uploadExit, archiveError, uploadError] = await Promise.all([
+    archive.exited,
+    upload.exited,
+    new Response(archive.stderr).text(),
+    new Response(upload.stderr).text()
   ]);
-  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"
+  if (archiveExit !== 0 || uploadExit !== 0)
+    throw new Error(`Remote Mac project synchronization failed: ${(archiveError || uploadError).trim()}`);
+  const install = await defaultTransport.capture([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(`cd ${shellQuote(project.remoteProjectRoot)} && ${shellQuote(project.profile.bunPath)} install --frozen-lockfile`)
+  ]);
+  requireRemoteSuccess(install, "Remote Mac dependency installation");
+};
+var consumeLines2 = async (stream, onLine) => {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffered += decoder.decode(value, { stream: true });
+      const lines = buffered.split(/\r?\n/u);
+      buffered = lines.pop() ?? "";
+      lines.forEach(onLine);
+    }
+    buffered += decoder.decode();
+    if (buffered)
+      onLine(buffered);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var startAbsoluteRemoteIosDevSession = async (options) => {
+  const startedAt = performance.now();
+  const transport = options.transport ?? defaultTransport;
+  const installAgent = options.installAgent ?? installAbsoluteRemoteMacAgent;
+  const syncProject = options.syncProject ?? syncAbsoluteRemoteMacProject;
+  const agentStartedAt = performance.now();
+  const agent = await installAgent(options.project);
+  const agentDuration = performance.now() - agentStartedAt;
+  const syncStartedAt = performance.now();
+  await syncProject(options.project);
+  const syncDuration = performance.now() - syncStartedAt;
+  const encodedConfig = Buffer.from(JSON.stringify(portableMobileConfig(options.project))).toString("base64url");
+  const remoteCommand = [
+    `cd ${shellQuote(options.project.remoteProjectRoot)}`,
+    "&&",
+    "exec",
+    shellQuote(options.project.profile.bunPath),
+    shellQuote(agent.remotePath),
+    "--port",
+    String(options.port),
+    "--mobile-config",
+    shellQuote(encodedConfig),
+    ...options.https ? ["--https"] : []
+  ].join(" ");
+  const command = [
+    ...absoluteRemoteMacSshBase(options.project.profile),
+    "-o",
+    "ExitOnForwardFailure=yes",
+    "-R",
+    `${options.port}:127.0.0.1:${options.port}`,
+    "/bin/sh -lc",
+    shellQuote(remoteCommand)
+  ];
+  const connectStartedAt = performance.now();
+  const process2 = transport.spawn(command, { signal: options.signal });
+  let state = "syncing";
+  let ready;
+  let fatal;
+  const pending = new Map;
+  let resolveReady;
+  let rejectReady;
+  const readyPromise = new Promise((resolve6, reject) => {
+    resolveReady = resolve6;
+    rejectReady = reject;
+  });
+  const handleEvent = (event) => {
+    if (event.v !== ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION) {
+      rejectReady(new Error("Remote Mac protocol version mismatch."));
+      return;
+    }
+    if (event.type === "log")
+      options.log?.(event.message);
+    if (event.type === "native-log")
+      options.nativeLog?.(event.entry);
+    if (event.type === "state") {
+      ({ state } = event);
+      options.onStateChange?.(state);
+    }
+    if (event.type === "timing")
+      options.onPhaseTiming?.(event);
+    if (event.type === "ready") {
+      ready = event;
+      resolveReady();
+    }
+    if (event.type === "fatal") {
+      fatal = new Error(event.error);
+      rejectReady(fatal);
+    }
+    if (event.type === "response") {
+      const request2 = pending.get(event.id);
+      if (!request2)
+        return;
+      pending.delete(event.id);
+      if (event.ok)
+        request2.resolve(event.result);
+      else
+        request2.reject(new Error(event.error ?? "Remote command failed."));
+    }
   };
-  return installRelease(artifactPath, metadata, safeOutputDirectory(projectRoot, options.outputDirectory));
+  const stdoutDone = consumeLines2(process2.stdout, (line) => {
+    if (!line.startsWith(ABSOLUTE_REMOTE_MAC_EVENT_PREFIX))
+      return;
+    try {
+      handleEvent(JSON.parse(line.slice(ABSOLUTE_REMOTE_MAC_EVENT_PREFIX.length)));
+    } catch {
+      options.log?.(`Remote Mac emitted an invalid protocol event.`);
+    }
+  }).catch((error) => {
+    fatal = error instanceof Error ? error : new Error("Failed to read the remote Mac protocol stream.");
+    rejectReady(fatal);
+  });
+  const stderrDone = consumeLines2(process2.stderr, (line) => options.log?.(`[remote] ${line}`)).catch((error) => options.log?.(`[remote] ${error instanceof Error ? error.message : "Failed to read SSH stderr."}`));
+  process2.exited.then(async (exitCode) => {
+    await Promise.all([stdoutDone, stderrDone]);
+    const error = fatal ?? new Error(`Remote Mac connection closed with status ${exitCode}.`);
+    if (!ready)
+      rejectReady(error);
+    pending.forEach(({ reject }) => reject(error));
+    pending.clear();
+    return;
+  });
+  await readyPromise;
+  if (!ready)
+    throw fatal ?? new Error("Remote Mac did not become ready.");
+  const totalDuration = performance.now() - startedAt;
+  let currentReady = {
+    ...ready,
+    timings: {
+      ...ready.timings,
+      "remote-agent": agentDuration,
+      "remote-connect": performance.now() - connectStartedAt,
+      "remote-sync": syncDuration,
+      total: totalDuration
+    }
+  };
+  options.log?.(`Remote Mac connected (${options.project.profile.name}); agent ${agent.uploaded ? "uploaded" : "cache hit"}, project synced, and iOS ready in ${totalDuration.toFixed(2)}ms.`);
+  const request = (commandName) => {
+    const id = randomUUID3();
+    const response = new Promise((resolve6, reject) => pending.set(id, { reject, resolve: resolve6 }));
+    process2.stdin.write(`${JSON.stringify({ command: commandName, id, v: 1 })}
+`);
+    process2.stdin.flush();
+    return response;
+  };
+  let closed = false;
+  const close = async () => {
+    if (closed)
+      return;
+    closed = true;
+    await request("close").catch(() => {
+      return;
+    });
+    process2.stdin.end();
+    await process2.exited.catch(() => {
+      return;
+    });
+  };
+  const makeSession = () => ({
+    close,
+    nativeCacheHit: currentReady.nativeCacheHit,
+    startedSimulator: currentReady.startedSimulator,
+    timings: currentReady.timings,
+    udid: currentReady.udid,
+    rebuild: async () => {
+      const rebuildStartedAt = performance.now();
+      const rebuildSyncStartedAt = performance.now();
+      await syncProject(options.project);
+      const rebuildSyncDuration = performance.now() - rebuildSyncStartedAt;
+      const result = await request("rebuild");
+      currentReady = {
+        ...result,
+        timings: {
+          ...result.timings,
+          "remote-sync": rebuildSyncDuration,
+          total: performance.now() - rebuildStartedAt
+        }
+      };
+      return makeSession();
+    },
+    relaunch: async () => {
+      await request("relaunch");
+    },
+    screenshot: async (destination) => {
+      const result = await request("screenshot");
+      const target = resolvePath2(options.project.projectRoot, destination);
+      const targetRelative = relative6(options.project.projectRoot, target);
+      if (targetRelative.startsWith("..") || isAbsolute5(targetRelative))
+        throw new Error("iOS screenshot must remain inside the project.");
+      await mkdir6(dirname5(target), { recursive: true });
+      await writeFile7(target, Buffer.from(result.data, "base64"));
+      return target;
+    },
+    get state() {
+      return state;
+    }
+  });
+  return makeSession();
 };
 // src/mobile/associationFiles.ts
 import {
-  access as access4,
-  mkdir as mkdir4,
-  readFile as readFile5,
-  rename as rename5,
-  rm as rm4,
-  writeFile as writeFile5
+  access as access7,
+  mkdir as mkdir7,
+  readFile as readFile9,
+  rename as rename8,
+  rm as rm6,
+  writeFile as writeFile8
 } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve7 } from "path";
 import { Elysia } from "elysia";
 
 // src/mobile/config.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve6 } from "path";
 var APP_ID_PATTERN = /^[A-Za-z][\w]*(?:\.[A-Za-z][\w]*)+$/;
 var SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*$/;
 var APPLE_APP_ID_PREFIX_PATTERN = /^[A-Z0-9]{10}$/;
 var CERTIFICATE_FINGERPRINT_PATTERN = /^[0-9A-F]{64}$/;
 var HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/;
 var resolveProjectPath = (projectRoot, value, field) => {
-  const root = resolve4(projectRoot);
-  const path = resolve4(root, value);
+  const root = resolve6(projectRoot);
+  const path = resolve6(root, value);
   if (path !== root && !path.startsWith(`${root}/`)) {
     throw new TypeError(`${field} must remain inside the project root.`);
   }
@@ -1130,8 +3166,9 @@ var normalizeEntry = (entry) => {
 };
 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.");
+  const isLoopbackHttp = parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]");
+  if (parsed.protocol !== "https:" && !isLoopbackHttp) {
+    throw new TypeError("mobile.server.productionOrigin must use HTTPS, except for a loopback development origin.");
   }
   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.");
@@ -1155,9 +3192,8 @@ var normalizeHosts = (hosts, productionOrigin) => {
     }
     return value;
   };
-  const normalized = new Set([
-    normalizeHostname(new URL(productionOrigin).hostname)
-  ]);
+  const productionHostname = new URL(productionOrigin).hostname;
+  const normalized = new Set(productionHostname === "[::1]" ? [] : [normalizeHostname(productionHostname)]);
   for (const host of hosts ?? []) {
     normalized.add(normalizeHostname(host));
   }
@@ -1172,6 +3208,15 @@ var normalizeAppleAppIdPrefix = (value) => {
   }
   return normalized;
 };
+var normalizeIosVersion = (value) => {
+  if (value === undefined)
+    return;
+  const normalized = requireText(value, "mobile.ios.version");
+  if (!/^\d+(?:\.\d+){0,2}$/u.test(normalized)) {
+    throw new TypeError("mobile.ios.version must contain one to three dot-separated integer components, for example 1.4.0.");
+  }
+  return normalized;
+};
 var normalizeCertificateFingerprints = (values) => [
   ...new Set((values ?? []).map((value) => requireText(value, "mobile.deepLinks.android.sha256CertificateFingerprints").replaceAll(":", "").toUpperCase()).map((value) => {
     if (!CERTIFICATE_FINGERPRINT_PATTERN.test(value)) {
@@ -1186,7 +3231,7 @@ var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
     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();
+  const deepLinkScheme = (config.deepLinks?.scheme ?? appId).trim().toLowerCase();
   if (deepLinkScheme && !SCHEME_PATTERN.test(deepLinkScheme)) {
     throw new TypeError("mobile.deepLinks.scheme is not a valid URL scheme.");
   }
@@ -1200,6 +3245,7 @@ var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
     deepLinkScheme,
     engine: "capacitor",
     entry: normalizeEntry(config.entry),
+    iosVersion: normalizeIosVersion(config.ios?.version),
     nativeProjectDirectory: resolveProjectPath(projectRoot, config.nativeProject?.directory ?? "mobile", "mobile.nativeProject.directory"),
     platforms: normalizePlatforms(config.platforms),
     productionOrigin
@@ -1287,7 +3333,7 @@ var createAbsoluteMobileAssociationPlugin = (mobile, projectRoot, options = {})
 var writeAtomic = async (path, source) => {
   let current;
   try {
-    current = await readFile5(path, "utf8");
+    current = await readFile9(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -1296,23 +3342,23 @@ var writeAtomic = async (path, source) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile5(temporary, source, { flag: "wx" });
-  await rename5(temporary, path);
+  await writeFile8(temporary, source, { flag: "wx" });
+  await rename8(temporary, path);
   return true;
 };
 var exists2 = async (path) => {
   try {
-    await access4(path);
+    await access7(path);
     return true;
   } catch {
     return false;
   }
 };
 var assertOwnedOutput = async (root) => {
-  const path = resolve5(root, OWNERSHIP_FILE);
+  const path = resolve7(root, OWNERSHIP_FILE);
   let ownership;
   try {
-    ownership = JSON.parse(await readFile5(path, "utf8"));
+    ownership = JSON.parse(await readFile9(path, "utf8"));
   } catch {
     throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
   }
@@ -1326,22 +3372,22 @@ var publishGeneratedDirectory = async (temporary, root) => {
     await assertOwnedOutput(root);
   const backup = `${root}.${crypto.randomUUID()}.previous`;
   if (hasCurrent)
-    await rename5(root, backup);
+    await rename8(root, backup);
   try {
-    await rename5(temporary, root);
+    await rename8(temporary, root);
   } catch (error) {
     if (hasCurrent)
-      await rename5(backup, root);
+      await rename8(backup, root);
     throw error;
   }
   if (hasCurrent)
-    await rm4(backup, { force: true, recursive: true });
+    await rm6(backup, { force: true, recursive: true });
 };
 var materializeHost = async (root, host, files) => {
-  const directory = resolve5(root, host, ".well-known");
-  await mkdir4(directory, { recursive: true });
+  const directory = resolve7(root, host, ".well-known");
+  await mkdir7(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document]) => {
-    const path = resolve5(directory, name);
+    const path = resolve7(directory, name);
     await writeAtomic(path, `${JSON.stringify(document, null, 2)}
 `);
     return path;
@@ -1366,7 +3412,7 @@ var associationEndpoints = (config, documents) => config.deepLinkHosts.flatMap((
   return endpoints;
 });
 var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
-  const root = resolve5(outputDirectory);
+  const root = resolve7(outputDirectory);
   const temporary = `${root}.${crypto.randomUUID()}.tmp`;
   const documents = createAbsoluteMobileAssociationDocuments(config, {
     requireAll: true
@@ -1377,16 +3423,16 @@ var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory)
   if (documents.apple) {
     files.push(["apple-app-site-association", documents.apple]);
   }
-  await mkdir4(temporary, { recursive: true });
+  await mkdir7(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
-    await writeAtomic(resolve5(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+    await writeAtomic(resolve7(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
 `);
     await publishGeneratedDirectory(temporary, root);
-    const written = temporaryPaths.map((path) => resolve5(root, path.slice(temporary.length + 1)));
+    const written = temporaryPaths.map((path) => resolve7(root, path.slice(temporary.length + 1)));
     return { root, written };
   } catch (error) {
-    await rm4(temporary, { force: true, recursive: true });
+    await rm6(temporary, { force: true, recursive: true });
     throw error;
   }
 };
@@ -1431,10 +3477,10 @@ var frameworks2 = new Set([
   "svelte",
   "vue"
 ]);
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isPageFramework2 = (value) => typeof value === "string" && frameworks2.has(value);
 var parseAbsoluteMobileBuildPageMetadata = (value) => {
-  if (!isRecord2(value))
+  if (!isRecord4(value))
     return;
   if (typeof value.bundleKey !== "string" || typeof value.contract !== "string" || !isPageFramework2(value.framework) || typeof value.pageId !== "string" || typeof value.propsSchemaHash !== "string") {
     return;
@@ -1448,45 +3494,75 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
   };
 };
 // src/mobile/buildPipeline.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join8, resolve as resolve8 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join12, resolve as resolve10 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
-import { createHash as createHash4 } from "crypto";
-import { readFile as readFile6 } from "fs/promises";
-import { join as join5, relative as relative4, resolve as resolve6 } from "path";
-var sha256 = (bytes) => createHash4("sha256").update(bytes).digest("hex");
+import { createHash as createHash8 } from "crypto";
+import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
+import { basename as basename2, dirname as dirname6, extname, join as join8, relative as relative7, resolve as resolve8 } from "path";
+var sha256 = (bytes) => createHash8("sha256").update(bytes).digest("hex");
+var STATIC_SCRIPT_PATTERN = /(<script\b[^>]*?\bsrc\s*=\s*["'])(\/[^"']+\.(?:js|ts))(["'][^>]*>)/giu;
+var rewriteStaticScriptPaths = (source, manifest) => source.replace(STATIC_SCRIPT_PATTERN, (match, prefix, path, suffix) => {
+  if (path.endsWith("/htmx.min.js"))
+    return match;
+  const key = toPascal(basename2(path, extname(path)));
+  const builtPath = manifest[key];
+  return builtPath ? `${prefix}${builtPath}${suffix}` : match;
+});
 var readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]);
 var resolveAssetPath = (buildDirectory, assetPath) => {
-  const resolvedBuildDirectory = resolve6(buildDirectory);
-  const resolvedAsset = resolve6(assetPath);
+  const resolvedBuildDirectory = resolve8(buildDirectory);
+  const resolvedAsset = resolve8(assetPath);
   if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
     return resolvedAsset;
   }
-  return join5(buildDirectory, assetPath.replace(/^\/+/, ""));
+  return join8(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 readFile6(resolvedAssetPath);
-  const bundlePath = `/${relative4(resolve6(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  let resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
+  if (metadata.framework === "html" || metadata.framework === "htmx") {
+    const source = await readFile10(resolvedAssetPath, "utf8");
+    const rewritten = rewriteStaticScriptPaths(source, manifest);
+    const documentHash = sha256(new TextEncoder().encode(rewritten));
+    resolvedAssetPath = join8(buildDirectory, ".absolutejs", "mobile-pages", `${documentHash}.html`);
+    await mkdir8(dirname6(resolvedAssetPath), { recursive: true });
+    await writeFile9(resolvedAssetPath, rewritten);
+  }
+  const pageAssetKey = metadata.bundleKey.replace(/Index$/u, "");
+  const styleAssetPath = [
+    `${pageAssetKey}BundledCSS`,
+    `${pageAssetKey}CompiledCSS`
+  ].map((key) => manifest[key]).find((path) => typeof path === "string");
+  const resolvedStylePath = styleAssetPath ? resolveAssetPath(buildDirectory, styleAssetPath) : undefined;
+  const [bytes, styleBytes] = await Promise.all([
+    readFile10(resolvedAssetPath),
+    resolvedStylePath ? readFile10(resolvedStylePath) : undefined
+  ]);
+  const bundlePath = `/${relative7(resolve8(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const styleBundlePath = resolvedStylePath ? `/${relative7(resolve8(buildDirectory), resolvedStylePath).replaceAll("\\", "/")}` : undefined;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
     contract: metadata.contract,
     framework: metadata.framework,
     pageId: metadata.pageId,
-    propsSchemaHash: metadata.propsSchemaHash
+    propsSchemaHash: metadata.propsSchemaHash,
+    ...styleBytes && styleBundlePath ? {
+      styleBundleHash: sha256(styleBytes),
+      styleBundlePath
+    } : {}
   };
 };
 var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   const [captured, producerBytes] = await Promise.all([
     captureAbsoluteMobileRouteGraph(options.app),
-    readFile6(options.producerPath)
+    readFile10(options.producerPath)
   ]);
   if (captured.length === 0) {
     throw new TypeError("No instrumented AbsoluteJS mobile page routes were found in the finalized Elysia route graph.");
@@ -1502,11 +3578,19 @@ var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   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 }) => ({
+    pages: pages.map(({
+      bundleHash,
+      bundlePath,
+      contract,
+      pageId,
+      styleBundleHash,
+      styleBundlePath
+    }) => ({
       bundleHash,
       bundlePath,
       contract,
-      pageId
+      pageId,
+      ...styleBundleHash && styleBundlePath ? { styleBundleHash, styleBundlePath } : {}
     })),
     producerHash,
     runtime: options.runtime
@@ -1566,16 +3650,17 @@ var captureAbsoluteMobileRouteGraph = async (app) => {
 
 // src/mobile/capacitorBundle.ts
 import {
-  copyFile as copyFile3,
-  mkdir as mkdir5,
-  mkdtemp as mkdtemp3,
-  readFile as readFile7,
-  rename as rename6,
-  rm as rm5,
-  writeFile as writeFile6
+  cp,
+  copyFile as copyFile5,
+  mkdir as mkdir9,
+  mkdtemp as mkdtemp4,
+  readFile as readFile11,
+  rename as rename9,
+  rm as rm7,
+  writeFile as writeFile10
 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { basename, dirname as dirname3, extname, join as join6, resolve as resolve7 } from "path";
+import { basename as basename3, dirname as dirname7, extname as extname2, join as join9, relative as relative8, resolve as resolve9 } from "path";
 
 // src/mobile/routeMatcher.ts
 var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
@@ -1731,14 +3816,14 @@ var envelopeResponse = (response, status) => new Response(JSON.stringify({
   protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
   response
 }), { headers: responseHeaders(), status });
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var normalizeJsonValue = (value) => {
   const serialized = JSON.stringify(value);
   if (serialized === undefined) {
     throw new TypeError("Mobile page props must be JSON-serializable.");
   }
   const parsed = JSON.parse(serialized);
-  if (!isRecord3(parsed)) {
+  if (!isRecord5(parsed)) {
     throw new TypeError("Mobile page props must serialize to an object.");
   }
   return parsed;
@@ -1848,6 +3933,13 @@ class AbsoluteMobilePageProtocolError extends Error {
     this.code = code;
   }
 }
+var disposeAbsoluteMobilePage = async (target = window) => {
+  const dispose = target.__ABSOLUTE_PAGE_DISPOSE__;
+  target.__ABSOLUTE_PAGE_DISPOSE__ = undefined;
+  target.__ABSOLUTE_PAGE_READY__ = undefined;
+  if (dispose)
+    await dispose();
+};
 var frameworks4 = new Set([
   "angular",
   "ember",
@@ -1863,14 +3955,14 @@ var upgradeReasons = new Set([
   "protocol",
   "runtime"
 ]);
-var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isFramework = (value) => typeof value === "string" && frameworks4.has(value);
 var isUpgradeReason = (value) => typeof value === "string" && upgradeReasons.has(value);
 var parsePageResult = (value) => {
   if (typeof value.contract !== "string" || !isFramework(value.framework) || typeof value.pageId !== "string" || typeof value.status !== "number") {
     throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The mobile page response is missing required page metadata.");
   }
-  if (!isRecord4(value.props)) {
+  if (!isRecord6(value.props)) {
     throw new AbsoluteMobilePageProtocolError("invalid-props", "The mobile page response must contain an object props value.");
   }
   return {
@@ -1903,12 +3995,17 @@ var activateAbsoluteMobilePage = async (value, options) => {
     throw new AbsoluteMobilePageProtocolError("invalid-envelope", "Expected a renderable mobile page response.");
   }
   const target = options.target ?? window;
+  await disposeAbsoluteMobilePage(target);
   target.__INITIAL_PROPS__ = envelope.response.props;
+  target.__ABS_ANGULAR_REQUEST_CONTEXT__ = envelope.response.props;
   target.__ABSOLUTE_PAGE_RENDER_MODE__ = "client";
   await options.loadPage({
     contract: envelope.response.contract,
     pageId: envelope.response.pageId
   });
+  if (target.__ABSOLUTE_PAGE_READY__) {
+    await target.__ABSOLUTE_PAGE_READY__;
+  }
   return {
     contract: envelope.response.contract,
     kind: "rendered",
@@ -1916,7 +4013,7 @@ var activateAbsoluteMobilePage = async (value, options) => {
   };
 };
 var parseAbsoluteMobilePageEnvelope = (value) => {
-  if (!isRecord4(value) || !isRecord4(value.response)) {
+  if (!isRecord6(value) || !isRecord6(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) {
@@ -2001,19 +4098,51 @@ var resolveAbsoluteMobileDeepLink = (manifest, value) => {
   }
   return `${url.pathname || "/"}${url.search}${url.hash}`;
 };
+var resolveAbsoluteMobileNavigation = (manifest, value, localOrigin) => {
+  const url = new URL(value, `${localOrigin}/`);
+  const local = new URL(localOrigin);
+  const production = new URL(manifest.productionOrigin);
+  const matches = (candidate, allowed) => candidate.protocol === allowed.protocol && candidate.host === allowed.host;
+  if (!matches(url, local) && !matches(url, production)) {
+    return;
+  }
+  return `${url.pathname}${url.search}${url.hash}`;
+};
 
 // 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 CLIENT_CSS_DEPENDENCY_PATTERN = /(?:@import\s+(?:url\(\s*)?|url\(\s*)["']?((?:\/|\.\.\/|\.\/)[^"')\s]+)["']?\s*\)?/gu;
+var CLIENT_MARKUP_DEPENDENCY_PATTERN = /<(?:script\b[^>]*\bsrc|link\b[^>]*\bhref|img\b[^>]*\bsrc|source\b[^>]*\bsrcset)\s*=\s*["']((?:\/|\.\.\/|\.\/)[^"',\s]+)/giu;
+var CAPACITOR_CLIENT_FRAMEWORKS = new Set([
+  "angular",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var CLIENT_ASSET_DIRECTORIES = ["assets", "html", "htmx", "indexes"];
 var errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var shellBootstrapModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join6(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
 };
+var shellAuthModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellAuth.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile auth shell module is missing.");
+};
+var shellSyncModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellSync.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile Sync shell module is missing.");
+};
 var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 var indexHtml = (appName) => `<!doctype html>
 <html>
@@ -2030,18 +4159,23 @@ var indexHtml = (appName) => `<!doctype html>
 </html>
 `;
 var sourceAssetPath = (buildDirectory, bundlePath) => {
-  const root = resolve7(buildDirectory);
-  const asset = resolve7(root, bundlePath.replace(/^\/+/, ""));
+  const root = resolve9(buildDirectory);
+  const asset = resolve9(root, bundlePath.replace(/^\/+/, ""));
   if (!asset.startsWith(`${root}/`)) {
     throw new TypeError("Mobile page bundle escaped the build directory.");
   }
   return asset;
 };
-var buildShellBootstrap = async (staging) => {
+var buildShellBootstrap = async (staging, auth, sync) => {
   const modulePath = shellBootstrapModule();
-  const entryPath = join6(staging, ".absolute-mobile-entry.ts");
-  await writeFile6(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
-void startAbsoluteMobileShell();
+  const authImport = auth ? `import { createAbsoluteMobileShellAuth } from ${JSON.stringify(shellAuthModule())};
+` : "";
+  const options = auth ? `{ createAuth: createAbsoluteMobileShellAuth${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }` : "";
+  const syncImport = sync ? `import { installAbsoluteMobileShellSync } from ${JSON.stringify(shellSyncModule())};
+` : "";
+  const entryPath = join9(staging, ".absolute-mobile-entry.ts");
+  await writeFile10(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+${authImport}${syncImport}void startAbsoluteMobileShell(${options});
 `);
   const build = await Bun.build({
     entrypoints: [entryPath],
@@ -2052,31 +4186,31 @@ void startAbsoluteMobileShell();
   if (!build.success || build.outputs.length !== 1) {
     throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
   }
-  await rename6(build.outputs[0]?.path ?? "", join6(staging, BOOTSTRAP_FILE));
-  await rm5(entryPath, { force: true });
+  await rename9(build.outputs[0]?.path ?? "", join9(staging, BOOTSTRAP_FILE));
+  await rm7(entryPath, { force: true });
 };
 var removePreviousBundle = async (backup, moved) => {
   if (!moved)
     return;
-  await rm5(backup, { force: true, recursive: true });
+  await rm7(backup, { force: true, recursive: true });
 };
 var restorePreviousBundle = async (backup, destination, moved) => {
   if (!moved)
     return;
-  await rename6(backup, destination);
+  await rename9(backup, destination);
 };
 var installBundle = async (staging, destination) => {
   const backup = `${destination}.previous-${crypto.randomUUID()}`;
   let movedPrevious = false;
   try {
-    await rename6(destination, backup);
+    await rename9(destination, backup);
     movedPrevious = true;
   } catch (error) {
     if (!errorHasCode2(error, "ENOENT"))
       throw error;
   }
   try {
-    await rename6(staging, destination);
+    await rename9(staging, destination);
     await removePreviousBundle(backup, movedPrevious);
   } catch (error) {
     await restorePreviousBundle(backup, destination, movedPrevious);
@@ -2084,21 +4218,62 @@ var installBundle = async (staging, destination) => {
   }
 };
 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}.`);
+  if (!CAPACITOR_CLIENT_FRAMEWORKS.has(page.framework)) {
+    throw new TypeError(`Capacitor client rendering does not yet support ${page.framework} page ${page.pageId}.`);
   }
-  const extension = extname(page.bundlePath) || ".js";
+  const extension = extname2(page.bundlePath) || ".js";
   const localBundlePath = `./pages/${page.bundleHash}${extension}`;
   const source = sourceAssetPath(buildDirectory, page.bundlePath);
-  await copyFile3(source, join6(staging, localBundlePath));
+  await copyFile5(source, join9(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
-  return { ...page, localBundlePath };
+  let localStylePath;
+  if (page.styleBundlePath && page.styleBundleHash) {
+    const styleExtension = extname2(page.styleBundlePath) || ".css";
+    localStylePath = `./styles/${page.styleBundleHash}${styleExtension}`;
+    const styleSource = sourceAssetPath(buildDirectory, page.styleBundlePath);
+    await mkdir9(dirname7(join9(staging, localStylePath)), {
+      recursive: true
+    });
+    await copyFile5(styleSource, join9(staging, localStylePath));
+    await copyAbsoluteClientDependencies(styleSource, buildDirectory, staging, copiedDependencies);
+  }
+  return {
+    ...page,
+    localBundlePath,
+    ...localStylePath ? { localStylePath } : {}
+  };
 };
-var absoluteClientImports = async (sourcePath) => {
-  const source = await readFile7(sourcePath, "utf8");
-  return [...source.matchAll(CLIENT_IMPORT_PATTERN)].flatMap((match) => {
-    const [specifier] = match.slice(1);
-    return specifier ? [specifier.split(/[?#]/u, 1)[0] ?? specifier] : [];
+var absoluteClientImports = async (sourcePath, buildDirectory) => {
+  const source = await readFile11(sourcePath, "utf8");
+  const extension = extname2(sourcePath).toLowerCase();
+  let scriptLoader;
+  if (extension === ".tsx")
+    scriptLoader = "tsx";
+  else if (extension === ".ts")
+    scriptLoader = "ts";
+  else if (extension === ".jsx")
+    scriptLoader = "jsx";
+  else if ([".js", ".mjs", ".cjs"].includes(extension))
+    scriptLoader = "js";
+  const scriptImports = scriptLoader ? new Bun.Transpiler({ loader: scriptLoader }).scanImports(source).map(({ path }) => path) : [];
+  const cssImports = extension === ".css" ? [...source.matchAll(CLIENT_CSS_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  const markupImports = extension === ".html" ? [...source.matchAll(CLIENT_MARKUP_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  return [...scriptImports, ...cssImports, ...markupImports].flatMap((specifier) => {
+    if (!specifier)
+      return [];
+    if (!specifier.startsWith("/") && !specifier.startsWith("./") && !specifier.startsWith("../")) {
+      return [];
+    }
+    const clean = specifier.split(/[?#]/u, 1)[0] ?? specifier;
+    if (clean.startsWith("/"))
+      return [clean];
+    const resolved = resolve9(dirname7(sourcePath), clean);
+    const root = resolve9(buildDirectory);
+    const relativePath = relative8(root, resolved).replaceAll("\\", "/");
+    if (relativePath === ".." || relativePath.startsWith("../")) {
+      throw new TypeError(`Mobile client dependency escaped the build directory: ${specifier}`);
+    }
+    return [`/${relativePath}`];
   });
 };
 var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, copied) => {
@@ -2106,13 +4281,13 @@ var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, co
     return;
   copied.add(specifier);
   const source = sourceAssetPath(buildDirectory, specifier);
-  const destination = join6(staging, specifier.replace(/^\/+/, ""));
-  await mkdir5(dirname3(destination), { recursive: true });
-  await copyFile3(source, destination);
+  const destination = join9(staging, specifier.replace(/^\/+/, ""));
+  await mkdir9(dirname7(destination), { recursive: true });
+  await copyFile5(source, destination);
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
 };
 var copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
-  const dependencies = await absoluteClientImports(sourcePath);
+  const dependencies = await absoluteClientImports(sourcePath, buildDirectory);
   await Promise.all(dependencies.map((specifier) => copyAbsoluteClientDependency(specifier, buildDirectory, staging, copied)));
 };
 var materializeAbsoluteCapacitorWebBundle = async (options) => {
@@ -2120,15 +4295,20 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
     throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
   }
   const destination = options.config.bundleDirectory;
-  await mkdir5(dirname3(destination), { recursive: true });
-  const staging = await mkdtemp3(join6(dirname3(destination), `.${basename(destination)}.stage-`));
+  await mkdir9(dirname7(destination), { recursive: true });
+  const staging = await mkdtemp4(join9(dirname7(destination), `.${basename3(destination)}.stage-`));
   try {
-    const pageDirectory = join6(staging, "pages");
-    await mkdir5(pageDirectory, { recursive: true });
+    const pageDirectory = join9(staging, "pages");
+    await mkdir9(pageDirectory, { recursive: true });
+    await Promise.all(CLIENT_ASSET_DIRECTORIES.map((directory) => ({
+      destination: join9(staging, directory),
+      source: join9(options.buildDirectory, directory)
+    })).filter(({ source }) => existsSync2(source)).map(({ destination: assetDestination, source }) => cp(source, assetDestination, { 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,
+      ...options.auth ? { auth: options.auth } : {},
       appId: options.config.appId,
       appName: options.config.appName,
       deepLinkHosts: options.config.deepLinkHosts,
@@ -2138,51 +4318,60 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       pages,
       productionOrigin: options.config.productionOrigin,
       routes: options.artifact.routes,
-      runtime: options.artifact.runtime
+      runtime: options.artifact.runtime,
+      ...options.sync ? {
+        sync: {
+          background: {
+            endpoint: new URL("/__absolute/sync/background", options.config.productionOrigin).href,
+            intervalMinutes: 15
+          },
+          socketTickets: true
+        }
+      } : {}
     };
     await Promise.all([
-      writeFile6(join6(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+      writeFile10(join9(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
-      writeFile6(join6(staging, INDEX_FILE), indexHtml(options.config.appName)),
-      buildShellBootstrap(staging)
+      writeFile10(join9(staging, INDEX_FILE), indexHtml(options.config.appName)),
+      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true)
     ]);
     await installBundle(staging, destination);
     return manifest;
   } catch (error) {
-    await rm5(staging, { force: true, recursive: true });
+    await rm7(staging, { force: true, recursive: true });
     throw error;
   }
 };
 
 // src/mobile/materializedBundle.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import {
-  access as access5,
-  mkdir as mkdir6,
-  mkdtemp as mkdtemp4,
-  readFile as readFile8,
-  rename as rename7,
-  rm as rm6,
-  writeFile as writeFile7
+  access as access8,
+  mkdir as mkdir10,
+  mkdtemp as mkdtemp5,
+  readFile as readFile12,
+  rename as rename10,
+  rm as rm8,
+  writeFile as writeFile11
 } from "fs/promises";
-import { dirname as dirname4, join as join7, resolve as resolvePath2 } from "path";
+import { dirname as dirname8, join as join10, resolve as resolvePath3 } from "path";
 import { pathToFileURL } from "url";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1;
 var CURRENT_BUNDLE_FILE = "current.json";
 var BUNDLES_DIRECTORY = "bundles";
 var ARTIFACT_FILE2 = "artifact.json";
 var BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
-var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var errorHasCode3 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var bundleIdFor = (currentReleaseId, releases) => {
   const identity = JSON.stringify({
     currentReleaseId,
     releases: releases.map(({ releaseId }) => releaseId)
   });
-  return `amb_${createHash5("sha256").update(identity).digest("hex")}`;
+  return `amb_${createHash9("sha256").update(identity).digest("hex")}`;
 };
 var parseBundleIndex = (value) => {
-  if (!isRecord5(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
+  if (!isRecord7(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
     throw new TypeError("Invalid materialized mobile compatibility bundle.");
   }
   const releases = value.releases.map(parseAbsoluteMobileCompatibilityArtifact);
@@ -2205,30 +4394,30 @@ var parseBundleIndex = (value) => {
   };
 };
 var writeRelease = async (root, release) => {
-  const directory = join7(root, release.artifact.releaseId);
-  const producerPath = join7(directory, release.artifact.producer.module);
-  await mkdir6(dirname4(producerPath), { recursive: true });
+  const directory = join10(root, release.artifact.releaseId);
+  const producerPath = join10(directory, release.artifact.producer.module);
+  await mkdir10(dirname8(producerPath), { recursive: true });
   await Promise.all([
-    writeFile7(join7(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile11(join10(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
-    writeFile7(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+    writeFile11(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 };
 var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join7(bundlesRoot, bundleId);
+  const destination = join10(bundlesRoot, bundleId);
   try {
-    await access5(destination);
+    await access8(destination);
     return destination;
   } catch (error) {
     if (!errorHasCode3(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp4(join7(bundlesRoot, ".stage-"));
+  const staging = await mkdtemp5(join10(bundlesRoot, ".stage-"));
   try {
     await Promise.all(releases.map((release) => writeRelease(staging, release)));
-    await rename7(staging, destination);
+    await rename10(staging, destination);
   } catch (error) {
-    await rm6(staging, { force: true, recursive: true });
+    await rm8(staging, { force: true, recursive: true });
     if (errorHasCode3(error, "EEXIST") || errorHasCode3(error, "ENOTEMPTY")) {
       return destination;
     }
@@ -2239,7 +4428,7 @@ var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
 var readCompatibilityModule = (modulePath) => import(pathToFileURL(modulePath).href);
 var resolveProducerHandler = (loaded, exportName) => {
   const value = loaded[exportName];
-  if (!isRecord5(value) || typeof value.handle !== "function") {
+  if (!isRecord7(value) || typeof value.handle !== "function") {
     throw new TypeError(`Compatibility producer export ${exportName} must expose handle(request).`);
   }
   const { handle } = value;
@@ -2256,16 +4445,16 @@ var resolveProducerHandler = (loaded, exportName) => {
   };
 };
 var loadAbsoluteMobileMaterializedBundle = async (root) => {
-  const resolvedRoot = resolvePath2(root);
-  const serialized = await readFile8(join7(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+  const resolvedRoot = resolvePath3(root);
+  const serialized = await readFile12(join10(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
   const parsed = JSON.parse(serialized);
   const index = parseBundleIndex(parsed);
-  const bundleRoot = join7(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+  const bundleRoot = join10(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
   return {
     artifacts: index.releases,
     currentReleaseId: index.currentReleaseId,
     loadProducer: async (artifact) => {
-      const modulePath = join7(bundleRoot, artifact.releaseId, artifact.producer.module);
+      const modulePath = join10(bundleRoot, artifact.releaseId, artifact.producer.module);
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer: Bun.file(modulePath)
@@ -2291,9 +4480,9 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     }
     return release;
   });
-  const root = resolvePath2(input.root);
-  const bundlesRoot = join7(root, BUNDLES_DIRECTORY);
-  await mkdir6(bundlesRoot, { recursive: true });
+  const root = resolvePath3(input.root);
+  const bundlesRoot = join10(root, BUNDLES_DIRECTORY);
+  await mkdir10(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
   const index = {
@@ -2302,22 +4491,22 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
     releases: artifacts
   };
-  const pointerPath = join7(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join7(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile7(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+  const pointerPath = join10(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join10(root, `.current-${crypto.randomUUID()}.json`);
+  await writeFile11(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
 `, { flag: "wx" });
-  await rename7(temporaryPointerPath, pointerPath);
+  await rename10(temporaryPointerPath, pointerPath);
   return index;
 };
 var readAbsoluteMobileMaterializedReleases = async (root) => {
-  const resolvedRoot = resolvePath2(root);
+  const resolvedRoot = resolvePath3(root);
   try {
-    const serialized = await readFile8(join7(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const serialized = await readFile12(join10(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
     const parsed = JSON.parse(serialized);
     const index = parseBundleIndex(parsed);
-    const bundleRoot = join7(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    const bundleRoot = join10(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
     return Promise.all(index.releases.map(async (artifact) => {
-      const producer = Bun.file(join7(bundleRoot, artifact.releaseId, artifact.producer.module));
+      const producer = Bun.file(join10(bundleRoot, artifact.releaseId, artifact.producer.module));
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer
@@ -2331,6 +4520,58 @@ var readAbsoluteMobileMaterializedReleases = async (root) => {
   }
 };
 
+// src/mobile/nativeAuth.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join11 } from "path";
+var ABSOLUTE_AUTH_PACKAGE = "@absolutejs/auth";
+var ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV = "ABSOLUTE_AUTH_NATIVE_CLIENTS";
+var ABSOLUTE_NATIVE_AUTH_SCOPES = ["openid", "profile"];
+var ABSOLUTE_SYNC_PACKAGE = "@absolutejs/sync";
+var readPackageManifest = (projectRoot) => {
+  try {
+    return JSON.parse(readFileSync2(join11(projectRoot, "package.json"), "utf8"));
+  } catch {
+    return;
+  }
+};
+var packageManifestHas = (manifest, packageName) => {
+  if (typeof manifest !== "object" || manifest === null)
+    return false;
+  return [
+    Reflect.get(manifest, "dependencies"),
+    Reflect.get(manifest, "devDependencies"),
+    Reflect.get(manifest, "optionalDependencies"),
+    Reflect.get(manifest, "peerDependencies")
+  ].some((dependencies) => typeof dependencies === "object" && dependencies !== null && Object.hasOwn(dependencies, packageName));
+};
+var createAbsoluteMobileAuthManifest = (config) => {
+  const scheme = config.deepLinkScheme ?? config.appId.toLowerCase();
+  return {
+    clientId: `absolutejs-native:${config.appId}`,
+    issuer: config.productionOrigin,
+    redirectUri: `${scheme}://auth/callback`,
+    scopes: [...ABSOLUTE_NATIVE_AUTH_SCOPES]
+  };
+};
+var installAbsoluteMobileAuthEnvironment = (projectRoot, config) => {
+  const auth = resolveAbsoluteMobileAuthManifest(projectRoot, config);
+  const serialized = serializeAbsoluteMobileAuthEnvironment(config, auth);
+  if (serialized === undefined)
+    delete process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV];
+  else
+    process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV] = serialized;
+  return auth;
+};
+var projectUsesAbsoluteAuth = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_AUTH_PACKAGE);
+var projectUsesAbsoluteSync = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_SYNC_PACKAGE);
+var resolveAbsoluteMobileAuthManifest = (projectRoot, config) => projectUsesAbsoluteAuth(projectRoot) ? createAbsoluteMobileAuthManifest(config) : undefined;
+var serializeAbsoluteMobileAuthEnvironment = (config, auth) => auth === undefined ? undefined : JSON.stringify([
+  {
+    ...auth,
+    name: `${config.appName} native app`
+  }
+]);
+
 // 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");
@@ -2341,12 +4582,11 @@ var serverExportName = (loaded, 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 restoreEnvironmentVariable = (name, previous) => {
+  if (previous !== undefined)
+    process.env[name] = previous;
+  else
+    delete process.env[name];
 };
 var requireRelease = (releases, releaseId) => {
   const release = releases.get(releaseId);
@@ -2366,11 +4606,11 @@ var loadServerApp = async (producerPath) => {
   return { app, exportName };
 };
 var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve8(options.buildDirectory);
+  const buildDirectory = resolve10(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join8(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join12(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile9(join8(buildDirectory, "manifest.json"), "utf8"),
+    readFile13(join12(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -2378,12 +4618,20 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     throw new TypeError("Invalid AbsoluteJS build manifest for mobile capture.");
   }
   const previousBuildDirectory = process.env.ABSOLUTE_BUILD_DIR;
+  const previousCompiledRuntime = process.env.ABSOLUTE_COMPILED_RUNTIME;
+  const previousConfigPath = process.env.ABSOLUTE_CONFIG;
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
+  process.env.ABSOLUTE_COMPILED_RUNTIME = "1";
+  if (options.configPath) {
+    process.env.ABSOLUTE_CONFIG = resolve10(options.projectRoot, options.configPath);
+  }
   let loaded;
   try {
-    loaded = await loadServerApp(resolve8(options.producerPath));
+    loaded = await loadServerApp(resolve10(options.producerPath));
   } finally {
-    restoreBuildDirectory(previousBuildDirectory);
+    restoreEnvironmentVariable("ABSOLUTE_BUILD_DIR", previousBuildDirectory);
+    restoreEnvironmentVariable("ABSOLUTE_COMPILED_RUNTIME", previousCompiledRuntime);
+    restoreEnvironmentVariable("ABSOLUTE_CONFIG", previousConfigPath);
   }
   const current = await buildAbsoluteMobileCompatibilityRelease({
     app: loaded.app,
@@ -2392,9 +4640,14 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve8(options.producerPath),
+    producerPath: resolve10(options.producerPath),
     runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
   });
+  const auth = resolveAbsoluteMobileAuthManifest(options.projectRoot, mobile);
+  const sync = auth !== undefined && projectUsesAbsoluteSync(options.projectRoot);
+  if (auth && !loaded.app.routes.some((route) => route.path === "/.well-known/openid-configuration")) {
+    throw new TypeError("@absolutejs/auth is installed, but its OIDC provider is not mounted. Native authentication requires the auth oidc configuration so AbsoluteJS can provision a public PKCE client.");
+  }
   const releasesById = new Map([current, ...previous].map((release) => [
     release.artifact.releaseId,
     release
@@ -2407,8 +4660,10 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   });
   await materializeAbsoluteCapacitorWebBundle({
     artifact: current.artifact,
+    ...auth ? { auth } : {},
     buildDirectory,
-    config: mobile
+    config: mobile,
+    ...sync ? { sync: true } : {}
   });
   return current.artifact;
 };
@@ -2433,6 +4688,64 @@ var ensureProducerStorage = () => {
 var runWithAbsoluteMobileProducer = (context, callback) => ensureProducerStorage().run(context, callback);
 
 // src/mobile/compatibilityDispatcher.ts
+var MOBILE_WEBVIEW_ORIGINS = new Set([
+  "capacitor://localhost",
+  "http://localhost",
+  "https://localhost"
+]);
+var MOBILE_REQUEST_HEADER_NAMES = Object.values(MOBILE_PAGE_REQUEST_HEADERS);
+var MOBILE_CORS_ALLOW_HEADERS = [
+  "accept",
+  "content-type",
+  "authorization",
+  "hx-current-url",
+  "hx-request",
+  "hx-target",
+  "hx-trigger",
+  "hx-trigger-name",
+  ...MOBILE_REQUEST_HEADER_NAMES
+].join(", ");
+var MOBILE_CORS_METHODS = new Set([
+  "DELETE",
+  "GET",
+  "HEAD",
+  "OPTIONS",
+  "PATCH",
+  "POST",
+  "PUT"
+]);
+var mobileWebViewOrigin = (request) => {
+  const origin = request.headers.get("origin");
+  return origin && MOBILE_WEBVIEW_ORIGINS.has(origin) ? origin : undefined;
+};
+var applyMobileCorsHeaders = (response, origin) => {
+  response.headers.set("access-control-allow-credentials", "true");
+  response.headers.set("access-control-allow-origin", origin);
+  response.headers.append("vary", "Origin");
+  return response;
+};
+var mobilePreflightResponse = (request) => {
+  if (request.method !== "OPTIONS")
+    return;
+  const origin = mobileWebViewOrigin(request);
+  if (!origin)
+    return;
+  const requestedHeaders = request.headers.get("access-control-request-headers");
+  const requestedMethod = request.headers.get("access-control-request-method")?.toUpperCase() ?? "";
+  if (!MOBILE_CORS_METHODS.has(requestedMethod))
+    return;
+  return new Response(null, {
+    headers: {
+      "access-control-allow-credentials": "true",
+      "access-control-allow-headers": requestedHeaders || MOBILE_CORS_ALLOW_HEADERS,
+      "access-control-allow-methods": [...MOBILE_CORS_METHODS].join(", "),
+      "access-control-allow-origin": origin,
+      "access-control-max-age": "600",
+      vary: "Origin, Access-Control-Request-Headers"
+    },
+    status: 204
+  });
+};
 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));
@@ -2460,6 +4773,9 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
   return new Elysia2({ name: "absolutejs-mobile-compatibility-dispatcher" }).request(async ({ request }) => {
     if (getCurrentAbsoluteMobileProducerContext())
       return;
+    const preflight = mobilePreflightResponse(request);
+    if (preflight)
+      return preflight;
     const parsed = parseAbsoluteMobilePageRequest(request);
     if (parsed.kind !== "mobile")
       return;
@@ -2483,23 +4799,28 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
       console.error(`[Mobile] Failed to load retained producer ${resolved.artifact.releaseId}:`, error);
       return createAbsoluteMobilePageErrorResponse(parsed.client.pageId);
     }
+  }).afterHandle("global", ({ request, responseValue }) => {
+    const origin = mobileWebViewOrigin(request);
+    if (!origin || !(responseValue instanceof Response))
+      return;
+    applyMobileCorsHeaders(responseValue, origin);
   }).as("global");
 };
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile10, rename as rename8, writeFile as writeFile8 } from "fs/promises";
-import { join as join9 } from "path";
+import { readFile as readFile14, rename as rename11, writeFile as writeFile12 } from "fs/promises";
+import { join as join13 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->";
 var END_MARKER = "<!-- absolutejs:deep-links:end -->";
 var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
 var NOT_FOUND = -1;
 var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var writeChangedFile = async (path, source) => {
-  const current = await readFile10(path, "utf8");
+  const current = await readFile14(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile8(temporary, source, { flag: "wx" });
-  await rename8(temporary, path);
+  await writeFile12(temporary, source, { flag: "wx" });
+  await rename11(temporary, path);
   return true;
 };
 var replaceManagedRegion = (source, region, insertAt) => {
@@ -2544,8 +4865,8 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join9(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile10(path, "utf8");
+  const path = join13(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile14(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
     throw new TypeError("Android MainActivity was not found.");
@@ -2570,8 +4891,8 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join9(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile10(path, "utf8");
+  const path = join13(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile14(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
 `;
@@ -2594,10 +4915,10 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join9(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join13(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
-    current = await readFile10(path, "utf8");
+    current = await readFile14(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -2607,13 +4928,13 @@ var configureIosEntitlements = async (config) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile8(temporary, source, { flag: "wx" });
-  await rename8(temporary, path);
+  await writeFile12(temporary, source, { flag: "wx" });
+  await rename11(temporary, path);
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join9(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const source = await readFile10(path, "utf8");
+  const path = join13(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const source = await readFile14(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
   ].map((match) => match[1]);
@@ -2650,15 +4971,158 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
     changed: results.filter(({ didChange }) => didChange).map(({ platform }) => platform)
   };
 };
+// src/mobile/releasePublisher.ts
+import { access as access9 } from "fs/promises";
+import { isAbsolute as isAbsolute6, relative as relative9, resolve as resolve11, sep as sep6 } 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 isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPublisher = (value) => isRecord8(value) && typeof value.publish === "function";
+var publisherModulePath = (projectRoot, requested) => {
+  const root = resolve11(projectRoot);
+  const path = resolve11(root, requested);
+  const projectRelative = relative9(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute6(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 access9(modulePath).catch(() => {
+    throw new TypeError(`Native release registry module does not exist: ${modulePath}`);
+  });
+  const loaded = await import(pathToFileURL3(modulePath).href);
+  const publisher = isRecord8(loaded) ? loaded.default ?? loaded.registry : undefined;
+  if (!isPublisher(publisher)) {
+    throw new TypeError("Native release registry module must default-export a registry with publish(options).");
+  }
+  return publisher;
+};
+var publishAbsoluteAndroidRelease = async (options) => {
+  const publisher = await loadAbsoluteNativeReleasePublisher(options.projectRoot, options.modulePath);
+  const publication = await publisher.publish({
+    allowUnsigned: options.allowUnsigned,
+    channel: options.channel,
+    googlePlay: options.googlePlay,
+    releaseRoot: options.release.releaseRoot,
+    signal: options.signal
+  });
+  const expected = options.release.metadata;
+  const actual = publication.record?.metadata;
+  if (!actual || actual.appId !== expected.appId || actual.platform !== "android" || actual.releaseId !== expected.releaseId || actual.sha256 !== expected.sha256 || actual.signed !== expected.signed || actual.versionCode !== expected.versionCode || typeof publication.reused !== "boolean") {
+    throw new TypeError("Native release registry returned a different Android release identity.");
+  }
+  if (options.channel !== undefined && (publication.channel?.channel !== options.channel || publication.channel.releaseId !== expected.releaseId)) {
+    throw new TypeError("Native release registry did not promote the requested channel.");
+  }
+  const { googlePlay } = publication;
+  if (options.googlePlay) {
+    if (!expected.versionCode || !googlePlay || googlePlay.receipt.provider !== "google-play" || googlePlay.receipt.packageName !== expected.appId || googlePlay.receipt.releaseId !== expected.releaseId || googlePlay.receipt.sha256 !== expected.sha256 || googlePlay.receipt.stage !== "committed" || googlePlay.receipt.intent.track !== options.googlePlay.track || typeof googlePlay.receipt.versionCode !== "string" || !/^\d+$/.test(googlePlay.receipt.versionCode) || Number(googlePlay.receipt.versionCode) !== expected.versionCode || typeof googlePlay.reused !== "boolean") {
+      throw new TypeError("Native release publisher did not commit the requested Google Play release.");
+    }
+  }
+  return publication;
+};
+var publishAbsoluteIosRelease = async (options) => {
+  const publisher = await loadAbsoluteNativeReleasePublisher(options.projectRoot, options.modulePath);
+  const publication = await publisher.publish({
+    allowUnsigned: options.allowUnsigned,
+    appStoreConnect: options.appStoreConnect,
+    channel: options.channel,
+    releaseRoot: options.release.releaseRoot,
+    signal: options.signal
+  });
+  const expected = options.release.metadata;
+  const actual = publication.record?.metadata;
+  if (!actual || actual.appId !== expected.appId || actual.platform !== "ios" || actual.releaseId !== expected.releaseId || actual.sha256 !== expected.sha256 || actual.signed !== expected.signed || actual.buildNumber !== expected.buildNumber || actual.marketingVersion !== expected.marketingVersion || typeof publication.reused !== "boolean") {
+    throw new TypeError("Native release registry returned a different iOS release identity.");
+  }
+  if (options.channel !== undefined && (publication.channel?.channel !== options.channel || publication.channel.releaseId !== expected.releaseId)) {
+    throw new TypeError("Native release registry did not promote the requested channel.");
+  }
+  if (options.appStoreConnect) {
+    const distributed = publication.appStoreConnect;
+    if (!expected.buildNumber || !distributed || distributed.receipt.provider !== "app-store-connect" || distributed.receipt.releaseId !== expected.releaseId || distributed.receipt.sha256 !== expected.sha256 || distributed.receipt.buildNumber !== expected.buildNumber || distributed.receipt.marketingVersion !== expected.marketingVersion || !["distributed", "review-submitted"].includes(distributed.receipt.stage) || JSON.stringify([...distributed.receipt.intent.groups].sort()) !== JSON.stringify([...options.appStoreConnect.groups ?? []].sort()) || distributed.receipt.intent.submitForReview !== (options.appStoreConnect.submitForReview ?? false) || typeof distributed.reused !== "boolean") {
+      throw new TypeError("Native release publisher did not complete the requested App Store Connect release.");
+    }
+  }
+  return publication;
+};
 // src/mobile/routeMetadataTransform.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname5, extname as extname2, relative as relative5, resolve as resolve9 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname9, extname as extname3, relative as relative10, resolve as resolve12 } from "path";
 import ts from "typescript";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
-var PAGE_HANDLER = "handleReactPageRequest";
+var PAGE_HANDLERS = new Map([
+  [
+    "handleHTMLPageRequest",
+    { framework: "html", inputKind: "static", propsProperty: "props" }
+  ],
+  [
+    "handleHTMXPageRequest",
+    { framework: "htmx", inputKind: "static", propsProperty: "props" }
+  ],
+  [
+    "handleAngularPageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "angular",
+      propsProperty: "requestContext",
+      sourceProperty: "pagePath"
+    }
+  ],
+  [
+    "handleReactPageRequest",
+    {
+      bundleProperty: "index",
+      framework: "react",
+      pageProperty: "Page",
+      propsProperty: "props"
+    }
+  ],
+  [
+    "handleSveltePageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "svelte",
+      propsProperty: "props",
+      sourceProperty: "pagePath"
+    }
+  ],
+  [
+    "handleVuePageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "vue",
+      propsProperty: "props",
+      sourceProperty: "pagePath"
+    }
+  ]
+]);
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname5(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname9(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
@@ -2670,7 +5134,7 @@ var createProgram = (entry, projectRoot) => {
       target: ts.ScriptTarget.ESNext
     });
   }
-  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync2(path, "utf8")).config, ts.sys, dirname5(configPath));
+  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync3(path, "utf8")).config, ts.sys, dirname9(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts.createProgram(parsed.fileNames, parsed.options);
@@ -2776,7 +5240,7 @@ var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   const declaration = symbol?.declarations?.[0];
   const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
   const exportedName = symbol?.name ?? expression.getText(sourceFile);
-  const source = posixPath(relative5(projectRoot, file));
+  const source = posixPath(relative10(projectRoot, file));
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
@@ -2808,13 +5272,108 @@ var assetKey = (expression, checker, seen = new Set) => {
   const [, key] = expression.arguments;
   return key && ts.isStringLiteralLike(key) ? key.text : undefined;
 };
+var staticString = (expression, bindings) => {
+  if (ts.isStringLiteralLike(expression))
+    return expression.text;
+  if (ts.isIdentifier(expression))
+    return bindings.get(expression.text);
+  if (ts.isNoSubstitutionTemplateLiteral(expression))
+    return expression.text;
+  if (!ts.isTemplateExpression(expression))
+    return;
+  let value = expression.head.text;
+  for (const span of expression.templateSpans) {
+    const substitution = staticString(span.expression, bindings);
+    if (substitution === undefined)
+      return;
+    value += substitution + span.literal.text;
+  }
+  return value;
+};
+var assetKeyWithBindings = (expression, checker, bindings = new Map) => {
+  if (!expression)
+    return;
+  if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "asset") {
+    const [, key] = expression.arguments;
+    return key ? staticString(key, bindings) : undefined;
+  }
+  return assetKey(expression, checker);
+};
+var callableObject = (call, checker) => {
+  const symbol = checker.getSymbolAtLocation(call.expression);
+  const resolved = symbol ? resolveAlias(symbol, checker) : undefined;
+  const declaration = resolved?.valueDeclaration ?? resolved?.declarations?.[0];
+  let callable;
+  if (declaration && ts.isFunctionDeclaration(declaration)) {
+    callable = declaration;
+  } else if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) {
+    callable = declaration.initializer;
+  }
+  if (!callable)
+    return;
+  const bindings = new Map;
+  callable.parameters.forEach((parameter, index) => {
+    if (!ts.isIdentifier(parameter.name))
+      return;
+    const argument = call.arguments[index];
+    if (!argument)
+      return;
+    const value = staticString(argument, new Map);
+    if (value !== undefined)
+      bindings.set(parameter.name.text, value);
+  });
+  const { body } = callable;
+  if (!body)
+    return;
+  const expressionBody = ts.isParenthesizedExpression(body) ? body.expression : body;
+  if (ts.isObjectLiteralExpression(expressionBody)) {
+    return { bindings, object: expressionBody };
+  }
+  if (ts.isBlock(body)) {
+    const returned = body.statements.find(ts.isReturnStatement)?.expression;
+    if (returned && ts.isObjectLiteralExpression(returned)) {
+      return { bindings, object: returned };
+    }
+  }
+  return;
+};
+var spreadObject = (expression, checker, bindings) => {
+  if (ts.isObjectLiteralExpression(expression)) {
+    return { bindings, object: expression };
+  }
+  if (!ts.isCallExpression(expression))
+    return;
+  return callableObject(expression, checker);
+};
+var objectAssetKey = (object, name, checker, bindings = new Map) => {
+  for (const property of [...object.properties].reverse()) {
+    if (propertyName(property) === name && ts.isShorthandPropertyAssignment(property)) {
+      return assetKeyWithBindings(property.name, checker, bindings);
+    }
+    if (propertyName(property) === name && ts.isPropertyAssignment(property)) {
+      return assetKeyWithBindings(property.initializer, checker, bindings);
+    }
+    if (!ts.isSpreadAssignment(property))
+      continue;
+    const nestedObject = spreadObject(property.expression, checker, bindings);
+    if (!nestedObject)
+      continue;
+    const nested = objectAssetKey(nestedObject.object, name, checker, nestedObject.bindings);
+    if (nested)
+      return nested;
+  }
+  return;
+};
 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;
+    if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && PAGE_HANDLERS.has(candidate.expression.text)) {
+      const definition = PAGE_HANDLERS.get(candidate.expression.text);
+      if (!definition)
+        return;
+      found = { definition, node: candidate };
       return;
     }
     ts.forEachChild(candidate, visit);
@@ -2833,30 +5392,67 @@ var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
   const [routePath] = node.arguments;
   if (!routePath || !ts.isStringLiteralLike(routePath))
     return;
-  const pageCall = findPageCall(node.arguments.slice(1));
+  const foundPageCall = findPageCall(node.arguments.slice(1));
+  const pageCall = foundPageCall?.node;
+  const definition = foundPageCall?.definition;
   const [input] = pageCall?.arguments ?? [];
-  if (!pageCall || !input || !ts.isObjectLiteralExpression(input)) {
+  if (!pageCall || !input) {
     return;
   }
-  const page = objectPropertyExpression(input, "Page");
-  if (!page)
+  if (!definition)
+    return;
+  if (definition.inputKind === "static") {
+    const bundleKey2 = assetKey(input, checker);
+    if (!bundleKey2)
+      return;
+    const pageId2 = `${definition.framework}:${bundleKey2}`;
+    const propsSchemaHash2 = hashAbsoluteMobilePropsSchema({
+      properties: {},
+      type: "object"
+    });
+    return {
+      inputKind: "static",
+      metadata: {
+        bundleKey: bundleKey2,
+        contract: `${definition.framework}:${pageId2}:${propsSchemaHash2}`,
+        framework: definition.framework,
+        pageId: pageId2,
+        propsSchemaHash: propsSchemaHash2
+      },
+      pageCallStart: pageCall.getStart(sourceFile),
+      routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
+    };
+  }
+  if (!ts.isObjectLiteralExpression(input) || !definition.bundleProperty) {
+    return;
+  }
+  const page = definition.pageProperty ? objectPropertyExpression(input, definition.pageProperty) : undefined;
+  const source = definition.sourceProperty ? objectAssetKey(input, definition.sourceProperty, checker) : undefined;
+  if (definition.pageProperty && !page)
+    return;
+  if (definition.sourceProperty && !source)
     return;
-  const props = objectPropertyExpression(input, "props");
-  const index = objectPropertyExpression(input, "index");
-  const bundleKey = assetKey(index, checker);
+  const props = objectPropertyExpression(input, definition.propsProperty);
+  const bundleKey = objectAssetKey(input, definition.bundleProperty, checker);
   if (!bundleKey)
     return;
-  const pageId = resolvePageIdentity(page, sourceFile, checker, projectRoot);
-  const schema = serializeType(pagePropsType(page, props, checker), checker);
+  const pageId = page ? resolvePageIdentity(page, sourceFile, checker, projectRoot) : `${definition.framework}:${source}`;
+  let propsType;
+  if (page)
+    propsType = pagePropsType(page, props, checker);
+  else if (props)
+    propsType = checker.getTypeAtLocation(props);
+  const schema = propsType ? serializeType(propsType, checker) : { properties: {}, type: "object" };
   const propsSchemaHash = hashAbsoluteMobilePropsSchema(schema);
   const metadata = {
     bundleKey,
-    contract: `react:${pageId}:${propsSchemaHash}`,
-    framework: "react",
+    contract: `${definition.framework}:${pageId}:${propsSchemaHash}`,
+    framework: definition.framework,
     pageId,
     propsSchemaHash
   };
   const result = {
+    inputKind: "object",
     metadata,
     pageCallStart: pageCall.getStart(sourceFile),
     routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
@@ -2883,7 +5479,7 @@ var analyzeProgram = (program, projectRoot) => {
   const checker = program.getTypeChecker();
   const analyzed = new Map;
   for (const sourceFile of program.getSourceFiles()) {
-    const resolvedFile = resolve9(sourceFile.fileName);
+    const resolvedFile = resolve12(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -2913,6 +5509,16 @@ var routeOptions = (existing, metadata) => {
 var transformPageCall = (node, page) => {
   if (!page)
     return;
+  if (page.inputKind === "static") {
+    const [pagePath, existingOptions, ...rest] = node.arguments;
+    if (!pagePath)
+      return;
+    const options = ts.factory.createObjectLiteralExpression([
+      ...existingOptions ? [ts.factory.createSpreadAssignment(existingOptions)] : [],
+      ts.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+    ]);
+    return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [pagePath, options, ...rest]);
+  }
   const [input] = node.arguments;
   if (!input || !ts.isObjectLiteralExpression(input))
     return;
@@ -2966,61 +5572,98 @@ var transformFile = (source, fileName, analysis) => {
 };
 var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
 var createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve9(options.projectRoot ?? process.cwd());
-  const entry = resolve9(options.entry);
+  const projectRoot = resolve12(options.projectRoot ?? process.cwd());
+  const entry = resolve12(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return {
     name: "absolute-mobile-route-metadata",
     setup(build) {
       build.onLoad({ filter: SOURCE_FILTER }, async ({ path }) => {
-        const analysis = analyzed.get(resolve9(path));
+        const analysis = analyzed.get(resolve12(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
         return {
           contents: transformFile(source, path, analysis),
-          loader: extname2(path).endsWith("x") ? "tsx" : "ts"
+          loader: extname3(path).endsWith("x") ? "tsx" : "ts"
         };
       });
     }
   };
 };
 var inspectAbsoluteMobileRouteMetadata = (options) => {
-  const projectRoot = resolve9(options.projectRoot ?? process.cwd());
-  const entry = resolve9(options.entry);
+  const projectRoot = resolve12(options.projectRoot ?? process.cwd());
+  const entry = resolve12(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return [...analyzed.entries()].flatMap(([file, analysis]) => [...analysis.byRouteCall.values()].map(({ metadata }) => ({
-    file: posixPath(relative5(projectRoot, file)),
+    file: posixPath(relative10(projectRoot, file)),
     metadata
   })));
 };
 export {
   writeAbsoluteCapacitorConfig,
+  waitForAbsoluteIosHmrLog,
   verifyAbsoluteMobileCompatibilityProducer,
   verifyAbsoluteMobileAssociationFiles,
+  validateAbsoluteSshDestination,
+  validateAbsoluteRemoteMacProfileName,
+  syncAbsoluteRemoteMacProject,
+  startAbsoluteRemoteIosDevSession,
+  startAbsoluteIosDevSession,
+  serializeAbsoluteMobileAuthEnvironment,
   runWithAbsoluteMobileProducer,
   retainAbsoluteMobileCompatibilityArtifacts,
   resolveAbsoluteMobileRoute,
+  resolveAbsoluteMobileNavigation,
   resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
+  resolveAbsoluteMobileAuthManifest,
+  repairAbsoluteIosDevSession,
+  removeAbsoluteRemoteMacProfile,
+  redactAbsoluteIosLog,
   readAbsoluteMobileMaterializedReleases,
+  publishAbsoluteIosRelease,
+  publishAbsoluteAndroidRelease,
+  projectUsesAbsoluteSync,
+  projectUsesAbsoluteAuth,
+  prepareAbsoluteIosRelease,
+  prepareAbsoluteIosDevProject,
+  prepareAbsoluteAndroidRelease,
+  parseIosSimulators,
+  parseIosRuntimes,
+  parseIosDeviceTypes,
   parseAbsoluteMobilePageRequest,
   parseAbsoluteMobilePageEnvelope,
   parseAbsoluteMobileCompatibilityArtifact,
   parseAbsoluteMobileBuildPageMetadata,
+  parseAbsoluteIosLogLine,
+  parseAbsoluteIosHmrLog,
+  pairAbsoluteRemoteMac,
   normalizeAbsoluteMobileConfig,
   navigateAbsoluteMobilePage,
+  materializeAbsoluteRemoteMacAgent,
   materializeAbsoluteMobileCompatibilityBundle,
   materializeAbsoluteMobileAssociationFiles,
   materializeAbsoluteCapacitorWebBundle,
   matchesAbsoluteMobileRoutePattern,
+  loadAbsoluteNativeReleasePublisher,
   loadAbsoluteMobileMaterializedBundle,
+  listAbsoluteRemoteMacProfiles,
+  isAbsoluteIosNativeRootInput,
+  installAbsoluteRemoteMacAgent,
+  installAbsoluteMobileAuthEnvironment,
+  inspectAbsoluteRemoteMac,
   inspectAbsoluteMobileRouteMetadata,
   hashAbsoluteMobilePropsSchema,
   getCurrentAbsoluteMobileProducerContext,
+  getAbsoluteRemoteMacProfile,
+  fingerprintAbsoluteIosNativeProject,
+  fingerprintAbsoluteIosDevProject,
   finalizeAbsoluteMobilePage,
   finalizeAbsoluteMobileCompatibilityBuild,
   fetchAbsoluteMobilePage,
+  disposeAbsoluteMobilePage,
+  createAbsoluteRemoteIosDevProject,
   createAbsoluteMobileUpgradeResponse,
   createAbsoluteMobileRouteMetadataPlugin,
   createAbsoluteMobilePageRequest,
@@ -3030,19 +5673,29 @@ export {
   createAbsoluteMobileCompatibilityDispatcher,
   createAbsoluteMobileCompatibilityArtifact,
   createAbsoluteMobileBlobArtifactStore,
+  createAbsoluteMobileAuthManifest,
   createAbsoluteMobileAssociationPlugin,
   createAbsoluteMobileAssociationDocuments,
+  createAbsoluteIosNativeWatcher,
   carryForwardAbsoluteMobileCompatibilityReleases,
   captureAbsoluteMobileRouteGraph,
   buildAbsoluteMobileCompatibilityRelease,
+  buildAbsoluteIosRelease,
   buildAbsoluteAndroidRelease,
   applyAbsoluteNativeDeepLinks,
   activateAbsoluteMobilePage,
   acceptsAbsoluteMobilePage,
+  absoluteRemoteProjectSyncCommands,
+  absoluteRemoteMacSshBase,
   MOBILE_PAGE_REQUEST_HEADERS,
   AbsoluteMobilePageProtocolError,
   APPLE_ASSOCIATION_PATH,
   ANDROID_ASSOCIATION_PATH,
+  ABSOLUTE_SYNC_PACKAGE,
+  ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION,
+  ABSOLUTE_REMOTE_MAC_EVENT_PREFIX,
+  ABSOLUTE_NATIVE_AUTH_SCOPES,
+  ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV,
   ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL,
   ABSOLUTE_MOBILE_ROUTE_DETAIL,
   ABSOLUTE_MOBILE_RETAINED_GENERATIONS,
@@ -3051,8 +5704,11 @@ export {
   ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
   ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT,
   ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+  ABSOLUTE_IOS_SIMULATOR_NAME,
+  ABSOLUTE_IOS_RELEASE_FORMAT,
+  ABSOLUTE_AUTH_PACKAGE,
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=EC6A042BA6D550B864756E2164756E21
+//# debugId=712D22B2B8D89AC264756E2164756E21
 //# sourceMappingURL=index.js.map