@absolutejs/absolute 0.20.0-beta.45 → 0.20.0-beta.47

package/dist/cli/index.js

@@ -718,7 +718,7 @@ var init_portScan = () => {};
 
 // src/mobile/config.ts
 import { resolve as resolve2 } from "path";
-var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FINGERPRINT_PATTERN, HOSTNAME_PATTERN, resolveProjectPath = (projectRoot, value, field) => {
+var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FINGERPRINT_PATTERN, HOSTNAME_PATTERN, EXPO_RESERVED_ROUTE_PREFIXES, resolveProjectPath = (projectRoot, value, field) => {
   const root = resolve2(projectRoot);
   const path = resolve2(root, value);
   if (path !== root && !path.startsWith(`${root}/`)) {
@@ -791,11 +791,31 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     }
     return value.match(/.{2}/g)?.join(":") ?? value;
   }))
-].sort(), normalizeExpoNativeRoutes = (config, projectRoot) => {
+].sort(), validateExpoNativeRouteSegment = (path, segment, index, count, parameters) => {
+  if (segment === "*" && (index !== count - 1 || count === 1)) {
+    throw new TypeError(`mobile.routes.native route ${path} must use * once, as the final segment after a static or parameterized prefix.`);
+  }
+  if (segment === "*")
+    return;
+  if (!segment.startsWith(":") && (segment.includes("*") || segment.includes(":"))) {
+    throw new TypeError(`mobile.routes.native route ${path} contains invalid segment ${segment}.`);
+  }
+  if (!segment.startsWith(":"))
+    return;
+  const name = segment.slice(1);
+  if (!/^[A-Za-z][A-Za-z0-9_]*$/u.test(name)) {
+    throw new TypeError(`mobile.routes.native route ${path} has invalid parameter ${segment}.`);
+  }
+  if (parameters.has(name)) {
+    throw new TypeError(`mobile.routes.native route ${path} repeats parameter ${segment}.`);
+  }
+  parameters.add(name);
+}, normalizeExpoNativeRoutes = (config, projectRoot) => {
   if (config.engine !== "expo")
     return {};
   const routes = config.routes?.native ?? {};
   const normalized = {};
+  const ownership = new Map;
   for (const [route, module] of Object.entries(routes)) {
     const path = normalizeEntry(route);
     if (path.includes("?") || path.includes("#") || path !== "/" && path.endsWith("/")) {
@@ -804,9 +824,18 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     if (path === "/__absolute/native") {
       throw new TypeError("mobile.routes.native reserves /__absolute/native for the Expo diagnostic screen.");
     }
-    if (path.includes("*") || path.includes(":")) {
-      throw new TypeError(`mobile.routes.native route ${path} must be static during the Expo experiment; parameters and wildcards are not supported yet.`);
+    const segments = path.split("/").filter(Boolean);
+    if (segments[0] && EXPO_RESERVED_ROUTE_PREFIXES.has(segments[0])) {
+      throw new TypeError(`mobile.routes.native route ${path} conflicts with an Expo Router or Metro reserved path.`);
+    }
+    const parameters = new Set;
+    segments.forEach((segment, index) => validateExpoNativeRouteSegment(path, segment, index, segments.length, parameters));
+    const signature = segments.map((segment) => segment.startsWith(":") ? ":" : segment).join("/");
+    const existing = ownership.get(signature);
+    if (existing) {
+      throw new TypeError(`mobile.routes.native routes ${existing} and ${path} claim the same Expo route pattern.`);
     }
+    ownership.set(signature, path);
     normalized[path] = resolveProjectPath(projectRoot, requireText(module, `mobile.routes.native[${path}]`), `mobile.routes.native[${path}]`);
   }
   return Object.fromEntries(Object.entries(normalized).sort(([left], [right]) => left.localeCompare(right)));
@@ -845,6 +874,16 @@ var init_config = __esm(() => {
   APPLE_APP_ID_PREFIX_PATTERN = /^[A-Z0-9]{10}$/;
   CERTIFICATE_FINGERPRINT_PATTERN = /^[0-9A-F]{64}$/;
   HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/;
+  EXPO_RESERVED_ROUTE_PREFIXES = new Set([
+    "_expo",
+    "_flight",
+    "_sitemap",
+    "assets",
+    "expo-dev-plugins",
+    "inspector",
+    "manifest",
+    "public"
+  ]);
 });
 
 // src/mobile/nativeAuth.ts
@@ -1314,6 +1353,279 @@ var init_syncSchema = __esm(() => {
   init_client();
 });
 
+// src/mobile/deviceCapabilities.ts
+import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
+import { extname, join as join7, relative, resolve as resolve4 } from "path";
+import { fileURLToPath } from "url";
+import ts from "typescript";
+var DEVICES_PACKAGE = "@absolutejs/devices", ADAPTERS, SOURCE_GLOB, IGNORED_DIRECTORIES, IDENTIFIER_PATTERN, providerModulePattern = (provider) => new RegExp(`^@absolutejs/devices-${provider}/[a-z][a-z0-9-]*$`, "u"), providerPackagePattern = (provider) => provider === "capacitor" ? /^@capacitor\/[a-z][a-z0-9-]*@\d+\.\d+\.\d+$/u : /^(?:expo-[a-z][a-z0-9-]*|@react-native-[a-z0-9-]+\/[a-z][a-z0-9-]*)@\d+\.\d+\.\d+$/u, providerLabel = (provider) => provider === "capacitor" ? "Capacitor" : "Expo", ANDROID_PERMISSION_PATTERN, IOS_USAGE_DESCRIPTIONS, IOS_PRIVACY_ACCESSED_API_REASONS, IOS_PRIVACY_ACCESSED_APIS, object2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
+  const value = JSON.parse(readFileSync7(path, "utf8"));
+  if (!object2(value))
+    throw new TypeError(`${path} must contain an object.`);
+  return value;
+}, text = (value, field) => {
+  if (typeof value !== "string" || value.length === 0)
+    throw new TypeError(`${field} must be a non-empty string.`);
+  return value;
+}, androidPermissions = (value, field) => {
+  if (value === undefined)
+    return;
+  if (!object2(value))
+    throw new TypeError(`${field} must be an object.`);
+  const { permissions } = value;
+  if (!Array.isArray(permissions) || !permissions.every((permission) => typeof permission === "string" && ANDROID_PERMISSION_PATTERN.test(permission)))
+    throw new TypeError(`${field}.permissions must contain Android permission names.`);
+  return [...permissions];
+}, iosPrivacyAccessedApis = (value, field) => {
+  if (value === undefined)
+    return;
+  if (!object2(value))
+    throw new TypeError(`${field} must be an object.`);
+  const privacy = {};
+  for (const api of IOS_PRIVACY_ACCESSED_APIS) {
+    const reasons = value[api];
+    if (reasons === undefined)
+      continue;
+    const supported = IOS_PRIVACY_ACCESSED_API_REASONS[api];
+    if (!Array.isArray(reasons) || reasons.length === 0 || !reasons.every((reason) => typeof reason === "string" && supported.has(reason)))
+      throw new TypeError(`${field} contains an unsupported API or reason.`);
+    privacy[api] = [...reasons];
+  }
+  if (Object.keys(value).some((api) => !IOS_PRIVACY_ACCESSED_APIS.some((known) => known === api)))
+    throw new TypeError(`${field} contains an unsupported API or reason.`);
+  return privacy;
+}, iosNativeRequirements = (value, field) => {
+  if (value === undefined)
+    return;
+  if (!object2(value))
+    throw new TypeError(`${field} must be an object.`);
+  const {
+    privacyAccessedApis,
+    pushNotifications,
+    systemBars,
+    usageDescriptions
+  } = value;
+  if (pushNotifications !== undefined && pushNotifications !== true)
+    throw new TypeError(`${field}.pushNotifications must be true.`);
+  if (systemBars !== undefined && systemBars !== true)
+    throw new TypeError(`${field}.systemBars must be true.`);
+  if (usageDescriptions !== undefined && (!Array.isArray(usageDescriptions) || !usageDescriptions.every((purpose) => typeof purpose === "string" && IOS_USAGE_DESCRIPTIONS.has(purpose))))
+    throw new TypeError(`${field}.usageDescriptions contains an unsupported purpose.`);
+  const privacy = iosPrivacyAccessedApis(privacyAccessedApis, `${field}.privacyAccessedApis`);
+  return {
+    ...privacy === undefined ? {} : { privacyAccessedApis: privacy },
+    ...pushNotifications === true ? { pushNotifications: true } : {},
+    ...systemBars === true ? { systemBars: true } : {},
+    ...usageDescriptions === undefined ? {} : { usageDescriptions: [...usageDescriptions] }
+  };
+}, parseProvider = (name, value, providerName) => {
+  if (!IDENTIFIER_PATTERN.test(name))
+    throw new TypeError("Device capability names must be identifiers.");
+  if (!object2(value))
+    throw new TypeError(`Device capability ${name} must be an object.`);
+  const factory = text(value.factory, `${name}.factory`);
+  const module = text(value.module, `${name}.module`);
+  if (!IDENTIFIER_PATTERN.test(factory))
+    throw new TypeError(`${name}.factory must be a JavaScript identifier.`);
+  if (!providerModulePattern(providerName).test(module))
+    throw new TypeError(`${name}.module must be an official devices-${providerName} subpath.`);
+  if (!Array.isArray(value.packages) || !value.packages.every((spec) => typeof spec === "string" && providerPackagePattern(providerName).test(spec)))
+    throw new TypeError(`${name}.packages must contain exact official ${providerLabel(providerName)} package versions.`);
+  const { plugins } = value;
+  if (plugins !== undefined && (!Array.isArray(plugins) || !plugins.every((plugin) => typeof plugin === "string" && /^expo-[a-z][a-z0-9-]*$/u.test(plugin))))
+    throw new TypeError(`${name}.plugins must contain Expo config plugin names.`);
+  let native;
+  const { native: nativeMetadata } = value;
+  if (nativeMetadata !== undefined) {
+    if (!object2(nativeMetadata))
+      throw new TypeError(`${name}.native must be an object.`);
+    const { android, ios } = nativeMetadata;
+    const permissions = androidPermissions(android, `${name}.native.android`);
+    const iosRequirements = iosNativeRequirements(ios, `${name}.native.ios`);
+    native = {
+      ...permissions === undefined ? {} : { android: { permissions } },
+      ...iosRequirements === undefined ? {} : { ios: iosRequirements }
+    };
+  }
+  return {
+    factory,
+    module,
+    ...native === undefined ? {} : { native },
+    ...plugins === undefined ? {} : { plugins: [...plugins] },
+    packages: [...value.packages]
+  };
+}, absoluteDeviceNativeRequirements = (plan) => {
+  const privacy = plan.capabilities.reduce((requirements, name) => {
+    for (const api of IOS_PRIVACY_ACCESSED_APIS) {
+      const reasons = plan.providers[name]?.native?.ios?.privacyAccessedApis?.[api] ?? [];
+      if (reasons.length === 0)
+        continue;
+      const current = requirements[api] ?? new Set;
+      for (const reason of reasons)
+        current.add(reason);
+      requirements[api] = current;
+    }
+    return requirements;
+  }, {});
+  return {
+    androidPermissions: [
+      ...new Set(plan.capabilities.flatMap((name) => plan.providers[name]?.native?.android?.permissions ?? []))
+    ].sort(),
+    iosPrivacyAccessedApis: IOS_PRIVACY_ACCESSED_APIS.flatMap((api) => {
+      const reasons = privacy[api];
+      return reasons ? [{ api, reasons: [...reasons].sort() }] : [];
+    }),
+    iosPushNotifications: plan.capabilities.some((name) => plan.providers[name]?.native?.ios?.pushNotifications === true),
+    iosSystemBars: plan.capabilities.some((name) => plan.providers[name]?.native?.ios?.systemBars === true),
+    iosUsageDescriptions: [
+      ...new Set(plan.capabilities.flatMap((name) => plan.providers[name]?.native?.ios?.usageDescriptions ?? []))
+    ].sort()
+  };
+}, loadAbsoluteDeviceCapabilityProviders = (projectRoot, provider = "capacitor") => {
+  const adapter = ADAPTERS[provider];
+  let path = join7(resolve4(projectRoot), "node_modules", adapter, "package.json");
+  try {
+    readFileSync7(path, "utf8");
+  } catch {
+    path = fileURLToPath(import.meta.resolve(`${adapter}/package.json`));
+  }
+  const manifest = readJson(path);
+  const { absolutejs } = manifest;
+  const devices = object2(absolutejs) ? absolutejs.devices : undefined;
+  if (!object2(devices) || devices.format !== 1 || devices.provider !== provider || !object2(devices.capabilities))
+    throw new TypeError(`${adapter} does not publish supported capability metadata.`);
+  const entries = Object.entries(devices.capabilities).map(([name, capability]) => ({
+    name,
+    provider: parseProvider(name, capability, provider)
+  }));
+  return Object.fromEntries(entries.sort((left, right) => left.name.localeCompare(right.name)).map(({ name, provider: capabilityProvider }) => [
+    name,
+    capabilityProvider
+  ]));
+}, isIgnored = (path) => path.split("/").some((segment) => IGNORED_DIRECTORIES.has(segment)), importedCapabilities = (source, file) => {
+  const names = new Set;
+  const namespaces = new Set;
+  const visit = (node) => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && !node.importClause?.isTypeOnly) {
+      const bindings = node.importClause?.namedBindings;
+      if (bindings && ts.isNamedImports(bindings)) {
+        for (const element of bindings.elements)
+          if (!element.isTypeOnly)
+            names.add((element.propertyName ?? element.name).text);
+      }
+      if (bindings && ts.isNamespaceImport(bindings))
+        namespaces.add(bindings.name.text);
+    }
+    if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const element of node.exportClause.elements)
+        if (!element.isTypeOnly)
+          names.add((element.propertyName ?? element.name).text);
+    }
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && namespaces.has(node.expression.text))
+      names.add(node.name.text);
+    ts.forEachChild(node, visit);
+  };
+  const extension = extname(file).toLowerCase();
+  const sources = extension === ".svelte" || extension === ".vue" ? [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/giu)].map((match) => match[1]).filter((value) => value !== undefined) : [source];
+  for (const [index, script] of sources.entries())
+    visit(ts.createSourceFile(`${file}#script-${index}`, script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX));
+  return names;
+}, assertAbsoluteDeviceCapabilityPackages = (projectRoot, plan) => {
+  const missing = missingAbsoluteDeviceCapabilityPackages(plan, directAbsoluteProjectPackages(projectRoot));
+  const mismatched = plan.requiredPackages.filter((spec) => {
+    const separator = spec.lastIndexOf("@");
+    const packageName = spec.slice(0, separator);
+    if (missing.includes(spec))
+      return false;
+    try {
+      return readJson(join7(resolve4(projectRoot), "node_modules", packageName, "package.json")).version !== spec.slice(separator + 1);
+    } catch {
+      return true;
+    }
+  });
+  const unmet = [...missing, ...mismatched];
+  if (unmet.length > 0)
+    throw new TypeError(`Device capabilities ${plan.capabilities.join(", ")} require ${unmet.join(", ")}. Run absolute mobile sync and approve the detected capability plugins.`);
+}, directAbsoluteProjectPackages = (projectRoot) => {
+  const manifest = readJson(join7(resolve4(projectRoot), "package.json"));
+  const packages = new Set;
+  for (const field of ["dependencies", "devDependencies"]) {
+    const dependencies = manifest[field];
+    if (object2(dependencies))
+      for (const name of Object.keys(dependencies))
+        packages.add(name);
+  }
+  return packages;
+}, discoverAbsoluteDeviceCapabilities = (projectRoot, providers = loadAbsoluteDeviceCapabilityProviders(projectRoot)) => {
+  const root = resolve4(projectRoot);
+  if (!existsSync3(root))
+    return [];
+  const known = new Set(Object.keys(providers));
+  const capabilities = new Set;
+  for (const path of SOURCE_GLOB.scanSync({ cwd: root })) {
+    const portable = relative(root, resolve4(root, path)).replaceAll("\\", "/");
+    if (isIgnored(portable))
+      continue;
+    const source = readFileSync7(resolve4(root, portable), "utf8");
+    for (const name of importedCapabilities(source, portable))
+      if (known.has(name))
+        capabilities.add(name);
+  }
+  return [...capabilities].sort();
+}, missingAbsoluteDeviceCapabilityPackages = (plan, directPackages) => plan.requiredPackages.filter((spec) => {
+  const packageName = spec.slice(0, spec.lastIndexOf("@"));
+  return !directPackages.has(packageName);
+}), resolveAbsoluteDeviceCapabilityPlan = (projectRoot, provider = "capacitor") => {
+  const allProviders = loadAbsoluteDeviceCapabilityProviders(projectRoot, provider);
+  const capabilities = discoverAbsoluteDeviceCapabilities(projectRoot, allProviders);
+  const providers = {};
+  for (const name of capabilities) {
+    const capabilityProvider = allProviders[name];
+    if (capabilityProvider)
+      providers[name] = capabilityProvider;
+  }
+  return {
+    capabilities,
+    providers,
+    requiredPackages: [
+      ...new Set(capabilities.flatMap((name) => providers[name]?.packages ?? []))
+    ].sort()
+  };
+};
+var init_deviceCapabilities = __esm(() => {
+  ADAPTERS = {
+    capacitor: "@absolutejs/devices-capacitor",
+    expo: "@absolutejs/devices-expo"
+  };
+  SOURCE_GLOB = new Bun.Glob("**/*.{js,jsx,ts,tsx,svelte,vue}");
+  IGNORED_DIRECTORIES = new Set([
+    ".absolutejs",
+    ".git",
+    ".test-builds",
+    ".test-shards",
+    "build",
+    "dist",
+    "node_modules",
+    "test",
+    "tests"
+  ]);
+  IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/u;
+  ANDROID_PERMISSION_PATTERN = /^android\.permission\.[A-Z][A-Z0-9_]*$/u;
+  IOS_USAGE_DESCRIPTIONS = new Set([
+    "camera",
+    "location-always",
+    "location-when-in-use",
+    "photo-library",
+    "photo-library-add"
+  ]);
+  IOS_PRIVACY_ACCESSED_API_REASONS = {
+    NSPrivacyAccessedAPICategoryFileTimestamp: new Set(["C617.1"])
+  };
+  IOS_PRIVACY_ACCESSED_APIS = [
+    "NSPrivacyAccessedAPICategoryFileTimestamp"
+  ];
+});
+
 // src/mobile/expoProject.ts
 import {
   access,
@@ -1327,7 +1639,7 @@ import {
   writeFile
 } from "fs/promises";
 import { createHash } from "crypto";
-import { basename as basename2, dirname as dirname4, join as join7, relative, resolve as resolve4 } from "path";
+import { basename as basename2, dirname as dirname4, join as join8, relative as relative2, resolve as resolve5, sep } from "path";
 var EXPO_GENERATED_HEADER = `// Generated by AbsoluteJS. Edit absolute.config.ts, then run absolute mobile sync.
 `, EXPO_ASSET_EXTENSION = ".absasset", EXPO_PROJECT_MARKER = ".absolutejs-expo-project", exists = async (path) => {
   try {
@@ -1337,17 +1649,27 @@ var EXPO_GENERATED_HEADER = `// Generated by AbsoluteJS. Edit absolute.config.ts
     return false;
   }
 }, portableRelative = (from, destination) => {
-  const value = relative(from, destination).replaceAll("\\", "/");
+  const value = relative2(from, destination).replaceAll("\\", "/");
   return value.startsWith(".") ? value : `./${value}`;
-}, routeSegments = (route) => route.split("/").filter(Boolean).map((segment) => {
-  if (segment.startsWith(":"))
-    return `[${segment.slice(1)}]`;
-  if (segment === "." || segment === ".." || !/^[A-Za-z0-9._~-]+$/u.test(segment)) {
-    throw new TypeError(`Expo native route ${route} contains an unsupported segment ${segment}.`);
-  }
-  return segment;
-}), routeFile = (project, route) => join7(project, "app", ...routeSegments(route), "index.tsx"), expoPackage = (auth, sync) => ({
+}, routeSegments = (route) => {
+  const segments = route.split("/").filter(Boolean);
+  return segments.map((segment, index) => {
+    if (segment.startsWith(":"))
+      return `[${segment.slice(1)}]`;
+    if (segment === "*" && index === segments.length - 1)
+      return "[...absoluteWildcard]";
+    if (segment === "." || segment === ".." || !/^[A-Za-z0-9._~-]+$/u.test(segment)) {
+      throw new TypeError(`Expo native route ${route} contains an unsupported segment ${segment}.`);
+    }
+    return segment;
+  });
+}, routeFile = (project, route) => join8(project, "app", ...routeSegments(route), "index.tsx"), packageDependencies = (plan) => Object.fromEntries(plan.requiredPackages.map((spec) => {
+  const separator = spec.lastIndexOf("@");
+  return [spec.slice(0, separator), spec.slice(separator + 1)];
+})), expoPackage = (auth, sync, devices) => ({
   dependencies: {
+    "@absolutejs/devices": "0.7.0",
+    "@absolutejs/devices-expo": "0.0.2",
     ...auth ? {
       "@absolutejs/auth": ABSOLUTE_EXPO_AUTH_CORE_VERSION,
       [ABSOLUTE_EXPO_AUTH_PACKAGE]: ABSOLUTE_EXPO_AUTH_VERSION
@@ -1379,7 +1701,8 @@ var EXPO_GENERATED_HEADER = `// Generated by AbsoluteJS. Edit absolute.config.ts
     "react-native": "0.86.3",
     "react-native-safe-area-context": "~5.7.0",
     "react-native-screens": "4.26.0",
-    "react-native-webview": "13.16.1"
+    "react-native-webview": "13.16.1",
+    ...packageDependencies(devices)
   },
   devDependencies: {
     "@types/react": "~19.2.2",
@@ -1394,36 +1717,107 @@ var EXPO_GENERATED_HEADER = `// Generated by AbsoluteJS. Edit absolute.config.ts
     start: "expo start --dev-client"
   },
   version: "0.0.0"
-}), expoAppConfig = (config, auth, sync) => ({
-  expo: {
-    android: {
-      intentFilters: config.deepLinkHosts.map((host2) => ({
-        action: "VIEW",
-        autoVerify: true,
-        category: ["BROWSABLE", "DEFAULT"],
-        data: [{ host: host2, pathPrefix: "/", scheme: "https" }]
-      })),
-      package: config.appId
-    },
-    experiments: { typedRoutes: true },
-    ios: {
-      associatedDomains: config.deepLinkHosts.map((host2) => `applinks:${host2}`),
-      bundleIdentifier: config.appId,
-      ...config.iosVersion ? { buildNumber: config.iosVersion } : {}
-    },
-    name: config.appName,
-    plugins: [
-      "expo-router",
-      ["expo-dev-client", { launchMode: "most-recent" }],
-      ...auth ? ["expo-secure-store"] : [],
-      ...sync ? ["expo-sqlite", "expo-background-task", "expo-task-manager"] : []
-    ],
-    runtimeVersion: { policy: "appVersion" },
-    scheme: config.deepLinkScheme,
-    slug: config.appId.toLowerCase().replaceAll(".", "-"),
-    version: config.iosVersion ?? "0.1.0"
-  }
-}), expoDynamicAppConfig, expoDevelopmentCaPlugin, metroConfig = (projectRoot) => `${EXPO_GENERATED_HEADER}const { getDefaultConfig } = require('expo/metro-config');
+}), expoAppConfig = (config, auth, sync, devices) => {
+  const requirements = absoluteDeviceNativeRequirements(devices);
+  const usageKey = (purpose) => {
+    if (purpose === "camera")
+      return "NSCameraUsageDescription";
+    if (purpose === "photo-library")
+      return "NSPhotoLibraryUsageDescription";
+    if (purpose === "photo-library-add")
+      return "NSPhotoLibraryAddUsageDescription";
+    if (purpose === "location-always")
+      return "NSLocationAlwaysAndWhenInUseUsageDescription";
+    return "NSLocationWhenInUseUsageDescription";
+  };
+  const usageDescription = (purpose) => {
+    if (purpose === "camera")
+      return `${config.appName} uses your camera when you choose to take a photo.`;
+    if (purpose === "photo-library")
+      return `${config.appName} accesses your photo library only for photo actions you choose.`;
+    if (purpose.startsWith("location-"))
+      return `${config.appName} uses your location only while you use the app and request a location-based action.`;
+    return `${config.appName} adds to your photo library only for photo actions you choose.`;
+  };
+  const descriptions = Object.fromEntries(requirements.iosUsageDescriptions.map((purpose) => [
+    usageKey(purpose),
+    usageDescription(purpose)
+  ]));
+  const devicePlugins = [
+    ...new Set(devices.capabilities.flatMap((name) => devices.providers[name]?.plugins ?? []))
+  ];
+  const configuredPlugins = devicePlugins.map((plugin) => {
+    if (plugin === "expo-image-picker")
+      return [
+        plugin,
+        {
+          cameraPermission: descriptions.NSCameraUsageDescription,
+          microphonePermission: false,
+          photosPermission: descriptions.NSPhotoLibraryUsageDescription
+        }
+      ];
+    if (plugin === "expo-location")
+      return [
+        plugin,
+        {
+          locationWhenInUsePermission: descriptions.NSLocationWhenInUseUsageDescription
+        }
+      ];
+    return plugin;
+  });
+  return {
+    expo: {
+      android: {
+        ...devicePlugins.includes("expo-image-picker") ? {
+          blockedPermissions: [
+            "android.permission.READ_EXTERNAL_STORAGE",
+            "android.permission.RECORD_AUDIO",
+            "android.permission.WRITE_EXTERNAL_STORAGE"
+          ]
+        } : {},
+        intentFilters: config.deepLinkHosts.map((host2) => ({
+          action: "VIEW",
+          autoVerify: true,
+          category: ["BROWSABLE", "DEFAULT"],
+          data: [{ host: host2, pathPrefix: "/", scheme: "https" }]
+        })),
+        package: config.appId,
+        permissions: requirements.androidPermissions
+      },
+      experiments: { typedRoutes: true },
+      ios: {
+        associatedDomains: config.deepLinkHosts.map((host2) => `applinks:${host2}`),
+        bundleIdentifier: config.appId,
+        infoPlist: descriptions,
+        ...requirements.iosPrivacyAccessedApis.length > 0 ? {
+          privacyManifests: {
+            NSPrivacyAccessedAPITypes: requirements.iosPrivacyAccessedApis.map(({ api, reasons }) => ({
+              NSPrivacyAccessedAPIType: api,
+              NSPrivacyAccessedAPITypeReasons: reasons
+            }))
+          }
+        } : {},
+        ...config.iosVersion ? { buildNumber: config.iosVersion } : {}
+      },
+      name: config.appName,
+      plugins: [
+        "expo-router",
+        ["expo-dev-client", { launchMode: "most-recent" }],
+        ...auth ? ["expo-secure-store"] : [],
+        ...sync ? [
+          "expo-sqlite",
+          "expo-background-task",
+          "expo-task-manager"
+        ] : [],
+        ...configuredPlugins
+      ],
+      runtimeVersion: { policy: "appVersion" },
+      scheme: config.deepLinkScheme,
+      slug: config.appId.toLowerCase().replaceAll(".", "-"),
+      version: config.iosVersion ?? "0.1.0"
+    }
+  };
+}, expoDynamicAppConfig, expoDevelopmentCaPlugin, metroConfig = (projectRoot) => `${EXPO_GENERATED_HEADER}const { getDefaultConfig } = require('expo/metro-config');
 const path = require('node:path');
 
 const projectRoot = __dirname;
@@ -1438,6 +1832,7 @@ config.watchFolders = [appRoot];
 
 module.exports = config;
 `, layoutSource = (auth, sync) => `${EXPO_GENERATED_HEADER}import { Stack } from 'expo-router';
+import '../src/generated/AbsoluteDevices';
 ${auth ? `import { useEffect, useState } from 'react';
 import { startAbsoluteExpoAuth } from '../src/generated/AbsoluteAuth';` : ""}
 ${sync ? "import { startAbsoluteExpoSync } from '../src/generated/AbsoluteSync';" : ""}
@@ -1452,7 +1847,76 @@ export default function AbsoluteLayout() {
 	if (!ready) return null;` : ""}
 	return <Stack screenOptions={{ headerShown: false }} />;
 }
-`, nativeDiagnosticSource, authRuntimeSource = (auth, appId) => {
+`, nativeDiagnosticSource, devicesRuntimeSource = (config, plan, auth) => {
+  const imports = plan.capabilities.map((name, index) => {
+    const provider = plan.providers[name];
+    if (!provider)
+      throw new TypeError(`Missing Expo device capability provider ${name}.`);
+    return `import { ${provider.factory} as absoluteExpoCapability${index} } from ${JSON.stringify(provider.module)};`;
+  });
+  const pushIndex = plan.capabilities.indexOf("pushNotifications");
+  const push = pushIndex !== -1;
+  if (push && !auth)
+    throw new TypeError("Expo push notifications require the provisioned AbsoluteJS Auth runtime.");
+  const entries = plan.capabilities.map((name, index) => `${JSON.stringify(name)}: absoluteExpoCapability${index}(${name === "pushNotifications" ? "absoluteExpoPushOptions" : ""})`).join(`,
+	`);
+  const pushSource = push ? `const INSTALLATION_KEY = 'absolutejs.push.installation-id';
+const requirePushResponse = async (response: Response, operation: string) => {
+	if (!response.ok) throw new Error(\`AbsoluteJS native push \${operation} failed with HTTP \${response.status}.\`);
+	return response.json() as Promise<Record<string, unknown>>;
+};
+const absoluteExpoPushOptions = {
+	onRegistration: async (registration: { platform: 'apns' | 'fcm'; token: string }) => {
+		const known = await absoluteExpoDevices.storage.get(INSTALLATION_KEY);
+		const register = (installationId?: string | null) => absoluteExpoAuth.fetch('/auth/push', {
+			body: JSON.stringify({ ...(installationId ? { installationId } : {}), platform: registration.platform, token: registration.token }),
+			headers: { 'content-type': 'application/json' },
+			method: 'POST'
+		});
+		let response = await register(known);
+		const conflict = response.status === 409 && await response.clone().json().then(value => typeof value === 'object' && value !== null && Reflect.get(value, 'code') === 'installation-ownership').catch(() => false);
+		if (known && conflict) {
+			await absoluteExpoDevices.storage.remove(INSTALLATION_KEY);
+			response = await register();
+		}
+		const result = await requirePushResponse(response, 'registration');
+		if (typeof result.installationId !== 'string' || !result.installationId || result.installationId.length > 128) throw new Error('AbsoluteJS native push returned an invalid installation identity.');
+		await absoluteExpoDevices.storage.set(INSTALLATION_KEY, result.installationId);
+	},
+	onUnregistration: async () => {
+		const installationId = await absoluteExpoDevices.storage.get(INSTALLATION_KEY);
+		if (!installationId) return;
+		await requirePushResponse(await absoluteExpoAuth.fetch('/auth/push', {
+			body: JSON.stringify({ installationId }),
+			headers: { 'content-type': 'application/json' },
+			method: 'DELETE'
+		}), 'removal');
+		await absoluteExpoDevices.storage.remove(INSTALLATION_KEY);
+	}
+};` : "";
+  return `${EXPO_GENERATED_HEADER}import { installDeviceAdapter } from '@absolutejs/devices/runtime';
+import { createExpoDeviceAdapter } from '@absolutejs/devices-expo';
+${push ? "import { absoluteExpoAuth } from './AbsoluteAuth';" : ""}
+${imports.join(`
+`)}
+
+${pushSource}
+
+export const absoluteExpoDeviceCapabilities = ${JSON.stringify(plan.capabilities)} as const;
+export const absoluteExpoDevices = createExpoDeviceAdapter({
+	storagePrefix: ${JSON.stringify(`absolutejs.${config.appId}.`)},
+	${entries}
+});
+installDeviceAdapter(absoluteExpoDevices);
+export const beforeAbsoluteExpoDeviceSignOut = async () => {
+	${push ? "await absoluteExpoDevices.pushNotifications?.disable();" : ""}
+};
+${push ? `absoluteExpoAuth.onPrincipalChange(principal => {
+	if (!principal) return;
+	void absoluteExpoDevices.pushNotifications?.queryPermission().then(permission => permission.state === 'granted' ? absoluteExpoDevices.pushNotifications?.enable() : undefined).catch(() => undefined);
+});` : ""}
+`;
+}, authRuntimeSource = (auth, appId) => {
   const storageIdentity = createHash("sha256").update(appId).digest("hex").slice(0, 24);
   return `${EXPO_GENERATED_HEADER}import { createAbsoluteExpoAuthClient } from '@absolutejs/auth-expo';
 import { createMobileAuthTransport, installAuthClientRuntimeTransport } from '@absolutejs/auth/client/mobile';
@@ -1585,20 +2049,22 @@ export const createAbsoluteExpoSyncBridge = async (
     "/__absolute/native",
     ...Object.keys(config.expoNativeRoutes)
   ];
-  return `${EXPO_GENERATED_HEADER}import * as Haptics from 'expo-haptics';
-import * as Linking from 'expo-linking';
+  const nativeRoutePatterns = nativeRoutes.map((route) => route.split("/").filter(Boolean));
+  return `${EXPO_GENERATED_HEADER}import * as Linking from 'expo-linking';
 import { router, usePathname } from 'expo-router';
 import { useEffect, useRef, useState } from 'react';
 import { ActivityIndicator, BackHandler, Platform, StyleSheet, View } from 'react-native';
 import { WebView, type WebViewMessageEvent } from 'react-native-webview';
 import { materializeAbsoluteWebBundle } from './webAssets';
+import { createExpoDevicesBridgeHost } from '@absolutejs/devices-expo/bridge';
+import { absoluteExpoDevices, beforeAbsoluteExpoDeviceSignOut } from './AbsoluteDevices';
 ${auth ? "import { absoluteExpoAuth, getAbsoluteExpoAuthPrincipal, startAbsoluteExpoAuth } from './AbsoluteAuth';" : ""}
 ${sync ? "import { createAbsoluteExpoSyncBridge, startAbsoluteExpoSync } from './AbsoluteSync';" : ""}
 
 const BRIDGE_FORMAT = 3;
 const MAX_MESSAGE_BYTES = 64 * 1024;
 const MAX_HTTP_BODY_BYTES = 48 * 1024;
-const NATIVE_ROUTES = new Set(${JSON.stringify(nativeRoutes)});
+const NATIVE_ROUTE_PATTERNS = ${JSON.stringify(nativeRoutePatterns)};
 const PRODUCTION_ORIGIN = ${JSON.stringify(config.productionOrigin)};
 const DEV_ORIGIN = Platform.OS === 'android'
 	? process.env.EXPO_PUBLIC_ABSOLUTE_DEV_ANDROID_ORIGIN
@@ -1607,6 +2073,19 @@ const HMR_TARGET = Platform.OS === 'android' ? 'expo-android' : 'expo-ios';
 const AUTH_ENABLED = ${auth ? "true" : "false"};
 const SYNC_ENABLED = ${sync ? "true" : "false"};
 
+const isNativeRoute = (pathname: string) => {
+	const segments = pathname.split('/').filter(Boolean);
+	return NATIVE_ROUTE_PATTERNS.some(pattern => {
+		for (let index = 0; index < pattern.length; index += 1) {
+			const expected = pattern[index]!;
+			if (expected === '*') return segments.length > index;
+			if (segments[index] === undefined) return false;
+			if (!expected.startsWith(':') && expected !== segments[index]) return false;
+		}
+		return segments.length === pattern.length;
+	});
+};
+
 const bridgeBootstrap = (path: string) => {
 	const initialPath = DEV_ORIGIN
 		? 'location.pathname + location.search + location.hash'
@@ -1647,10 +2126,11 @@ const bridgeBootstrap = (path: string) => {
 			const id = 'web_' + Date.now().toString(36) + '_' + (++sequence).toString(36);
 			send({ format: 3, id, kind: 'request', method, params, path: currentPath });
 			return new Promise((resolve, reject) => {
+				const interactive = method.startsWith('devices.camera.') || method.startsWith('devices.photos.') || method.startsWith('devices.documents.') || method.endsWith('.requestPermission');
 				const timer = setTimeout(() => {
 					pending.delete(id);
 					reject(new Error('Expo bridge request timed out.'));
-				}, 10000);
+				}, interactive ? 5 * 60 * 1000 : 30 * 1000);
 				pending.set(id, { reject, resolve, timer });
 			});
 		},
@@ -1681,7 +2161,7 @@ const bridgeBootstrap = (path: string) => {
 		const anchor = event.target instanceof Element ? event.target.closest('a[href]') : null;
 		if (!anchor) return;
 		const url = new URL(anchor.href, location.href);
-		if (!${JSON.stringify(nativeRoutes)}.includes(url.pathname)) return;
+		if (!isNativeRoute(url.pathname)) return;
 		event.preventDefault();
 		send({ format: 3, kind: 'event', event: 'navigation', path: url.pathname + url.search + url.hash });
 	}, true);
@@ -1689,17 +2169,6 @@ const bridgeBootstrap = (path: string) => {
 })(); true;\`;
 };
 
-const impact = async (params: Record<string, unknown>) => {
-	const style = params.style;
-	if (style === 'selection') return Haptics.selectionAsync();
-	if (style === 'success' || style === 'warning' || style === 'error') {
-		const value = style === 'success' ? Haptics.NotificationFeedbackType.Success : style === 'warning' ? Haptics.NotificationFeedbackType.Warning : Haptics.NotificationFeedbackType.Error;
-		return Haptics.notificationAsync(value);
-	}
-	const value = style === 'light' ? Haptics.ImpactFeedbackStyle.Light : style === 'heavy' ? Haptics.ImpactFeedbackStyle.Heavy : Haptics.ImpactFeedbackStyle.Medium;
-	return Haptics.impactAsync(value);
-};
-
 const bridgeFetch = async (params: Record<string, unknown>) => {
 	if (typeof params.method !== 'string' || !['DELETE', 'GET', 'PATCH', 'POST', 'PUT'].includes(params.method) || typeof params.url !== 'string' || typeof params.headers !== 'object' || params.headers === null || Array.isArray(params.headers) || params.body !== undefined && typeof params.body !== 'string') throw new Error('Expo bridge HTTP request is invalid.');
 	const url = new URL(params.url);
@@ -1731,10 +2200,12 @@ const authStatus = async () => {
 export function AbsoluteWebHost() {
 	const pathname = usePathname() || '/';
 	const webView = useRef<WebView>(null);
+	const devicesBridge = useRef<{ close(): void | Promise<void>; request(method: string, params: Record<string, unknown>): Promise<unknown> } | undefined>(undefined);
 	const syncBridge = useRef<{ close(): void | Promise<void>; request(method: string, params: Record<string, unknown>): Promise<unknown> } | undefined>(undefined);
 	const [indexUri, setIndexUri] = useState<string>();
 	const [canGoBack, setCanGoBack] = useState(false);
 	const [runtimeReady, setRuntimeReady] = useState(!AUTH_ENABLED && !SYNC_ENABLED);
+	const [devicesReady, setDevicesReady] = useState(false);
 	const activeWebPath = useRef(pathname);
 
 	useEffect(() => {
@@ -1784,6 +2255,23 @@ export function AbsoluteWebHost() {
 		if (new TextEncoder().encode(source).byteLength > MAX_MESSAGE_BYTES) throw new Error('Expo bridge response exceeds 64 KiB.');
 		webView.current?.injectJavaScript(\`globalThis.__absoluteExpoReceive(\${JSON.stringify(source)}); true;\`);
 	};
+	useEffect(() => {
+		let active = true;
+		void createExpoDevicesBridgeHost(absoluteExpoDevices, (event, payload) => {
+			if (!active) return;
+			respond({ event, format: BRIDGE_FORMAT, kind: 'event', path: activeWebPath.current, payload });
+		}).then(host => {
+			if (!active) return void host.close();
+			devicesBridge.current = host;
+			setDevicesReady(true);
+		});
+		return () => {
+			active = false;
+			const host = devicesBridge.current;
+			devicesBridge.current = undefined;
+			void host?.close();
+		};
+	}, []);
 	const hasOrigin = (source: string, origin: string) => {
 		try { return new URL(source).origin === origin; } catch { return false; }
 	};
@@ -1796,18 +2284,16 @@ export function AbsoluteWebHost() {
 		if (message.kind === 'event' && (message.event === 'navigation' || message.event === 'ready')) {
 			const target = new URL(message.path, PRODUCTION_ORIGIN);
 			if (target.origin !== PRODUCTION_ORIGIN) return;
-			if (NATIVE_ROUTES.has(target.pathname)) router.push(message.path as never);
+			if (isNativeRoute(target.pathname)) router.push(message.path as never);
 			else activeWebPath.current = message.path;
 			return;
 		}
 		if (message.kind !== 'request' || typeof message.id !== 'string' || message.path !== activeWebPath.current) return;
 		try {
 			if (typeof message.params !== 'object' || message.params === null || Array.isArray(message.params)) throw new Error('Expo bridge method params are invalid.');
-			if (message.method === 'devices.haptics.impact') {
-				const style = (message.params as Record<string, unknown>).style;
-				if (typeof style !== 'string' || !['error', 'heavy', 'light', 'medium', 'selection', 'success', 'vibrate', 'warning'].includes(style)) throw new Error('Expo bridge haptics style is invalid.');
-				await impact(message.params as Record<string, unknown>);
-				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: null });
+			if (typeof message.method === 'string' && message.method.startsWith('devices.')) {
+				if (!devicesBridge.current) throw new Error('Expo devices bridge is unavailable.');
+				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: await devicesBridge.current.request(message.method, message.params as Record<string, unknown>) });
 			} else if (message.method === 'http.fetch') {
 				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: await bridgeFetch(message.params as Record<string, unknown>) });
 			} else if (message.method === 'auth.signIn') {
@@ -1816,7 +2302,8 @@ export function AbsoluteWebHost() {
 				await absoluteExpoAuth.signIn({ authorizationParameters: { login_hint: params.email, ...(params.signup ? { screen_hint: 'signup' } : {}) } });
 				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: await authStatus() });` : "throw new Error('Expo Auth is not configured.');"}
 			} else if (message.method === 'auth.signOut') {
-				${auth ? `await absoluteExpoAuth.signOut();
+				${auth ? `await beforeAbsoluteExpoDeviceSignOut();
+				await absoluteExpoAuth.signOut();
 				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: null });` : "throw new Error('Expo Auth is not configured.');"}
 			} else if (message.method === 'auth.status') {
 				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: await authStatus() });
@@ -1831,7 +2318,7 @@ export function AbsoluteWebHost() {
 		}
 	};
 
-	if (!indexUri || !runtimeReady) return <View style={styles.loading}><ActivityIndicator /></View>;
+	if (!indexUri || !runtimeReady || !devicesReady) return <View style={styles.loading}><ActivityIndicator /></View>;
 	return <WebView
 		allowFileAccess
 		allowFileAccessFromFileURLs
@@ -1903,13 +2390,25 @@ const styles = StyleSheet.create({ loading: { alignItems: 'center', flex: 1, jus
   await writeFile(temporary, source, { flag: "wx" });
   await rename(temporary, path);
   return true;
+}, pruneStaleManagedExpoRoutes = async (project, expected) => {
+  const appDirectory = join8(project, "app");
+  if (!await exists(appDirectory))
+    return 0;
+  const files = await walkFiles(appDirectory);
+  const stale = (await Promise.all(files.map(async (path) => ({
+    managed: path.endsWith(".tsx") && (await readFile(path, "utf8")).startsWith(EXPO_GENERATED_HEADER),
+    path
+  })))).filter(({ managed, path }) => managed && !expected.has(path));
+  await Promise.all(stale.map(({ path }) => rm(path, { force: true })));
+  return stale.length;
 }, jsonSource = (value) => `${JSON.stringify(value, null, "\t")}
 `, emptyWebAssetsSource, writeAbsoluteExpoProject = async (config, options) => {
   if (config.engine !== "expo")
     throw new TypeError("Expo project generation requires mobile.engine: expo.");
-  const projectRoot = resolve4(options.projectRoot);
+  const projectRoot = resolve5(options.projectRoot);
   const project = config.nativeProjectDirectory;
   const auth = resolveAbsoluteMobileAuthManifest(projectRoot, config);
+  const devices = resolveAbsoluteDeviceCapabilityPlan(projectRoot, "expo");
   const syncEnabled = Boolean(auth && projectUsesAbsoluteSync(projectRoot));
   const syncSchema = syncEnabled ? { components: discoverAbsoluteSyncSchema(projectRoot).components } : undefined;
   const routeModules = Object.entries(config.expoNativeRoutes);
@@ -1922,7 +2421,7 @@ const styles = StyleSheet.create({ loading: { alignItems: 'center', flex: 1, jus
   if (missing) {
     throw new TypeError(`Expo native route ${missing.route} references missing module ${missing.module}.`);
   }
-  const marker = join7(project, EXPO_PROJECT_MARKER);
+  const marker = join8(project, EXPO_PROJECT_MARKER);
   if (await exists(project) && !await exists(marker)) {
     const entries = await readdir(project);
     if (entries.length > 0 && !options.force) {
@@ -1935,7 +2434,7 @@ const styles = StyleSheet.create({ loading: { alignItems: 'center', flex: 1, jus
   const authEnabled = Boolean(auth);
   const files = new Map([
     [
-      join7(project, ".gitignore"),
+      join8(project, ".gitignore"),
       `.expo/
 android/
 ios/
@@ -1943,61 +2442,66 @@ node_modules/
 `
     ],
     [
-      join7(project, "app.json"),
-      jsonSource(expoAppConfig(config, authEnabled, syncEnabled))
+      join8(project, "app.json"),
+      jsonSource(expoAppConfig(config, authEnabled, syncEnabled, devices))
     ],
-    [join7(project, "app.config.js"), expoDynamicAppConfig],
+    [join8(project, "app.config.js"), expoDynamicAppConfig],
     [
-      join7(project, "package.json"),
-      jsonSource(expoPackage(authEnabled, syncEnabled))
+      join8(project, "package.json"),
+      jsonSource(expoPackage(authEnabled, syncEnabled, devices))
     ],
-    [join7(project, "metro.config.js"), metroConfig(projectRoot)],
+    [join8(project, "metro.config.js"), metroConfig(projectRoot)],
     [
-      join7(project, "plugins", "withAbsoluteDevelopmentCa.js"),
+      join8(project, "plugins", "withAbsoluteDevelopmentCa.js"),
       expoDevelopmentCaPlugin
     ],
     [
-      join7(project, "tsconfig.json"),
+      join8(project, "tsconfig.json"),
       jsonSource(expoTsConfig(projectRoot, project, authEnabled, syncEnabled))
     ],
     [
-      join7(project, "app", "_layout.tsx"),
+      join8(project, "app", "_layout.tsx"),
       layoutSource(authEnabled, syncEnabled)
     ],
     [
-      join7(project, "app", "__absolute", "native", "index.tsx"),
+      join8(project, "app", "__absolute", "native", "index.tsx"),
       nativeDiagnosticSource
     ],
     [
-      join7(project, "src", "generated", "AbsoluteWebHost.tsx"),
+      join8(project, "src", "generated", "AbsoluteDevices.ts"),
+      devicesRuntimeSource(config, devices, authEnabled)
+    ],
+    [
+      join8(project, "src", "generated", "AbsoluteWebHost.tsx"),
       webHostSource(config, auth, syncEnabled)
     ]
   ]);
   if (auth) {
-    files.set(join7(project, "src", "generated", "AbsoluteAuth.ts"), authRuntimeSource(auth, config.appId));
+    files.set(join8(project, "src", "generated", "AbsoluteAuth.ts"), authRuntimeSource(auth, config.appId));
   }
   if (syncSchema) {
-    files.set(join7(project, "src", "generated", "AbsoluteSync.ts"), syncRuntimeSource(config, syncSchema));
+    files.set(join8(project, "src", "generated", "AbsoluteSync.ts"), syncRuntimeSource(config, syncSchema));
   }
-  const webAssetsPath = join7(project, "src", "generated", "webAssets.ts");
+  const webAssetsPath = join8(project, "src", "generated", "webAssets.ts");
   if (!await exists(webAssetsPath)) {
     files.set(webAssetsPath, emptyWebAssetsSource);
   }
   if (!config.expoNativeRoutes["/"]) {
-    files.set(join7(project, "app", "index.tsx"), webRouteSource);
+    files.set(join8(project, "app", "index.tsx"), webRouteSource);
   }
-  files.set(join7(project, "app", "[...absolute].tsx"), catchAllRouteSource);
+  files.set(join8(project, "app", "[...absolute].tsx"), catchAllRouteSource);
   for (const [route, module] of routeModules) {
-    const wrapper = route === "/" ? join7(project, "app", "index.tsx") : routeFile(project, route);
+    const wrapper = route === "/" ? join8(project, "app", "index.tsx") : routeFile(project, route);
     files.set(wrapper, nativeWrapperSource(wrapper, module));
   }
+  const removed = await pruneStaleManagedExpoRoutes(project, new Set([...files.keys()].filter((path) => path.startsWith(`${join8(project, "app")}${sep}`))));
   const changes = await Promise.all([...files].map(([path, source]) => writeManagedFile(path, source, true)));
-  const changed = changes.filter(Boolean).length;
+  const changed = removed + changes.filter(Boolean).length;
   return { changed, path: project, written: [...files.keys()] };
 }, walkFiles = async (root, directory = root) => {
   const entries = await readdir(directory, { withFileTypes: true });
   const nested = await Promise.all(entries.map((entry) => {
-    const path = join7(directory, entry.name);
+    const path = join8(directory, entry.name);
     if (entry.isDirectory())
       return walkFiles(root, path);
     if (entry.isFile())
@@ -2058,11 +2562,11 @@ export const materializeAbsoluteWebBundle = async () => {
 `, syncAbsoluteExpoWebAssets = async (config) => {
   if (config.engine !== "expo")
     throw new TypeError("Expo asset sync requires mobile.engine: expo.");
-  const marker = join7(config.nativeProjectDirectory, EXPO_PROJECT_MARKER);
+  const marker = join8(config.nativeProjectDirectory, EXPO_PROJECT_MARKER);
   if (!await exists(marker)) {
     throw new TypeError("Expo asset sync requires an AbsoluteJS-managed Expo project. Run mobile init first.");
   }
-  const manifestPath = join7(config.bundleDirectory, "absolute-mobile-manifest.json");
+  const manifestPath = join8(config.bundleDirectory, "absolute-mobile-manifest.json");
   const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
   const appBuild = typeof manifest === "object" && manifest !== null && typeof Reflect.get(manifest, "appBuild") === "string" ? String(Reflect.get(manifest, "appBuild")) : undefined;
   if (!appBuild)
@@ -2071,23 +2575,23 @@ export const materializeAbsoluteWebBundle = async () => {
   const bundleHash = createHash("sha256");
   const filesWithContents = await Promise.all(files.map(async (file) => ({ contents: await readFile(file), file })));
   filesWithContents.forEach(({ contents, file }) => {
-    bundleHash.update(relative(config.bundleDirectory, file).replaceAll("\\", "/"));
+    bundleHash.update(relative2(config.bundleDirectory, file).replaceAll("\\", "/"));
     bundleHash.update("\x00");
     bundleHash.update(contents);
     bundleHash.update("\x00");
   });
   const bundleId = `amexpo_${bundleHash.digest("hex")}`;
-  const destination = join7(config.nativeProjectDirectory, "assets", "absolute");
+  const destination = join8(config.nativeProjectDirectory, "assets", "absolute");
   await mkdir(dirname4(destination), { recursive: true });
-  const staging = await mkdtemp(join7(dirname4(destination), `.${basename2(destination)}.stage-`));
+  const staging = await mkdtemp(join8(dirname4(destination), `.${basename2(destination)}.stage-`));
   let assets;
   try {
     assets = await Promise.all(files.map(async (source, index) => {
       const name = `${String(index).padStart(6, "0")}${EXPO_ASSET_EXTENSION}`;
-      await cp(source, join7(staging, name));
+      await cp(source, join8(staging, name));
       return {
-        asset: portableRelative(join7(config.nativeProjectDirectory, "src", "generated"), join7(destination, name)),
-        path: relative(config.bundleDirectory, source).replaceAll("\\", "/")
+        asset: portableRelative(join8(config.nativeProjectDirectory, "src", "generated"), join8(destination, name)),
+        path: relative2(config.bundleDirectory, source).replaceAll("\\", "/")
       };
     }));
     await installStagedDirectory(staging, destination);
@@ -2095,13 +2599,14 @@ export const materializeAbsoluteWebBundle = async () => {
     await rm(staging, { force: true, recursive: true });
     throw error;
   }
-  const generated = join7(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
+  const generated = join8(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
   await writeManagedFile(generated, assetModuleSource(assets, bundleId), true);
   return { appBuild, assets: assets.length, bundleId, path: destination };
 };
 var init_expoProject = __esm(() => {
   init_nativeAuth();
   init_syncSchema();
+  init_deviceCapabilities();
   expoDynamicAppConfig = `${EXPO_GENERATED_HEADER}const config = require('./app.json');
 
 if (process.env.ABSOLUTE_EXPO_DEVELOPMENT === '1' && process.env.ABSOLUTE_EXPO_DEVELOPMENT_CA_PATH) {
@@ -2207,14 +2712,14 @@ import {
   isIP
 } from "net";
 import { readFile as readFile2 } from "fs/promises";
-var closeServer = (server) => new Promise((resolve5, reject) => {
+var closeServer = (server) => new Promise((resolve6, reject) => {
   server.close((error) => {
     if (error)
       reject(error);
     else
-      resolve5();
+      resolve6();
   });
-}), listen = (server, port) => new Promise((resolve5, reject) => {
+}), listen = (server, port) => new Promise((resolve6, reject) => {
   server.once("error", reject);
   server.listen(port, "0.0.0.0", () => {
     server.off("error", reject);
@@ -2223,11 +2728,11 @@ var closeServer = (server) => new Promise((resolve5, reject) => {
       reject(new Error("Could not determine the iOS device helper port."));
       return;
     }
-    resolve5(address.port);
+    resolve6(address.port);
   });
 }), findEphemeralPort = async () => {
   const probe = createTcpServer();
-  const port = await new Promise((resolve5, reject) => {
+  const port = await new Promise((resolve6, reject) => {
     probe.once("error", reject);
     probe.listen(0, "127.0.0.1", () => {
       const address = probe.address();
@@ -2235,7 +2740,7 @@ var closeServer = (server) => new Promise((resolve5, reject) => {
         reject(new Error("Could not allocate the iOS CA enrollment port."));
         return;
       }
-      resolve5(address.port);
+      resolve6(address.port);
     });
   });
   await closeServer(probe);
@@ -2292,12 +2797,12 @@ var init_iosPhysicalDeviceTransport = () => {};
 // src/cli/utils.ts
 var {$: $2 } = globalThis.Bun;
 import { execSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync8 } from "fs";
 import { createServer as createServer3 } from "net";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 var COMPOSE_PATH = "db/docker-compose.db.yml", DEFAULT_SERVER_ENTRY = "src/backend/server.ts", isWSLEnvironment = () => {
   try {
-    const release = readFileSync7("/proc/version", "utf-8");
+    const release = readFileSync8("/proc/version", "utf-8");
     return /microsoft|wsl/i.test(release);
   } catch {
     return false;
@@ -2396,8 +2901,8 @@ var COMPOSE_PATH = "db/docker-compose.db.yml", DEFAULT_SERVER_ENTRY = "src/backe
 }, printHint = () => {
   console.log("\x1B[90mpress h + enter to show shortcuts\x1B[0m");
 }, readDbScripts = async () => {
-  const pkgPath = resolve5("package.json");
-  if (!existsSync3(pkgPath))
+  const pkgPath = resolve6("package.json");
+  if (!existsSync4(pkgPath))
     return null;
   const pkg = await Bun.file(pkgPath).json();
   const upCommand = pkg.scripts?.["db:up"];
@@ -2431,7 +2936,7 @@ var init_utils = __esm(() => {
 // src/mobile/emulatorDoctor.ts
 import { access as access3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command) => {
   try {
     const result = Bun.spawnSync(command, {
@@ -2476,15 +2981,15 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
   }
 }, absoluteManagedAndroidSdkRoot = (host2, env = process.env) => {
   if (host2 === "windows") {
-    return join9(env.LOCALAPPDATA ?? join9(homedir3(), "AppData", "Local"), "AbsoluteJS", "Android", "Sdk");
+    return join10(env.LOCALAPPDATA ?? join10(homedir3(), "AppData", "Local"), "AbsoluteJS", "Android", "Sdk");
   }
   if (host2 === "wsl") {
     const localAppData = windowsLocalAppDataFromWsl();
     if (localAppData) {
-      return join9(localAppData, "AbsoluteJS", "Android", "Sdk");
+      return join10(localAppData, "AbsoluteJS", "Android", "Sdk");
     }
   }
-  return join9(homedir3(), ".absolutejs", "android-sdk");
+  return join10(homedir3(), ".absolutejs", "android-sdk");
 }, pathExists = async (path) => {
   try {
     await access3(path);
@@ -2537,7 +3042,7 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
   const capture = input.capture ?? captureCommand;
   const androidRoot = input.androidRoot === null ? undefined : input.androidRoot ?? env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host2, env);
   const windowsAndroidTools = host2 === "windows" || host2 === "wsl";
-  const android = (segments) => androidRoot ? join9(androidRoot, ...segments) : undefined;
+  const android = (segments) => androidRoot ? join10(androidRoot, ...segments) : undefined;
   const paths = (values) => values.filter((value) => Boolean(value));
   const adb = await findExecutable("adb", paths([
     android(["platform-tools", windowsAndroidTools ? "adb.exe" : "adb"])
@@ -2644,8 +3149,8 @@ var init_emulatorDoctor = __esm(() => {
 
 // src/mobile/capacitorProject.ts
 import { access as access4, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "fs/promises";
-import { relative as relative2, resolve as resolve6 } from "path";
-var CONFIG_FILE = "capacitor.config.ts", portableRelative2 = (root, path) => relative2(root, path).replaceAll("\\", "/"), capacitorConfigSource = (config, projectRoot) => `import type { CapacitorConfig } from '@capacitor/cli';
+import { relative as relative3, resolve as resolve7 } from "path";
+var CONFIG_FILE = "capacitor.config.ts", portableRelative2 = (root, path) => relative3(root, path).replaceAll("\\", "/"), capacitorConfigSource = (config, projectRoot) => `import type { CapacitorConfig } from '@capacitor/cli';
 
 const config: CapacitorConfig = {
 	appId: ${JSON.stringify(config.appId)},
@@ -2668,8 +3173,8 @@ export default config;
     return false;
   }
 }, writeAbsoluteCapacitorConfig = async (config, options) => {
-  const projectRoot = resolve6(options.projectRoot);
-  const destination = resolve6(projectRoot, CONFIG_FILE);
+  const projectRoot = resolve7(options.projectRoot);
+  const destination = resolve7(projectRoot, CONFIG_FILE);
   const source = capacitorConfigSource(config, projectRoot);
   if (await exists2(destination)) {
     const current = await readFile3(destination, "utf8");
@@ -2704,10 +3209,10 @@ import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 import {
   dirname as dirname5,
   isAbsolute,
-  join as join10,
-  relative as relative3,
-  resolve as resolve7,
-  sep,
+  join as join11,
+  relative as relative4,
+  resolve as resolve8,
+  sep as sep2,
   win32
 } from "path";
 var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_FORMAT = 1, NATIVE_CACHE_FORMAT = 1, HASH_RADIX = 16, EXECUTABLE_MODE_MASK = 73, NATIVE_PUBLIC_PATH_SEGMENTS = 5, CAPACITOR_PROJECT_DIRECTORY_PATTERN, ANDROID_TIMING_PHASES, androidTimingSummary = (timings, physicalDevice = false) => ANDROID_TIMING_PHASES.map(([phase, label]) => {
@@ -2876,21 +3381,21 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     return;
   throw new DOMException("Android development startup was cancelled.", "AbortError");
 }, journalPaths = (projectRoot) => {
-  const root = join10(projectRoot, ".absolutejs", "mobile", "dev-session");
+  const root = join11(projectRoot, ".absolutejs", "mobile", "dev-session");
   return {
-    backup: join10(root, "capacitor.config.backup.json"),
-    caBackup: join10(root, "absolutejs_dev_ca.backup.pem"),
-    journal: join10(root, "journal.json"),
-    manifestBackup: join10(root, "AndroidManifest.backup.xml"),
-    networkConfigBackup: join10(root, "absolutejs_dev_network_security.backup.xml"),
+    backup: join11(root, "capacitor.config.backup.json"),
+    caBackup: join11(root, "absolutejs_dev_ca.backup.pem"),
+    journal: join11(root, "journal.json"),
+    manifestBackup: join11(root, "AndroidManifest.backup.xml"),
+    networkConfigBackup: join11(root, "absolutejs_dev_network_security.backup.xml"),
     root
   };
 }, isInside = (root, path) => {
-  const resolvedRoot = resolve7(root);
-  const resolvedPath = resolve7(path);
-  const relativePath = relative3(resolvedRoot, resolvedPath);
-  return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
-}, isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), nativeCachePath = (projectRoot) => join10(projectRoot, ".absolutejs", "mobile", "cache", "android-debug.json"), parseNativeCache = (value) => {
+  const resolvedRoot = resolve8(root);
+  const resolvedPath = resolve8(path);
+  const relativePath = relative4(resolvedRoot, resolvedPath);
+  return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep2}`) && !isAbsolute(relativePath);
+}, isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), nativeCachePath = (projectRoot) => join11(projectRoot, ".absolutejs", "mobile", "cache", "android-debug.json"), parseNativeCache = (value) => {
   if (!isRecord(value))
     return null;
   const { appId, fingerprint, format, installations } = value;
@@ -2922,27 +3427,27 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     });
   }
 }, nativeDependencySources = async (nativeDirectory) => {
-  const settings = await readFile4(join10(nativeDirectory, "capacitor.settings.gradle"), "utf8");
+  const settings = await readFile4(join11(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: resolve7(nativeDirectory, match[2] ?? "")
+    source: resolve8(nativeDirectory, match[2] ?? "")
   }));
   if (dependencies.length === 0) {
     throw new Error("Capacitor Android settings did not declare any native dependencies.");
   }
   return { dependencies, settings };
 }, shouldIgnoreNativePath = (relativePath, ignorePublicBundle) => {
-  const parts = relativePath.split(sep);
+  const parts = relativePath.split(sep2);
   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";
 }, collectNativePath = async (root, label, path, isDirectory, isFile, isSymbolicLink, ignorePublicBundle) => {
-  const relativePath = relative3(root, path);
+  const relativePath = relative4(root, path);
   if (shouldIgnoreNativePath(relativePath, ignorePublicBundle))
     return [];
-  const identity = `${label}:${relativePath.split(sep).join("/")}\x00`;
+  const identity = `${label}:${relativePath.split(sep2).join("/")}\x00`;
   if (isDirectory) {
     return collectNativeDirectory(root, label, path, ignorePublicBundle);
   }
@@ -2962,7 +3467,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
 }, 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, join10(directory, entry.name), entry.isDirectory(), entry.isFile(), entry.isSymbolicLink(), ignorePublicBundle)));
+  const records = await Promise.all(entries.map((entry) => collectNativePath(root, label, join11(directory, entry.name), entry.isDirectory(), entry.isFile(), entry.isSymbolicLink(), ignorePublicBundle)));
   return records.flat();
 }, hashNativeTree = async (root, label, ignorePublicBundle) => {
   const resolvedRoot = await realpath(root);
@@ -3091,11 +3596,11 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   await mkdir2(paths.root, { recursive: true });
   await writeFile3(paths.backup, source, { flag: "wx" });
   await writeFile3(paths.manifestBackup, manifestSource, { flag: "wx" });
-  const resourceRoot = join10(dirname5(nativeManifestPath), "res");
-  const caPath = join10(resourceRoot, "raw", "absolutejs_dev_ca.pem");
+  const resourceRoot = join11(dirname5(nativeManifestPath), "res");
+  const caPath = join11(resourceRoot, "raw", "absolutejs_dev_ca.pem");
   const existingNetworkConfig = manifestSource.match(/android:networkSecurityConfig=["']@xml\/([a-z0-9_]+)["']/u)?.[1];
   const networkConfigName = existingNetworkConfig ?? "absolutejs_dev_network_security";
-  const networkConfigPath = join10(resourceRoot, "xml", `${networkConfigName}.xml`);
+  const networkConfigPath = join11(resourceRoot, "xml", `${networkConfigName}.xml`);
   const backupProjectedFile = async ([path, backupPath]) => {
     if (!await pathExists2(path))
       return { path };
@@ -3188,12 +3693,12 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   }
   return result.stdout.trim();
 }, mirroredCapacitorDependencies = async (project, capture) => {
-  const settingsPath = join10(project.nativeDirectory, "capacitor.settings.gradle");
+  const settingsPath = join11(project.nativeDirectory, "capacitor.settings.gradle");
   const settings = await readFile4(settingsPath, "utf8");
   const dependencies = [];
   const rewrittenSettings = settings.replace(CAPACITOR_PROJECT_DIRECTORY_PATTERN, (_statement, projectName, sourcePath) => {
     const name = projectName.slice(1).replaceAll(/[^a-zA-Z0-9_.-]/gu, "_");
-    const source = resolve7(project.nativeDirectory, sourcePath);
+    const source = resolve8(project.nativeDirectory, sourcePath);
     dependencies.push({
       name,
       windowsSource: windowsPathFromWsl(source, capture)
@@ -3234,7 +3739,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   ].join("; ");
   return Buffer.from(source, "utf16le").toString("base64");
 }, gradleArtifactPath = (nativeDirectory, task, windows = false) => {
-  const pathJoin = windows ? win32.join : join10;
+  const pathJoin = windows ? win32.join : join11;
   if (task === "assembleDebug") {
     return pathJoin(nativeDirectory, "app", "build", "outputs", "apk", "debug", "app-debug.apk");
   }
@@ -3247,7 +3752,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   if (task !== "assembleRelease" || await pathExists2(primary)) {
     return primary;
   }
-  return join10(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk");
+  return join11(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk");
 }, buildAbsoluteAndroidGradleArtifact = async (options) => {
   const { project, task } = options;
   const capture = options.capture ?? captureCommand2;
@@ -3257,7 +3762,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   if (project.host === "wsl") {
     const windowsSource = windowsPathFromWsl(project.nativeDirectory, capture);
     const buildId = Bun.hash(project.projectRoot).toString(HASH_RADIX);
-    const managedBuildDirectory = resolve7(project.androidRoot, "..", "..", "Builds", `${project.config.appId}-${buildId}`);
+    const managedBuildDirectory = resolve8(project.androidRoot, "..", "..", "Builds", `${project.config.appId}-${buildId}`);
     const windowsDirectory = windowsPathFromWsl(managedBuildDirectory, capture);
     const windowsAndroidRoot = windowsPathFromWsl(project.androidRoot, capture);
     const { dependencies, rewrittenSettings } = await mirroredCapacitorDependencies(project, capture);
@@ -3440,7 +3945,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     "chromium:I"
   ], { env }, onLine);
 }, prepareAbsoluteAndroidDevProject = async (config, options) => {
-  const projectRoot = resolve7(options.projectRoot);
+  const projectRoot = resolve8(options.projectRoot);
   const host2 = detectAbsoluteMobileHost();
   const androidRoot = process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host2);
   const checks = await inspectAbsoluteMobileToolchain({ androidRoot, host: host2 });
@@ -3459,18 +3964,18 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   if (!adb || options.target !== "device" && !emulator) {
     throw new Error("Android SDK tools disappeared after readiness checks.");
   }
-  const cap = join10(projectRoot, "node_modules", ".bin", host2 === "windows" ? "cap.cmd" : "cap");
+  const cap = join11(projectRoot, "node_modules", ".bin", host2 === "windows" ? "cap.cmd" : "cap");
   if (!await pathExists2(cap)) {
     throw new Error("Capacitor CLI is not installed. Run absolute mobile init first.");
   }
   await writeAbsoluteCapacitorConfig(config, { projectRoot });
   await mkdir2(config.bundleDirectory, { recursive: true });
-  const placeholder = join10(config.bundleDirectory, "index.html");
+  const placeholder = join11(config.bundleDirectory, "index.html");
   if (!await pathExists2(placeholder)) {
     await writeFile3(placeholder, `<!doctype html><title>AbsoluteJS mobile development</title>
 `);
   }
-  const nativeDirectory = join10(config.nativeProjectDirectory, "android");
+  const nativeDirectory = join11(config.nativeProjectDirectory, "android");
   if (!await pathExists2(nativeDirectory)) {
     if (!options.createNativeProject) {
       throw new Error("Android native project has not been created.");
@@ -3531,8 +4036,8 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   await requireSuccess([project.cap, "sync", "android"], "Capacitor Android synchronization", run, { cwd: project.projectRoot, env, signal: options.signal });
   throwIfAborted(options.signal);
   transition("configuring");
-  const nativeConfigPath = join10(project.nativeDirectory, "app", "src", "main", "assets", "capacitor.config.json");
-  const nativeManifestPath = join10(project.nativeDirectory, "app", "src", "main", "AndroidManifest.xml");
+  const nativeConfigPath = join11(project.nativeDirectory, "app", "src", "main", "assets", "capacitor.config.json");
+  const nativeManifestPath = join11(project.nativeDirectory, "app", "src", "main", "AndroidManifest.xml");
   let connectedSerial;
   let nativeLogs = null;
   const closeNativeLogs = async () => {
@@ -3691,7 +4196,7 @@ var init_androidEmulatorController = __esm(() => {
 import { createHash as createHash3 } from "crypto";
 import { cp as cp2, mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile5, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename3, join as join11 } from "path";
+import { basename as basename3, join as join12 } from "path";
 var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION = "15859902", LICENSE_ACCEPTANCE_RESPONSES = 100, COMMAND_LINE_TOOLS, defaultRun = async (command, options = {}) => {
   const subprocess = Bun.spawn(command, {
     env: options.env,
@@ -3723,7 +4228,7 @@ var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION
     exitCode: result.exitCode,
     stdout: result.stdout.toString()
   };
-}, commandPath = (root, host2, tool) => join11(root, "cmdline-tools", "latest", "bin", host2 === "windows" || host2 === "wsl" ? `${tool}.bat` : tool), executablePath = (root, host2, directory, tool) => join11(root, directory, host2 === "windows" || host2 === "wsl" ? `${tool}.exe` : tool), windowsPath = (path) => {
+}, commandPath = (root, host2, tool) => join12(root, "cmdline-tools", "latest", "bin", host2 === "windows" || host2 === "wsl" ? `${tool}.bat` : tool), executablePath = (root, host2, directory, tool) => join12(root, directory, host2 === "windows" || host2 === "wsl" ? `${tool}.exe` : tool), windowsPath = (path) => {
   const match = /^\/mnt\/([a-z])\/(.*)$/i.exec(path);
   if (!match)
     return path;
@@ -3797,10 +4302,10 @@ var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION
   if (digest !== release.sha256) {
     throw new Error(`Android command-line-tools checksum mismatch: expected ${release.sha256}, received ${digest}.`);
   }
-  const temporary = await mkdtemp2(join11(tmpdir(), "absolutejs-android-sdk-"));
+  const temporary = await mkdtemp2(join12(tmpdir(), "absolutejs-android-sdk-"));
   try {
-    const archive = join11(temporary, "command-line-tools.zip");
-    const extracted = join11(temporary, "extracted");
+    const archive = join12(temporary, "command-line-tools.zip");
+    const extracted = join12(temporary, "extracted");
     await Bun.write(archive, bytes);
     await mkdir3(extracted, { recursive: true });
     const extraction = plan.host === "windows" ? [
@@ -3817,12 +4322,12 @@ var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION
     if (await input.run(extraction) !== 0) {
       throw new Error("Failed to extract Android command-line tools.");
     }
-    const destination = join11(plan.androidRoot, "cmdline-tools", "latest");
-    await mkdir3(join11(plan.androidRoot, "cmdline-tools"), {
+    const destination = join12(plan.androidRoot, "cmdline-tools", "latest");
+    await mkdir3(join12(plan.androidRoot, "cmdline-tools"), {
       recursive: true
     });
     await rm3(destination, { force: true, recursive: true });
-    await cp2(join11(extracted, "cmdline-tools"), destination, {
+    await cp2(join12(extracted, "cmdline-tools"), destination, {
       recursive: true
     });
   } finally {
@@ -4007,7 +4512,7 @@ import {
   stat,
   writeFile as writeFile4
 } from "fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute2, join as join12, relative as relative4, resolve as resolve8, sep as sep2 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join13, relative as relative5, resolve as resolve9, sep as sep3 } from "path";
 var developmentTeamArgument = (value) => {
   if (value === undefined)
     return;
@@ -4064,8 +4569,8 @@ var developmentTeamArgument = (value) => {
 }, ignoredFingerprintDirectories, fingerprintFiles = async (root, current = root, options = {}) => {
   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 = join12(current, entry.name);
-    const projectRelative = relative4(root, path).replaceAll("\\", "/");
+    const path = join13(current, entry.name);
+    const projectRelative = relative5(root, path).replaceAll("\\", "/");
     const ignored = entry.isDirectory() && (ignoredFingerprintDirectories.has(entry.name) || projectRelative === "App/App/public" && options.includePublicBundle !== true);
     if (ignored)
       return [];
@@ -4079,17 +4584,17 @@ var developmentTeamArgument = (value) => {
   const files = await fingerprintFiles(nativeDirectory, nativeDirectory, options);
   const contents = await Promise.all(files.map((file) => readFile6(file)));
   files.forEach((file, index) => {
-    hasher.update(relative4(nativeDirectory, file).replaceAll("\\", "/"));
+    hasher.update(relative5(nativeDirectory, file).replaceAll("\\", "/"));
     hasher.update("\x00");
     hasher.update(contents[index] ?? new Uint8Array);
     hasher.update("\x00");
   });
   return hasher.digest("hex");
 }, safeOutputDirectory = (projectRoot, requested) => {
-  const root = resolve8(projectRoot);
-  const output = resolve8(root, requested ?? ".absolutejs/mobile/releases/ios");
-  const projectRelative = relative4(root, output);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep2}`) || isAbsolute2(projectRelative)) {
+  const root = resolve9(projectRoot);
+  const output = resolve9(root, requested ?? ".absolutejs/mobile/releases/ios");
+  const projectRelative = relative5(root, output);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep3}`) || isAbsolute2(projectRelative)) {
     throw new TypeError("mobile build --outdir must remain inside the project.");
   }
   return output;
@@ -4098,7 +4603,7 @@ var developmentTeamArgument = (value) => {
     return;
   const entries = await readdir3(root, { withFileTypes: true });
   const matches = await Promise.all(entries.map(async (entry) => {
-    const path = join12(root, entry.name);
+    const path = join13(root, entry.name);
     if (entry.isDirectory() && entry.name.endsWith(extension))
       return path;
     if (entry.isFile() && entry.name.endsWith(extension))
@@ -4121,10 +4626,10 @@ var developmentTeamArgument = (value) => {
     throw new TypeError("iOS build number must be a positive integer.");
   return value;
 }, installRelease = async (artifactPath, metadata, outputRoot) => {
-  const releaseRoot = join12(outputRoot, metadata.releaseId);
-  const destination = join12(releaseRoot, "App.ipa");
+  const releaseRoot = join13(outputRoot, metadata.releaseId);
+  const destination = join13(releaseRoot, "App.ipa");
   if (await pathExists3(releaseRoot)) {
-    const value = JSON.parse(await readFile6(join12(releaseRoot, "release.json"), "utf8"));
+    const value = JSON.parse(await readFile6(join13(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.`);
     }
@@ -4144,14 +4649,14 @@ var developmentTeamArgument = (value) => {
     };
   }
   await mkdir4(dirname6(releaseRoot), { recursive: true });
-  const staging = await mkdtemp3(join12(dirname6(releaseRoot), ".ios-stage-"));
+  const staging = await mkdtemp3(join13(dirname6(releaseRoot), ".ios-stage-"));
   try {
-    await copyFile2(artifactPath, join12(staging, "App.ipa"));
+    await copyFile2(artifactPath, join13(staging, "App.ipa"));
     const complete = {
       ...metadata,
       artifact: "App.ipa"
     };
-    await writeFile4(join12(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+    await writeFile4(join13(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
 `, { flag: "wx" });
     await rename4(staging, releaseRoot);
     return { artifactPath: destination, metadata: complete, releaseRoot };
@@ -4168,22 +4673,22 @@ var developmentTeamArgument = (value) => {
   const marketingVersion = options.config.iosVersion;
   if (!marketingVersion)
     throw new TypeError("iOS release builds require mobile.ios.version in absolutejs.config.ts.");
-  const manifest = requireManifest(JSON.parse(await readFile6(join12(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  const manifest = requireManifest(JSON.parse(await readFile6(join13(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 = join12(options.config.nativeProjectDirectory, "ios");
+  const nativeDirectory = join13(options.config.nativeProjectDirectory, "ios");
   let buildNumber = requireBuildNumber(options.buildNumber);
   if (options.prepareBuildNumber) {
     const nativeFingerprint = await fingerprintAbsoluteIosNativeProject(nativeDirectory);
     const buildIdentity = createHash4("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}\x00${marketingVersion}`).digest("hex");
     buildNumber = requireBuildNumber(await options.prepareBuildNumber(buildIdentity));
   }
-  const stagingParent = resolve8(options.projectRoot, ".absolutejs/mobile");
+  const stagingParent = resolve9(options.projectRoot, ".absolutejs/mobile");
   await mkdir4(stagingParent, { recursive: true });
-  const staging = await mkdtemp3(join12(stagingParent, ".ios-build-"));
-  const archivePath = join12(staging, "App.xcarchive");
-  const exportPath = join12(staging, "export");
-  const exportPlist = join12(staging, "ExportOptions.plist");
+  const staging = await mkdtemp3(join13(stagingParent, ".ios-build-"));
+  const archivePath = join13(staging, "App.xcarchive");
+  const exportPath = join13(staging, "export");
+  const exportPlist = join13(staging, "ExportOptions.plist");
   await mkdir4(exportPath, { recursive: true });
   await writeFile4(exportPlist, exportOptions());
   const run = options.run ?? defaultRun2;
@@ -4197,7 +4702,7 @@ var developmentTeamArgument = (value) => {
     const archiveExit = await run([
       "xcodebuild",
       "-workspace",
-      join12(nativeDirectory, "App", "App.xcworkspace"),
+      join13(nativeDirectory, "App", "App.xcworkspace"),
       "-scheme",
       "App",
       "-configuration",
@@ -4211,7 +4716,7 @@ var developmentTeamArgument = (value) => {
     ], { cwd: nativeDirectory });
     if (archiveExit !== 0)
       throw new TypeError("Xcode failed to archive the iOS app.");
-    const archivedApp = await findByExtension(join12(archivePath, "Products", "Applications"), ".app");
+    const archivedApp = await findByExtension(join13(archivePath, "Products", "Applications"), ".app");
     const capture = options.capture ?? defaultCapture2;
     const signed = archivedApp ? capture([
       "codesign",
@@ -4285,7 +4790,7 @@ import {
   writeFile as writeFile5
 } from "fs/promises";
 import { isIP as isIP2 } from "net";
-import { dirname as dirname7, isAbsolute as isAbsolute3, join as join13, relative as relative5, resolve as resolve9, sep as sep3 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute3, join as join14, relative as relative6, resolve as resolve10, sep as sep4 } from "path";
 var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000, BOOT_POLL_MS = 1000, DEV_JOURNAL_FORMAT2 = 1, NATIVE_CACHE_FORMAT2 = 1, isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), pathExists4 = async (path) => {
   try {
     await access7(path);
@@ -4503,16 +5008,16 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
   const leftPro = left.name.includes("Pro") ? 1 : 0;
   return rightPro - leftPro;
 })[0], journalPaths2 = (projectRoot) => {
-  const root = join13(projectRoot, ".absolutejs", "mobile", "ios-dev-session");
+  const root = join14(projectRoot, ".absolutejs", "mobile", "ios-dev-session");
   return {
-    configBackup: join13(root, "capacitor-config.backup"),
-    infoBackup: join13(root, "Info.plist.backup"),
-    journal: join13(root, "journal.json"),
+    configBackup: join14(root, "capacitor-config.backup"),
+    infoBackup: join14(root, "Info.plist.backup"),
+    journal: join14(root, "journal.json"),
     root
   };
-}, nativeCachePath2 = (projectRoot) => join13(projectRoot, ".absolutejs", "mobile", "ios-native-cache.json"), isInside2 = (root, path) => {
-  const value = relative5(resolve9(root), resolve9(path));
-  return value === "" || !value.startsWith(`..${sep3}`) && value !== ".." && !isAbsolute3(value);
+}, nativeCachePath2 = (projectRoot) => join14(projectRoot, ".absolutejs", "mobile", "ios-native-cache.json"), isInside2 = (root, path) => {
+  const value = relative6(resolve10(root), resolve10(path));
+  return value === "" || !value.startsWith(`..${sep4}`) && value !== ".." && !isAbsolute3(value);
 }, parseJournal2 = (value) => {
   if (!isRecord3(value) || value.format !== DEV_JOURNAL_FORMAT2)
     return null;
@@ -4567,8 +5072,8 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
 }, writeDevProjection = async (project, port, https, serverHost = "localhost") => {
   const paths = journalPaths2(project.projectRoot);
   await repairAbsoluteIosDevSession(project.projectRoot);
-  const nativeConfigPath = join13(project.nativeDirectory, "App", "App", "capacitor.config.json");
-  const infoPath = join13(project.nativeDirectory, "App", "App", "Info.plist");
+  const nativeConfigPath = join14(project.nativeDirectory, "App", "App", "capacitor.config.json");
+  const infoPath = join14(project.nativeDirectory, "App", "App", "Info.plist");
   const [configSource, infoSource] = await Promise.all([
     readFile7(nativeConfigPath, "utf8"),
     readFile7(infoPath, "utf8")
@@ -4729,12 +5234,12 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
   ]);
   return result.exitCode === 0 && result.stdout.includes(project.config.appId);
 }, buildIosDebugApp = async (project, udid, fingerprint, run, signal) => {
-  const derivedDataPath = join13(project.projectRoot, ".absolutejs", "mobile", "ios-derived-data", createHash5("sha256").update(project.config.appId).digest("hex").slice(0, 16));
+  const derivedDataPath = join14(project.projectRoot, ".absolutejs", "mobile", "ios-derived-data", createHash5("sha256").update(project.config.appId).digest("hex").slice(0, 16));
   await mkdir5(derivedDataPath, { recursive: true });
   await requireSuccess2([
     project.xcodebuild,
     "-workspace",
-    join13(project.nativeDirectory, "App", "App.xcworkspace"),
+    join14(project.nativeDirectory, "App", "App.xcworkspace"),
     "-scheme",
     "App",
     "-configuration",
@@ -4745,17 +5250,17 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
     derivedDataPath,
     "build"
   ], "iOS simulator build", run, { cwd: project.nativeDirectory, signal });
-  const appPath = join13(derivedDataPath, "Build", "Products", "Debug-iphonesimulator", "App.app");
+  const appPath = join14(derivedDataPath, "Build", "Products", "Debug-iphonesimulator", "App.app");
   if (!await pathExists4(appPath))
     throw new Error(`Xcode did not produce the simulator app at ${appPath}.`);
   return appPath;
 }, buildPhysicalIosDebugApp = async (project, identifier, run, signal) => {
-  const derivedDataPath = join13(project.projectRoot, ".absolutejs", "mobile", "ios-derived-data", createHash5("sha256").update(project.config.appId).digest("hex").slice(0, 16));
+  const derivedDataPath = join14(project.projectRoot, ".absolutejs", "mobile", "ios-derived-data", createHash5("sha256").update(project.config.appId).digest("hex").slice(0, 16));
   await mkdir5(derivedDataPath, { recursive: true });
   await requireSuccess2([
     project.xcodebuild,
     "-workspace",
-    join13(project.nativeDirectory, "App", "App.xcworkspace"),
+    join14(project.nativeDirectory, "App", "App.xcworkspace"),
     "-scheme",
     "App",
     "-configuration",
@@ -4767,7 +5272,7 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
     "-allowProvisioningUpdates",
     "build"
   ], "iOS physical-device build (configure automatic signing and a Development Team in Xcode if this is the first run)", run, { cwd: project.nativeDirectory, signal });
-  const appPath = join13(derivedDataPath, "Build", "Products", "Debug-iphoneos", "App.app");
+  const appPath = join14(derivedDataPath, "Build", "Products", "Debug-iphoneos", "App.app");
   if (!await pathExists4(appPath))
     throw new Error(`Xcode did not produce the physical-device app at ${appPath}.`);
   return appPath;
@@ -4878,7 +5383,7 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
   if (detectAbsoluteMobileHost() !== "macos")
     throw new Error("iOS development requires macOS and Xcode.");
   const target = options.target ?? "simulator";
-  const projectRoot = resolve9(options.projectRoot);
+  const projectRoot = resolve10(options.projectRoot);
   const checks = await inspectAbsoluteMobileToolchain({ host: "macos" });
   const failed = checks.filter((check) => check.platform === "ios" && !(target === "device" && check.id === "ios.runtime") && (check.status === "fail" || check.status === "warn"));
   if (failed.length > 0)
@@ -4887,16 +5392,16 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
   const xcodebuild = checks.find((check) => check.id === "ios.xcodebuild")?.path;
   if (!xcrun || !xcodebuild)
     throw new Error("Xcode tools disappeared after readiness checks.");
-  const cap = join13(projectRoot, "node_modules", ".bin", "cap");
+  const cap = join14(projectRoot, "node_modules", ".bin", "cap");
   if (!await pathExists4(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 = join13(config.bundleDirectory, "index.html");
+  const placeholder = join14(config.bundleDirectory, "index.html");
   if (!await pathExists4(placeholder))
     await writeFile5(placeholder, `<!doctype html><title>AbsoluteJS mobile development</title>
 `);
-  const nativeDirectory = join13(config.nativeProjectDirectory, "ios");
+  const nativeDirectory = join14(config.nativeProjectDirectory, "ios");
   if (!await pathExists4(nativeDirectory)) {
     if (!options.createNativeProject)
       throw new Error("iOS native project has not been created.");
@@ -5121,7 +5626,7 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
       screenshot: async (destination) => {
         if (deviceIdentifier)
           throw new Error("Physical iOS screenshots are captured in Xcode Device Hub; the CLI never records a device screen automatically.");
-        const resolved = resolve9(project.projectRoot, destination);
+        const resolved = resolve10(project.projectRoot, destination);
         if (!isInside2(project.projectRoot, resolved))
           throw new Error("iOS screenshot destination must remain inside the project.");
         await mkdir5(dirname7(resolved), { recursive: true });
@@ -5185,13 +5690,13 @@ import { isIP as isIP3 } from "net";
 import {
   dirname as dirname8,
   isAbsolute as isAbsolute4,
-  join as join14,
+  join as join15,
   posix,
-  relative as relative6,
+  relative as relative7,
   resolve as resolvePath,
-  sep as sep4
+  sep as sep5
 } from "path";
-var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TIMEOUT_MS = 2000, PROFILE_NAME, SSH_DESTINATION, defaultProfilePath = () => join14(homedir4(), ".absolutejs", "mobile", "remote-macs.json"), emptyStore = () => ({
+var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TIMEOUT_MS = 2000, PROFILE_NAME, SSH_DESTINATION, defaultProfilePath = () => join15(homedir4(), ".absolutejs", "mobile", "remote-macs.json"), emptyStore = () => ({
   format: PROFILE_FORMAT,
   profiles: {}
 }), loadStore = async (path = defaultProfilePath()) => {
@@ -5367,9 +5872,9 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
     throw new TypeError("Remote Expo execution requires mobile.engine: expo.");
   return createAbsoluteRemoteIosDevProject(config, projectRoot, profile);
 }, createAbsoluteRemoteIosDevProject = (config, projectRoot, profile) => ({
-  cap: join14(resolvePath(projectRoot), "node_modules", ".bin", "cap"),
+  cap: join15(resolvePath(projectRoot), "node_modules", ".bin", "cap"),
   config,
-  nativeDirectory: join14(config.nativeProjectDirectory, "ios"),
+  nativeDirectory: join15(config.nativeProjectDirectory, "ios"),
   profile,
   projectRoot: resolvePath(projectRoot),
   remote: true,
@@ -5416,8 +5921,8 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
   return { ...artifact, remotePath, uploaded: true };
 }, materializeAbsoluteRemoteMacAgent = async (projectRoot) => {
   const shippedCandidates = [
-    join14(import.meta.dir, "remoteMacAgentEntry.js"),
-    join14(import.meta.dir, "..", "mobile", "remoteMacAgentEntry.js")
+    join15(import.meta.dir, "remoteMacAgentEntry.js"),
+    join15(import.meta.dir, "..", "mobile", "remoteMacAgentEntry.js")
   ];
   let path;
   for (const candidate of shippedCandidates) {
@@ -5428,13 +5933,13 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
   }
   if (!path) {
     const sourceCandidates = [
-      join14(import.meta.dir, "remoteMacAgentEntry.ts"),
-      join14(import.meta.dir, "..", "..", "src", "mobile", "remoteMacAgentEntry.ts")
+      join15(import.meta.dir, "remoteMacAgentEntry.ts"),
+      join15(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 = join14(resolvePath(projectRoot), ".absolutejs", "mobile", "remote-agent");
+    const outdir = join15(resolvePath(projectRoot), ".absolutejs", "mobile", "remote-agent");
     await mkdir6(outdir, { recursive: true });
     const result = await Bun.build({
       entrypoints: [source],
@@ -5444,12 +5949,12 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
     });
     if (!result.success)
       throw new AggregateError(result.logs, "Failed to build the AbsoluteJS remote Mac agent.");
-    path = join14(outdir, "remoteMacAgentEntry.js");
+    path = join15(outdir, "remoteMacAgentEntry.js");
   }
   const bytes = await Bun.file(path).arrayBuffer();
   const sha256 = createHash6("sha256").update(new Uint8Array(bytes)).digest("hex");
   return { bytes: bytes.byteLength, path, sha256 };
-}, portableRelativePath = (root, path) => relative6(root, path).split(sep4).join(posix.sep), portableMobileConfig = (project) => ({
+}, portableRelativePath = (root, path) => relative7(root, path).split(sep5).join(posix.sep), portableMobileConfig = (project) => ({
   appId: project.config.appId,
   appName: project.config.appName,
   bundleDirectory: portableRelativePath(project.projectRoot, project.config.bundleDirectory),
@@ -5665,8 +6170,8 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
   const pending = new Map;
   let resolveReady;
   let rejectReady;
-  const readyPromise = new Promise((resolve10, reject) => {
-    resolveReady = resolve10;
+  const readyPromise = new Promise((resolve11, reject) => {
+    resolveReady = resolve11;
     rejectReady = reject;
   });
   const handleEvent = (event) => {
@@ -5767,7 +6272,7 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
   options.log?.(`Remote Mac connected (${options.project.profile.name}); agent ${agent.uploaded ? "uploaded" : "cache hit"}, project synced, and ${expo ? "Expo " : ""}iOS ready in ${totalDuration.toFixed(2)}ms.`);
   const request = (commandName) => {
     const id = randomUUID4();
-    const response = new Promise((resolve10, reject) => pending.set(id, { reject, resolve: resolve10 }));
+    const response = new Promise((resolve11, reject) => pending.set(id, { reject, resolve: resolve11 }));
     process2.stdin.write(`${JSON.stringify({ command: commandName, id, v: ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION })}
 `);
     const flush = async () => {
@@ -5787,7 +6292,7 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
     if (closed)
       return;
     closed = true;
-    const timeout = () => new Promise((resolve10) => setTimeout(() => resolve10("timeout"), REMOTE_SESSION_CLOSE_TIMEOUT_MS));
+    const timeout = () => new Promise((resolve11) => setTimeout(() => resolve11("timeout"), REMOTE_SESSION_CLOSE_TIMEOUT_MS));
     await Promise.race([
       request("close").catch(() => {
         return;
@@ -5835,7 +6340,7 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
     screenshot: async (destination) => {
       const result = await request("screenshot");
       const target = resolvePath(options.project.projectRoot, destination);
-      const targetRelative = relative6(options.project.projectRoot, target);
+      const targetRelative = relative7(options.project.projectRoot, target);
       if (targetRelative.startsWith("..") || isAbsolute4(targetRelative))
         throw new Error("iOS screenshot must remain inside the project.");
       await mkdir6(dirname8(target), { recursive: true });
@@ -5875,16 +6380,16 @@ __export(exports_devCert, {
 });
 import {
   copyFileSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   rmSync
 } from "fs";
 import { X509Certificate as X509Certificate2 } from "crypto";
 import { isIP as isIP4 } from "net";
 import { platform as platform2 } from "os";
-import { join as join15 } from "path";
-var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE_HOSTS, CERTIFICATE_HOSTNAME_PATTERN, devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`), devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`), certFilesExist = () => existsSync4(CERT_PATH) && existsSync4(KEY_PATH), normalizeDevCertificateHosts = (hosts = []) => {
+import { join as join16 } from "path";
+var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE_HOSTS, CERTIFICATE_HOSTNAME_PATTERN, devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`), devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`), certFilesExist = () => existsSync5(CERT_PATH) && existsSync5(KEY_PATH), normalizeDevCertificateHosts = (hosts = []) => {
   const normalized = new Set(DEFAULT_CERTIFICATE_HOSTS);
   for (const host2 of hosts) {
     const value = host2.trim().toLowerCase();
@@ -5898,7 +6403,7 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
   return [...normalized];
 }, certificateIsUsable = (hosts) => {
   try {
-    const certPem = readFileSync8(CERT_PATH, "utf-8");
+    const certPem = readFileSync9(CERT_PATH, "utf-8");
     const certificate = new X509Certificate2(certPem);
     if (new Date(certificate.validTo).getTime() <= Date.now())
       return false;
@@ -5983,8 +6488,8 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
     return null;
   try {
     return {
-      cert: readFileSync8(paths.cert, "utf-8"),
-      key: readFileSync8(paths.key, "utf-8")
+      cert: readFileSync9(paths.cert, "utf-8"),
+      key: readFileSync9(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -6080,7 +6585,7 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
   if (platform2() !== "linux")
     return false;
   try {
-    return /microsoft|wsl/i.test(readFileSync8("/proc/version", "utf-8"));
+    return /microsoft|wsl/i.test(readFileSync9("/proc/version", "utf-8"));
   } catch {
     return false;
   }
@@ -6096,8 +6601,8 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
   }
 }, mkcertCaRoot = () => runCapture(["mkcert", "-CAROOT"]), getDevCertificateAuthorityPath = () => {
   const caRoot = hasMkcert() ? mkcertCaRoot() : null;
-  const rootCertificate = caRoot ? join15(caRoot, "rootCA.pem") : null;
-  if (rootCertificate && existsSync4(rootCertificate))
+  const rootCertificate = caRoot ? join16(caRoot, "rootCA.pem") : null;
+  if (rootCertificate && existsSync5(rootCertificate))
     return rootCertificate;
   if (certFilesExist())
     return CERT_PATH;
@@ -6111,13 +6616,13 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
   const caRoot = mkcertCaRoot();
   if (!caRoot)
     return false;
-  const rootCa = join15(caRoot, "rootCA.pem");
-  if (!existsSync4(rootCa))
+  const rootCa = join16(caRoot, "rootCA.pem");
+  if (!existsSync5(rootCa))
     return false;
   const winTemp = windowsTempDir();
   if (!winTemp)
     return false;
-  const staged = join15(winTemp, "absolutejs-mkcert-rootCA.crt");
+  const staged = join16(winTemp, "absolutejs-mkcert-rootCA.crt");
   try {
     copyFileSync(rootCa, staged);
   } catch {
@@ -6153,7 +6658,7 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
       devLog("Trusted the local CA in the Windows store \u2014 Chrome/Edge on Windows now accept dev HTTPS");
     } else {
       const caRoot = mkcertCaRoot();
-      const hint = caRoot ? toWindowsPath(join15(caRoot, "rootCA.pem")) : null;
+      const hint = caRoot ? toWindowsPath(join16(caRoot, "rootCA.pem")) : null;
       devWarn("Could not auto-trust the local CA on Windows; Windows browsers may warn.");
       if (hint) {
         console.log(`  Run in PowerShell: Import-Certificate -FilePath "${hint}" -CertStoreLocation Cert:\\CurrentUser\\Root`);
@@ -6169,9 +6674,9 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
   return true;
 };
 var init_devCert = __esm(() => {
-  CERT_DIR = join15(process.cwd(), ".absolutejs");
-  CERT_PATH = join15(CERT_DIR, "cert.pem");
-  KEY_PATH = join15(CERT_DIR, "key.pem");
+  CERT_DIR = join16(process.cwd(), ".absolutejs");
+  CERT_PATH = join16(CERT_DIR, "cert.pem");
+  KEY_PATH = join16(CERT_DIR, "key.pem");
   DEFAULT_CERTIFICATE_HOSTS = ["localhost", "127.0.0.1", "::1"];
   CERTIFICATE_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])?))*$/u;
 });
@@ -6187,9 +6692,9 @@ __export(exports_eslintChunked, {
   ruleSummary: () => ruleSummary,
   upstreamRef: () => upstreamRef
 });
-import { existsSync as existsSync6 } from "fs";
-import { relative as relative7, resolve as resolve10 } from "path";
-var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAULT_REPORT = ".absolutejs/lint-report.txt", CHILD_HEAP_MB = 4096, DJB2_SEED = 5381, DJB2_MULTIPLIER = 33, MS_PER_SECOND = 1000, SUMMARY_RULE_WIDTH = 60, SUMMARY_COUNT_PAD = 5, PORCELAIN_STATUS_WIDTH = 3, RENAME_ARROW = " -> ", ASCII_ESC = 27, LINTABLE_EXTENSIONS, ANSI_COLOR, stripAnsi = (text) => text.replace(ANSI_COLOR, ""), shardOf = (path, shards) => [...path].reduce((accumulator, character) => (Math.imul(accumulator, DJB2_MULTIPLIER) ^ character.charCodeAt(0)) >>> 0, DJB2_SEED) % shards, gitLines = (cmd, cwd) => Bun.spawnSync(cmd, { cwd }).stdout.toString().split(`
+import { existsSync as existsSync7 } from "fs";
+import { relative as relative8, resolve as resolve11 } from "path";
+var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAULT_REPORT = ".absolutejs/lint-report.txt", CHILD_HEAP_MB = 4096, DJB2_SEED = 5381, DJB2_MULTIPLIER = 33, MS_PER_SECOND = 1000, SUMMARY_RULE_WIDTH = 60, SUMMARY_COUNT_PAD = 5, PORCELAIN_STATUS_WIDTH = 3, RENAME_ARROW = " -> ", ASCII_ESC = 27, LINTABLE_EXTENSIONS, ANSI_COLOR, stripAnsi = (text2) => text2.replace(ANSI_COLOR, ""), shardOf = (path, shards) => [...path].reduce((accumulator, character) => (Math.imul(accumulator, DJB2_MULTIPLIER) ^ character.charCodeAt(0)) >>> 0, DJB2_SEED) % shards, gitLines = (cmd, cwd) => Bun.spawnSync(cmd, { cwd }).stdout.toString().split(`
 `).map((line) => line.trimEnd()).filter(Boolean), applyChangedBase = (parsed, base) => {
   parsed.changedOnly = true;
   parsed.changedBase = base;
@@ -6200,7 +6705,7 @@ var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAUL
 }, matchesAnyGlob = (file, globs) => globs.some((pattern) => new Bun.Glob(pattern).match(file)), resolveLintSet = (parsed, cwd) => {
   const visible = gitVisibleFiles(cwd);
   const matched = parsed.globs.length === 0 ? visible.filter((file) => LINTABLE_EXTENSIONS.test(file)) : visible.filter((file) => matchesAnyGlob(file, parsed.globs));
-  return matched.filter((file) => existsSync6(resolve10(cwd, file))).sort();
+  return matched.filter((file) => existsSync7(resolve11(cwd, file))).sort();
 }, resolveLintTargets = (args, cwd = process.cwd()) => resolveLintSet(parseChunkedArgs(args), cwd), buildShardChunks = (files, shards, chunkSize) => {
   const shardFiles = Array.from({ length: shards }, () => []);
   for (const file of files)
@@ -6222,7 +6727,7 @@ var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAUL
     "content"
   ];
   const proc = Bun.spawn([
-    resolve10(cwd, "node_modules/.bin/eslint"),
+    resolve11(cwd, "node_modules/.bin/eslint"),
     "--color",
     ...hasMaxWarnings ? [] : ["--max-warnings", "0"],
     ...cacheArgs,
@@ -6269,7 +6774,7 @@ var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAUL
   const fingerprint = createEslintCacheFingerprint(cwd);
   for (let shard = 0;shard < parsed.shards; shard++)
     prepareEslintCache({
-      cacheLocation: relative7(cwd, resolve10(cwd, `${cachePrefix}${shard}`)),
+      cacheLocation: relative8(cwd, resolve11(cwd, `${cachePrefix}${shard}`)),
       cwd,
       fingerprint
     });
@@ -6310,7 +6815,7 @@ var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAUL
   const header = `eslint report \u2014 ${files.length} files, ${totalChunks} chunks, ${elapsed}s
 ${"=".repeat(SUMMARY_RULE_WIDTH)}
 `;
-  await Bun.write(resolve10(cwd, parsed.outFile), header + report + summary);
+  await Bun.write(resolve11(cwd, parsed.outFile), header + report + summary);
   console.log(summary);
   console.log(`Full report written to ${parsed.outFile}`);
   if (failedChunks > 0) {
@@ -6397,14 +6902,14 @@ var init_eslintChunked = __esm(() => {
 // src/cli/scripts/eslint.ts
 import { createHash as createHash7 } from "crypto";
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   renameSync,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
-import { dirname as dirname9, relative as relative8, resolve as resolve11 } from "path";
+import { dirname as dirname9, relative as relative9, resolve as resolve12 } from "path";
 var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION = "1", CACHE_FINGERPRINT_SUFFIX = ".fingerprint", flagValue = (args, flag) => {
   const assignment = args.find((arg) => arg.startsWith(`${flag}=`));
   if (assignment)
@@ -6428,20 +6933,20 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
   return false;
 }, findEslintConfigPath = (cwd = process.cwd()) => {
   for (const name of CONFIG_CANDIDATES) {
-    const candidate = resolve11(cwd, name);
-    if (existsSync7(candidate))
+    const candidate = resolve12(cwd, name);
+    if (existsSync8(candidate))
       return candidate;
   }
   return null;
 }, fingerprintLocation = (cacheLocation, cwd) => {
-  const absolute = resolve11(cwd, cacheLocation);
-  return /[\\/]$/.test(cacheLocation) ? resolve11(absolute, CACHE_FINGERPRINT_SUFFIX.slice(1)) : `${absolute}${CACHE_FINGERPRINT_SUFFIX}`;
+  const absolute = resolve12(cwd, cacheLocation);
+  return /[\\/]$/.test(cacheLocation) ? resolve12(absolute, CACHE_FINGERPRINT_SUFFIX.slice(1)) : `${absolute}${CACHE_FINGERPRINT_SUFFIX}`;
 }, addFileToFingerprint = (hash, path, label) => {
-  if (!existsSync7(path))
+  if (!existsSync8(path))
     return;
   hash.update(label);
   hash.update("\x00");
-  hash.update(readFileSync10(path));
+  hash.update(readFileSync11(path));
   hash.update("\x00");
 }, packageNameFor = (specifier) => {
   if (specifier.startsWith("@"))
@@ -6451,7 +6956,7 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
 }, configPackageNames = (configPath2) => {
   if (!configPath2)
     return [];
-  const source = readFileSync10(configPath2, "utf-8");
+  const source = readFileSync11(configPath2, "utf-8");
   const names = new Set;
   for (const match of source.matchAll(/(?:from\s+|import\s*(?:\(\s*)?|require\s*\(\s*)(['"])([^'".][^'"]*)\1/g)) {
     const [, , specifier] = match;
@@ -6470,11 +6975,11 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
     return Object.keys(value);
   });
 }, lintDependencyNames = (cwd, configPath2) => {
-  const manifestPath = resolve11(cwd, "package.json");
-  if (!existsSync7(manifestPath))
+  const manifestPath = resolve12(cwd, "package.json");
+  if (!existsSync8(manifestPath))
     return configPackageNames(configPath2);
   try {
-    const manifest = JSON.parse(readFileSync10(manifestPath, "utf-8"));
+    const manifest = JSON.parse(readFileSync11(manifestPath, "utf-8"));
     const lintPackages = manifestDependencyNames(manifest).filter((name) => /eslint|typescript/.test(name));
     return [
       ...new Set([...lintPackages, ...configPackageNames(configPath2)])
@@ -6485,8 +6990,8 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
 }, findInstalledManifest = (cwd, dependency) => {
   let directory = cwd;
   while (true) {
-    const candidate = resolve11(directory, "node_modules", dependency, "package.json");
-    if (existsSync7(candidate))
+    const candidate = resolve12(directory, "node_modules", dependency, "package.json");
+    if (existsSync8(candidate))
       return candidate;
     const parent = dirname9(directory);
     if (parent === directory)
@@ -6508,7 +7013,7 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
   hash.update(`absolute-eslint-config:${CACHE_CONTRACT_VERSION}\x00`);
   const configPath2 = findEslintConfigPath(cwd);
   if (configPath2)
-    addFileToFingerprint(hash, configPath2, relative8(cwd, configPath2));
+    addFileToFingerprint(hash, configPath2, relative9(cwd, configPath2));
   return hash.digest("hex");
 }, writeFingerprint = (path, fingerprint) => {
   mkdirSync5(dirname9(path), { recursive: true });
@@ -6518,10 +7023,10 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
   renameSync(temporary, path);
 }, prepareEslintCache = (options) => {
   const cwd = options.cwd ?? process.cwd();
-  const cachePath = resolve11(cwd, options.cacheLocation);
+  const cachePath = resolve12(cwd, options.cacheLocation);
   const metadataPath = fingerprintLocation(options.cacheLocation, cwd);
   const fingerprint = options.fingerprint ?? createEslintCacheFingerprint(cwd);
-  const prior = existsSync7(metadataPath) ? readFileSync10(metadataPath, "utf-8").trim() : null;
+  const prior = existsSync8(metadataPath) ? readFileSync11(metadataPath, "utf-8").trim() : null;
   if (prior === fingerprint)
     return false;
   rmSync3(cachePath, { force: true, recursive: true });
@@ -6609,7 +7114,7 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
     return;
   let source;
   try {
-    source = readFileSync10(configPath2, "utf-8");
+    source = readFileSync11(configPath2, "utf-8");
   } catch {
     return;
   }
@@ -6648,7 +7153,7 @@ Detected at: ${configPath2}${reset}`);
   return `${minutes}m ${seconds}s`;
 }, handleClearCache = (cacheLocation, cwd = process.cwd()) => {
   try {
-    const cachePath = resolve11(cwd, cacheLocation);
+    const cachePath = resolve12(cwd, cacheLocation);
     const metadataPath = fingerprintLocation(cacheLocation, cwd);
     rmSync3(cachePath, { force: true, recursive: true });
     rmSync3(metadataPath, { force: true, recursive: true });
@@ -6677,7 +7182,7 @@ Detected at: ${configPath2}${reset}`);
     return;
   }
   if (args.includes("--chunked")) {
-    if (!existsSync7(resolve11("node_modules", ".bin", "eslint"))) {
+    if (!existsSync8(resolve12("node_modules", ".bin", "eslint"))) {
       console.error("\x1B[31m\u2717\x1B[0m ESLint is not installed in this project. Add it (and a flat `eslint.config.*`): bun add -d eslint");
       process.exit(1);
     }
@@ -6685,7 +7190,7 @@ Detected at: ${configPath2}${reset}`);
     await eslintChunked2(args);
     return;
   }
-  if (!existsSync7(resolve11("node_modules", ".bin", "eslint"))) {
+  if (!existsSync8(resolve12("node_modules", ".bin", "eslint"))) {
     console.error("\x1B[31m\u2717\x1B[0m ESLint is not installed in this project. Add it (and a flat `eslint.config.*`): bun add -d eslint");
     process.exit(1);
   }
@@ -6876,8 +7381,8 @@ var isRecord4 = (value) => typeof value === "object" && value !== null, getIslan
 var init_islands = () => {};
 
 // src/build/islandEntries.ts
-import { dirname as dirname10, extname, join as join18, relative as relative9, resolve as resolve13 } from "path";
-import ts from "typescript";
+import { dirname as dirname10, extname as extname2, join as join19, relative as relative10, resolve as resolve14 } from "path";
+import ts2 from "typescript";
 var frameworks, isRecord5 = (value) => typeof value === "object" && value !== null, resolveRegistryExport = (mod) => {
   if (isRecord5(mod.islandRegistry))
     return mod.islandRegistry;
@@ -6888,9 +7393,9 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   if (sourcePath.startsWith("file://")) {
     return new URL(sourcePath).pathname;
   }
-  return resolve13(dirname10(registryPath), sourcePath);
+  return resolve14(dirname10(registryPath), sourcePath);
 }, getObjectPropertyName = (name) => {
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name)) {
     return name.text;
   }
   return null;
@@ -6903,7 +7408,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   });
 }, collectNamedImports = (imports, importClause, source) => {
   const bindings = importClause.namedBindings;
-  if (!bindings || !ts.isNamedImports(bindings))
+  if (!bindings || !ts2.isNamedImports(bindings))
     return;
   for (const element of bindings.elements) {
     imports.set(element.name.text, {
@@ -6917,7 +7422,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   const bindings = importClause.namedBindings;
   if (!bindings)
     return;
-  if (ts.isNamespaceImport(bindings)) {
+  if (ts2.isNamespaceImport(bindings)) {
     registryNamespaceNames.add(bindings.name.text);
     return;
   }
@@ -6935,13 +7440,13 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   const frameworkRegistry = registry2[framework] ?? {};
   registry2[framework] = frameworkRegistry;
   for (const property of frameworkNode.properties) {
-    if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property))
+    if (!ts2.isPropertyAssignment(property) && !ts2.isShorthandPropertyAssignment(property))
       continue;
     const componentName = getObjectPropertyName(property.name);
     if (!componentName)
       continue;
-    const initializer = ts.isPropertyAssignment(property) ? property.initializer : property.name;
-    if (!ts.isIdentifier(initializer))
+    const initializer = ts2.isPropertyAssignment(property) ? property.initializer : property.name;
+    if (!ts2.isIdentifier(initializer))
       continue;
     const reference = imports.get(initializer.text);
     if (!reference)
@@ -6955,7 +7460,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   }
 }, processDefineIslandRegistry = (node, imports, definitions, registry2) => {
   const [firstArg] = node.arguments;
-  if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+  if (!firstArg || !ts2.isObjectLiteralExpression(firstArg))
     return;
   const validFrameworks = [
     "react",
@@ -6964,7 +7469,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
     "angular"
   ];
   for (const property of firstArg.properties) {
-    if (!ts.isPropertyAssignment(property))
+    if (!ts2.isPropertyAssignment(property))
       continue;
     const frameworkName = getObjectPropertyName(property.name);
     if (!frameworkName)
@@ -6972,28 +7477,28 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
     const framework = validFrameworks.find((f) => f === frameworkName);
     if (!framework)
       continue;
-    if (!ts.isObjectLiteralExpression(property.initializer))
+    if (!ts2.isObjectLiteralExpression(property.initializer))
       continue;
     addRegistryEntries(property.initializer, framework, imports, definitions, registry2);
   }
 }, walkRegistryNode = (node, imports, registryFactoryNames, registryNamespaceNames, definitions, registry2) => {
-  if (ts.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, registryFactoryNames, registryNamespaceNames)) {
+  if (ts2.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, registryFactoryNames, registryNamespaceNames)) {
     processDefineIslandRegistry(node, imports, definitions, registry2);
   }
-  ts.forEachChild(node, (child) => walkRegistryNode(child, imports, registryFactoryNames, registryNamespaceNames, definitions, registry2));
+  ts2.forEachChild(node, (child) => walkRegistryNode(child, imports, registryFactoryNames, registryNamespaceNames, definitions, registry2));
 }, isDefineIslandRegistryCall = (expression, registryFactoryNames, registryNamespaceNames) => {
-  if (ts.isIdentifier(expression)) {
+  if (ts2.isIdentifier(expression)) {
     return registryFactoryNames.has(expression.text);
   }
-  return ts.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && ts.isIdentifier(expression.expression) && registryNamespaceNames.has(expression.expression.text);
+  return ts2.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && ts2.isIdentifier(expression.expression) && registryNamespaceNames.has(expression.expression.text);
 }, hasIslandRegistryNamedExport = (sourceFile) => {
   for (const statement of sourceFile.statements) {
-    if (ts.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) && statement.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === "islandRegistry")) {
+    if (ts2.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword) && statement.declarationList.declarations.some((declaration) => ts2.isIdentifier(declaration.name) && declaration.name.text === "islandRegistry")) {
       return true;
     }
-    if (!ts.isExportDeclaration(statement) || !statement.exportClause)
+    if (!ts2.isExportDeclaration(statement) || !statement.exportClause)
       continue;
-    if (!ts.isNamedExports(statement.exportClause))
+    if (!ts2.isNamedExports(statement.exportClause))
       continue;
     if (statement.exportClause.elements.some((element) => element.name.text === "islandRegistry")) {
       return true;
@@ -7002,7 +7507,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   return false;
 }, collectImportDeclarations = (sourceFile, registryPath, imports, registryFactoryNames, registryNamespaceNames) => {
   for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+    if (!ts2.isImportDeclaration(statement) || !ts2.isStringLiteral(statement.moduleSpecifier))
       continue;
     const { importClause } = statement;
     if (!importClause)
@@ -7013,7 +7518,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
     collectRegistryHelperImports(importClause, statement.moduleSpecifier.text, registryFactoryNames, registryNamespaceNames);
   }
 }, parseIslandRegistryBuildInfo = (registrySource, registryPath) => {
-  const sourceFile = ts.createSourceFile(registryPath, registrySource, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const sourceFile = ts2.createSourceFile(registryPath, registrySource, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
   const imports = new Map;
   const registryFactoryNames = new Set(["defineIslandRegistry"]);
   const registryNamespaceNames = new Set;
@@ -7045,7 +7550,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
     registry: registry2
   };
 }, loadIslandRegistryBuildInfo = async (registryPath) => {
-  const resolvedRegistryPath = resolve13(registryPath);
+  const resolvedRegistryPath = resolve14(registryPath);
   const registrySource = Bun.file(resolvedRegistryPath);
   const registrySourceText = await registrySource.text();
   const parsedInfo = parseIslandRegistryBuildInfo(registrySourceText, resolvedRegistryPath);
@@ -7075,25 +7580,25 @@ var init_islandEntries = __esm(() => {
 
 // src/build/islandRegistryTransform.ts
 import { basename as basename6 } from "path";
-import ts2 from "typescript";
-var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts2.isIdentifier(name) || ts2.isStringLiteral(name) ? name.text : null, isIslandRegistryHelperImport2 = (source) => source === "@absolutejs/absolute/islands" || source.endsWith("/islands") || source.endsWith("/core/islands"), collectRegistryFactory = (sourceFile) => {
+import ts3 from "typescript";
+var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts3.isIdentifier(name) || ts3.isStringLiteral(name) ? name.text : null, isIslandRegistryHelperImport2 = (source) => source === "@absolutejs/absolute/islands" || source.endsWith("/islands") || source.endsWith("/core/islands"), collectRegistryFactory = (sourceFile) => {
   const factoryNames = new Set;
   const namespaceNames = new Set;
   for (const statement of sourceFile.statements) {
-    if (!ts2.isImportDeclaration(statement))
+    if (!ts3.isImportDeclaration(statement))
       continue;
-    if (!ts2.isStringLiteral(statement.moduleSpecifier))
+    if (!ts3.isStringLiteral(statement.moduleSpecifier))
       continue;
     if (!isIslandRegistryHelperImport2(statement.moduleSpecifier.text))
       continue;
     const bindings = statement.importClause?.namedBindings;
     if (!bindings)
       continue;
-    if (ts2.isNamespaceImport(bindings)) {
+    if (ts3.isNamespaceImport(bindings)) {
       namespaceNames.add(bindings.name.text);
       continue;
     }
-    if (!ts2.isNamedImports(bindings))
+    if (!ts3.isNamedImports(bindings))
       continue;
     for (const element of bindings.elements) {
       const imported = element.propertyName?.text ?? element.name.text;
@@ -7104,20 +7609,20 @@ var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts2.isIdentifier(name)
   }
   return { factoryNames, namespaceNames };
 }, isDefineIslandRegistryCall2 = (expression, factoryNames, namespaceNames) => {
-  if (ts2.isIdentifier(expression))
+  if (ts3.isIdentifier(expression))
     return factoryNames.has(expression.text);
-  return ts2.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && ts2.isIdentifier(expression.expression) && namespaceNames.has(expression.expression.text);
+  return ts3.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && ts3.isIdentifier(expression.expression) && namespaceNames.has(expression.expression.text);
 }, findDefineIslandRegistryCall = (sourceFile, factoryNames, namespaceNames) => {
   let found = null;
   const visit = (node) => {
     if (found)
       return;
-    const [firstArg] = ts2.isCallExpression(node) ? node.arguments : [];
-    if (ts2.isCallExpression(node) && isDefineIslandRegistryCall2(node.expression, factoryNames, namespaceNames) && firstArg && ts2.isObjectLiteralExpression(firstArg)) {
+    const [firstArg] = ts3.isCallExpression(node) ? node.arguments : [];
+    if (ts3.isCallExpression(node) && isDefineIslandRegistryCall2(node.expression, factoryNames, namespaceNames) && firstArg && ts3.isObjectLiteralExpression(firstArg)) {
       found = node;
       return;
     }
-    ts2.forEachChild(node, visit);
+    ts3.forEachChild(node, visit);
   };
   visit(sourceFile);
   return found;
@@ -7127,8 +7632,8 @@ var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts2.isIdentifier(name)
 }, transformIslandRegistrySource = (source, filePath, info2) => {
   if (!source.includes("defineIslandRegistry"))
     return null;
-  const scriptKind = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS;
-  const sourceFile = ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest, true, scriptKind);
+  const scriptKind = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS;
+  const sourceFile = ts3.createSourceFile(filePath, source, ts3.ScriptTarget.Latest, true, scriptKind);
   const { factoryNames, namespaceNames } = collectRegistryFactory(sourceFile);
   if (factoryNames.size === 0 && namespaceNames.size === 0)
     return null;
@@ -7136,7 +7641,7 @@ var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts2.isIdentifier(name)
   if (!call)
     return null;
   const [objectLiteral] = call.arguments;
-  if (!objectLiteral || !ts2.isObjectLiteralExpression(objectLiteral)) {
+  if (!objectLiteral || !ts3.isObjectLiteralExpression(objectLiteral)) {
     return null;
   }
   const definitionLookup = new Map;
@@ -7151,20 +7656,20 @@ var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts2.isIdentifier(name)
   const edits = [];
   const replacedLocals = new Set;
   for (const frameworkProperty of objectLiteral.properties) {
-    if (!ts2.isPropertyAssignment(frameworkProperty))
+    if (!ts3.isPropertyAssignment(frameworkProperty))
       continue;
     const frameworkName = getObjectPropertyName2(frameworkProperty.name);
     const framework = VALID_FRAMEWORKS.find((f) => f === frameworkName);
     if (!framework)
       continue;
-    if (!ts2.isObjectLiteralExpression(frameworkProperty.initializer))
+    if (!ts3.isObjectLiteralExpression(frameworkProperty.initializer))
       continue;
     for (const componentProperty of frameworkProperty.initializer.properties) {
       let componentKey = null;
       let localName = null;
       let replaceNode = null;
       let replacementText = "";
-      if (ts2.isShorthandPropertyAssignment(componentProperty)) {
+      if (ts3.isShorthandPropertyAssignment(componentProperty)) {
         componentKey = componentProperty.name.text;
         localName = componentProperty.name.text;
         const reference = definitionLookup.get(`${framework}:${componentKey}`);
@@ -7172,7 +7677,7 @@ var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts2.isIdentifier(name)
           continue;
         replaceNode = componentProperty;
         replacementText = `${quoteKey(componentKey)}: ${definitionLiteral(reference)}`;
-      } else if (ts2.isPropertyAssignment(componentProperty) && ts2.isIdentifier(componentProperty.initializer)) {
+      } else if (ts3.isPropertyAssignment(componentProperty) && ts3.isIdentifier(componentProperty.initializer)) {
         componentKey = getObjectPropertyName2(componentProperty.name);
         localName = componentProperty.initializer.text;
         if (!componentKey)
@@ -7196,7 +7701,7 @@ var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts2.isIdentifier(name)
   if (edits.length === 0)
     return null;
   for (const statement of sourceFile.statements) {
-    if (!ts2.isImportDeclaration(statement))
+    if (!ts3.isImportDeclaration(statement))
       continue;
     const clause = statement.importClause;
     if (!clause)
@@ -7205,11 +7710,11 @@ var VALID_FRAMEWORKS, getObjectPropertyName2 = (name) => ts2.isIdentifier(name)
     if (clause.name)
       localNames.push(clause.name.text);
     const bindings = clause.namedBindings;
-    if (bindings && ts2.isNamedImports(bindings)) {
+    if (bindings && ts3.isNamedImports(bindings)) {
       for (const element of bindings.elements) {
         localNames.push(element.name.text);
       }
-    } else if (bindings && ts2.isNamespaceImport(bindings)) {
+    } else if (bindings && ts3.isNamespaceImport(bindings)) {
       localNames.push(bindings.name.text);
     }
     if (localNames.length === 0)
@@ -7266,18 +7771,18 @@ var init_islandRegistryTransform = __esm(() => {
 });
 
 // src/build/bunStringRawUnicodePlugin.ts
-import { extname as extname2 } from "path";
-import ts3 from "typescript";
+import { extname as extname3 } from "path";
+import ts4 from "typescript";
 var NON_ASCII, getScriptKind = (filePath) => {
   if (/\.[cm]?tsx$/.test(filePath))
-    return ts3.ScriptKind.TSX;
+    return ts4.ScriptKind.TSX;
   if (/\.[cm]?jsx$/.test(filePath))
-    return ts3.ScriptKind.JSX;
+    return ts4.ScriptKind.JSX;
   if (/\.[cm]?ts$/.test(filePath))
-    return ts3.ScriptKind.TS;
-  return ts3.ScriptKind.JS;
+    return ts4.ScriptKind.TS;
+  return ts4.ScriptKind.JS;
 }, getLoader = (filePath) => {
-  const extension = extname2(filePath);
+  const extension = extname3(filePath);
   if (extension === ".tsx")
     return "tsx";
   if (extension === ".jsx")
@@ -7286,24 +7791,24 @@ var NON_ASCII, getScriptKind = (filePath) => {
     return "ts";
   }
   return "js";
-}, isStringRawTag = (node) => ts3.isPropertyAccessExpression(node.tag) && ts3.isIdentifier(node.tag.expression) && node.tag.expression.text === "String" && node.tag.name.text === "raw", getRawText = (node) => node.rawText ?? node.text, rewriteBunStringRawUnicode = (source, filePath = "input.ts") => {
+}, isStringRawTag = (node) => ts4.isPropertyAccessExpression(node.tag) && ts4.isIdentifier(node.tag.expression) && node.tag.expression.text === "String" && node.tag.name.text === "raw", getRawText = (node) => node.rawText ?? node.text, rewriteBunStringRawUnicode = (source, filePath = "input.ts") => {
   if (!source.includes("String.raw") || !NON_ASCII.test(source))
     return source;
-  const sourceFile = ts3.createSourceFile(filePath, source, ts3.ScriptTarget.Latest, true, getScriptKind(filePath));
+  const sourceFile = ts4.createSourceFile(filePath, source, ts4.ScriptTarget.Latest, true, getScriptKind(filePath));
   const replacements = [];
   const visit = (node) => {
-    if (ts3.isTaggedTemplateExpression(node) && isStringRawTag(node)) {
-      const rawSegments = ts3.isNoSubstitutionTemplateLiteral(node.template) ? [getRawText(node.template)] : [
+    if (ts4.isTaggedTemplateExpression(node) && isStringRawTag(node)) {
+      const rawSegments = ts4.isNoSubstitutionTemplateLiteral(node.template) ? [getRawText(node.template)] : [
         getRawText(node.template.head),
         ...node.template.templateSpans.map((span) => getRawText(span.literal))
       ];
       if (rawSegments.some((segment) => NON_ASCII.test(segment))) {
-        const expressions = ts3.isTemplateExpression(node.template) ? node.template.templateSpans.map((span) => {
+        const expressions = ts4.isTemplateExpression(node.template) ? node.template.templateSpans.map((span) => {
           const expression = source.slice(span.expression.getStart(sourceFile), span.expression.end);
           return rewriteBunStringRawUnicode(expression, filePath);
         }) : [];
         const args = [
-          `{ raw: [${rawSegments.map((text) => JSON.stringify(text)).join(", ")}] }`,
+          `{ raw: [${rawSegments.map((text2) => JSON.stringify(text2)).join(", ")}] }`,
           ...expressions
         ];
         replacements.push({
@@ -7314,7 +7819,7 @@ var NON_ASCII, getScriptKind = (filePath) => {
         return;
       }
     }
-    ts3.forEachChild(node, visit);
+    ts4.forEachChild(node, visit);
   };
   visit(sourceFile);
   let result = source;
@@ -7579,20 +8084,20 @@ var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-
 // src/mobile/buildRelease.ts
 import { createHash as createHash9 } from "crypto";
 import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
-import { basename as basename7, dirname as dirname11, extname as extname3, join as join19, relative as relative10, resolve as resolve14 } from "path";
+import { basename as basename7, dirname as dirname11, extname as extname4, join as join20, relative as relative11, resolve as resolve15 } from "path";
 var sha256 = (bytes) => createHash9("sha256").update(bytes).digest("hex"), STATIC_SCRIPT_PATTERN, rewriteStaticScriptPaths = (source, manifest) => source.replace(STATIC_SCRIPT_PATTERN, (match, prefix, path, suffix) => {
   if (path.endsWith("/htmx.min.js"))
     return match;
-  const key = toPascal(basename7(path, extname3(path)));
+  const key = toPascal(basename7(path, extname4(path)));
   const builtPath = manifest[key];
   return builtPath ? `${prefix}${builtPath}${suffix}` : match;
 }), readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]), resolveAssetPath = (buildDirectory, assetPath) => {
-  const resolvedBuildDirectory = resolve14(buildDirectory);
-  const resolvedAsset = resolve14(assetPath);
+  const resolvedBuildDirectory = resolve15(buildDirectory);
+  const resolvedAsset = resolve15(assetPath);
   if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
     return resolvedAsset;
   }
-  return join19(buildDirectory, assetPath.replace(/^\/+/, ""));
+  return join20(buildDirectory, assetPath.replace(/^\/+/, ""));
 }, pageFor = async (metadata, manifest, buildDirectory) => {
   const assetPath = manifest[metadata.bundleKey];
   if (!assetPath) {
@@ -7603,7 +8108,7 @@ var sha256 = (bytes) => createHash9("sha256").update(bytes).digest("hex"), STATI
     const source = await readFile9(resolvedAssetPath, "utf8");
     const rewritten = rewriteStaticScriptPaths(source, manifest);
     const documentHash = sha256(new TextEncoder().encode(rewritten));
-    resolvedAssetPath = join19(buildDirectory, ".absolutejs", "mobile-pages", `${documentHash}.html`);
+    resolvedAssetPath = join20(buildDirectory, ".absolutejs", "mobile-pages", `${documentHash}.html`);
     await mkdir8(dirname11(resolvedAssetPath), { recursive: true });
     await writeFile7(resolvedAssetPath, rewritten);
   }
@@ -7617,8 +8122,8 @@ var sha256 = (bytes) => createHash9("sha256").update(bytes).digest("hex"), STATI
     readFile9(resolvedAssetPath),
     resolvedStylePath ? readFile9(resolvedStylePath) : undefined
   ]);
-  const bundlePath = `/${relative10(resolve14(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
-  const styleBundlePath = resolvedStylePath ? `/${relative10(resolve14(buildDirectory), resolvedStylePath).replaceAll("\\", "/")}` : undefined;
+  const bundlePath = `/${relative11(resolve15(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const styleBundlePath = resolvedStylePath ? `/${relative11(resolve15(buildDirectory), resolvedStylePath).replaceAll("\\", "/")}` : undefined;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
@@ -7819,40 +8324,40 @@ import {
   rm as rm6,
   writeFile as writeFile8
 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import { basename as basename8, dirname as dirname12, extname as extname4, join as join20, relative as relative11, resolve as resolve15 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { basename as basename8, dirname as dirname12, extname as extname5, join as join21, relative as relative12, resolve as resolve16 } from "path";
 var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-mobile-bootstrap.js", INDEX_FILE = "index.html", CLIENT_CSS_DEPENDENCY_PATTERN, CLIENT_MARKUP_DEPENDENCY_PATTERN, CAPACITOR_CLIENT_FRAMEWORKS, CLIENT_ASSET_DIRECTORIES, errorHasCode = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code, shellBootstrapModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join21(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync10);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
 }, shellAuthModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellAuth.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join21(import.meta.dir, `shellAuth.${extension}`)).find(existsSync10);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile auth shell module is missing.");
 }, shellExpoAuthModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellExpoAuth.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join21(import.meta.dir, `shellExpoAuth.${extension}`)).find(existsSync10);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS Expo auth bridge module is missing.");
 }, shellSyncModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellSync.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join21(import.meta.dir, `shellSync.${extension}`)).find(existsSync10);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile Sync shell module is missing.");
 }, shellExpoSyncModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellExpoSync.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join21(import.meta.dir, `shellExpoSync.${extension}`)).find(existsSync10);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS Expo Sync bridge module is missing.");
 }, shellPushModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellPush.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join21(import.meta.dir, `shellPush.${extension}`)).find(existsSync10);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile push shell module is missing.");
 }, shellExpoDevicesModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellExpoDevices.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join21(import.meta.dir, `shellExpoDevices.${extension}`)).find(existsSync10);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS Expo device bridge module is missing.");
@@ -7883,8 +8388,8 @@ var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-
 	</body>
 </html>
 `, sourceAssetPath = (buildDirectory, bundlePath) => {
-  const root = resolve15(buildDirectory);
-  const asset = resolve15(root, bundlePath.replace(/^\/+/, ""));
+  const root = resolve16(buildDirectory);
+  const asset = resolve16(root, bundlePath.replace(/^\/+/, ""));
   if (!asset.startsWith(`${root}/`)) {
     throw new TypeError("Mobile page bundle escaped the build directory.");
   }
@@ -7899,15 +8404,15 @@ var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-
   const segments = specifier.split("/");
   const packageName = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0] ?? "";
   const subpath = specifier.slice(packageName.length);
-  const packageDirectory = join20(resolve15(projectRoot), "node_modules", packageName);
-  const manifest = JSON.parse(await readFile10(join20(packageDirectory, "package.json"), "utf8"));
+  const packageDirectory = join21(resolve16(projectRoot), "node_modules", packageName);
+  const manifest = JSON.parse(await readFile10(join21(packageDirectory, "package.json"), "utf8"));
   const exports = typeof manifest === "object" && manifest !== null ? Reflect.get(manifest, "exports") : undefined;
   const entry = typeof exports === "object" && exports !== null ? Reflect.get(exports, subpath ? `.${subpath}` : ".") : undefined;
   const target = importEntryTarget(entry);
   if (typeof target !== "string" || !target.startsWith("./"))
     throw new TypeError(`${specifier} does not publish an import entry.`);
-  const resolved = resolve15(packageDirectory, target);
-  if (!resolved.startsWith(`${resolve15(packageDirectory)}/`))
+  const resolved = resolve16(packageDirectory, target);
+  if (!resolved.startsWith(`${resolve16(packageDirectory)}/`))
     throw new TypeError(`${specifier} has an unsafe import entry.`);
   return resolved;
 }, buildShellBootstrap = async (staging, auth, sync, storagePrefix, engine, deviceCapabilities, projectRoot) => {
@@ -7936,10 +8441,10 @@ var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-
 const absoluteMobilePushCapability = absoluteDeviceCapability${pushIndex}(absoluteMobilePush.capabilityOptions);
 ` : "";
   const capabilityOptions = shellCapabilities.map((name, index) => `${JSON.stringify(name)}: ${name === "pushNotifications" ? "absoluteMobilePushCapability" : `absoluteDeviceCapability${index}()`}`).join(", ");
-  const entryPath = join20(staging, ".absolute-mobile-entry.ts");
+  const entryPath = join21(staging, ".absolute-mobile-entry.ts");
   const baseAdapterModule = capacitor ? await resolveProjectImport(projectRoot, "@absolutejs/devices-capacitor") : shellExpoDevicesModule();
   const adapterImport = capacitor ? `import { installCapacitorDeviceAdapterIfNative } from ${JSON.stringify(baseAdapterModule)};` : `import { createAbsoluteExpoBridgeFetch, installAbsoluteExpoWebDeviceAdapter } from ${JSON.stringify(baseAdapterModule)};`;
-  const adapterInstall = capacitor ? `installCapacitorDeviceAdapterIfNative({ storagePrefix: ${JSON.stringify(storagePrefix)}${capabilityOptions ? `, ${capabilityOptions}` : ""} });` : "installAbsoluteExpoWebDeviceAdapter();";
+  const adapterInstall = capacitor ? `installCapacitorDeviceAdapterIfNative({ storagePrefix: ${JSON.stringify(storagePrefix)}${capabilityOptions ? `, ${capabilityOptions}` : ""} });` : `installAbsoluteExpoWebDeviceAdapter(${JSON.stringify(deviceCapabilities.capabilities)});`;
   let shellOptions = auth ? options : "{ createFetch: createAbsoluteExpoBridgeFetch }";
   if (capacitor)
     shellOptions = options;
@@ -7961,7 +8466,7 @@ void startAbsoluteMobileShell(${shellOptions});
   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 ?? "", join20(staging, BOOTSTRAP_FILE));
+  await rename7(build.outputs[0]?.path ?? "", join21(staging, BOOTSTRAP_FILE));
   await rm6(entryPath, { force: true });
 }, removePreviousBundle = async (backup, moved) => {
   if (!moved)
@@ -7992,20 +8497,20 @@ void startAbsoluteMobileShell(${shellOptions});
   if (!CAPACITOR_CLIENT_FRAMEWORKS.has(page.framework)) {
     throw new TypeError(`Capacitor client rendering does not yet support ${page.framework} page ${page.pageId}.`);
   }
-  const extension = extname4(page.bundlePath) || ".js";
+  const extension = extname5(page.bundlePath) || ".js";
   const localBundlePath = `./pages/${page.bundleHash}${extension}`;
   const source = sourceAssetPath(buildDirectory, page.bundlePath);
-  await copyFile4(source, join20(staging, localBundlePath));
+  await copyFile4(source, join21(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
   let localStylePath;
   if (page.styleBundlePath && page.styleBundleHash) {
-    const styleExtension = extname4(page.styleBundlePath) || ".css";
+    const styleExtension = extname5(page.styleBundlePath) || ".css";
     localStylePath = `./styles/${page.styleBundleHash}${styleExtension}`;
     const styleSource = sourceAssetPath(buildDirectory, page.styleBundlePath);
-    await mkdir9(dirname12(join20(staging, localStylePath)), {
+    await mkdir9(dirname12(join21(staging, localStylePath)), {
       recursive: true
     });
-    await copyFile4(styleSource, join20(staging, localStylePath));
+    await copyFile4(styleSource, join21(staging, localStylePath));
     await copyAbsoluteClientDependencies(styleSource, buildDirectory, staging, copiedDependencies);
   }
   return {
@@ -8015,7 +8520,7 @@ void startAbsoluteMobileShell(${shellOptions});
   };
 }, absoluteClientImports = async (sourcePath, buildDirectory) => {
   const source = await readFile10(sourcePath, "utf8");
-  const extension = extname4(sourcePath).toLowerCase();
+  const extension = extname5(sourcePath).toLowerCase();
   let scriptLoader;
   if (extension === ".tsx")
     scriptLoader = "tsx";
@@ -8037,9 +8542,9 @@ void startAbsoluteMobileShell(${shellOptions});
     const clean = specifier.split(/[?#]/u, 1)[0] ?? specifier;
     if (clean.startsWith("/"))
       return [clean];
-    const resolved = resolve15(dirname12(sourcePath), clean);
-    const root = resolve15(buildDirectory);
-    const relativePath = relative11(root, resolved).replaceAll("\\", "/");
+    const resolved = resolve16(dirname12(sourcePath), clean);
+    const root = resolve16(buildDirectory);
+    const relativePath = relative12(root, resolved).replaceAll("\\", "/");
     if (relativePath === ".." || relativePath.startsWith("../")) {
       throw new TypeError(`Mobile client dependency escaped the build directory: ${specifier}`);
     }
@@ -8050,7 +8555,7 @@ void startAbsoluteMobileShell(${shellOptions});
     return;
   copied.add(specifier);
   const source = sourceAssetPath(buildDirectory, specifier);
-  const destination = join20(staging, specifier.replace(/^\/+/, ""));
+  const destination = join21(staging, specifier.replace(/^\/+/, ""));
   await mkdir9(dirname12(destination), { recursive: true });
   await copyFile4(source, destination);
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
@@ -8063,14 +8568,14 @@ void startAbsoluteMobileShell(${shellOptions});
   }
   const destination = options.config.bundleDirectory;
   await mkdir9(dirname12(destination), { recursive: true });
-  const staging = await mkdtemp4(join20(dirname12(destination), `.${basename8(destination)}.stage-`));
+  const staging = await mkdtemp4(join21(dirname12(destination), `.${basename8(destination)}.stage-`));
   try {
-    const pageDirectory = join20(staging, "pages");
+    const pageDirectory = join21(staging, "pages");
     await mkdir9(pageDirectory, { recursive: true });
     await Promise.all(CLIENT_ASSET_DIRECTORIES.map((directory) => ({
-      destination: join20(staging, directory),
-      source: join20(options.buildDirectory, directory)
-    })).filter(({ source }) => existsSync9(source)).map(({ destination: assetDestination, source }) => cp3(source, assetDestination, { recursive: true })));
+      destination: join21(staging, directory),
+      source: join21(options.buildDirectory, directory)
+    })).filter(({ source }) => existsSync10(source)).map(({ destination: assetDestination, source }) => cp3(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 = {
@@ -8103,9 +8608,9 @@ void startAbsoluteMobileShell(${shellOptions});
       } : {}
     };
     await Promise.all([
-      writeFile8(join20(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+      writeFile8(join21(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
-      writeFile8(join20(staging, INDEX_FILE), indexHtml(options.config.appName, options.config.productionOrigin)),
+      writeFile8(join21(staging, INDEX_FILE), indexHtml(options.config.appName, options.config.productionOrigin)),
       buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true, `absolutejs.${options.auth?.clientId ?? options.config.appId}.`, options.config.engine, options.deviceCapabilities, options.projectRoot)
     ]);
     await installBundle(staging, destination);
@@ -8161,7 +8666,7 @@ import {
   rm as rm7,
   writeFile as writeFile9
 } from "fs/promises";
-import { dirname as dirname13, join as join21, resolve as resolvePath3 } from "path";
+import { dirname as dirname13, join as join22, resolve as resolvePath3 } from "path";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "current.json", BUNDLES_DIRECTORY = "bundles", ARTIFACT_FILE = "artifact.json", BUNDLE_ID_PATTERN, isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code, bundleIdFor = (currentReleaseId, releases) => {
   const identity = JSON.stringify({
     currentReleaseId,
@@ -8191,16 +8696,16 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     releases
   };
 }, writeRelease = async (root, release) => {
-  const directory = join21(root, release.artifact.releaseId);
-  const producerPath = join21(directory, release.artifact.producer.module);
+  const directory = join22(root, release.artifact.releaseId);
+  const producerPath = join22(directory, release.artifact.producer.module);
   await mkdir10(dirname13(producerPath), { recursive: true });
   await Promise.all([
-    writeFile9(join21(directory, ARTIFACT_FILE), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile9(join22(directory, ARTIFACT_FILE), `${JSON.stringify(release.artifact, null, "\t")}
 `),
     writeFile9(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 }, installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join21(bundlesRoot, bundleId);
+  const destination = join22(bundlesRoot, bundleId);
   try {
     await access8(destination);
     return destination;
@@ -8208,7 +8713,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     if (!errorHasCode2(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp5(join21(bundlesRoot, ".stage-"));
+  const staging = await mkdtemp5(join22(bundlesRoot, ".stage-"));
   try {
     await Promise.all(releases.map((release) => writeRelease(staging, release)));
     await rename8(staging, destination);
@@ -8237,7 +8742,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     return release;
   });
   const root = resolvePath3(input.root);
-  const bundlesRoot = join21(root, BUNDLES_DIRECTORY);
+  const bundlesRoot = join22(root, BUNDLES_DIRECTORY);
   await mkdir10(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
@@ -8247,8 +8752,8 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
     releases: artifacts
   };
-  const pointerPath = join21(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join21(root, `.current-${crypto.randomUUID()}.json`);
+  const pointerPath = join22(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join22(root, `.current-${crypto.randomUUID()}.json`);
   await writeFile9(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
 `, { flag: "wx" });
   await rename8(temporaryPointerPath, pointerPath);
@@ -8256,12 +8761,12 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
 }, readAbsoluteMobileMaterializedReleases = async (root) => {
   const resolvedRoot = resolvePath3(root);
   try {
-    const serialized = await readFile11(join21(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const serialized = await readFile11(join22(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
     const parsed = JSON.parse(serialized);
     const index = parseBundleIndex(parsed);
-    const bundleRoot = join21(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    const bundleRoot = join22(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
     return Promise.all(index.releases.map(async (artifact) => {
-      const producer = Bun.file(join21(bundleRoot, artifact.releaseId, artifact.producer.module));
+      const producer = Bun.file(join22(bundleRoot, artifact.releaseId, artifact.producer.module));
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer
@@ -8280,261 +8785,6 @@ var init_materializedBundle = __esm(() => {
   BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
 });
 
-// src/mobile/deviceCapabilities.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { extname as extname5, join as join22, relative as relative12, resolve as resolve16 } from "path";
-import ts4 from "typescript";
-var DEVICES_PACKAGE = "@absolutejs/devices", CAPACITOR_ADAPTER = "@absolutejs/devices-capacitor", SOURCE_GLOB, IGNORED_DIRECTORIES, IDENTIFIER_PATTERN, CAPACITOR_MODULE_PATTERN, CAPACITOR_PACKAGE_PATTERN, ANDROID_PERMISSION_PATTERN, IOS_USAGE_DESCRIPTIONS, IOS_PRIVACY_ACCESSED_API_REASONS, IOS_PRIVACY_ACCESSED_APIS, object2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
-  const value = JSON.parse(readFileSync12(path, "utf8"));
-  if (!object2(value))
-    throw new TypeError(`${path} must contain an object.`);
-  return value;
-}, text = (value, field) => {
-  if (typeof value !== "string" || value.length === 0)
-    throw new TypeError(`${field} must be a non-empty string.`);
-  return value;
-}, androidPermissions = (value, field) => {
-  if (value === undefined)
-    return;
-  if (!object2(value))
-    throw new TypeError(`${field} must be an object.`);
-  const { permissions } = value;
-  if (!Array.isArray(permissions) || !permissions.every((permission) => typeof permission === "string" && ANDROID_PERMISSION_PATTERN.test(permission)))
-    throw new TypeError(`${field}.permissions must contain Android permission names.`);
-  return [...permissions];
-}, iosPrivacyAccessedApis = (value, field) => {
-  if (value === undefined)
-    return;
-  if (!object2(value))
-    throw new TypeError(`${field} must be an object.`);
-  const privacy = {};
-  for (const api of IOS_PRIVACY_ACCESSED_APIS) {
-    const reasons = value[api];
-    if (reasons === undefined)
-      continue;
-    const supported = IOS_PRIVACY_ACCESSED_API_REASONS[api];
-    if (!Array.isArray(reasons) || reasons.length === 0 || !reasons.every((reason) => typeof reason === "string" && supported.has(reason)))
-      throw new TypeError(`${field} contains an unsupported API or reason.`);
-    privacy[api] = [...reasons];
-  }
-  if (Object.keys(value).some((api) => !IOS_PRIVACY_ACCESSED_APIS.some((known) => known === api)))
-    throw new TypeError(`${field} contains an unsupported API or reason.`);
-  return privacy;
-}, iosNativeRequirements = (value, field) => {
-  if (value === undefined)
-    return;
-  if (!object2(value))
-    throw new TypeError(`${field} must be an object.`);
-  const {
-    privacyAccessedApis,
-    pushNotifications,
-    systemBars,
-    usageDescriptions
-  } = value;
-  if (pushNotifications !== undefined && pushNotifications !== true)
-    throw new TypeError(`${field}.pushNotifications must be true.`);
-  if (systemBars !== undefined && systemBars !== true)
-    throw new TypeError(`${field}.systemBars must be true.`);
-  if (usageDescriptions !== undefined && (!Array.isArray(usageDescriptions) || !usageDescriptions.every((purpose) => typeof purpose === "string" && IOS_USAGE_DESCRIPTIONS.has(purpose))))
-    throw new TypeError(`${field}.usageDescriptions contains an unsupported purpose.`);
-  const privacy = iosPrivacyAccessedApis(privacyAccessedApis, `${field}.privacyAccessedApis`);
-  return {
-    ...privacy === undefined ? {} : { privacyAccessedApis: privacy },
-    ...pushNotifications === true ? { pushNotifications: true } : {},
-    ...systemBars === true ? { systemBars: true } : {},
-    ...usageDescriptions === undefined ? {} : { usageDescriptions: [...usageDescriptions] }
-  };
-}, parseProvider = (name, value) => {
-  if (!IDENTIFIER_PATTERN.test(name))
-    throw new TypeError("Device capability names must be identifiers.");
-  if (!object2(value))
-    throw new TypeError(`Device capability ${name} must be an object.`);
-  const factory = text(value.factory, `${name}.factory`);
-  const module = text(value.module, `${name}.module`);
-  if (!IDENTIFIER_PATTERN.test(factory))
-    throw new TypeError(`${name}.factory must be a JavaScript identifier.`);
-  if (!CAPACITOR_MODULE_PATTERN.test(module))
-    throw new TypeError(`${name}.module must be an official devices-capacitor subpath.`);
-  if (!Array.isArray(value.packages) || !value.packages.every((spec) => typeof spec === "string" && CAPACITOR_PACKAGE_PATTERN.test(spec)))
-    throw new TypeError(`${name}.packages must contain exact official Capacitor package versions.`);
-  let native;
-  const { native: nativeMetadata } = value;
-  if (nativeMetadata !== undefined) {
-    if (!object2(nativeMetadata))
-      throw new TypeError(`${name}.native must be an object.`);
-    const { android, ios } = nativeMetadata;
-    const permissions = androidPermissions(android, `${name}.native.android`);
-    const iosRequirements = iosNativeRequirements(ios, `${name}.native.ios`);
-    native = {
-      ...permissions === undefined ? {} : { android: { permissions } },
-      ...iosRequirements === undefined ? {} : { ios: iosRequirements }
-    };
-  }
-  return {
-    factory,
-    module,
-    ...native === undefined ? {} : { native },
-    packages: [...value.packages]
-  };
-}, absoluteDeviceNativeRequirements = (plan) => {
-  const privacy = plan.capabilities.reduce((requirements, name) => {
-    for (const api of IOS_PRIVACY_ACCESSED_APIS) {
-      const reasons = plan.providers[name]?.native?.ios?.privacyAccessedApis?.[api] ?? [];
-      if (reasons.length === 0)
-        continue;
-      const current = requirements[api] ?? new Set;
-      for (const reason of reasons)
-        current.add(reason);
-      requirements[api] = current;
-    }
-    return requirements;
-  }, {});
-  return {
-    androidPermissions: [
-      ...new Set(plan.capabilities.flatMap((name) => plan.providers[name]?.native?.android?.permissions ?? []))
-    ].sort(),
-    iosPrivacyAccessedApis: IOS_PRIVACY_ACCESSED_APIS.flatMap((api) => {
-      const reasons = privacy[api];
-      return reasons ? [{ api, reasons: [...reasons].sort() }] : [];
-    }),
-    iosPushNotifications: plan.capabilities.some((name) => plan.providers[name]?.native?.ios?.pushNotifications === true),
-    iosSystemBars: plan.capabilities.some((name) => plan.providers[name]?.native?.ios?.systemBars === true),
-    iosUsageDescriptions: [
-      ...new Set(plan.capabilities.flatMap((name) => plan.providers[name]?.native?.ios?.usageDescriptions ?? []))
-    ].sort()
-  };
-}, loadAbsoluteDeviceCapabilityProviders = (projectRoot) => {
-  const path = join22(resolve16(projectRoot), "node_modules", CAPACITOR_ADAPTER, "package.json");
-  const manifest = readJson(path);
-  const { absolutejs } = manifest;
-  const devices = object2(absolutejs) ? absolutejs.devices : undefined;
-  if (!object2(devices) || devices.format !== 1 || devices.provider !== "capacitor" || !object2(devices.capabilities))
-    throw new TypeError(`${CAPACITOR_ADAPTER} does not publish supported capability metadata.`);
-  const entries = Object.entries(devices.capabilities).map(([name, provider]) => ({
-    name,
-    provider: parseProvider(name, provider)
-  }));
-  return Object.fromEntries(entries.sort((left, right) => left.name.localeCompare(right.name)).map(({ name, provider }) => [name, provider]));
-}, isIgnored2 = (path) => path.split("/").some((segment) => IGNORED_DIRECTORIES.has(segment)), importedCapabilities = (source, file) => {
-  const names = new Set;
-  const namespaces = new Set;
-  const visit = (node) => {
-    if (ts4.isImportDeclaration(node) && ts4.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && !node.importClause?.isTypeOnly) {
-      const bindings = node.importClause?.namedBindings;
-      if (bindings && ts4.isNamedImports(bindings)) {
-        for (const element of bindings.elements)
-          if (!element.isTypeOnly)
-            names.add((element.propertyName ?? element.name).text);
-      }
-      if (bindings && ts4.isNamespaceImport(bindings))
-        namespaces.add(bindings.name.text);
-    }
-    if (ts4.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts4.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && node.exportClause && ts4.isNamedExports(node.exportClause)) {
-      for (const element of node.exportClause.elements)
-        if (!element.isTypeOnly)
-          names.add((element.propertyName ?? element.name).text);
-    }
-    if (ts4.isPropertyAccessExpression(node) && ts4.isIdentifier(node.expression) && namespaces.has(node.expression.text))
-      names.add(node.name.text);
-    ts4.forEachChild(node, visit);
-  };
-  const extension = extname5(file).toLowerCase();
-  const sources = extension === ".svelte" || extension === ".vue" ? [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/giu)].map((match) => match[1]).filter((value) => value !== undefined) : [source];
-  for (const [index, script] of sources.entries())
-    visit(ts4.createSourceFile(`${file}#script-${index}`, script, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TSX));
-  return names;
-}, assertAbsoluteDeviceCapabilityPackages = (projectRoot, plan) => {
-  const missing = missingAbsoluteDeviceCapabilityPackages(plan, directAbsoluteProjectPackages(projectRoot));
-  const mismatched = plan.requiredPackages.filter((spec) => {
-    const separator = spec.lastIndexOf("@");
-    const packageName = spec.slice(0, separator);
-    if (missing.includes(spec))
-      return false;
-    try {
-      return readJson(join22(resolve16(projectRoot), "node_modules", packageName, "package.json")).version !== spec.slice(separator + 1);
-    } catch {
-      return true;
-    }
-  });
-  const unmet = [...missing, ...mismatched];
-  if (unmet.length > 0)
-    throw new TypeError(`Device capabilities ${plan.capabilities.join(", ")} require ${unmet.join(", ")}. Run absolute mobile sync and approve the detected capability plugins.`);
-}, directAbsoluteProjectPackages = (projectRoot) => {
-  const manifest = readJson(join22(resolve16(projectRoot), "package.json"));
-  const packages = new Set;
-  for (const field of ["dependencies", "devDependencies"]) {
-    const dependencies = manifest[field];
-    if (object2(dependencies))
-      for (const name of Object.keys(dependencies))
-        packages.add(name);
-  }
-  return packages;
-}, discoverAbsoluteDeviceCapabilities = (projectRoot, providers = loadAbsoluteDeviceCapabilityProviders(projectRoot)) => {
-  const root = resolve16(projectRoot);
-  const known = new Set(Object.keys(providers));
-  const capabilities = new Set;
-  for (const path of SOURCE_GLOB.scanSync({ cwd: root })) {
-    const portable = relative12(root, resolve16(root, path)).replaceAll("\\", "/");
-    if (isIgnored2(portable))
-      continue;
-    const source = readFileSync12(resolve16(root, portable), "utf8");
-    for (const name of importedCapabilities(source, portable))
-      if (known.has(name))
-        capabilities.add(name);
-  }
-  return [...capabilities].sort();
-}, missingAbsoluteDeviceCapabilityPackages = (plan, directPackages) => plan.requiredPackages.filter((spec) => {
-  const packageName = spec.slice(0, spec.lastIndexOf("@"));
-  return !directPackages.has(packageName);
-}), resolveAbsoluteDeviceCapabilityPlan = (projectRoot) => {
-  const allProviders = loadAbsoluteDeviceCapabilityProviders(projectRoot);
-  const capabilities = discoverAbsoluteDeviceCapabilities(projectRoot, allProviders);
-  const providers = {};
-  for (const name of capabilities) {
-    const provider = allProviders[name];
-    if (provider)
-      providers[name] = provider;
-  }
-  return {
-    capabilities,
-    providers,
-    requiredPackages: [
-      ...new Set(capabilities.flatMap((name) => providers[name]?.packages ?? []))
-    ].sort()
-  };
-};
-var init_deviceCapabilities = __esm(() => {
-  SOURCE_GLOB = new Bun.Glob("**/*.{js,jsx,ts,tsx,svelte,vue}");
-  IGNORED_DIRECTORIES = new Set([
-    ".absolutejs",
-    ".git",
-    ".test-builds",
-    ".test-shards",
-    "build",
-    "dist",
-    "node_modules",
-    "test",
-    "tests"
-  ]);
-  IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/u;
-  CAPACITOR_MODULE_PATTERN = /^@absolutejs\/devices-capacitor\/[a-z][a-z0-9-]*$/u;
-  CAPACITOR_PACKAGE_PATTERN = /^@capacitor\/[a-z][a-z0-9-]*@\d+\.\d+\.\d+$/u;
-  ANDROID_PERMISSION_PATTERN = /^android\.permission\.[A-Z][A-Z0-9_]*$/u;
-  IOS_USAGE_DESCRIPTIONS = new Set([
-    "camera",
-    "location-always",
-    "location-when-in-use",
-    "photo-library",
-    "photo-library-add"
-  ]);
-  IOS_PRIVACY_ACCESSED_API_REASONS = {
-    NSPrivacyAccessedAPICategoryFileTimestamp: new Set(["C617.1"])
-  };
-  IOS_PRIVACY_ACCESSED_APIS = [
-    "NSPrivacyAccessedAPICategoryFileTimestamp"
-  ];
-});
-
 // src/mobile/buildPipeline.ts
 import { readFile as readFile12 } from "fs/promises";
 import { join as join23, resolve as resolve17 } from "path";
@@ -8606,11 +8856,8 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
   const auth = resolveAbsoluteMobileAuthManifest(options.projectRoot, mobile);
   const sync = auth !== undefined && projectUsesAbsoluteSync(options.projectRoot);
   const syncSchema = sync ? discoverAbsoluteSyncSchema(options.projectRoot) : undefined;
-  const deviceCapabilities = resolveAbsoluteDeviceCapabilityPlan(options.projectRoot);
+  const deviceCapabilities = resolveAbsoluteDeviceCapabilityPlan(options.projectRoot, mobile.engine);
   const usesPush = deviceCapabilities.capabilities.includes("pushNotifications");
-  if (mobile.engine === "expo" && deviceCapabilities.capabilities.some((capability) => capability !== "haptics")) {
-    throw new TypeError("Experimental Expo builds currently bridge only @absolutejs/devices haptics. Other detected device capabilities require their Expo adapters.");
-  }
   if (usesPush && !auth)
     throw new TypeError("Portable push notifications require @absolutejs/auth so provider tokens can be registered without exposing identity controls to page code.");
   if (usesPush && !loaded.app.routes.some((route) => route.path === "/auth/push" || route.path === "/auth/mobile/push"))
@@ -8663,10 +8910,10 @@ var init_buildPipeline = __esm(() => {
 });
 
 // src/mobile/routeMetadataTransform.ts
-import { existsSync as existsSync10, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
 import { dirname as dirname14, extname as extname6, relative as relative13, resolve as resolve18 } from "path";
 import ts5 from "typescript";
-var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.replace(/\\/g, "/"), findTsconfig = (entry, projectRoot) => ts5.findConfigFile(dirname14(entry), existsSync10, "tsconfig.json") ?? ts5.findConfigFile(projectRoot, existsSync10, "tsconfig.json"), createProgram = (entry, projectRoot) => {
+var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.replace(/\\/g, "/"), findTsconfig = (entry, projectRoot) => ts5.findConfigFile(dirname14(entry), existsSync11, "tsconfig.json") ?? ts5.findConfigFile(projectRoot, existsSync11, "tsconfig.json"), createProgram = (entry, projectRoot) => {
   const configPath2 = findTsconfig(entry, projectRoot);
   if (!configPath2) {
     return ts5.createProgram([entry], {
@@ -9934,7 +10181,7 @@ var init_rewriteImports = __esm(() => {
 
 // src/cli/scripts/start.ts
 var {env: env2 } = globalThis.Bun;
-import { existsSync as existsSync11, readFileSync as readFileSync15, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync15, rmSync as rmSync4 } from "fs";
 import { basename as basename9, join as join26, resolve as resolve21 } from "path";
 var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, resolvePackageVersion = (candidates) => {
   for (const candidate of candidates) {
@@ -9992,7 +10239,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     resolve21(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync11(candidate))
+    if (existsSync12(candidate))
       return candidate;
   }
   return resolve21(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
@@ -10029,7 +10276,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   serverEntry,
   totalDuration
 }) => {
-  const usesDocker = existsSync11(resolve21(COMPOSE_PATH));
+  const usesDocker = existsSync12(resolve21(COMPOSE_PATH));
   const scripts = usesDocker ? await readDbScripts() : null;
   if (scripts)
     await startDatabase(scripts);
@@ -10140,7 +10387,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   ].filter((val) => Boolean(val));
   const outputPath = resolve21(resolvedOutdir, `${entryName}.js`);
   if (options.prebuilt) {
-    if (!existsSync11(outputPath)) {
+    if (!existsSync12(outputPath)) {
       throw new Error(`Prepared production server not found: ${outputPath}`);
     }
     return runPreparedServer({
@@ -10267,11 +10514,11 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!serverBundle.success) {
     handleBundleFailure(serverBundle, bundleStart, serverEntry);
   }
-  if (!existsSync11(outputPath)) {
+  if (!existsSync12(outputPath)) {
     console.error(cliTag2("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync11(resolve21(resolvedOutdir, "angular", "vendor", "server"))) {
+  if (existsSync12(resolve21(resolvedOutdir, "angular", "vendor", "server"))) {
     const { readdirSync: readdirSync2 } = await import("fs");
     const vendorDir = resolve21(resolvedOutdir, "angular", "vendor", "server");
     const vendorEntries = readdirSync2(vendorDir).filter((fileName) => fileName.endsWith(".js"));
@@ -10470,11 +10717,11 @@ var exports_build = {};
 __export(exports_build, {
   build: () => build
 });
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync17 } from "fs";
 import { join as join27, resolve as resolve23 } from "path";
 var PROFILE_TOP = 15, PROFILE_COL = 8, FRAMEWORK_KEYS, cliTag3 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, printProfile = (buildDir) => {
   const traceDir = join27(buildDir, ".absolute-trace");
-  if (!existsSync13(traceDir))
+  if (!existsSync14(traceDir))
     return;
   const files = readdirSync3(traceDir).filter((file) => file.endsWith(".json")).sort();
   const latest = files[files.length - 1];
@@ -10573,7 +10820,7 @@ import {
   verify
 } from "crypto";
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   lstatSync,
   mkdirSync as mkdirSync8,
   mkdtempSync,
@@ -10773,7 +11020,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
   const cwd = options.cwd ?? process.cwd();
   const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
   const path = resolve24(cwd, proofLocation);
-  if (!existsSync14(path))
+  if (!existsSync15(path))
     return { reason: `missing lint proof: ${proofLocation}`, valid: false };
   let proof;
   try {
@@ -10890,7 +11137,7 @@ var init_lintProof = __esm(() => {
 // src/build/scanConventions.ts
 import { basename as basename10 } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 var CONVENTION_RE, classifyFile = (file, pageFiles, defaults, pages) => {
   const fileName = basename10(file);
   const match = CONVENTION_RE.exec(fileName);
@@ -10915,7 +11162,7 @@ var CONVENTION_RE, classifyFile = (file, pageFiles, defaults, pages) => {
   else if (kind === "loading")
     pages[pageName].loading = file;
 }, scanConventions = async (pagesDir, pattern) => {
-  if (!existsSync15(pagesDir)) {
+  if (!existsSync16(pagesDir)) {
     const pageFiles2 = [];
     return { conventions: undefined, pageFiles: pageFiles2 };
   }
@@ -10942,7 +11189,7 @@ var exports_ls = {};
 __export(exports_ls, {
   runLs: () => runLs
 });
-import { existsSync as existsSync16, readFileSync as readFileSync19, statSync } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync19, statSync } from "fs";
 import { basename as basename11, extname as extname7, join as join28, relative as relative15 } from "path";
 var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELDS, readStringField = (source, key) => {
   const value = Reflect.get(source, key);
@@ -10993,10 +11240,10 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
     return pages ? [{ label, pages: sortPages(pages) }] : [];
   });
 }, resolveDiskPath = (buildDir, value) => {
-  if (existsSync16(value))
+  if (existsSync17(value))
     return value;
   const underBuild = join28(buildDir, value);
-  if (existsSync16(underBuild))
+  if (existsSync17(underBuild))
     return underBuild;
   return join28(process.cwd(), value);
 }, fileSize = (diskPath) => {
@@ -11124,7 +11371,7 @@ ${colors.dim}${frameworkCount} ${frameworkCount === 1 ? "framework" : "framework
   }
   const sizesDir = resolveSizesDir(args, candidates);
   const manifestPath = join28(sizesDir, "manifest.json");
-  if (!existsSync16(manifestPath)) {
+  if (!existsSync17(manifestPath)) {
     printDim(`No build at ${relativeOrSelf(manifestPath)}. Run \`absolute build\` first, or pass \`--outdir <dir>\`.`);
     return;
   }
@@ -11974,7 +12221,7 @@ var exports_heapDiff = {};
 __export(exports_heapDiff, {
   runHeapDiff: () => runHeapDiff
 });
-import { existsSync as existsSync17, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync20 } from "fs";
 var TOP = 15, STRING_TYPES, aggregate = (path) => {
   const data = JSON.parse(readFileSync20(path, "utf-8"));
   const { nodes, strings } = data;
@@ -12005,7 +12252,7 @@ var TOP = 15, STRING_TYPES, aggregate = (path) => {
     return;
   }
   for (const path of [beforePath, afterPath]) {
-    if (existsSync17(path))
+    if (existsSync18(path))
       continue;
     process.stdout.write(`${colors.red}No such file: ${path}${colors.reset}
 `);
@@ -12126,7 +12373,7 @@ var isRecord9 = (value) => typeof value === "object" && value !== null && !Array
 // src/cli/config/schema/fromType.ts
 import ts6 from "typescript";
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync21,
   statSync as statSync2,
@@ -12321,7 +12568,7 @@ export { value };
   const cached = cache.get(cacheKey);
   if (cached)
     return cached;
-  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync18(resolve25(cwd, "types/index.ts"));
+  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync19(resolve25(cwd, "types/index.ts"));
   const signature = cacheSignature(cwd, typeName, local, specifier);
   const fromDisk = readDiskCache(cwd, typeName, signature, specifier);
   if (fromDisk) {
@@ -12349,16 +12596,16 @@ var init_fromType = __esm(() => {
 
 // src/cli/config/absolute/resolveAbsoluteConfig.ts
 import ts7 from "typescript";
-import { existsSync as existsSync19, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync22 } from "fs";
 import { resolve as resolve26 } from "path";
 var CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath = (cwd, override) => {
   if (override) {
     const resolved = resolve26(cwd, override);
-    return existsSync19(resolved) ? resolved : null;
+    return existsSync20(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES2) {
     const candidate = resolve26(cwd, name);
-    if (existsSync19(candidate))
+    if (existsSync20(candidate))
       return candidate;
   }
   return null;
@@ -12682,7 +12929,7 @@ var emptyOutcome = () => ({
 
 // src/cli/generate/routeWiring.ts
 import ts8 from "typescript";
-import { existsSync as existsSync20, readFileSync as readFileSync23, readdirSync as readdirSync4, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync23, readdirSync as readdirSync4, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname18, join as join30 } from "path";
 var DEFAULT_SEPARATOR = `
 		`, BOUNDARY_USE, applyEdits = (text2, edits) => {
@@ -12831,13 +13078,13 @@ ${newLines.join(`
   return lines.join(`
 `);
 }, hasChain = (path) => {
-  if (!existsSync20(path))
+  if (!existsSync21(path))
     return false;
   const sourceFile = parse2(path, readFileSync23(path, "utf-8"));
   const found = findElysiaNew(sourceFile);
   return found !== null;
 }, firstChainFile = (pluginsDir) => {
-  if (!existsSync20(pluginsDir))
+  if (!existsSync21(pluginsDir))
     return null;
   for (const name of readdirSync4(pluginsDir)) {
     if (!name.endsWith(".ts"))
@@ -12940,7 +13187,7 @@ var init_routeWiring = __esm(() => {
 });
 
 // src/cli/generate/generateApi.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname19, join as join31 } from "path";
 var apiPluginTemplate = (pluginName, base) => `import { Elysia } from 'elysia';
 
@@ -12955,7 +13202,7 @@ export const ${pluginName} = new Elysia()
   const outcome = { ...emptyOutcome(), route: base };
   const pluginsDir = join31(dirname19(project.serverEntry), "plugins");
   const fileAbs = join31(pluginsDir, `${pluginName}.ts`);
-  if (existsSync21(fileAbs)) {
+  if (existsSync22(fileAbs)) {
     outcome.notes.push(`${pluginName} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
@@ -13028,7 +13275,7 @@ var init_componentTemplates = __esm(() => {
 });
 
 // src/cli/generate/generateComponent.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname20, join as join32 } from "path";
 var generateComponent = (project, framework, rawName) => {
   const def = frameworks6[framework];
@@ -13041,7 +13288,7 @@ var generateComponent = (project, framework, rawName) => {
     return outcome;
   }
   const fileAbs = join32(frameworkDir, "components", def.componentFile({ kebab, pascal }));
-  if (existsSync22(fileAbs)) {
+  if (existsSync23(fileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
@@ -13061,7 +13308,7 @@ var init_generateComponent = __esm(() => {
 
 // src/cli/generate/cssStrategy.ts
 import ts9 from "typescript";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { join as join33 } from "path";
 var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
 	margin: 0 auto;
@@ -13109,7 +13356,7 @@ var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
     return {
       assetKey: sharedKey,
       contents: DEFAULT_CSS,
-      create: !existsSync23(cssFileAbs2),
+      create: !existsSync24(cssFileAbs2),
       cssFileAbs: cssFileAbs2,
       shared: true
     };
@@ -13118,7 +13365,7 @@ var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
   return {
     assetKey: `${pascal}${CSS_SUFFIX}`,
     contents: DEFAULT_CSS,
-    create: !existsSync23(cssFileAbs),
+    create: !existsSync24(cssFileAbs),
     cssFileAbs,
     shared: false
   };
@@ -13127,7 +13374,7 @@ var init_cssStrategy = () => {};
 
 // src/cli/generate/navData.ts
 import ts10 from "typescript";
-import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync24, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync12, readFileSync as readFileSync24, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname21 } from "path";
 var NAV_DATA_TEMPLATE = `type NavItem = {
 	href: string;
@@ -13166,7 +13413,7 @@ export const navData: NavItem[] = [];
   }
   return items;
 }, readNavItems = (navDataPath) => {
-  if (!existsSync24(navDataPath))
+  if (!existsSync25(navDataPath))
     return [];
   const text2 = readFileSync24(navDataPath, "utf-8");
   const sourceFile = ts10.createSourceFile(navDataPath, text2, ts10.ScriptTarget.Latest, true);
@@ -13203,7 +13450,7 @@ ${indentOf(text2, array.getStart(sourceFile))}`;
 ${indent}${entry}`;
   return text2.slice(0, insertAt) + insertion + text2.slice(insertAt);
 }, upsertNavItem = (navDataPath, item) => {
-  const created = !existsSync24(navDataPath);
+  const created = !existsSync25(navDataPath);
   if (created) {
     mkdirSync12(dirname21(navDataPath), { recursive: true });
     writeFileSync12(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
@@ -13369,7 +13616,7 @@ var init_pageTemplates = __esm(() => {
 
 // src/cli/generate/generatePage.ts
 import {
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   mkdirSync as mkdirSync13,
   readFileSync as readFileSync25,
   readdirSync as readdirSync5,
@@ -13382,7 +13629,7 @@ var writeNew = (path, contents) => {
 }, toHref = (fromDir, toFile) => {
   const rel = relative17(fromDir, toFile).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
-}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join34(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync25(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join34(pagesDir, name))), resyncPage = (file, items) => {
+}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join34(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync26(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join34(pagesDir, name))), resyncPage = (file, items) => {
   const html = readFileSync25(file, "utf-8");
   const synced = syncStaticNav(html, items);
   if (synced === null || synced === html)
@@ -13411,7 +13658,7 @@ var writeNew = (path, contents) => {
     return outcome;
   }
   const pageFileAbs = join34(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
-  if (existsSync25(pageFileAbs)) {
+  if (existsSync26(pageFileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${pageFileAbs} \u2014 skipped.`);
     return outcome;
   }
@@ -13797,11 +14044,11 @@ var init_catalog = __esm(() => {
 });
 
 // src/cli/integrations/addPlugin.ts
-import { existsSync as existsSync26, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync27 } from "fs";
 import { join as join35 } from "path";
 var isRecord11 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readPackageJson = (cwd) => {
   const path = join35(cwd, "package.json");
-  if (!existsSync26(path))
+  if (!existsSync27(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync27(path, "utf-8"));
@@ -14296,16 +14543,16 @@ var init_authCatalog = __esm(() => {
 
 // src/cli/config/auth/resolveAuthSettings.ts
 import ts12 from "typescript";
-import { existsSync as existsSync27, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync28 } from "fs";
 import { resolve as resolve28 } from "path";
 var AUTH_PACKAGE = "@absolutejs/auth", CONFIG_CANDIDATES3, findAuthSettingsPath = (cwd, override) => {
   if (override) {
     const resolved = resolve28(cwd, override);
-    return existsSync27(resolved) ? resolved : null;
+    return existsSync28(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES3) {
     const candidate = resolve28(cwd, name);
-    if (existsSync27(candidate))
+    if (existsSync28(candidate))
       return candidate;
   }
   return null;
@@ -14401,10 +14648,10 @@ var init_resolveAuthSettings = __esm(() => {
 
 // src/cli/config/auth/resolveAuthState.ts
 import ts13 from "typescript";
-import { existsSync as existsSync28, readdirSync as readdirSync6, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync6, readFileSync as readFileSync29 } from "fs";
 import { join as join36, relative as relative19, resolve as resolve29 } from "path";
 var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutejs/absolute-auth", NPM_URL = "https://www.npmjs.com/package/@absolutejs/auth", SKIP_DIRS, MAX_FILES = 4000, SETUP_EXPORTS, isRecord12 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson2 = (path) => {
-  if (!existsSync28(path))
+  if (!existsSync29(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync29(path, "utf-8"));
@@ -14533,7 +14780,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
   scaffoldable: isScaffoldableFeature(feature.id)
 })), resolveAuthState = (cwd) => {
   const installedVersion = installedVersionFor(cwd);
-  const root = existsSync28(join36(cwd, "src")) ? join36(cwd, "src") : cwd;
+  const root = existsSync29(join36(cwd, "src")) ? join36(cwd, "src") : cwd;
   let match = null;
   let setupPath = null;
   for (const file of candidateFiles(root)) {
@@ -14578,7 +14825,7 @@ var init_resolveAuthState = __esm(() => {
 });
 
 // src/cli/config/auth/scaffoldAuthFeature.ts
-import { existsSync as existsSync29, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync30, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname23, join as join37, relative as relative20, resolve as resolve30 } from "path";
 var renderScaffold = (scaffold) => {
   const importNames = [...scaffold.imports, `type ${scaffold.typeName}`];
@@ -14606,7 +14853,7 @@ ${body}
   if (setupPath)
     return dirname23(resolve30(cwd, setupPath));
   const src = join37(cwd, "src");
-  return existsSync29(src) ? src : cwd;
+  return existsSync30(src) ? src : cwd;
 }, spreadFor = (scaffold) => `import { ${scaffold.exportName} } from './${scaffold.exportName}';
 // add to your auth() call:
 ${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
@@ -14621,7 +14868,7 @@ ${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
     return failure2(`Unknown auth feature "${id}".`);
   const filePath = join37(targetDir(cwd), `${scaffold.exportName}.ts`);
   const relPath = relative20(cwd, filePath);
-  if (existsSync29(filePath)) {
+  if (existsSync30(filePath)) {
     return {
       created: null,
       installed: false,
@@ -14648,13 +14895,13 @@ var init_scaffoldAuthFeature = __esm(() => {
 });
 
 // src/cli/htmx/install.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync14, readFileSync as readFileSync30, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync14, readFileSync as readFileSync30, writeFileSync as writeFileSync16 } from "fs";
 import { join as join38 } from "path";
 var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   join38(import.meta.dir, "htmx.min.js"),
   join38(import.meta.dir, "htmx", "htmx.min.js"),
   join38(import.meta.dir, "..", "htmx", "htmx.min.js")
-].find((path) => existsSync30(path)) ?? null, detectHtmxVersion = (content) => {
+].find((path) => existsSync31(path)) ?? null, detectHtmxVersion = (content) => {
   const match = content.match(/version:"([0-9.]+)"/);
   return match ? match[1] : null;
 }, fetchHtmx = async (version2) => {
@@ -14666,7 +14913,7 @@ var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   return response.text();
 }, installedHtmxVersion = (htmxDir) => {
   const file = join38(htmxDir, "htmx.min.js");
-  if (!existsSync30(file))
+  if (!existsSync31(file))
     return null;
   return detectHtmxVersion(readFileSync30(file, "utf-8"));
 }, readVendoredHtmx = () => {
@@ -14834,7 +15081,7 @@ var exports_analyze = {};
 __export(exports_analyze, {
   runAnalyze: () => runAnalyze
 });
-import { existsSync as existsSync31, readFileSync as readFileSync31, statSync as statSync3, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync31, statSync as statSync3, writeFileSync as writeFileSync17 } from "fs";
 import { join as join40, resolve as resolve31 } from "path";
 var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_WIDTH = 16, SIZE_WIDTH = 12, CHANGE_WIDTH = 10, CATEGORY_ORDER, categoryOf = (key) => {
   if (key.startsWith("Island"))
@@ -14856,7 +15103,7 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   }
 }, readSizes = (manifestDir) => {
   const manifestPath = join40(manifestDir, "manifest.json");
-  if (!existsSync31(manifestPath))
+  if (!existsSync32(manifestPath))
     return null;
   const manifest = JSON.parse(readFileSync31(manifestPath, "utf-8"));
   const sizes = {};
@@ -14866,7 +15113,7 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   return sizes;
 }, readBaseline = (cwd) => {
   const path = join40(cwd, BASELINE_FILE);
-  if (!existsSync31(path))
+  if (!existsSync32(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync31(path, "utf-8"));
@@ -15200,7 +15447,7 @@ var exports_remove = {};
 __export(exports_remove, {
   runRemove: () => runRemove
 });
-import { existsSync as existsSync32, readFileSync as readFileSync32 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync32 } from "fs";
 import { relative as relative22 } from "path";
 var write3 = (text2) => process.stdout.write(`${text2}
 `), fail3 = (message) => {
@@ -15211,7 +15458,7 @@ var write3 = (text2) => process.stdout.write(`${text2}
   const candidates = [findRoutingFile(serverEntry), serverEntry];
   const seen = new Set;
   return candidates.filter((file) => {
-    if (file === null || seen.has(file) || !existsSync32(file))
+    if (file === null || seen.has(file) || !existsSync33(file))
       return false;
     seen.add(file);
     return readFileSync32(file, "utf-8").includes(handler);
@@ -15341,10 +15588,10 @@ __export(exports_env, {
   runEnv: () => runEnv,
   scanEnvUsage: () => scanEnvUsage
 });
-import { existsSync as existsSync33, readFileSync as readFileSync33 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync33 } from "fs";
 import { join as join41 } from "path";
 var {env: env3, Glob: Glob3 } = globalThis.Bun;
-var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text2) => [...text2.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync33(join41(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
+var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text2) => [...text2.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync34(join41(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
   const scans = scanPatterns().map((pattern) => Array.fromAsync(new Glob3(pattern).scan({ cwd: process.cwd() })));
   const files = (await Promise.all(scans)).flat();
   const usage = new Map;
@@ -15410,7 +15657,7 @@ __export(exports_db, {
   quoteIdent: () => quoteIdent,
   runDb: () => runDb
 });
-import { existsSync as existsSync34, mkdirSync as mkdirSync15, readFileSync as readFileSync34, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync15, readFileSync as readFileSync34, writeFileSync as writeFileSync18 } from "fs";
 import { join as join42 } from "path";
 var {env: env4, spawn: spawn3, SQL } = globalThis.Bun;
 var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA_TYPES, SEED_CANDIDATES, VALUE_FLAGS, paint = (text2, color) => `${color}${text2}${colors.reset}`, chunkRows = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, idx) => items.slice(idx * size, idx * size + size)), quoteIdent = (name) => `"${name.replace(/"/g, '""')}"`, resolveUrl = (explicit) => {
@@ -15531,7 +15778,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
   console.log(paint(`\u2713 backup \u2192 ${file}`, colors.green));
   console.log(paint(`  ${chosen.length} tables, ${total} rows`, colors.dim));
 }, runRestore = async (file, options) => {
-  if (!existsSync34(file))
+  if (!existsSync35(file))
     throw new Error(`Backup not found: ${file}`);
   const payload = JSON.parse(readFileSync34(file, "utf-8"));
   const names = Object.keys(payload.tables).filter((name) => keepTable(name, options));
@@ -15555,7 +15802,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
   const total = order.reduce((sum, name) => sum + (payload.tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 restored ${order.length} tables, ${total} rows (idempotent upsert by primary key)`, colors.green));
 }, runSeed = async (entry) => {
-  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync34(join42(process.cwd(), candidate)));
+  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync35(join42(process.cwd(), candidate)));
   if (target === undefined)
     throw new Error(`No seed script found (looked for ${SEED_CANDIDATES.join(", ")}). Pass a path: absolute db seed <file>.`);
   console.log(paint(`seeding via ${target}\u2026`, colors.cyan));
@@ -15616,7 +15863,7 @@ __export(exports_logs, {
 });
 import {
   closeSync as closeSync2,
-  existsSync as existsSync35,
+  existsSync as existsSync36,
   openSync as openSync4,
   readSync as readSync2,
   statSync as statSync4,
@@ -15683,7 +15930,7 @@ var DEFAULT_LINES = 40, POLL_MS = 250, LINES_FLAG_SPAN = 2, readFrom = (path, st
     printAvailable(instances);
     return;
   }
-  if (match.logFile === null || !existsSync35(match.logFile)) {
+  if (match.logFile === null || !existsSync36(match.logFile)) {
     printDim3(`"${name}" has no captured log (untracked, or started outside the CLI).`);
     return;
   }
@@ -15703,14 +15950,14 @@ var init_logs = __esm(() => {
 
 // src/cli/typeGraphCoherence.ts
 import {
-  existsSync as existsSync36,
+  existsSync as existsSync37,
   readFileSync as readFileSync35,
   realpathSync as realpathSync2,
   rmSync as rmSync6,
   writeFileSync as writeFileSync19
 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname25, join as join43, resolve as resolve32, sep as sep5 } from "path";
+import { dirname as dirname25, join as join43, resolve as resolve32, sep as sep6 } from "path";
 var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   try {
     const parsed = JSON.parse(readFileSync35(path, "utf-8"));
@@ -15754,7 +16001,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
 }, findInstallRoot = (cwd) => {
   let directory = resolve32(cwd);
   for (;; ) {
-    if (existsSync36(join43(directory, "bun.lock")) || existsSync36(join43(directory, "bun.lockb"))) {
+    if (existsSync37(join43(directory, "bun.lock")) || existsSync37(join43(directory, "bun.lockb"))) {
       return directory;
     }
     const parent = dirname25(directory);
@@ -15766,7 +16013,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   let directory = resolve32(cwd);
   for (;; ) {
     const candidate = join43(directory, "package.json");
-    if (existsSync36(candidate))
+    if (existsSync37(candidate))
       return candidate;
     if (directory === installRoot)
       return join43(installRoot, "package.json");
@@ -15870,8 +16117,8 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
 }, removeDuplicateTypeGraphPackages = (report) => {
   const manifest = readManifest(join43(report.installRoot, "package.json")) ?? {};
   const rootName = manifestName(manifest, "<workspace>");
-  const installPrefix = `${realpathSync2(report.installRoot)}${sep5}`;
-  const nodeModulesSegment = `${sep5}node_modules${sep5}`;
+  const installPrefix = `${realpathSync2(report.installRoot)}${sep6}`;
+  const nodeModulesSegment = `${sep6}node_modules${sep6}`;
   const removed = [];
   const stalePaths = duplicateTypeGraphPackages(report).flatMap((duplicate) => {
     const selected = preferredIdentity(duplicate, rootName);
@@ -15907,7 +16154,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync37, mkdirSync as mkdirSync16, readFileSync as readFileSync36, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync16, readFileSync as readFileSync36, writeFileSync as writeFileSync20 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { arch as arch4, platform as platform5 } from "os";
 import { join as join44 } from "path";
@@ -15945,7 +16192,7 @@ var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
     return [];
   const label = `${field.replace("Directory", "")} pages`;
   return [
-    existsSync37(join44(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
+    existsSync38(join44(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
   ];
 }), envCheck = async () => {
   const vars = await collectEnvVars();
@@ -16007,7 +16254,7 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const fixes = [];
   for (const field of FRAMEWORK_FIELDS2) {
     const dir = readString2(config, field);
-    if (dir === undefined || existsSync37(join44(cwd, dir)))
+    if (dir === undefined || existsSync38(join44(cwd, dir)))
       continue;
     mkdirSync16(join44(cwd, dir, "pages"), { recursive: true });
     fixes.push(`created ${dir}/pages`);
@@ -16018,7 +16265,7 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   if (missing.length === 0)
     return null;
   const envExample = join44(cwd, ".env.example");
-  const existing = existsSync37(envExample) ? readFileSync36(envExample, "utf-8") : "";
+  const existing = existsSync38(envExample) ? readFileSync36(envExample, "utf-8") : "";
   const existingKeys = new Set(existing.split(`
 `).map((line) => line.split("=")[0]?.trim()));
   const toAdd = missing.filter((entry) => !existingKeys.has(entry.key));
@@ -16392,10 +16639,10 @@ var init_inspect = __esm(() => {
 });
 
 // src/build/scanEntryPoints.ts
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 var {Glob: Glob4 } = globalThis.Bun;
 var scanEntryPoints = async (dir, pattern) => {
-  if (!existsSync38(dir))
+  if (!existsSync39(dir))
     return [];
   const entryPaths = [];
   const glob = new Glob4(pattern);
@@ -16547,7 +16794,7 @@ var exports_islands = {};
 __export(exports_islands, {
   runIslands: () => runIslands
 });
-import { existsSync as existsSync39, readFileSync as readFileSync38, statSync as statSync5 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync38, statSync as statSync5 } from "fs";
 import { join as join45, relative as relative23, resolve as resolve34 } from "path";
 var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.write(`${colors.dim}${message}${colors.reset}
 `), hostFrameworkOf = (pagePath, cwd, config) => {
@@ -16567,7 +16814,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
   }
 }, readManifestSizes2 = (manifestDir) => {
   const manifestPath = join45(manifestDir, "manifest.json");
-  if (!existsSync39(manifestPath))
+  if (!existsSync40(manifestPath))
     return null;
   const manifest = JSON.parse(readFileSync38(manifestPath, "utf-8"));
   const sizes = new Map;
@@ -16707,7 +16954,7 @@ var init_islands2 = __esm(() => {
 });
 
 // src/build/externalAssetPlugin.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync40, mkdirSync as mkdirSync17, statSync as statSync6 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync41, mkdirSync as mkdirSync17, statSync as statSync6 } from "fs";
 import { basename as basename12, dirname as dirname27, join as join46, resolve as resolve35 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
@@ -16729,12 +16976,12 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         if (!relPath)
           continue;
         const assetPath = resolve35(sourceDir, relPath);
-        if (!existsSync40(assetPath))
+        if (!existsSync41(assetPath))
           continue;
         if (!statSync6(assetPath).isFile())
           continue;
         const targetPath = join46(outDir, basename12(assetPath));
-        if (existsSync40(targetPath))
+        if (existsSync41(targetPath))
           continue;
         mkdirSync17(dirname27(targetPath), { recursive: true });
         copyFileSync2(assetPath, targetPath);
@@ -16754,7 +17001,7 @@ __export(exports_compile, {
 var {env: env5 } = globalThis.Bun;
 import {
   cpSync,
-  existsSync as existsSync41,
+  existsSync as existsSync42,
   mkdirSync as mkdirSync18,
   readdirSync as readdirSync7,
   readFileSync as readFileSync39,
@@ -16845,7 +17092,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const normalizedOutdir = resolve36(outdir);
   const copyReference = (filePath, relPath) => {
     const assetSource = resolve36(dirname28(filePath), relPath);
-    if (!existsSync41(assetSource) || !statSync7(assetSource).isFile())
+    if (!existsSync42(assetSource) || !statSync7(assetSource).isFile())
       return;
     const assetTarget = resolve36(normalizedOutdir, relPath.replace(/^\.\//, ""));
     if (assetTarget !== normalizedOutdir && !assetTarget.startsWith(`${normalizedOutdir}/`))
@@ -16929,7 +17176,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     resolve36(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync41(candidate))
+    if (existsSync42(candidate))
       return candidate;
   }
   return resolve36(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
@@ -17004,7 +17251,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!buildConfig.angularDirectory)
     return;
   const angularScopeDir = resolve36(process.cwd(), "node_modules", "@angular");
-  const angularPackages = existsSync41(angularScopeDir) ? readdirSync7(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
+  const angularPackages = existsSync42(angularScopeDir) ? readdirSync7(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
   const roots = new Set([...angularPackages, "rxjs", "tslib", "typescript"]);
   const seen = new Set;
   for (const specifier of roots) {
@@ -17023,7 +17270,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   copyChunkReferencedPackages(outdir, seen);
 }, collectRuntimePackageSpecifiers = (distDir) => {
   const nodeModulesDir = join47(distDir, "node_modules");
-  if (!existsSync41(nodeModulesDir))
+  if (!existsSync42(nodeModulesDir))
     return [];
   const specifiers = [];
   for (const entry of readdirSync7(nodeModulesDir, { withFileTypes: true })) {
@@ -17064,9 +17311,9 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const packageDir = join47(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
   const subPackageDir = subpath ? join47(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync41(join47(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const resolvedPackageDir = subPackageDir && existsSync42(join47(subPackageDir, "package.json")) ? subPackageDir : packageDir;
   const packageJsonPath = join47(resolvedPackageDir, "package.json");
-  if (!existsSync41(packageJsonPath))
+  if (!existsSync42(packageJsonPath))
     return null;
   const pkg = JSON.parse(readFileSync39(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir !== subPackageDir && subpath ? `.${subpath}` : ".";
@@ -17091,7 +17338,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
 }, findContainingRuntimePackageDir = (filePath) => {
   let dir = dirname28(filePath);
   while (dir !== dirname28(dir)) {
-    if (isNodeModulesPath(dir) && existsSync41(join47(dir, "package.json"))) {
+    if (isNodeModulesPath(dir) && existsSync42(join47(dir, "package.json"))) {
       return dir;
     }
     dir = dirname28(dir);
@@ -17771,11 +18018,11 @@ export default server;
     process.exit(1);
   }
   const outputPath = resolve36(resolvedOutdir, `${entryName}.js`);
-  if (!existsSync41(outputPath)) {
+  if (!existsSync42(outputPath)) {
     console.error(cliTag4("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync41(resolve36(resolvedOutdir, "angular", "vendor", "server"))) {
+  if (existsSync42(resolve36(resolvedOutdir, "angular", "vendor", "server"))) {
     const vendorDir = resolve36(resolvedOutdir, "angular", "vendor", "server");
     const vendorEntries = readdirSync7(vendorDir).filter((fileName) => fileName.endsWith(".js"));
     const angularServerVendorPaths = {};
@@ -19739,7 +19986,7 @@ import {
   stat as stat3,
   writeFile as writeFile15
 } from "fs/promises";
-import { dirname as dirname31, isAbsolute as isAbsolute7, join as join53, relative as relative27, resolve as resolve40, sep as sep6 } from "path";
+import { dirname as dirname31, isAbsolute as isAbsolute7, join as join53, relative as relative27, resolve as resolve40, sep as sep7 } from "path";
 var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), requireManifest2 = (value) => {
   if (!isRecord13(value) || typeof value.appBuild !== "string" || typeof value.appId !== "string" || typeof value.runtime !== "string") {
     throw new TypeError("Invalid embedded AbsoluteJS mobile manifest.");
@@ -19807,7 +20054,7 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
   const root = resolve40(projectRoot);
   const output = resolve40(root, requested ?? ".absolutejs/mobile/releases/android");
   const projectRelative = relative27(root, output);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute7(projectRelative)) {
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep7}`) || isAbsolute7(projectRelative)) {
     throw new TypeError("mobile build --outdir must remain inside the project.");
   }
   return output;
@@ -20393,7 +20640,7 @@ var init_androidTestReport = __esm(() => {
 
 // src/mobile/releasePublisher.ts
 import { access as access13 } from "fs/promises";
-import { isAbsolute as isAbsolute8, relative as relative28, resolve as resolve41, sep as sep7 } from "path";
+import { isAbsolute as isAbsolute8, relative as relative28, resolve as resolve41, sep as sep8 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -20418,7 +20665,7 @@ var prepareAbsoluteIosRelease = async (publisher, options) => {
   const root = resolve41(projectRoot);
   const path = resolve41(root, requested);
   const projectRelative = relative28(root, path);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep7}`) || isAbsolute8(projectRelative)) {
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep8}`) || isAbsolute8(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
   return path;
@@ -20633,9 +20880,9 @@ var init_mobileInspect = __esm(() => {
 });
 
 // src/mobile/ciWorkflow.ts
-import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import { access as access15, mkdir as mkdir15, readFile as readFile23, writeFile as writeFile17 } from "fs/promises";
-import { dirname as dirname32, extname as extname9, relative as relative30, resolve as resolve43, sep as sep8 } from "path";
+import { dirname as dirname32, extname as extname9, relative as relative30, resolve as resolve43, sep as sep9 } from "path";
 var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1, SECRET_NAME_PATTERN, CI_ENV_INDENTATION = 6, RESERVED_SECRET_NAMES, exists4 = async (path) => {
   try {
     await access15(path);
@@ -20647,12 +20894,12 @@ var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1, SECRET_NAME_PATTERN, CI_ENV_INDENTAT
   const root = resolve43(projectRoot);
   const path = resolve43(root, value);
   const portable = relative30(root, path).replaceAll("\\", "/");
-  if (portable === ".." || portable.startsWith(`..${sep8}`) || portable.startsWith("../") || portable === "") {
+  if (portable === ".." || portable.startsWith(`..${sep9}`) || portable.startsWith("../") || portable === "") {
     throw new TypeError(`${field} must remain inside the project root.`);
   }
   if (/\r|\n/u.test(portable) || portable.startsWith("-"))
     throw new TypeError(`${field} contains an unsafe path.`);
-  if (!options.allowMissing && !existsSync42(path))
+  if (!options.allowMissing && !existsSync43(path))
     throw new TypeError(`${field} does not exist inside the project.`);
   return portable;
 }, workflowOutputPath = (projectRoot, value) => {
@@ -20660,7 +20907,7 @@ var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1, SECRET_NAME_PATTERN, CI_ENV_INDENTAT
   const workflows = resolve43(root, ".github/workflows");
   const path = resolve43(root, value ?? ".github/workflows/absolute-mobile.yml");
   const portable = relative30(workflows, path);
-  if (portable === ".." || portable.startsWith(`..${sep8}`) || extname9(path) !== ".yml" && extname9(path) !== ".yaml") {
+  if (portable === ".." || portable.startsWith(`..${sep9}`) || extname9(path) !== ".yml" && extname9(path) !== ".yaml") {
     throw new TypeError("mobile ci github --output must be a .yml or .yaml file inside .github/workflows.");
   }
   return path;
@@ -21213,7 +21460,26 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
     throw new TypeError(`Expo exited with status ${exitCode}.`);
 }, ensureExpoPackages = async (project, args) => {
   try {
-    await access16(join56(project, "node_modules", "expo", "package.json"));
+    const manifest = JSON.parse(await readFile24(join56(project, "package.json"), "utf8"));
+    const dependencies = typeof manifest === "object" && manifest !== null ? Reflect.get(manifest, "dependencies") : undefined;
+    if (typeof dependencies !== "object" || dependencies === null || Array.isArray(dependencies))
+      throw new TypeError("Generated Expo dependencies are invalid.");
+    await Promise.all(Object.entries(dependencies).map(async ([name, expected]) => {
+      if (typeof expected !== "string")
+        throw new TypeError("Generated Expo dependency version is invalid.");
+      const installed = JSON.parse(await readFile24(join56(project, "node_modules", name, "package.json"), "utf8"));
+      const actual = typeof installed === "object" && installed !== null ? Reflect.get(installed, "version") : undefined;
+      if (typeof actual !== "string")
+        throw new TypeError("Installed Expo dependency version is invalid.");
+      if (/^\d+\.\d+\.\d+$/u.test(expected) && actual !== expected)
+        throw new TypeError("Installed Expo dependency is outdated.");
+      if (expected.startsWith("~")) {
+        const wanted = expected.slice(1).split(".").map(Number);
+        const found = actual.split(".").map(Number);
+        if (found[0] !== wanted[0] || found[1] !== wanted[1] || (found[2] ?? -1) < (wanted[2] ?? 0))
+          throw new TypeError("Installed Expo dependency is outdated.");
+      }
+    }));
     return;
   } catch {}
   const approved = args.includes("--yes") || await confirmInstall("The experimental Expo shell dependencies are missing. Install the pinned Expo SDK 57 toolchain now?");
@@ -22779,10 +23045,10 @@ __export(exports_typecheck, {
   typecheck: () => typecheck
 });
 import { resolve as resolve45, join as join57 } from "path";
-import { existsSync as existsSync43, readFileSync as readFileSync40 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync40 } from "fs";
 import { mkdir as mkdir17, writeFile as writeFile19 } from "fs/promises";
 var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve45(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
-  if (!existsSync43(resolveConfigPath(configPath2))) {
+  if (!existsSync44(resolveConfigPath(configPath2))) {
     const defaultService = {};
     return [defaultService];
   }
@@ -22804,7 +23070,7 @@ var isCommandService3 = (service) => service.kind === "command" || Array.isArray
   return { exitCode, name, output: (stdout + stderr).trim() };
 }, shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`, runShell = async (name, command) => run(name, ["/bin/bash", "-lc", command]), findBin = (name) => {
   const local = resolve45("node_modules", ".bin", name);
-  return existsSync43(local) ? local : null;
+  return existsSync44(local) ? local : null;
 }, ANSI_COLOR_REGEX, ANSI_PURPLE_REGEX, ANSI_CYAN_REGEX, ANSI_TOKEN_END_REGEX, stripAnsi4 = (str) => str.replace(ANSI_COLOR_REGEX, ""), formatSvelteOutput = (output) => {
   const cwd = `${process.cwd()}/`;
   const summaryMatch = stripAnsi4(output).match(/svelte-check found (\d+) error/);
@@ -22856,7 +23122,7 @@ Found ${errorCount} error${suffix}.`;
     resolve45(import.meta.dir, "../../types", fileName),
     resolve45(import.meta.dir, "../../../types", fileName)
   ];
-  return candidates.find((candidate) => existsSync43(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => existsSync44(candidate)) ?? candidates[0];
 }, ABSOLUTE_TYPECHECK_FILES, readProjectTsconfig = () => {
   try {
     return JSON.parse(readFileSync40(resolve45("tsconfig.json"), "utf-8"));
@@ -23215,13 +23481,13 @@ var {$: $3, env } = globalThis.Bun;
 import { spawn as nodeSpawn } from "child_process";
 import {
   createWriteStream,
-  existsSync as existsSync5,
-  readFileSync as readFileSync9,
+  existsSync as existsSync6,
+  readFileSync as readFileSync10,
   rmSync as rmSync2,
   writeFileSync as writeFileSync4
 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join16, resolve as resolvePath2 } from "path";
+import { join as join17, resolve as resolvePath2 } from "path";
 
 // src/dev/tunnel/client.ts
 var RECONNECT_DELAY_MS = 2000;
@@ -23731,7 +23997,7 @@ init_expoProject();
 init_iosPhysicalDeviceTransport();
 import { spawn } from "child_process";
 import { access as access2 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var METRO_READY_TIMEOUT_MS = 60000;
 var PROCESS_CLOSE_TIMEOUT_MS = 2000;
 var commandEnvironment = (options) => ({
@@ -23744,7 +24010,7 @@ var commandEnvironment = (options) => ({
   ...options.metroHost ? { REACT_NATIVE_PACKAGER_HOSTNAME: options.metroHost } : {}
 });
 var absoluteExpoExecutable = async (project) => {
-  const executable = join8(project, "node_modules", ".bin", "expo");
+  const executable = join9(project, "node_modules", ".bin", "expo");
   try {
     await access2(executable);
     return executable;
@@ -23840,18 +24106,18 @@ var stopProcess = async (process2) => {
     return;
   process2.kill("SIGTERM");
   await Promise.race([
-    new Promise((resolve5) => process2.once("exit", () => resolve5())),
-    new Promise((resolve5) => setTimeout(resolve5, PROCESS_CLOSE_TIMEOUT_MS))
+    new Promise((resolve6) => process2.once("exit", () => resolve6())),
+    new Promise((resolve6) => setTimeout(resolve6, PROCESS_CLOSE_TIMEOUT_MS))
   ]);
   if (process2.exitCode === null)
     process2.kill("SIGKILL");
 };
-var waitForExit = (process2) => new Promise((resolve5) => {
+var waitForExit = (process2) => new Promise((resolve6) => {
   if (process2.exitCode !== null) {
-    resolve5(process2.exitCode);
+    resolve6(process2.exitCode);
     return;
   }
-  process2.once("exit", (code) => resolve5(code ?? 1));
+  process2.once("exit", (code) => resolve6(code ?? 1));
 });
 var runUtilityCommand = async (run, command, args, options) => {
   const child = run(command, args, {
@@ -23931,9 +24197,9 @@ var startAbsoluteExpoDevSession = async (options) => {
   }) : undefined;
   let metroReady = false;
   let resolveMetro;
-  const metroPromise = new Promise((resolve5, reject) => {
+  const metroPromise = new Promise((resolve6, reject) => {
     if (!metro) {
-      resolve5();
+      resolve6();
       return;
     }
     const timeout = setTimeout(() => {
@@ -23941,7 +24207,7 @@ var startAbsoluteExpoDevSession = async (options) => {
     }, METRO_READY_TIMEOUT_MS);
     resolveMetro = () => {
       clearTimeout(timeout);
-      resolve5();
+      resolve6();
     };
     metro.once("exit", (code) => {
       if (!metroReady) {
@@ -24306,7 +24572,7 @@ var DEFAULT_PORT_RANGE = 10;
 var RESTART_PARK_POLL_MS = 20;
 var NODE_API_IMPORT_ERROR = "To load Node-API modules, use require() or process.dlopen instead of import.";
 var sourceServerBootstrap = resolvePath2(import.meta.dir, "../../dev/serverBootstrap.ts");
-var serverBootstrap = existsSync5(sourceServerBootstrap) ? sourceServerBootstrap : resolvePath2(import.meta.dir, "../dev/serverBootstrap.js");
+var serverBootstrap = existsSync6(sourceServerBootstrap) ? sourceServerBootstrap : resolvePath2(import.meta.dir, "../dev/serverBootstrap.js");
 var formatServerBootDiagnostic = (output, serverEntry) => {
   if (!output.includes(NODE_API_IMPORT_ERROR))
     return null;
@@ -24496,7 +24762,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
         const generated = await writeAbsoluteExpoProject(normalized, {
           projectRoot: process.cwd()
         });
-        const dependenciesReady = existsSync5(join16(generated.path, "node_modules", "expo", "package.json")) && existsSync5(join16(generated.path, "node_modules", "expo-dev-client", "package.json"));
+        const dependenciesReady = existsSync6(join17(generated.path, "node_modules", "expo", "package.json")) && existsSync6(join17(generated.path, "node_modules", "expo-dev-client", "package.json"));
         if (!dependenciesReady) {
           const install = await confirmPrompt("Expo development dependencies are missing. Install the pinned SDK 57 development client now?");
           if (!install) {
@@ -24506,7 +24772,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
             cwd: generated.path,
             stdio: "inherit"
           });
-          const installExit = await new Promise((resolve10) => installProcess.once("exit", (code) => resolve10(code ?? 1)));
+          const installExit = await new Promise((resolve11) => installProcess.once("exit", (code) => resolve11(code ?? 1)));
           if (installExit !== 0) {
             throw new TypeError(`Expo dependency installation exited with status ${installExit}.`);
           }
@@ -24575,12 +24841,12 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           }
         }
         if (ready) {
-          const nativeDirectory = join16(normalized.nativeProjectDirectory, "android");
+          const nativeDirectory = join17(normalized.nativeProjectDirectory, "android");
           let createNativeProject = false;
-          if (!existsSync5(nativeDirectory)) {
+          if (!existsSync6(nativeDirectory)) {
             createNativeProject = await confirmPrompt("Create the managed Capacitor Android project now?");
           }
-          if (existsSync5(nativeDirectory) || createNativeProject) {
+          if (existsSync6(nativeDirectory) || createNativeProject) {
             androidDevProject = await prepareAbsoluteAndroidDevProject(normalized, {
               createNativeProject,
               projectRoot: process.cwd(),
@@ -24595,8 +24861,8 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           if (!remote) {
             console.log(cliTag("\x1B[33m", "iOS target skipped. Pair a Mac with `absolute mobile pair mac <name> <user@host>`."));
           } else {
-            const nativeDirectory = join16(normalized.nativeProjectDirectory, "ios");
-            if (!existsSync5(nativeDirectory)) {
+            const nativeDirectory = join17(normalized.nativeProjectDirectory, "ios");
+            if (!existsSync6(nativeDirectory)) {
               console.log(cliTag("\x1B[33m", "The iOS project is missing. Run `absolute mobile init` before remote development."));
             } else {
               iosDevProject = createAbsoluteRemoteIosDevProject(normalized, process.cwd(), remote);
@@ -24616,12 +24882,12 @@ var dev = async (serverEntry, configPath2, options = {}) => {
             }
           }
           if (ready) {
-            const nativeDirectory = join16(normalized.nativeProjectDirectory, "ios");
+            const nativeDirectory = join17(normalized.nativeProjectDirectory, "ios");
             let createNativeProject = false;
-            if (!existsSync5(nativeDirectory)) {
+            if (!existsSync6(nativeDirectory)) {
               createNativeProject = await confirmPrompt("Create the managed Capacitor iOS project now?");
             }
-            if (existsSync5(nativeDirectory) || createNativeProject) {
+            if (existsSync6(nativeDirectory) || createNativeProject) {
               iosDevProject = await prepareAbsoluteIosDevProject(normalized, {
                 createNativeProject,
                 projectRoot: process.cwd(),
@@ -24690,12 +24956,12 @@ var dev = async (serverEntry, configPath2, options = {}) => {
     startedAt: new Date().toISOString()
   });
   const instanceLog = createWriteStream(instanceLogFile, { flags: "w" });
-  const writeInstanceLog = (text) => {
+  const writeInstanceLog = (text2) => {
     try {
-      instanceLog.write(text.replace(ANSI_LOG_REGEX, ""));
+      instanceLog.write(text2.replace(ANSI_LOG_REGEX, ""));
     } catch {}
   };
-  const usesDocker = existsSync5(resolvePath2(COMPOSE_PATH));
+  const usesDocker = existsSync6(resolvePath2(COMPOSE_PATH));
   const scripts = usesDocker ? await readDbScripts() : null;
   if (scripts)
     await startDatabase(scripts);
@@ -25181,8 +25447,8 @@ var dev = async (serverEntry, configPath2, options = {}) => {
   const ANSI_COLOR_SEQUENCE_RE = new RegExp(`${ANSI_ESCAPE}\\[[0-9;]*m`, "g");
   let restartScanBuffer = "";
   const handleChunk = (value) => {
-    const text = value.toString("utf8");
-    restartScanBuffer += text;
+    const text2 = value.toString("utf8");
+    restartScanBuffer += text2;
     let newlineIdx;
     while ((newlineIdx = restartScanBuffer.indexOf(`
 `)) !== -1) {
@@ -25250,13 +25516,13 @@ var dev = async (serverEntry, configPath2, options = {}) => {
     const merged = {};
     const candidates = [".env", ".env.development", ".env.local"];
     for (const name of candidates) {
-      let text;
+      let text2;
       try {
-        text = readFileSync9(resolvePath2(process.cwd(), name), "utf8");
+        text2 = readFileSync10(resolvePath2(process.cwd(), name), "utf8");
       } catch {
         continue;
       }
-      for (const rawLine of text.split(`
+      for (const rawLine of text2.split(`
 `)) {
         const line = rawLine.trim();
         if (!line || line.startsWith("#"))
@@ -25274,7 +25540,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
     }
     return merged;
   };
-  const heapPreloadPath = join16(tmpdir2(), `absolute-heap-${process.pid}.ts`);
+  const heapPreloadPath = join17(tmpdir2(), `absolute-heap-${process.pid}.ts`);
   let heapSnapshotEnabled = false;
   try {
     writeFileSync4(heapPreloadPath, DEV_CHILD_PRELOAD);
@@ -25407,7 +25673,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
       if (now - last < 100)
         return;
       recentlyHandled.set(filename, now);
-      scheduleServerRestart(join16(serverEntryDir, filename));
+      scheduleServerRestart(join17(serverEntryDir, filename));
     };
     const recoveryScan = async () => {
       let entries;
@@ -25426,7 +25692,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           continue;
         let fileStat;
         try {
-          fileStat = statSync(join16(serverEntryDir, entry.name));
+          fileStat = statSync(join17(serverEntryDir, entry.name));
         } catch {
           continue;
         }
@@ -25814,9 +26080,9 @@ init_eslint();
 init_constants();
 init_utils();
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync12 } from "fs";
 import { arch as arch2, cpus, platform as platform3, totalmem, version } from "os";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 var bold = (str) => `\x1B[1m${str}\x1B[0m`;
 var getBinaryVersion = (binary, flag = "--version") => {
   try {
@@ -25836,7 +26102,7 @@ var getPackageVersion = (packageName) => {
     const pkgPath = __require.resolve(`${packageName}/package.json`, {
       paths: [process.cwd()]
     });
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     const ver = pkg.version;
     return ver;
   } catch {
@@ -25846,10 +26112,10 @@ var getPackageVersion = (packageName) => {
 var getAbsoluteVersion = () => {
   try {
     const candidates = [
-      resolve12(import.meta.dir, "..", "..", "package.json"),
-      resolve12(import.meta.dir, "..", "..", "..", "package.json")
+      resolve13(import.meta.dir, "..", "..", "package.json"),
+      resolve13(import.meta.dir, "..", "..", "..", "package.json")
     ];
-    const pkgPath = candidates.find((candidate) => existsSync8(candidate));
+    const pkgPath = candidates.find((candidate) => existsSync9(candidate));
     if (pkgPath)
       return readPackageVersion(pkgPath);
   } catch {
@@ -25858,7 +26124,7 @@ var getAbsoluteVersion = () => {
   return getPackageVersion("@absolutejs/absolute");
 };
 var readPackageVersion = (pkgPath) => {
-  const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
   const ver = pkg.version;
   return ver;
 };
@@ -25890,7 +26156,7 @@ var detectCI = () => {
 };
 var isDockerEnvironment = () => {
   try {
-    return existsSync8("/.dockerenv");
+    return existsSync9("/.dockerenv");
   } catch {
     return false;
   }
@@ -25960,11 +26226,11 @@ var info = () => {
 // src/cli/cache.ts
 init_constants();
 import { mkdir as mkdir7 } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var {Glob } = globalThis.Bun;
 var CACHE_DIR = ".absolutejs";
 var MAX_FILES_PER_BATCH = 200;
-var isIgnored = (file, ignorePatterns) => ignorePatterns.some((pat) => new Glob(pat).match(file));
+var isIgnored2 = (file, ignorePatterns) => ignorePatterns.some((pat) => new Glob(pat).match(file));
 var collectFiles = async (pattern, ignorePatterns) => {
   const files = [];
   const glob = new Glob(pattern);
@@ -25972,7 +26238,7 @@ var collectFiles = async (pattern, ignorePatterns) => {
     cwd: ".",
     dot: false
   })) {
-    if (!isIgnored(file, ignorePatterns))
+    if (!isIgnored2(file, ignorePatterns))
       files.push(file);
   }
   return files;
@@ -26012,7 +26278,7 @@ var hashFiles = async (paths) => {
 };
 var loadCache = async (tool) => {
   try {
-    const path = join17(CACHE_DIR, `${tool}.cache.json`);
+    const path = join18(CACHE_DIR, `${tool}.cache.json`);
     const data = await Bun.file(path).json();
     const result = data;
     return result;
@@ -26059,7 +26325,7 @@ var runTool = async (adapter, args) => {
 };
 var saveCache = async (tool, data) => {
   await mkdir7(CACHE_DIR, { recursive: true });
-  const path = join17(CACHE_DIR, `${tool}.cache.json`);
+  const path = join18(CACHE_DIR, `${tool}.cache.json`);
   await Bun.write(path, JSON.stringify(data, null, "\t"));
 };
 
@@ -26152,7 +26418,7 @@ init_getDurationString();
 init_instanceRegistry();
 import {
   appendFileSync,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync7,
   readdirSync as readdirSync2,
   readFileSync as readFileSync16,
@@ -26723,7 +26989,7 @@ var createWorkspaceTui = ({
 // src/cli/scripts/workspace.ts
 init_utils();
 var sourceServerBootstrap2 = resolve22(import.meta.dir, "../../dev/serverBootstrap.ts");
-var serverBootstrap2 = existsSync12(sourceServerBootstrap2) ? sourceServerBootstrap2 : resolve22(import.meta.dir, "../dev/serverBootstrap.js");
+var serverBootstrap2 = existsSync13(sourceServerBootstrap2) ? sourceServerBootstrap2 : resolve22(import.meta.dir, "../dev/serverBootstrap.js");
 var ANSI_REGEX2 = new RegExp(`${String.fromCharCode(ANSI_ESCAPE_CODE)}\\[[0-?]*[ -/]*[@-~]`, "g");
 var sleep = (durationMs) => Bun.sleep(durationMs);
 var stripAnsi3 = (value) => value.replace(ANSI_REGEX2, "");
@@ -27370,7 +27636,7 @@ var workspace = async (subcommand, options) => {
     const resolved = resolveService(name, service, workspaceEnv, options);
     const port = resolveWorkspaceServicePort(resolved.service, resolved.env);
     killStaleServicePort(port);
-    if (isAbsoluteService(resolved.service) && resolved.configPath && !existsSync12(resolved.configPath)) {
+    if (isAbsoluteService(resolved.service) && resolved.configPath && !existsSync13(resolved.configPath)) {
       throw new Error(`${name} references missing config "${resolved.configPath}"`);
     }
     serviceBootStartedAt.set(name, performance.now());