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

package/dist/mobile/index.js

@@ -617,7 +617,7 @@ var verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes
 // src/mobile/androidRelease.ts
 import { createHash as createHash4 } from "crypto";
 import {
-  access as access3,
+  access as access4,
   copyFile as copyFile2,
   mkdir as mkdir3,
   mkdtemp as mkdtemp2,
@@ -630,6 +630,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 +648,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 +707,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 +724,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,
@@ -714,7 +892,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("\\", "/");
@@ -736,7 +914,7 @@ export default config;
 `;
 var exists = async (path) => {
   try {
-    await access(path);
+    await access2(path);
     return true;
   } catch {
     return false;
@@ -766,9 +944,9 @@ 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;
@@ -795,7 +973,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,
@@ -965,14 +1143,14 @@ 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 ?? [];
@@ -1015,9 +1193,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;
@@ -1072,7 +1250,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),
@@ -1148,7 +1326,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;
@@ -1183,7 +1361,7 @@ var buildAbsoluteAndroidRelease = async (options) => {
 // src/mobile/iosRelease.ts
 import { createHash as createHash5 } from "crypto";
 import {
-  access as access4,
+  access as access5,
   copyFile as copyFile3,
   mkdir as mkdir4,
   mkdtemp as mkdtemp3,
@@ -1207,9 +1385,9 @@ var requireManifest2 = (value) => {
     runtime: value.runtime
   };
 };
-var pathExists3 = async (path) => {
+var pathExists4 = async (path) => {
   try {
-    await access4(path);
+    await access5(path);
     return true;
   } catch {
     return false;
@@ -1290,7 +1468,7 @@ var safeOutputDirectory2 = (projectRoot, requested) => {
 };
 var sha256File2 = async (path) => createHash5("sha256").update(await readFile5(path)).digest("hex");
 var findByExtension = async (root, extension) => {
-  if (!await pathExists3(root))
+  if (!await pathExists4(root))
     return;
   const entries = await readdir3(root, { withFileTypes: true });
   const matches = await Promise.all(entries.map(async (entry) => {
@@ -1322,7 +1500,7 @@ var requireBuildNumber = (value) => {
 var installRelease2 = async (artifactPath, metadata, outputRoot) => {
   const releaseRoot = join5(outputRoot, metadata.releaseId);
   const destination = join5(releaseRoot, "App.ipa");
-  if (await pathExists3(releaseRoot)) {
+  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.`);
@@ -1461,28 +1639,922 @@ var buildAbsoluteIosRelease = async (options) => {
     });
   }
 };
-// src/mobile/associationFiles.ts
+// 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 access5,
+  access as access6,
+  copyFile as copyFile4,
   mkdir as mkdir5,
-  readFile as readFile6,
+  readFile as readFile7,
   rename as rename6,
   rm as rm5,
   writeFile as writeFile6
 } from "fs/promises";
-import { resolve as resolve6 } from "path";
+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/associationFiles.ts
+import {
+  access as access7,
+  mkdir as mkdir6,
+  readFile as readFile8,
+  rename as rename7,
+  rm as rm6,
+  writeFile as writeFile7
+} from "fs/promises";
+import { resolve as resolve7 } from "path";
 import { Elysia } from "elysia";
 
 // src/mobile/config.ts
-import { resolve as resolve5 } 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 = resolve5(projectRoot);
-  const path = resolve5(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.`);
   }
@@ -1670,7 +2742,7 @@ var createAbsoluteMobileAssociationPlugin = (mobile, projectRoot, options = {})
 var writeAtomic = async (path, source) => {
   let current;
   try {
-    current = await readFile6(path, "utf8");
+    current = await readFile8(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -1679,23 +2751,23 @@ var writeAtomic = async (path, source) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile6(temporary, source, { flag: "wx" });
-  await rename6(temporary, path);
+  await writeFile7(temporary, source, { flag: "wx" });
+  await rename7(temporary, path);
   return true;
 };
 var exists2 = async (path) => {
   try {
-    await access5(path);
+    await access7(path);
     return true;
   } catch {
     return false;
   }
 };
 var assertOwnedOutput = async (root) => {
-  const path = resolve6(root, OWNERSHIP_FILE);
+  const path = resolve7(root, OWNERSHIP_FILE);
   let ownership;
   try {
-    ownership = JSON.parse(await readFile6(path, "utf8"));
+    ownership = JSON.parse(await readFile8(path, "utf8"));
   } catch {
     throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
   }
@@ -1709,22 +2781,22 @@ var publishGeneratedDirectory = async (temporary, root) => {
     await assertOwnedOutput(root);
   const backup = `${root}.${crypto.randomUUID()}.previous`;
   if (hasCurrent)
-    await rename6(root, backup);
+    await rename7(root, backup);
   try {
-    await rename6(temporary, root);
+    await rename7(temporary, root);
   } catch (error) {
     if (hasCurrent)
-      await rename6(backup, root);
+      await rename7(backup, root);
     throw error;
   }
   if (hasCurrent)
-    await rm5(backup, { force: true, recursive: true });
+    await rm6(backup, { force: true, recursive: true });
 };
 var materializeHost = async (root, host, files) => {
-  const directory = resolve6(root, host, ".well-known");
-  await mkdir5(directory, { recursive: true });
+  const directory = resolve7(root, host, ".well-known");
+  await mkdir6(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document]) => {
-    const path = resolve6(directory, name);
+    const path = resolve7(directory, name);
     await writeAtomic(path, `${JSON.stringify(document, null, 2)}
 `);
     return path;
@@ -1749,7 +2821,7 @@ var associationEndpoints = (config, documents) => config.deepLinkHosts.flatMap((
   return endpoints;
 });
 var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
-  const root = resolve6(outputDirectory);
+  const root = resolve7(outputDirectory);
   const temporary = `${root}.${crypto.randomUUID()}.tmp`;
   const documents = createAbsoluteMobileAssociationDocuments(config, {
     requireAll: true
@@ -1760,16 +2832,16 @@ var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory)
   if (documents.apple) {
     files.push(["apple-app-site-association", documents.apple]);
   }
-  await mkdir5(temporary, { recursive: true });
+  await mkdir6(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
-    await writeAtomic(resolve6(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+    await writeAtomic(resolve7(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
 `);
     await publishGeneratedDirectory(temporary, root);
-    const written = temporaryPaths.map((path) => resolve6(root, path.slice(temporary.length + 1)));
+    const written = temporaryPaths.map((path) => resolve7(root, path.slice(temporary.length + 1)));
     return { root, written };
   } catch (error) {
-    await rm5(temporary, { force: true, recursive: true });
+    await rm6(temporary, { force: true, recursive: true });
     throw error;
   }
 };
@@ -1814,10 +2886,10 @@ var frameworks2 = new Set([
   "svelte",
   "vue"
 ]);
-var isRecord3 = (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 (!isRecord3(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;
@@ -1831,23 +2903,23 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
   };
 };
 // src/mobile/buildPipeline.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join9, resolve as resolve9 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join10, resolve as resolve10 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
-import { createHash as createHash6 } from "crypto";
-import { readFile as readFile7 } from "fs/promises";
-import { join as join6, relative as relative5, resolve as resolve7 } from "path";
-var sha256 = (bytes) => createHash6("sha256").update(bytes).digest("hex");
+import { createHash as createHash7 } from "crypto";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join7, relative as relative6, resolve as resolve8 } from "path";
+var sha256 = (bytes) => createHash7("sha256").update(bytes).digest("hex");
 var readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]);
 var resolveAssetPath = (buildDirectory, assetPath) => {
-  const resolvedBuildDirectory = resolve7(buildDirectory);
-  const resolvedAsset = resolve7(assetPath);
+  const resolvedBuildDirectory = resolve8(buildDirectory);
+  const resolvedAsset = resolve8(assetPath);
   if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
     return resolvedAsset;
   }
-  return join6(buildDirectory, assetPath.replace(/^\/+/, ""));
+  return join7(buildDirectory, assetPath.replace(/^\/+/, ""));
 };
 var pageFor = async (metadata, manifest, buildDirectory) => {
   const assetPath = manifest[metadata.bundleKey];
@@ -1855,8 +2927,8 @@ var pageFor = async (metadata, manifest, buildDirectory) => {
     throw new TypeError(`Mobile page ${metadata.pageId} references missing manifest asset ${metadata.bundleKey}.`);
   }
   const resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
-  const bytes = await readFile7(resolvedAssetPath);
-  const bundlePath = `/${relative5(resolve7(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const bytes = await readFile9(resolvedAssetPath);
+  const bundlePath = `/${relative6(resolve8(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
@@ -1869,7 +2941,7 @@ var pageFor = async (metadata, manifest, buildDirectory) => {
 var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   const [captured, producerBytes] = await Promise.all([
     captureAbsoluteMobileRouteGraph(options.app),
-    readFile7(options.producerPath)
+    readFile9(options.producerPath)
   ]);
   if (captured.length === 0) {
     throw new TypeError("No instrumented AbsoluteJS mobile page routes were found in the finalized Elysia route graph.");
@@ -1949,16 +3021,16 @@ var captureAbsoluteMobileRouteGraph = async (app) => {
 
 // src/mobile/capacitorBundle.ts
 import {
-  copyFile as copyFile4,
-  mkdir as mkdir6,
+  copyFile as copyFile5,
+  mkdir as mkdir7,
   mkdtemp as mkdtemp4,
-  readFile as readFile8,
-  rename as rename7,
-  rm as rm6,
-  writeFile as writeFile7
+  readFile as readFile10,
+  rename as rename8,
+  rm as rm7,
+  writeFile as writeFile8
 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { basename, dirname as dirname4, extname, join as join7, resolve as resolve8 } from "path";
+import { basename as basename2, dirname as dirname5, extname, join as join8, resolve as resolve9 } from "path";
 
 // src/mobile/routeMatcher.ts
 var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
@@ -2114,14 +3186,14 @@ var envelopeResponse = (response, status) => new Response(JSON.stringify({
   protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
   response
 }), { headers: responseHeaders(), status });
-var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var 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 (!isRecord4(parsed)) {
+  if (!isRecord5(parsed)) {
     throw new TypeError("Mobile page props must serialize to an object.");
   }
   return parsed;
@@ -2246,14 +3318,14 @@ var upgradeReasons = new Set([
   "protocol",
   "runtime"
 ]);
-var isRecord5 = (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 (!isRecord5(value.props)) {
+  if (!isRecord6(value.props)) {
     throw new AbsoluteMobilePageProtocolError("invalid-props", "The mobile page response must contain an object props value.");
   }
   return {
@@ -2299,7 +3371,7 @@ var activateAbsoluteMobilePage = async (value, options) => {
   };
 };
 var parseAbsoluteMobilePageEnvelope = (value) => {
-  if (!isRecord5(value) || !isRecord5(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) {
@@ -2392,7 +3464,7 @@ var INDEX_FILE = "index.html";
 var CLIENT_IMPORT_PATTERN = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s*)["'](\/[^"']+)["']/gu;
 var errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var shellBootstrapModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join7(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
+  const candidate = ["js", "ts"].map((extension) => join8(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
@@ -2413,8 +3485,8 @@ var indexHtml = (appName) => `<!doctype html>
 </html>
 `;
 var sourceAssetPath = (buildDirectory, bundlePath) => {
-  const root = resolve8(buildDirectory);
-  const asset = resolve8(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.");
   }
@@ -2422,8 +3494,8 @@ var sourceAssetPath = (buildDirectory, bundlePath) => {
 };
 var buildShellBootstrap = async (staging) => {
   const modulePath = shellBootstrapModule();
-  const entryPath = join7(staging, ".absolute-mobile-entry.ts");
-  await writeFile7(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+  const entryPath = join8(staging, ".absolute-mobile-entry.ts");
+  await writeFile8(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
 void startAbsoluteMobileShell();
 `);
   const build = await Bun.build({
@@ -2435,31 +3507,31 @@ void startAbsoluteMobileShell();
   if (!build.success || build.outputs.length !== 1) {
     throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
   }
-  await rename7(build.outputs[0]?.path ?? "", join7(staging, BOOTSTRAP_FILE));
-  await rm6(entryPath, { force: true });
+  await rename8(build.outputs[0]?.path ?? "", join8(staging, BOOTSTRAP_FILE));
+  await rm7(entryPath, { force: true });
 };
 var removePreviousBundle = async (backup, moved) => {
   if (!moved)
     return;
-  await rm6(backup, { force: true, recursive: true });
+  await rm7(backup, { force: true, recursive: true });
 };
 var restorePreviousBundle = async (backup, destination, moved) => {
   if (!moved)
     return;
-  await rename7(backup, destination);
+  await rename8(backup, destination);
 };
 var installBundle = async (staging, destination) => {
   const backup = `${destination}.previous-${crypto.randomUUID()}`;
   let movedPrevious = false;
   try {
-    await rename7(destination, backup);
+    await rename8(destination, backup);
     movedPrevious = true;
   } catch (error) {
     if (!errorHasCode2(error, "ENOENT"))
       throw error;
   }
   try {
-    await rename7(staging, destination);
+    await rename8(staging, destination);
     await removePreviousBundle(backup, movedPrevious);
   } catch (error) {
     await restorePreviousBundle(backup, destination, movedPrevious);
@@ -2473,12 +3545,12 @@ var copyClientPage = async (page, buildDirectory, staging, copiedDependencies) =
   const extension = extname(page.bundlePath) || ".js";
   const localBundlePath = `./pages/${page.bundleHash}${extension}`;
   const source = sourceAssetPath(buildDirectory, page.bundlePath);
-  await copyFile4(source, join7(staging, localBundlePath));
+  await copyFile5(source, join8(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
   return { ...page, localBundlePath };
 };
 var absoluteClientImports = async (sourcePath) => {
-  const source = await readFile8(sourcePath, "utf8");
+  const source = await readFile10(sourcePath, "utf8");
   return [...source.matchAll(CLIENT_IMPORT_PATTERN)].flatMap((match) => {
     const [specifier] = match.slice(1);
     return specifier ? [specifier.split(/[?#]/u, 1)[0] ?? specifier] : [];
@@ -2489,9 +3561,9 @@ var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, co
     return;
   copied.add(specifier);
   const source = sourceAssetPath(buildDirectory, specifier);
-  const destination = join7(staging, specifier.replace(/^\/+/, ""));
-  await mkdir6(dirname4(destination), { recursive: true });
-  await copyFile4(source, destination);
+  const destination = join8(staging, specifier.replace(/^\/+/, ""));
+  await mkdir7(dirname5(destination), { recursive: true });
+  await copyFile5(source, destination);
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
 };
 var copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
@@ -2503,11 +3575,11 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
     throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
   }
   const destination = options.config.bundleDirectory;
-  await mkdir6(dirname4(destination), { recursive: true });
-  const staging = await mkdtemp4(join7(dirname4(destination), `.${basename(destination)}.stage-`));
+  await mkdir7(dirname5(destination), { recursive: true });
+  const staging = await mkdtemp4(join8(dirname5(destination), `.${basename2(destination)}.stage-`));
   try {
-    const pageDirectory = join7(staging, "pages");
-    await mkdir6(pageDirectory, { recursive: true });
+    const pageDirectory = join8(staging, "pages");
+    await mkdir7(pageDirectory, { recursive: true });
     const copiedDependencies = new Set;
     const pages = await Promise.all(options.artifact.pages.map((page) => copyClientPage(page, options.buildDirectory, staging, copiedDependencies)));
     const manifest = {
@@ -2524,48 +3596,48 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       runtime: options.artifact.runtime
     };
     await Promise.all([
-      writeFile7(join7(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+      writeFile8(join8(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
-      writeFile7(join7(staging, INDEX_FILE), indexHtml(options.config.appName)),
+      writeFile8(join8(staging, INDEX_FILE), indexHtml(options.config.appName)),
       buildShellBootstrap(staging)
     ]);
     await installBundle(staging, destination);
     return manifest;
   } catch (error) {
-    await rm6(staging, { force: true, recursive: true });
+    await rm7(staging, { force: true, recursive: true });
     throw error;
   }
 };
 
 // src/mobile/materializedBundle.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import {
-  access as access6,
-  mkdir as mkdir7,
+  access as access8,
+  mkdir as mkdir8,
   mkdtemp as mkdtemp5,
-  readFile as readFile9,
-  rename as rename8,
-  rm as rm7,
-  writeFile as writeFile8
+  readFile as readFile11,
+  rename as rename9,
+  rm as rm8,
+  writeFile as writeFile9
 } from "fs/promises";
-import { dirname as dirname5, join as join8, resolve as resolvePath2 } from "path";
+import { dirname as dirname6, join as join9, resolve as resolvePath2 } from "path";
 import { pathToFileURL } from "url";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1;
 var CURRENT_BUNDLE_FILE = "current.json";
 var BUNDLES_DIRECTORY = "bundles";
 var ARTIFACT_FILE2 = "artifact.json";
 var BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
-var isRecord6 = (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_${createHash7("sha256").update(identity).digest("hex")}`;
+  return `amb_${createHash8("sha256").update(identity).digest("hex")}`;
 };
 var parseBundleIndex = (value) => {
-  if (!isRecord6(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
+  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);
@@ -2588,30 +3660,30 @@ var parseBundleIndex = (value) => {
   };
 };
 var writeRelease = async (root, release) => {
-  const directory = join8(root, release.artifact.releaseId);
-  const producerPath = join8(directory, release.artifact.producer.module);
-  await mkdir7(dirname5(producerPath), { recursive: true });
+  const directory = join9(root, release.artifact.releaseId);
+  const producerPath = join9(directory, release.artifact.producer.module);
+  await mkdir8(dirname6(producerPath), { recursive: true });
   await Promise.all([
-    writeFile8(join8(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile9(join9(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
-    writeFile8(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+    writeFile9(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 };
 var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join8(bundlesRoot, bundleId);
+  const destination = join9(bundlesRoot, bundleId);
   try {
-    await access6(destination);
+    await access8(destination);
     return destination;
   } catch (error) {
     if (!errorHasCode3(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp5(join8(bundlesRoot, ".stage-"));
+  const staging = await mkdtemp5(join9(bundlesRoot, ".stage-"));
   try {
     await Promise.all(releases.map((release) => writeRelease(staging, release)));
-    await rename8(staging, destination);
+    await rename9(staging, destination);
   } catch (error) {
-    await rm7(staging, { force: true, recursive: true });
+    await rm8(staging, { force: true, recursive: true });
     if (errorHasCode3(error, "EEXIST") || errorHasCode3(error, "ENOTEMPTY")) {
       return destination;
     }
@@ -2622,7 +3694,7 @@ var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
 var readCompatibilityModule = (modulePath) => import(pathToFileURL(modulePath).href);
 var resolveProducerHandler = (loaded, exportName) => {
   const value = loaded[exportName];
-  if (!isRecord6(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;
@@ -2640,15 +3712,15 @@ var resolveProducerHandler = (loaded, exportName) => {
 };
 var loadAbsoluteMobileMaterializedBundle = async (root) => {
   const resolvedRoot = resolvePath2(root);
-  const serialized = await readFile9(join8(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+  const serialized = await readFile11(join9(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
   const parsed = JSON.parse(serialized);
   const index = parseBundleIndex(parsed);
-  const bundleRoot = join8(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+  const bundleRoot = join9(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
   return {
     artifacts: index.releases,
     currentReleaseId: index.currentReleaseId,
     loadProducer: async (artifact) => {
-      const modulePath = join8(bundleRoot, artifact.releaseId, artifact.producer.module);
+      const modulePath = join9(bundleRoot, artifact.releaseId, artifact.producer.module);
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer: Bun.file(modulePath)
@@ -2675,8 +3747,8 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     return release;
   });
   const root = resolvePath2(input.root);
-  const bundlesRoot = join8(root, BUNDLES_DIRECTORY);
-  await mkdir7(bundlesRoot, { recursive: true });
+  const bundlesRoot = join9(root, BUNDLES_DIRECTORY);
+  await mkdir8(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
   const index = {
@@ -2685,22 +3757,22 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
     releases: artifacts
   };
-  const pointerPath = join8(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join8(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile8(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+  const pointerPath = join9(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join9(root, `.current-${crypto.randomUUID()}.json`);
+  await writeFile9(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
 `, { flag: "wx" });
-  await rename8(temporaryPointerPath, pointerPath);
+  await rename9(temporaryPointerPath, pointerPath);
   return index;
 };
 var readAbsoluteMobileMaterializedReleases = async (root) => {
   const resolvedRoot = resolvePath2(root);
   try {
-    const serialized = await readFile9(join8(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const serialized = await readFile11(join9(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
     const parsed = JSON.parse(serialized);
     const index = parseBundleIndex(parsed);
-    const bundleRoot = join8(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    const bundleRoot = join9(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
     return Promise.all(index.releases.map(async (artifact) => {
-      const producer = Bun.file(join8(bundleRoot, artifact.releaseId, artifact.producer.module));
+      const producer = Bun.file(join9(bundleRoot, artifact.releaseId, artifact.producer.module));
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer
@@ -2749,11 +3821,11 @@ var loadServerApp = async (producerPath) => {
   return { app, exportName };
 };
 var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve9(options.buildDirectory);
+  const buildDirectory = resolve10(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join9(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join10(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile10(join9(buildDirectory, "manifest.json"), "utf8"),
+    readFile12(join10(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -2764,7 +3836,7 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
   let loaded;
   try {
-    loaded = await loadServerApp(resolve9(options.producerPath));
+    loaded = await loadServerApp(resolve10(options.producerPath));
   } finally {
     restoreBuildDirectory(previousBuildDirectory);
   }
@@ -2775,7 +3847,7 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve9(options.producerPath),
+    producerPath: resolve10(options.producerPath),
     runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
   });
   const releasesById = new Map([current, ...previous].map((release) => [
@@ -2869,20 +3941,20 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
   }).as("global");
 };
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile11, rename as rename9, writeFile as writeFile9 } from "fs/promises";
-import { join as join10 } from "path";
+import { readFile as readFile13, rename as rename10, writeFile as writeFile10 } from "fs/promises";
+import { join as join11 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->";
 var END_MARKER = "<!-- absolutejs:deep-links:end -->";
 var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
 var NOT_FOUND = -1;
 var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var writeChangedFile = async (path, source) => {
-  const current = await readFile11(path, "utf8");
+  const current = await readFile13(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile9(temporary, source, { flag: "wx" });
-  await rename9(temporary, path);
+  await writeFile10(temporary, source, { flag: "wx" });
+  await rename10(temporary, path);
   return true;
 };
 var replaceManagedRegion = (source, region, insertAt) => {
@@ -2927,8 +3999,8 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join10(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile11(path, "utf8");
+  const path = join11(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile13(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
     throw new TypeError("Android MainActivity was not found.");
@@ -2953,8 +4025,8 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join10(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile11(path, "utf8");
+  const path = join11(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile13(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
 `;
@@ -2977,10 +4049,10 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join10(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join11(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
-    current = await readFile11(path, "utf8");
+    current = await readFile13(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -2990,13 +4062,13 @@ var configureIosEntitlements = async (config) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile9(temporary, source, { flag: "wx" });
-  await rename9(temporary, path);
+  await writeFile10(temporary, source, { flag: "wx" });
+  await rename10(temporary, path);
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join10(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const source = await readFile11(path, "utf8");
+  const path = join11(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const source = await readFile13(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
   ].map((match) => match[1]);
@@ -3034,8 +4106,8 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
   };
 };
 // src/mobile/releasePublisher.ts
-import { access as access7 } from "fs/promises";
-import { isAbsolute as isAbsolute4, relative as relative6, resolve as resolve10, sep as sep4 } from "path";
+import { access as access9 } from "fs/promises";
+import { isAbsolute as isAbsolute5, relative as relative7, resolve as resolve11, sep as sep5 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -3058,24 +4130,24 @@ var prepareAbsoluteAndroidRelease = async (publisher, options) => {
   }
   return versionCode;
 };
-var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isPublisher = (value) => isRecord7(value) && typeof value.publish === "function";
+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 = resolve10(projectRoot);
-  const path = resolve10(root, requested);
-  const projectRelative = relative6(root, path);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep4}`) || isAbsolute4(projectRelative)) {
+  const root = resolve11(projectRoot);
+  const path = resolve11(root, requested);
+  const projectRelative = relative7(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep5}`) || isAbsolute5(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
   return path;
 };
 var loadAbsoluteNativeReleasePublisher = async (projectRoot, requestedModulePath) => {
   const modulePath = publisherModulePath(projectRoot, requestedModulePath);
-  await access7(modulePath).catch(() => {
+  await access9(modulePath).catch(() => {
     throw new TypeError(`Native release registry module does not exist: ${modulePath}`);
   });
   const loaded = await import(pathToFileURL3(modulePath).href);
-  const publisher = isRecord7(loaded) ? loaded.default ?? loaded.registry : undefined;
+  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).");
   }
@@ -3133,13 +4205,13 @@ var publishAbsoluteIosRelease = async (options) => {
 };
 // src/mobile/routeMetadataTransform.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname6, extname as extname2, relative as relative7, resolve as resolve11 } from "path";
+import { dirname as dirname7, extname as extname2, relative as relative8, 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 posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname6(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname7(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
@@ -3151,7 +4223,7 @@ var createProgram = (entry, projectRoot) => {
       target: ts.ScriptTarget.ESNext
     });
   }
-  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync2(path, "utf8")).config, ts.sys, dirname6(configPath));
+  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync2(path, "utf8")).config, ts.sys, dirname7(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts.createProgram(parsed.fileNames, parsed.options);
@@ -3257,7 +4329,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(relative7(projectRoot, file));
+  const source = posixPath(relative8(projectRoot, file));
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
@@ -3364,7 +4436,7 @@ var analyzeProgram = (program, projectRoot) => {
   const checker = program.getTypeChecker();
   const analyzed = new Map;
   for (const sourceFile of program.getSourceFiles()) {
-    const resolvedFile = resolve11(sourceFile.fileName);
+    const resolvedFile = resolve12(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -3447,14 +4519,14 @@ var transformFile = (source, fileName, analysis) => {
 };
 var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
 var createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve11(options.projectRoot ?? process.cwd());
-  const entry = resolve11(options.entry);
+  const 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(resolve11(path));
+        const analysis = analyzed.get(resolve12(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
@@ -3467,32 +4539,42 @@ var createAbsoluteMobileRouteMetadataPlugin = (options) => {
   };
 };
 var inspectAbsoluteMobileRouteMetadata = (options) => {
-  const projectRoot = resolve11(options.projectRoot ?? process.cwd());
-  const entry = resolve11(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(relative7(projectRoot, file)),
+    file: posixPath(relative8(projectRoot, file)),
     metadata
   })));
 };
 export {
   writeAbsoluteCapacitorConfig,
+  waitForAbsoluteIosHmrLog,
   verifyAbsoluteMobileCompatibilityProducer,
   verifyAbsoluteMobileAssociationFiles,
+  startAbsoluteIosDevSession,
   runWithAbsoluteMobileProducer,
   retainAbsoluteMobileCompatibilityArtifacts,
   resolveAbsoluteMobileRoute,
   resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
+  repairAbsoluteIosDevSession,
+  redactAbsoluteIosLog,
   readAbsoluteMobileMaterializedReleases,
   publishAbsoluteIosRelease,
   publishAbsoluteAndroidRelease,
   prepareAbsoluteIosRelease,
+  prepareAbsoluteIosDevProject,
   prepareAbsoluteAndroidRelease,
+  parseIosSimulators,
+  parseIosRuntimes,
+  parseIosDeviceTypes,
   parseAbsoluteMobilePageRequest,
   parseAbsoluteMobilePageEnvelope,
   parseAbsoluteMobileCompatibilityArtifact,
   parseAbsoluteMobileBuildPageMetadata,
+  parseAbsoluteIosLogLine,
+  parseAbsoluteIosHmrLog,
   normalizeAbsoluteMobileConfig,
   navigateAbsoluteMobilePage,
   materializeAbsoluteMobileCompatibilityBundle,
@@ -3501,10 +4583,12 @@ export {
   matchesAbsoluteMobileRoutePattern,
   loadAbsoluteNativeReleasePublisher,
   loadAbsoluteMobileMaterializedBundle,
+  isAbsoluteIosNativeRootInput,
   inspectAbsoluteMobileRouteMetadata,
   hashAbsoluteMobilePropsSchema,
   getCurrentAbsoluteMobileProducerContext,
   fingerprintAbsoluteIosNativeProject,
+  fingerprintAbsoluteIosDevProject,
   finalizeAbsoluteMobilePage,
   finalizeAbsoluteMobileCompatibilityBuild,
   fetchAbsoluteMobilePage,
@@ -3519,6 +4603,7 @@ export {
   createAbsoluteMobileBlobArtifactStore,
   createAbsoluteMobileAssociationPlugin,
   createAbsoluteMobileAssociationDocuments,
+  createAbsoluteIosNativeWatcher,
   carryForwardAbsoluteMobileCompatibilityReleases,
   captureAbsoluteMobileRouteGraph,
   buildAbsoluteMobileCompatibilityRelease,
@@ -3539,9 +4624,10 @@ export {
   ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
   ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT,
   ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+  ABSOLUTE_IOS_SIMULATOR_NAME,
   ABSOLUTE_IOS_RELEASE_FORMAT,
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=8F6E00755BF98A2E64756E2164756E21
+//# debugId=048422942BB9C32864756E2164756E21
 //# sourceMappingURL=index.js.map