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

package/dist/cli/index.js

@@ -847,122 +847,755 @@ var init_config = __esm(() => {
   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])?))*$/;
 });
 
-// src/mobile/expoProject.ts
-import {
-  access,
-  cp,
-  mkdir,
-  mkdtemp,
-  readdir,
-  readFile,
-  rename,
-  rm,
-  writeFile
-} from "fs/promises";
-import { createHash } from "crypto";
-import { basename as basename2, dirname as dirname3, join as join5, relative, resolve as resolve3 } 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) => {
+// src/mobile/nativeAuth.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+var ABSOLUTE_AUTH_PACKAGE = "@absolutejs/auth", ABSOLUTE_EXPO_AUTH_CORE_VERSION = "0.75.6", ABSOLUTE_EXPO_AUTH_PACKAGE = "@absolutejs/auth-expo", ABSOLUTE_EXPO_AUTH_VERSION = "0.0.2", ABSOLUTE_EXPO_SYNC_CORE_VERSION = "2.31.0", ABSOLUTE_EXPO_SYNC_PACKAGE = "@absolutejs/sync-expo", ABSOLUTE_EXPO_SYNC_VERSION = "0.0.2", ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV = "ABSOLUTE_AUTH_NATIVE_CLIENTS", ABSOLUTE_NATIVE_AUTH_SCOPES, ABSOLUTE_SYNC_PACKAGE = "@absolutejs/sync", readPackageManifest = (projectRoot) => {
   try {
-    await access(path);
-    return true;
+    return JSON.parse(readFileSync5(join5(projectRoot, "package.json"), "utf8"));
   } catch {
+    return;
+  }
+}, packageManifestHas = (manifest, packageName) => {
+  if (typeof manifest !== "object" || manifest === null)
     return false;
+  return [
+    Reflect.get(manifest, "dependencies"),
+    Reflect.get(manifest, "devDependencies"),
+    Reflect.get(manifest, "optionalDependencies"),
+    Reflect.get(manifest, "peerDependencies")
+  ].some((dependencies) => typeof dependencies === "object" && dependencies !== null && Object.hasOwn(dependencies, packageName));
+}, createAbsoluteMobileAuthManifest = (config) => {
+  const scheme = config.deepLinkScheme ?? config.appId.toLowerCase();
+  return {
+    clientId: `absolutejs-native:${config.appId}`,
+    issuer: config.productionOrigin,
+    redirectUri: `${scheme}://auth/callback`,
+    scopes: [...ABSOLUTE_NATIVE_AUTH_SCOPES]
+  };
+}, installAbsoluteMobileAuthEnvironment = (projectRoot, config) => {
+  const auth = resolveAbsoluteMobileAuthManifest(projectRoot, config);
+  const serialized = serializeAbsoluteMobileAuthEnvironment(config, auth);
+  if (serialized === undefined)
+    delete process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV];
+  else
+    process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV] = serialized;
+  return auth;
+}, projectUsesAbsoluteAuth = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_AUTH_PACKAGE), projectUsesAbsoluteSync = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_SYNC_PACKAGE), resolveAbsoluteMobileAuthManifest = (projectRoot, config) => projectUsesAbsoluteAuth(projectRoot) ? createAbsoluteMobileAuthManifest(config) : undefined, serializeAbsoluteMobileAuthEnvironment = (config, auth) => auth === undefined ? undefined : JSON.stringify([
+  {
+    ...auth,
+    name: `${config.appName} native app`
   }
-}, portableRelative = (from, destination) => {
-  const value = relative(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}.`);
+]);
+var init_nativeAuth = __esm(() => {
+  ABSOLUTE_NATIVE_AUTH_SCOPES = ["openid", "profile"];
+});
+
+// node_modules/@absolutejs/sync/dist/client/index.js
+var RUNTIME_TRANSPORT, host, isRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations")) && Array.isArray(Reflect.get(value, "clients")), registry, pools, SyncLocalDataPolicyError, SyncLocalStoreSchemaError, positiveVersion = (value, label) => {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new SyncLocalStoreSchemaError("INVALID_PLAN", `${label} must be a positive safe integer`);
+  return value;
+}, isSchemaBundle = (schema) => ("components" in schema), validatePolicyMatch = (match, label) => {
+  if (match.length === 0 || match.trim() !== match || /^\*+$/.test(match) || match.includes("**"))
+    throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.match must be an exact name or a non-empty glob without adjacent wildcards.`);
+}, validateSyncLocalDataPolicy = (policy, label = "localData") => {
+  if (policy.maxBytesPerNamespace !== undefined && (!Number.isSafeInteger(policy.maxBytesPerNamespace) || policy.maxBytesPerNamespace < 1))
+    throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.maxBytesPerNamespace must be a positive safe integer.`);
+  for (const [index, rule] of (policy.collections ?? []).entries()) {
+    validatePolicyMatch(rule.match, `${label}.collections[${index}]`);
+    if (rule.maxAgeMs !== undefined && (!Number.isSafeInteger(rule.maxAgeMs) || rule.maxAgeMs < 1))
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}].maxAgeMs must be a positive safe integer.`);
+    if (rule.persistence === "memory-only" && rule.protection === "required")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}] cannot require at-rest protection when it is memory-only.`);
+    if (rule.sensitivity !== undefined && rule.sensitivity !== "public" && rule.protection !== "required" && rule.persistence !== "memory-only")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}] declares ${rule.sensitivity} data without required protection or memory-only persistence.`);
   }
-  return segment;
-}), routeFile = (project, route) => join5(project, "app", ...routeSegments(route), "index.tsx"), expoPackage = () => ({
-  dependencies: {
-    expo: "~57.0.9",
-    "expo-asset": "~57.0.15",
-    "expo-constants": "~57.0.16",
-    "expo-dev-client": "~57.0.16",
-    "expo-file-system": "~57.0.6",
-    "expo-haptics": "~57.0.2",
-    "expo-linking": "~57.0.8",
-    "expo-router": "~57.0.17",
-    react: "19.2.3",
-    "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"
-  },
-  devDependencies: {
-    "@types/react": "~19.2.2",
-    typescript: "~6.0.3"
-  },
-  main: "expo-router/entry",
-  name: "absolutejs-expo-shell",
-  private: true,
-  scripts: {
-    android: "expo run:android",
-    ios: "expo run:ios",
-    start: "expo start --dev-client"
-  },
-  version: "0.0.0"
-}), expoAppConfig = (config) => ({
-  expo: {
-    android: {
-      intentFilters: config.deepLinkHosts.map((host) => ({
-        action: "VIEW",
-        autoVerify: true,
-        category: ["BROWSABLE", "DEFAULT"],
-        data: [{ host, pathPrefix: "/", scheme: "https" }]
-      })),
-      package: config.appId
-    },
-    experiments: { typedRoutes: true },
-    ios: {
-      associatedDomains: config.deepLinkHosts.map((host) => `applinks:${host}`),
-      bundleIdentifier: config.appId,
-      ...config.iosVersion ? { buildNumber: config.iosVersion } : {}
-    },
-    name: config.appName,
-    plugins: [
-      "expo-router",
-      ["expo-dev-client", { launchMode: "most-recent" }]
-    ],
-    runtimeVersion: { policy: "appVersion" },
-    scheme: config.deepLinkScheme,
-    slug: config.appId.toLowerCase().replaceAll(".", "-"),
-    version: config.iosVersion ?? "0.1.0"
+  for (const [index, rule] of (policy.mutations ?? []).entries()) {
+    validatePolicyMatch(rule.match, `${label}.mutations[${index}]`);
+    if (rule.conflict !== undefined && rule.conflict.strategy !== "client-wins" && rule.conflict.strategy !== "manual" && rule.conflict.strategy !== "server-wins")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.strategy is invalid.`);
+    if (rule.conflict?.maxAttempts !== undefined && (!Number.isSafeInteger(rule.conflict.maxAttempts) || rule.conflict.maxAttempts < 1))
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.maxAttempts must be a positive safe integer.`);
+    if (rule.conflict?.maxAttempts !== undefined && rule.conflict.strategy !== "client-wins")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.maxAttempts is only valid for client-wins.`);
+    if (rule.persistence === "memory-only" && rule.protection === "required")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}] cannot require at-rest protection when it is memory-only.`);
+    if (rule.sensitivity !== undefined && rule.sensitivity !== "public" && rule.protection !== "required" && rule.persistence !== "memory-only")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}] declares ${rule.sensitivity} arguments without required protection.`);
   }
-}), expoDynamicAppConfig, expoDevelopmentCaPlugin, metroConfig = (projectRoot) => `${EXPO_GENERATED_HEADER}const { getDefaultConfig } = require('expo/metro-config');
-const path = require('node:path');
-
-const projectRoot = __dirname;
-const appRoot = ${JSON.stringify(projectRoot)};
-const config = getDefaultConfig(projectRoot);
-config.resolver.assetExts.push('absasset');
-config.resolver.nodeModulesPaths = [
-	path.join(projectRoot, 'node_modules'),
-	path.join(appRoot, 'node_modules')
-];
-config.watchFolders = [appRoot];
+  return policy;
+}, normalizeSyncLocalSchemaComponents = (schema = { version: 1 }) => {
+  const components = isSchemaBundle(schema) ? [...schema.components] : [{ ...schema, id: "@absolutejs/app" }];
+  const ids = new Set;
+  for (const component of components) {
+    if (typeof component.id !== "string" || component.id.trim() !== component.id || component.id.length === 0)
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", "Sync schema component id must be non-empty and trimmed");
+    if (ids.has(component.id))
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", `Sync schema component "${component.id}" is declared more than once`);
+    ids.add(component.id);
+    if (component.localData)
+      validateSyncLocalDataPolicy(component.localData, `${component.id}.localData`);
+  }
+  return components.sort((a, b) => a.id.localeCompare(b.id));
+}, resolveSyncLocalSchemaComponents = (storedVersions, schema = { version: 1 }) => {
+  const components = normalizeSyncLocalSchemaComponents(schema).map((component) => {
+    const current = resolveSyncLocalMigrations(component.version, component);
+    return {
+      id: component.id,
+      ...resolveSyncLocalMigrations(storedVersions[component.id] ?? current.minimumCompatibleVersion, component)
+    };
+  });
+  const active = new Set(components.map((component) => component.id));
+  const orphanedComponents = Object.keys(storedVersions).filter((id) => !active.has(id)).sort();
+  return { components, orphanedComponents };
+}, resolveSyncLocalMigrations = (storedVersion, schema = { version: 1 }) => {
+  positiveVersion(storedVersion, "Stored Sync schema version");
+  const targetVersion = positiveVersion(schema.version, "Target Sync schema version");
+  const migrations = [...schema.migrations ?? []].sort((a, b) => a.toVersion - b.toVersion);
+  const versions = new Set;
+  for (const migration of migrations) {
+    positiveVersion(migration.toVersion, "Sync migration toVersion");
+    if (versions.has(migration.toVersion))
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", `Sync migration ${migration.toVersion} is declared more than once`);
+    versions.add(migration.toVersion);
+  }
+  const inferredMinimum = migrations[0] ? migrations[0].toVersion - 1 : targetVersion;
+  const minimumCompatibleVersion = positiveVersion(schema.minimumCompatibleVersion ?? inferredMinimum, "Minimum compatible Sync schema version");
+  if (minimumCompatibleVersion > targetVersion)
+    throw new SyncLocalStoreSchemaError("INVALID_PLAN", "Minimum compatible Sync schema version cannot exceed its target");
+  if (storedVersion > targetVersion)
+    throw new SyncLocalStoreSchemaError("SCHEMA_TOO_NEW", `Stored Sync schema ${storedVersion} is newer than this runtime's schema ${targetVersion}`, { storedVersion, targetVersion });
+  if (storedVersion < minimumCompatibleVersion)
+    throw new SyncLocalStoreSchemaError("SCHEMA_TOO_OLD", `Stored Sync schema ${storedVersion} is older than the minimum compatible schema ${minimumCompatibleVersion}`, { storedVersion, targetVersion });
+  const steps = [];
+  for (let version = storedVersion + 1;version <= targetVersion; version++) {
+    const migration = migrations.find((candidate) => candidate.toVersion === version);
+    if (migration === undefined)
+      throw new SyncLocalStoreSchemaError("MIGRATION_MISSING", `Sync migration ${version - 1} -> ${version} is missing`, { storedVersion, targetVersion });
+    steps.push(migration);
+  }
+  return { minimumCompatibleVersion, steps, targetVersion };
+};
+var init_client = __esm(() => {
+  RUNTIME_TRANSPORT = Symbol.for("@absolutejs/sync/client-runtime-transport");
+  host = globalThis;
+  registry = (() => {
+    const existing = host[RUNTIME_TRANSPORT];
+    if (isRegistry(existing))
+      return existing;
+    if (typeof existing === "object" && existing !== null && Array.isArray(Reflect.get(existing, "installations"))) {
+      Reflect.set(existing, "clients", []);
+      return existing;
+    }
+    const created = { clients: [], installations: [] };
+    Object.defineProperty(host, RUNTIME_TRANSPORT, {
+      configurable: false,
+      enumerable: false,
+      value: created,
+      writable: false
+    });
+    return created;
+  })();
+  pools = new Map;
+  SyncLocalDataPolicyError = class SyncLocalDataPolicyError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "SyncLocalDataPolicyError";
+      this.code = code;
+    }
+  };
+  SyncLocalStoreSchemaError = class SyncLocalStoreSchemaError extends Error {
+    code;
+    storedVersion;
+    targetVersion;
+    constructor(code, message, versions = {}) {
+      super(message);
+      this.name = "SyncLocalStoreSchemaError";
+      this.code = code;
+      this.storedVersion = versions.storedVersion;
+      this.targetVersion = versions.targetVersion;
+    }
+  };
+});
 
-module.exports = config;
-`, layoutSource, nativeDiagnosticSource, webHostSource = (config) => {
-  const nativeRoutes = [
-    "/__absolute/native",
-    ...Object.keys(config.expoNativeRoutes)
-  ];
-  return `${EXPO_GENERATED_HEADER}import * as Haptics from 'expo-haptics';
-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';
+// src/mobile/syncSchema.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname3, join as join6, resolve as resolve3 } from "path";
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value), manifestAt = (path) => {
+  try {
+    const value = JSON.parse(readFileSync6(path, "utf8"));
+    return object(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}, localSchemaMetadata = (manifest) => {
+  const absolutejs = Reflect.get(manifest, "absolutejs");
+  if (!object(absolutejs))
+    return;
+  const sync = Reflect.get(absolutejs, "sync");
+  if (!object(sync))
+    return;
+  return Reflect.get(sync, "localSchema");
+}, packageManifestPath = (projectRoot, packageName) => {
+  let directory = resolve3(projectRoot);
+  while (true) {
+    const candidate = join6(directory, "node_modules", packageName, "package.json");
+    const manifest = manifestAt(candidate);
+    if (manifest && Reflect.get(manifest, "name") === packageName)
+      return candidate;
+    const parent = dirname3(directory);
+    if (parent === directory)
+      return;
+    directory = parent;
+  }
+}, metadataError = (id, detail) => new TypeError(`Invalid AbsoluteJS Sync schema metadata for ${id}: ${detail}`), positiveVersion2 = (value, id, field) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+    throw metadataError(id, `${field} must be a positive safe integer.`);
+  return value;
+}, nonEmpty = (value, id, field) => {
+  if (typeof value !== "string" || value.trim() !== value || value.length === 0)
+    throw metadataError(id, `${field} must be a non-empty trimmed string.`);
+  return value;
+}, requireObject = (value, id, detail) => {
+  if (!object(value))
+    throw metadataError(id, detail);
+  return value;
+}, unknownField = (record, key) => record[key], normalizeJsonValue = (value, id, field) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return value;
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (Array.isArray(value))
+    return value.map((entry) => normalizeJsonValue(entry, id, field));
+  if (object(value))
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      normalizeJsonValue(entry, id, field)
+    ]));
+  throw metadataError(id, `${field} must be JSON-safe.`);
+}, operation = (value, id, index) => {
+  const record = requireObject(value, id, `migration operation ${index} must be an object.`);
+  const type = Reflect.get(record, "type");
+  const collection = nonEmpty(Reflect.get(record, "collection"), id, `operation ${index}.collection`);
+  if (type === "delete-collection")
+    return { collection, type };
+  if (type === "rename-field")
+    return {
+      collection,
+      from: nonEmpty(Reflect.get(record, "from"), id, `operation ${index}.from`),
+      to: nonEmpty(Reflect.get(record, "to"), id, `operation ${index}.to`),
+      type
+    };
+  const field = nonEmpty(Reflect.get(record, "field"), id, `operation ${index}.field`);
+  if (type === "remove-field")
+    return { collection, field, type };
+  if (type === "set-default")
+    return {
+      collection,
+      field,
+      type,
+      value: normalizeJsonValue(Reflect.get(record, "value"), id, `operation ${index}.value`)
+    };
+  throw metadataError(id, `operation ${index}.type is not supported.`);
+}, migration = (value, id, index) => {
+  const record = requireObject(value, id, `migration ${index} must be an object.`);
+  const allowed = new Set(["operations", "toVersion"]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `migration ${index}.${unsupported} is not declarative metadata.`);
+  const declaredOperations = Reflect.get(record, "operations");
+  if (declaredOperations !== undefined && !Array.isArray(declaredOperations))
+    throw metadataError(id, `migration ${index}.operations must be an array.`);
+  const operations = Array.isArray(declaredOperations) ? declaredOperations : [];
+  return {
+    operations: operations.map((entry, operationIndex) => operation(entry, id, operationIndex)),
+    toVersion: positiveVersion2(Reflect.get(record, "toVersion"), id, `migration ${index}.toVersion`)
+  };
+}, localDataPolicy = (value, id) => {
+  const record = requireObject(value, id, "localData must be an object.");
+  const allowed = new Set([
+    "collections",
+    "maxBytesPerNamespace",
+    "mutations"
+  ]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `localData.${unsupported} is not supported.`);
+  const collectionRules = Reflect.get(record, "collections");
+  const mutationRules = Reflect.get(record, "mutations");
+  if (collectionRules !== undefined && !Array.isArray(collectionRules))
+    throw metadataError(id, "localData.collections must be an array.");
+  if (mutationRules !== undefined && !Array.isArray(mutationRules))
+    throw metadataError(id, "localData.mutations must be an array.");
+  const collections = Array.isArray(collectionRules) ? collectionRules.map((entry, index) => {
+    const rule = requireObject(entry, id, `localData.collections[${index}] must be an object.`);
+    const allowedRuleKeys = new Set([
+      "evictionPriority",
+      "match",
+      "maxAgeMs",
+      "onProtectionUnavailable",
+      "persistence",
+      "protection",
+      "sensitivity"
+    ]);
+    const unsupportedRuleKey = Object.keys(rule).find((key) => !allowedRuleKeys.has(key));
+    if (unsupportedRuleKey)
+      throw metadataError(id, `localData.collections[${index}].${unsupportedRuleKey} is not supported.`);
+    const match = nonEmpty(Reflect.get(rule, "match"), id, `localData.collections[${index}].match`);
+    const persistence = unknownField(rule, "persistence");
+    const sensitivity = unknownField(rule, "sensitivity");
+    const protection = unknownField(rule, "protection");
+    const onProtectionUnavailable = unknownField(rule, "onProtectionUnavailable");
+    const evictionPriority = unknownField(rule, "evictionPriority");
+    const maxAge = unknownField(rule, "maxAgeMs");
+    if (persistence !== undefined && persistence !== "durable" && persistence !== "memory-only")
+      throw metadataError(id, `localData.collections[${index}].persistence is invalid.`);
+    if (sensitivity !== undefined && sensitivity !== "public" && sensitivity !== "private" && sensitivity !== "secret")
+      throw metadataError(id, `localData.collections[${index}].sensitivity is invalid.`);
+    if (protection !== undefined && protection !== "none" && protection !== "required")
+      throw metadataError(id, `localData.collections[${index}].protection is invalid.`);
+    if (onProtectionUnavailable !== undefined && onProtectionUnavailable !== "error" && onProtectionUnavailable !== "memory-only")
+      throw metadataError(id, `localData.collections[${index}].onProtectionUnavailable is invalid.`);
+    if (evictionPriority !== undefined && evictionPriority !== "critical" && evictionPriority !== "normal" && evictionPriority !== "disposable")
+      throw metadataError(id, `localData.collections[${index}].evictionPriority is invalid.`);
+    return {
+      match,
+      ...sensitivity ? { sensitivity } : {},
+      ...persistence ? { persistence } : {},
+      ...protection ? { protection } : {},
+      ...onProtectionUnavailable ? {
+        onProtectionUnavailable
+      } : {},
+      ...evictionPriority ? { evictionPriority } : {},
+      ...maxAge === undefined ? {} : {
+        maxAgeMs: positiveVersion2(maxAge, id, `localData.collections[${index}].maxAgeMs`)
+      }
+    };
+  }) : undefined;
+  const mutations = Array.isArray(mutationRules) ? mutationRules.map((entry, index) => {
+    const rule = requireObject(entry, id, `localData.mutations[${index}] must be an object.`);
+    const allowedRuleKeys = new Set([
+      "conflict",
+      "match",
+      "onProtectionUnavailable",
+      "persistence",
+      "protection",
+      "sensitivity"
+    ]);
+    const unsupportedRuleKey = Object.keys(rule).find((key) => !allowedRuleKeys.has(key));
+    if (unsupportedRuleKey)
+      throw metadataError(id, `localData.mutations[${index}].${unsupportedRuleKey} is not supported.`);
+    const protection = unknownField(rule, "protection");
+    const sensitivity = unknownField(rule, "sensitivity");
+    const persistence = unknownField(rule, "persistence");
+    const onProtectionUnavailable = unknownField(rule, "onProtectionUnavailable");
+    const declaredConflict = unknownField(rule, "conflict");
+    let conflict;
+    if (declaredConflict !== undefined) {
+      const conflictRecord = requireObject(declaredConflict, id, `localData.mutations[${index}].conflict must be an object.`);
+      const unsupportedConflictKey = Object.keys(conflictRecord).find((key) => key !== "maxAttempts" && key !== "strategy");
+      if (unsupportedConflictKey)
+        throw metadataError(id, `localData.mutations[${index}].conflict.${unsupportedConflictKey} is not supported.`);
+      const strategy = unknownField(conflictRecord, "strategy");
+      if (strategy !== "client-wins" && strategy !== "manual" && strategy !== "server-wins")
+        throw metadataError(id, `localData.mutations[${index}].conflict.strategy is invalid.`);
+      const maxAttempts = unknownField(conflictRecord, "maxAttempts");
+      if (maxAttempts !== undefined && strategy !== "client-wins")
+        throw metadataError(id, `localData.mutations[${index}].conflict.maxAttempts requires client-wins.`);
+      conflict = {
+        strategy,
+        ...maxAttempts === undefined ? {} : {
+          maxAttempts: positiveVersion2(maxAttempts, id, `localData.mutations[${index}].conflict.maxAttempts`)
+        }
+      };
+    }
+    if (protection !== undefined && protection !== "none" && protection !== "required")
+      throw metadataError(id, `localData.mutations[${index}].protection is invalid.`);
+    if (sensitivity !== undefined && sensitivity !== "public" && sensitivity !== "private" && sensitivity !== "secret")
+      throw metadataError(id, `localData.mutations[${index}].sensitivity is invalid.`);
+    if (onProtectionUnavailable !== undefined && onProtectionUnavailable !== "error" && onProtectionUnavailable !== "memory-only")
+      throw metadataError(id, `localData.mutations[${index}].onProtectionUnavailable is invalid.`);
+    if (persistence !== undefined && persistence !== "durable" && persistence !== "memory-only")
+      throw metadataError(id, `localData.mutations[${index}].persistence is invalid.`);
+    return {
+      match: nonEmpty(Reflect.get(rule, "match"), id, `localData.mutations[${index}].match`),
+      ...conflict ? { conflict } : {},
+      ...sensitivity ? { sensitivity } : {},
+      ...onProtectionUnavailable ? { onProtectionUnavailable } : {},
+      ...persistence ? {
+        persistence
+      } : {},
+      ...protection ? { protection } : {}
+    };
+  }) : undefined;
+  const quota = Reflect.get(record, "maxBytesPerNamespace");
+  return {
+    ...collections ? { collections } : {},
+    ...mutations ? { mutations } : {},
+    ...quota === undefined ? {} : {
+      maxBytesPerNamespace: positiveVersion2(quota, id, "localData.maxBytesPerNamespace")
+    }
+  };
+}, component = (id, value) => {
+  const record = requireObject(value, id, "localSchema must be an object.");
+  const allowed = new Set([
+    "localData",
+    "migrations",
+    "minimumCompatibleVersion",
+    "version"
+  ]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `${unsupported} is not supported.`);
+  const version = positiveVersion2(Reflect.get(record, "version"), id, "version");
+  const declaredMinimum = Reflect.get(record, "minimumCompatibleVersion");
+  const minimumCompatibleVersion = declaredMinimum === undefined ? Math.max(1, version - 2) : positiveVersion2(declaredMinimum, id, "minimumCompatibleVersion");
+  const declaredMigrations = Reflect.get(record, "migrations");
+  const declaredLocalData = Reflect.get(record, "localData");
+  if (declaredMigrations !== undefined && !Array.isArray(declaredMigrations))
+    throw metadataError(id, "migrations must be an array.");
+  const migrations = Array.isArray(declaredMigrations) ? declaredMigrations : undefined;
+  return {
+    id,
+    ...declaredLocalData === undefined ? {} : { localData: localDataPolicy(declaredLocalData, id) },
+    minimumCompatibleVersion,
+    ...Array.isArray(migrations) ? {
+      migrations: migrations.map((entry, index) => migration(entry, id, index))
+    } : {},
+    version
+  };
+}, dependencyNames = (manifest) => [
+  Reflect.get(manifest, "dependencies"),
+  Reflect.get(manifest, "optionalDependencies"),
+  Reflect.get(manifest, "devDependencies"),
+  Reflect.get(manifest, "peerDependencies")
+].flatMap((dependencies) => object(dependencies) ? Object.keys(dependencies) : []).filter((name, index, names) => names.indexOf(name) === index).sort(), discoverAbsoluteSyncSchema = (projectRoot) => {
+  const appManifestPath = join6(resolve3(projectRoot), "package.json");
+  const appManifest = manifestAt(appManifestPath);
+  if (!appManifest)
+    return {
+      components: [
+        {
+          id: "@absolutejs/app",
+          minimumCompatibleVersion: 1,
+          version: 1
+        }
+      ],
+      sources: []
+    };
+  const appMetadata = localSchemaMetadata(appManifest);
+  const components = [
+    appMetadata === undefined ? { id: "@absolutejs/app", minimumCompatibleVersion: 1, version: 1 } : component("@absolutejs/app", appMetadata)
+  ];
+  const sources = [
+    { id: "@absolutejs/app", manifestPath: appManifestPath }
+  ];
+  for (const name of dependencyNames(appManifest)) {
+    const manifestPath = packageManifestPath(projectRoot, name);
+    if (!manifestPath)
+      continue;
+    const manifest = manifestAt(manifestPath);
+    if (!manifest)
+      continue;
+    const metadata = localSchemaMetadata(manifest);
+    if (metadata === undefined)
+      continue;
+    components.push(component(name, metadata));
+    sources.push({ id: name, manifestPath });
+  }
+  components.sort((left, right) => left.id.localeCompare(right.id));
+  sources.sort((left, right) => left.id.localeCompare(right.id));
+  resolveSyncLocalSchemaComponents({}, { components });
+  return { components, sources };
+};
+var init_syncSchema = __esm(() => {
+  init_client();
+});
+
+// src/mobile/expoProject.ts
+import {
+  access,
+  cp,
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  writeFile
+} from "fs/promises";
+import { createHash } from "crypto";
+import { basename as basename2, dirname as dirname4, join as join7, relative, resolve as resolve4 } 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 {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}, portableRelative = (from, destination) => {
+  const value = relative(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) => ({
+  dependencies: {
+    ...auth ? {
+      "@absolutejs/auth": ABSOLUTE_EXPO_AUTH_CORE_VERSION,
+      [ABSOLUTE_EXPO_AUTH_PACKAGE]: ABSOLUTE_EXPO_AUTH_VERSION
+    } : {},
+    ...sync ? {
+      "@absolutejs/sync": ABSOLUTE_EXPO_SYNC_CORE_VERSION,
+      [ABSOLUTE_EXPO_SYNC_PACKAGE]: ABSOLUTE_EXPO_SYNC_VERSION
+    } : {},
+    expo: "~57.0.9",
+    "expo-asset": "~57.0.15",
+    "expo-constants": "~57.0.16",
+    "expo-dev-client": "~57.0.16",
+    "expo-file-system": "~57.0.6",
+    "expo-haptics": "~57.0.2",
+    "expo-linking": "~57.0.8",
+    ...sync ? {
+      "expo-background-task": "~57.0.14",
+      "expo-network": "~57.0.1",
+      "expo-sqlite": "~57.0.2",
+      "expo-task-manager": "~57.0.14",
+      "expo-updates": "~57.0.19"
+    } : {},
+    "expo-router": "~57.0.17",
+    ...auth ? {
+      "expo-secure-store": "~57.0.2",
+      "expo-web-browser": "~57.0.2"
+    } : {},
+    react: "19.2.3",
+    "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"
+  },
+  devDependencies: {
+    "@types/react": "~19.2.2",
+    typescript: "~6.0.3"
+  },
+  main: "expo-router/entry",
+  name: "absolutejs-expo-shell",
+  private: true,
+  scripts: {
+    android: "expo run:android",
+    ios: "expo run:ios",
+    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');
+const path = require('node:path');
+
+const projectRoot = __dirname;
+const appRoot = ${JSON.stringify(projectRoot)};
+const config = getDefaultConfig(projectRoot);
+config.resolver.assetExts.push('absasset');
+config.resolver.nodeModulesPaths = [
+	path.join(projectRoot, 'node_modules'),
+	path.join(appRoot, 'node_modules')
+];
+config.watchFolders = [appRoot];
+
+module.exports = config;
+`, layoutSource = (auth, sync) => `${EXPO_GENERATED_HEADER}import { Stack } from 'expo-router';
+${auth ? `import { useEffect, useState } from 'react';
+import { startAbsoluteExpoAuth } from '../src/generated/AbsoluteAuth';` : ""}
+${sync ? "import { startAbsoluteExpoSync } from '../src/generated/AbsoluteSync';" : ""}
+
+export default function AbsoluteLayout() {
+	${auth ? `const [ready, setReady] = useState(false);
+	useEffect(() => {
+		let active = true;
+		void ${sync ? "startAbsoluteExpoSync" : "startAbsoluteExpoAuth"}().then(() => { if (active) setReady(true); });
+		return () => { active = false; };
+	}, []);
+	if (!ready) return null;` : ""}
+	return <Stack screenOptions={{ headerShown: false }} />;
+}
+`, nativeDiagnosticSource, 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';
+
+export const absoluteExpoAuth = createAbsoluteExpoAuthClient({
+	allowedOrigins: [${JSON.stringify(auth.issuer)}],
+	clientId: ${JSON.stringify(auth.clientId)},
+	issuer: ${JSON.stringify(auth.issuer)},
+	redirectUri: ${JSON.stringify(auth.redirectUri)},
+	resource: ${JSON.stringify(auth.issuer)},
+	scopes: ${JSON.stringify(auth.scopes)},
+	storagePrefix: ${JSON.stringify(`absolutejs.auth.${storageIdentity}`)}
+});
+installAuthClientRuntimeTransport(createMobileAuthTransport(absoluteExpoAuth, { baseUrl: ${JSON.stringify(auth.issuer)} }));
+
+let currentPrincipal: Awaited<ReturnType<typeof absoluteExpoAuth.principal>> = null;
+absoluteExpoAuth.onPrincipalChange(principal => {
+	currentPrincipal = principal;
+});
+export const getAbsoluteExpoAuthPrincipal = () => currentPrincipal;
+
+let startPromise: Promise<void> | undefined;
+export const startAbsoluteExpoAuth = () => {
+	startPromise ??= absoluteExpoAuth.start().then(async () => {
+		currentPrincipal = await absoluteExpoAuth.principal();
+	});
+
+	return startPromise;
+};
+`;
+}, syncRuntimeSource = (config, schema) => {
+  const storageIdentity = createHash("sha256").update(config.appId).digest("hex").slice(0, 24);
+  const backgroundEndpoint = new URL("/__absolute/sync/background", config.productionOrigin).href;
+  const backgroundTask = `${config.appId}.absolutejs.sync`;
+  return `${EXPO_GENERATED_HEADER}import { runHeadlessSync } from '@absolutejs/sync/client/headless';
+import type { SyncLocalStoreSchemaBundle } from '@absolutejs/sync/client';
+import { installSyncClientRuntimeTransport } from '@absolutejs/sync/client/runtime';
+import {
+	createExpoSyncBridgeHost,
+	createExpoSyncLocalStore,
+	createExpoSyncProtection,
+	createExpoSyncSocketBridgeHost,
+	defineExpoSyncBackgroundTask,
+	installExpoSyncLifecycle,
+	registerExpoSyncBackgroundTask
+} from '@absolutejs/sync-expo';
+import * as Updates from 'expo-updates';
+import { absoluteExpoAuth, startAbsoluteExpoAuth } from './AbsoluteAuth';
+
+const BACKGROUND_TASK = ${JSON.stringify(backgroundTask)};
+const BACKGROUND_ENDPOINT = ${JSON.stringify(backgroundEndpoint)};
+const PRODUCTION_ORIGIN = ${JSON.stringify(config.productionOrigin)};
+const STORAGE_SCHEMA: SyncLocalStoreSchemaBundle = ${JSON.stringify(schema)};
+const store = createExpoSyncLocalStore({
+	databaseName: ${JSON.stringify(`absolutejs-sync-${storageIdentity}.db`)},
+	protection: createExpoSyncProtection({ storagePrefix: ${JSON.stringify(`absolutejs.sync.${storageIdentity}`)} }),
+	storageSchema: STORAGE_SCHEMA
+});
+
+const runBackgroundSync = async () => {
+	await startAbsoluteExpoAuth();
+	const principal = await absoluteExpoAuth.principal();
+	if (!principal) return;
+	await runHeadlessSync({
+		endpoint: BACKGROUND_ENDPOINT,
+		fetch: (url, init) => absoluteExpoAuth.fetch(url, init),
+		namespace: principal.namespace,
+		store
+	});
+};
+defineExpoSyncBackgroundTask(BACKGROUND_TASK, runBackgroundSync);
+
+let activeNamespace: string | undefined;
+let started = false;
+let startPromise: Promise<void> | undefined;
+export const startAbsoluteExpoSync = () => {
+	startPromise ??= (async () => {
+		await startAbsoluteExpoAuth();
+		const principal = await absoluteExpoAuth.principal();
+		activeNamespace = principal?.namespace;
+		installSyncClientRuntimeTransport({
+			...(principal ? { durable: { namespace: principal.namespace, store }, socketTicket: () => absoluteExpoAuth.socketTicket() } : {}),
+			registerClient: client => installExpoSyncLifecycle({ client })
+		});
+		await registerExpoSyncBackgroundTask(BACKGROUND_TASK, { minimumInterval: 15 });
+		started = true;
+	})();
+
+	return startPromise;
+};
+
+absoluteExpoAuth.onPrincipalChange(principal => {
+	if (!started || principal?.namespace === activeNamespace) return;
+	void Updates.reloadAsync();
+});
+
+export const createAbsoluteExpoSyncBridge = async (
+	emit: (event: 'sync.socket' | 'sync.wake', payload: Record<string, unknown>) => void
+) => {
+	await startAbsoluteExpoSync();
+	const principal = await absoluteExpoAuth.principal();
+	if (!principal) return {
+		close: () => undefined,
+		request: async () => { throw new Error('Expo Sync requires an authenticated principal.'); }
+	};
+	const transactions = createExpoSyncBridgeHost({ namespace: principal.namespace, store });
+	const sockets = createExpoSyncSocketBridgeHost({
+		allowedOrigin: PRODUCTION_ORIGIN,
+		emit: payload => emit('sync.socket', payload),
+		socketTicket: audience => absoluteExpoAuth.socketTicket(audience)
+	});
+	const removeLifecycle = installExpoSyncLifecycle({
+		client: { reconnect: () => emit('sync.wake', {}) }
+	});
+
+	return {
+		close: async () => {
+			removeLifecycle();
+			await Promise.all([transactions.close(), sockets.close()]);
+		},
+		request: (method: string, params: Record<string, unknown>) =>
+			method.startsWith('sync.socket.')
+				? sockets.request(method, params)
+				: transactions.request(method, params)
+	};
+};
+`;
+}, webHostSource = (config, auth, sync) => {
+  const nativeRoutes = [
+    "/__absolute/native",
+    ...Object.keys(config.expoNativeRoutes)
+  ];
+  return `${EXPO_GENERATED_HEADER}import * as Haptics from 'expo-haptics';
+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';
+${auth ? "import { absoluteExpoAuth, getAbsoluteExpoAuthPrincipal, startAbsoluteExpoAuth } from './AbsoluteAuth';" : ""}
+${sync ? "import { createAbsoluteExpoSyncBridge, startAbsoluteExpoSync } from './AbsoluteSync';" : ""}
 
-const BRIDGE_FORMAT = 1;
+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)});
@@ -971,6 +1604,8 @@ const DEV_ORIGIN = Platform.OS === 'android'
 	? process.env.EXPO_PUBLIC_ABSOLUTE_DEV_ANDROID_ORIGIN
 	: process.env.EXPO_PUBLIC_ABSOLUTE_DEV_IOS_ORIGIN;
 const HMR_TARGET = Platform.OS === 'android' ? 'expo-android' : 'expo-ios';
+const AUTH_ENABLED = ${auth ? "true" : "false"};
+const SYNC_ENABLED = ${sync ? "true" : "false"};
 
 const bridgeBootstrap = (path: string) => {
 	const initialPath = DEV_ORIGIN
@@ -978,6 +1613,7 @@ const bridgeBootstrap = (path: string) => {
 		: JSON.stringify(path);
 	return \`(() => {
 	const pending = new Map();
+	const listeners = new Map();
 	let sequence = 0;
 	let currentPath = \${initialPath};
 	const send = value => {
@@ -987,6 +1623,10 @@ const bridgeBootstrap = (path: string) => {
 	};
 	globalThis.__absoluteExpoReceive = source => {
 		const message = JSON.parse(source);
+		if (message.kind === 'event') {
+			for (const listener of listeners.get(message.event) || []) listener(message.payload || {});
+			return;
+		}
 		const operation = pending.get(message.id);
 		if (!operation) return;
 		pending.delete(message.id);
@@ -994,9 +1634,18 @@ const bridgeBootstrap = (path: string) => {
 		message.error ? operation.reject(new Error(message.error.message)) : operation.resolve(message.result);
 	};
 	globalThis.__absoluteExpoBridge = {
+		on(event, listener) {
+			const values = listeners.get(event) || new Set();
+			values.add(listener);
+			listeners.set(event, values);
+			return () => {
+				values.delete(listener);
+				if (values.size === 0) listeners.delete(event);
+			};
+		},
 		request(method, params) {
 			const id = 'web_' + Date.now().toString(36) + '_' + (++sequence).toString(36);
-			send({ format: 1, id, kind: 'request', method, params, path: currentPath });
+			send({ format: 3, id, kind: 'request', method, params, path: currentPath });
 			return new Promise((resolve, reject) => {
 				const timer = setTimeout(() => {
 					pending.delete(id);
@@ -1007,7 +1656,7 @@ const bridgeBootstrap = (path: string) => {
 		},
 		setPath(path) {
 			currentPath = path;
-			send({ format: 1, kind: 'event', event: 'navigation', path });
+			send({ format: 3, kind: 'event', event: 'navigation', path });
 		}
 	};
 	if (\${DEV_ORIGIN ? 'true' : 'false'}) {
@@ -1015,7 +1664,7 @@ const bridgeBootstrap = (path: string) => {
 			const path = location.pathname + location.search + location.hash;
 			if (path === currentPath) return;
 			currentPath = path;
-			send({ format: 1, kind: 'event', event: 'navigation', path });
+			send({ format: 3, kind: 'event', event: 'navigation', path });
 		};
 		for (const method of ['pushState', 'replaceState']) {
 			const original = history[method];
@@ -1034,9 +1683,9 @@ const bridgeBootstrap = (path: string) => {
 		const url = new URL(anchor.href, location.href);
 		if (!${JSON.stringify(nativeRoutes)}.includes(url.pathname)) return;
 		event.preventDefault();
-		send({ format: 1, kind: 'event', event: 'navigation', path: url.pathname + url.search + url.hash });
+		send({ format: 3, kind: 'event', event: 'navigation', path: url.pathname + url.search + url.hash });
 	}, true);
-	send({ format: 1, kind: 'event', event: 'ready', path: currentPath });
+	send({ format: 3, kind: 'event', event: 'ready', path: currentPath });
 })(); true;\`;
 };
 
@@ -1052,16 +1701,16 @@ const impact = async (params: Record<string, unknown>) => {
 };
 
 const bridgeFetch = async (params: Record<string, unknown>) => {
-	if (params.method !== 'GET' || typeof params.url !== 'string' || typeof params.headers !== 'object' || params.headers === null || Array.isArray(params.headers)) throw new Error('Expo bridge HTTP request is invalid.');
+	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);
 	if (url.origin !== PRODUCTION_ORIGIN || url.username || url.password) throw new Error('Expo bridge HTTP request left productionOrigin.');
 	const headers = new Headers();
 	for (const [name, value] of Object.entries(params.headers as Record<string, unknown>)) {
 		const normalized = name.toLowerCase();
-		if (typeof value !== 'string' || (normalized !== 'accept' && !normalized.startsWith('x-absolute-mobile-'))) throw new Error('Expo bridge HTTP header is not allowed.');
+		if (typeof value !== 'string' || (normalized !== 'accept' && normalized !== 'content-type' && !normalized.startsWith('x-absolute-mobile-'))) throw new Error('Expo bridge HTTP header is not allowed.');
 		headers.set(normalized, value);
 	}
-	const response = await fetch(url, { headers, method: 'GET', redirect: 'manual' });
+	const response = await ${auth ? "absoluteExpoAuth.fetchOptional" : "fetch"}(url, { ...(typeof params.body === 'string' ? { body: params.body } : {}), headers, method: params.method, redirect: 'manual' });
 	if (new URL(response.url || url.href).origin !== PRODUCTION_ORIGIN || response.status >= 300 && response.status < 400) throw new Error('Expo bridge HTTP redirects are not allowed.');
 	const body = await response.text();
 	if (new TextEncoder().encode(body).byteLength > MAX_HTTP_BODY_BYTES) throw new Error('Expo bridge HTTP response exceeds 48 KiB.');
@@ -1073,13 +1722,45 @@ const bridgeFetch = async (params: Record<string, unknown>) => {
 	return { body, headers: responseHeaders, status: response.status };
 };
 
+const authStatus = async () => {
+	${auth ? `const user = await absoluteExpoAuth.status();
+	const principal = getAbsoluteExpoAuthPrincipal();
+	return { principal: principal ? { namespace: principal.namespace } : null, user };` : "throw new Error('Expo Auth is not configured.');"}
+};
+
 export function AbsoluteWebHost() {
 	const pathname = usePathname() || '/';
 	const webView = useRef<WebView>(null);
+	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 activeWebPath = useRef(pathname);
 
+	useEffect(() => {
+		if (!AUTH_ENABLED && !SYNC_ENABLED) return;
+		let active = true;
+		${auth ? `const stop = absoluteExpoAuth.onPrincipalChange(principal => {
+			if (!active) return;
+			const source = JSON.stringify({ event: 'auth.principal', format: BRIDGE_FORMAT, kind: 'event', path: activeWebPath.current, payload: { principal: principal ? { namespace: principal.namespace } : null } });
+			webView.current?.injectJavaScript(\`globalThis.__absoluteExpoReceive(\${JSON.stringify(source)}); true;\`);
+		});
+		void ${sync ? "startAbsoluteExpoSync" : "startAbsoluteExpoAuth"}().then(async () => {
+			${sync ? `syncBridge.current = await createAbsoluteExpoSyncBridge((event, payload) => {
+				const source = JSON.stringify({ event, format: BRIDGE_FORMAT, kind: 'event', path: activeWebPath.current, payload });
+				webView.current?.injectJavaScript(\`globalThis.__absoluteExpoReceive(\${JSON.stringify(source)}); true;\`);
+			});` : ""}
+			if (active) setRuntimeReady(true);
+		});
+		return () => {
+			active = false;
+			stop();
+			const bridge = syncBridge.current;
+			syncBridge.current = undefined;
+			void bridge?.close();
+		};` : ""}
+	}, []);
+
 	useEffect(() => {
 		if (DEV_ORIGIN) {
 			const target = new URL(pathname, DEV_ORIGIN);
@@ -1129,6 +1810,19 @@ export function AbsoluteWebHost() {
 				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: null });
 			} 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') {
+				${auth ? `const params = message.params as Record<string, unknown>;
+				if (typeof params.email !== 'string' || typeof params.signup !== 'boolean') throw new Error('Expo Auth sign-in params are invalid.');
+				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();
+				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() });
+			} else if (typeof message.method === 'string' && message.method.startsWith('sync.')) {
+				if (!syncBridge.current) throw new Error('Expo Sync bridge is unavailable.');
+				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: await syncBridge.current.request(message.method, message.params as Record<string, unknown>) });
 			} else {
 				throw new Error('Expo bridge method is not allowed.');
 			}
@@ -1137,7 +1831,7 @@ export function AbsoluteWebHost() {
 		}
 	};
 
-	if (!indexUri) return <View style={styles.loading}><ActivityIndicator /></View>;
+	if (!indexUri || !runtimeReady) return <View style={styles.loading}><ActivityIndicator /></View>;
 	return <WebView
 		allowFileAccess
 		allowFileAccessFromFileURLs
@@ -1159,10 +1853,32 @@ export function AbsoluteWebHost() {
 
 const styles = StyleSheet.create({ loading: { alignItems: 'center', flex: 1, justifyContent: 'center' }, web: { flex: 1 } });
 `;
-}, webRouteSource, catchAllRouteSource, nativeWrapperSource = (wrapper, module) => `${EXPO_GENERATED_HEADER}export { default } from ${JSON.stringify(portableRelative(dirname3(wrapper), module).replace(/\.(?:[cm]?[jt]sx?)$/u, ""))};
-`, expoTsConfig = (projectRoot, project) => ({
+}, webRouteSource, catchAllRouteSource, nativeWrapperSource = (wrapper, module) => `${EXPO_GENERATED_HEADER}export { default } from ${JSON.stringify(portableRelative(dirname4(wrapper), module).replace(/\.(?:[cm]?[jt]sx?)$/u, ""))};
+`, expoTsConfig = (projectRoot, project, auth, sync) => ({
   compilerOptions: {
     paths: {
+      ...auth ? {
+        "@absolutejs/auth": [
+          "./node_modules/@absolutejs/auth/dist/index.d.ts"
+        ],
+        "@absolutejs/auth/*": [
+          "./node_modules/@absolutejs/auth/dist/*"
+        ]
+      } : {},
+      ...sync ? {
+        "@absolutejs/sync": [
+          "./node_modules/@absolutejs/sync/dist/index.d.ts"
+        ],
+        "@absolutejs/sync-expo": [
+          "./node_modules/@absolutejs/sync-expo/dist/index.d.ts"
+        ],
+        "@absolutejs/sync-expo/*": [
+          "./node_modules/@absolutejs/sync-expo/dist/*"
+        ],
+        "@absolutejs/sync/*": [
+          "./node_modules/@absolutejs/sync/dist/*"
+        ]
+      } : {},
       "*": [
         "./node_modules/*",
         `${portableRelative(project, projectRoot)}/node_modules/*`
@@ -1174,7 +1890,7 @@ const styles = StyleSheet.create({ loading: { alignItems: 'center', flex: 1, jus
   },
   extends: "expo/tsconfig.base"
 }), writeManagedFile = async (path, source, force) => {
-  await mkdir(dirname3(path), { recursive: true });
+  await mkdir(dirname4(path), { recursive: true });
   if (await exists(path)) {
     const current = await readFile(path, "utf8");
     if (current === source)
@@ -1191,8 +1907,11 @@ const styles = StyleSheet.create({ loading: { alignItems: 'center', flex: 1, jus
 `, emptyWebAssetsSource, writeAbsoluteExpoProject = async (config, options) => {
   if (config.engine !== "expo")
     throw new TypeError("Expo project generation requires mobile.engine: expo.");
-  const projectRoot = resolve3(options.projectRoot);
+  const projectRoot = resolve4(options.projectRoot);
   const project = config.nativeProjectDirectory;
+  const auth = resolveAbsoluteMobileAuthManifest(projectRoot, config);
+  const syncEnabled = Boolean(auth && projectUsesAbsoluteSync(projectRoot));
+  const syncSchema = syncEnabled ? { components: discoverAbsoluteSyncSchema(projectRoot).components } : undefined;
   const routeModules = Object.entries(config.expoNativeRoutes);
   const moduleChecks = await Promise.all(routeModules.map(async ([route, module]) => ({
     exists: await exists(module),
@@ -1203,7 +1922,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 = join5(project, EXPO_PROJECT_MARKER);
+  const marker = join7(project, EXPO_PROJECT_MARKER);
   if (await exists(project) && !await exists(marker)) {
     const entries = await readdir(project);
     if (entries.length > 0 && !options.force) {
@@ -1213,47 +1932,63 @@ const styles = StyleSheet.create({ loading: { alignItems: 'center', flex: 1, jus
   await mkdir(project, { recursive: true });
   await writeFile(marker, `format=1
 `);
+  const authEnabled = Boolean(auth);
   const files = new Map([
     [
-      join5(project, ".gitignore"),
+      join7(project, ".gitignore"),
       `.expo/
 android/
 ios/
 node_modules/
 `
     ],
-    [join5(project, "app.json"), jsonSource(expoAppConfig(config))],
-    [join5(project, "app.config.js"), expoDynamicAppConfig],
-    [join5(project, "package.json"), jsonSource(expoPackage())],
-    [join5(project, "metro.config.js"), metroConfig(projectRoot)],
     [
-      join5(project, "plugins", "withAbsoluteDevelopmentCa.js"),
+      join7(project, "app.json"),
+      jsonSource(expoAppConfig(config, authEnabled, syncEnabled))
+    ],
+    [join7(project, "app.config.js"), expoDynamicAppConfig],
+    [
+      join7(project, "package.json"),
+      jsonSource(expoPackage(authEnabled, syncEnabled))
+    ],
+    [join7(project, "metro.config.js"), metroConfig(projectRoot)],
+    [
+      join7(project, "plugins", "withAbsoluteDevelopmentCa.js"),
       expoDevelopmentCaPlugin
     ],
     [
-      join5(project, "tsconfig.json"),
-      jsonSource(expoTsConfig(projectRoot, project))
+      join7(project, "tsconfig.json"),
+      jsonSource(expoTsConfig(projectRoot, project, authEnabled, syncEnabled))
+    ],
+    [
+      join7(project, "app", "_layout.tsx"),
+      layoutSource(authEnabled, syncEnabled)
     ],
-    [join5(project, "app", "_layout.tsx"), layoutSource],
     [
-      join5(project, "app", "__absolute", "native", "index.tsx"),
+      join7(project, "app", "__absolute", "native", "index.tsx"),
       nativeDiagnosticSource
     ],
     [
-      join5(project, "src", "generated", "AbsoluteWebHost.tsx"),
-      webHostSource(config)
+      join7(project, "src", "generated", "AbsoluteWebHost.tsx"),
+      webHostSource(config, auth, syncEnabled)
     ]
   ]);
-  const webAssetsPath = join5(project, "src", "generated", "webAssets.ts");
+  if (auth) {
+    files.set(join7(project, "src", "generated", "AbsoluteAuth.ts"), authRuntimeSource(auth, config.appId));
+  }
+  if (syncSchema) {
+    files.set(join7(project, "src", "generated", "AbsoluteSync.ts"), syncRuntimeSource(config, syncSchema));
+  }
+  const webAssetsPath = join7(project, "src", "generated", "webAssets.ts");
   if (!await exists(webAssetsPath)) {
     files.set(webAssetsPath, emptyWebAssetsSource);
   }
   if (!config.expoNativeRoutes["/"]) {
-    files.set(join5(project, "app", "index.tsx"), webRouteSource);
+    files.set(join7(project, "app", "index.tsx"), webRouteSource);
   }
-  files.set(join5(project, "app", "[...absolute].tsx"), catchAllRouteSource);
+  files.set(join7(project, "app", "[...absolute].tsx"), catchAllRouteSource);
   for (const [route, module] of routeModules) {
-    const wrapper = route === "/" ? join5(project, "app", "index.tsx") : routeFile(project, route);
+    const wrapper = route === "/" ? join7(project, "app", "index.tsx") : routeFile(project, route);
     files.set(wrapper, nativeWrapperSource(wrapper, module));
   }
   const changes = await Promise.all([...files].map(([path, source]) => writeManagedFile(path, source, true)));
@@ -1262,7 +1997,7 @@ node_modules/
 }, walkFiles = async (root, directory = root) => {
   const entries = await readdir(directory, { withFileTypes: true });
   const nested = await Promise.all(entries.map((entry) => {
-    const path = join5(directory, entry.name);
+    const path = join7(directory, entry.name);
     if (entry.isDirectory())
       return walkFiles(root, path);
     if (entry.isFile())
@@ -1323,11 +2058,11 @@ export const materializeAbsoluteWebBundle = async () => {
 `, syncAbsoluteExpoWebAssets = async (config) => {
   if (config.engine !== "expo")
     throw new TypeError("Expo asset sync requires mobile.engine: expo.");
-  const marker = join5(config.nativeProjectDirectory, EXPO_PROJECT_MARKER);
+  const marker = join7(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 = join5(config.bundleDirectory, "absolute-mobile-manifest.json");
+  const manifestPath = join7(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)
@@ -1342,16 +2077,16 @@ export const materializeAbsoluteWebBundle = async () => {
     bundleHash.update("\x00");
   });
   const bundleId = `amexpo_${bundleHash.digest("hex")}`;
-  const destination = join5(config.nativeProjectDirectory, "assets", "absolute");
-  await mkdir(dirname3(destination), { recursive: true });
-  const staging = await mkdtemp(join5(dirname3(destination), `.${basename2(destination)}.stage-`));
+  const destination = join7(config.nativeProjectDirectory, "assets", "absolute");
+  await mkdir(dirname4(destination), { recursive: true });
+  const staging = await mkdtemp(join7(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, join5(staging, name));
+      await cp(source, join7(staging, name));
       return {
-        asset: portableRelative(join5(config.nativeProjectDirectory, "src", "generated"), join5(destination, name)),
+        asset: portableRelative(join7(config.nativeProjectDirectory, "src", "generated"), join7(destination, name)),
         path: relative(config.bundleDirectory, source).replaceAll("\\", "/")
       };
     }));
@@ -1360,11 +2095,13 @@ export const materializeAbsoluteWebBundle = async () => {
     await rm(staging, { force: true, recursive: true });
     throw error;
   }
-  const generated = join5(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
+  const generated = join7(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();
   expoDynamicAppConfig = `${EXPO_GENERATED_HEADER}const config = require('./app.json');
 
 if (process.env.ABSOLUTE_EXPO_DEVELOPMENT === '1' && process.env.ABSOLUTE_EXPO_DEVELOPMENT_CA_PATH) {
@@ -1415,12 +2152,6 @@ const withAbsoluteDevelopmentCa = config => {
 };
 
 module.exports = withAbsoluteDevelopmentCa;
-`;
-  layoutSource = `${EXPO_GENERATED_HEADER}import { Stack } from 'expo-router';
-
-export default function AbsoluteLayout() {
-	return <Stack screenOptions={{ headerShown: false }} />;
-}
 `;
   nativeDiagnosticSource = `${EXPO_GENERATED_HEADER}import * as Haptics from 'expo-haptics';
 import { Link } from 'expo-router';
@@ -1476,14 +2207,14 @@ import {
   isIP
 } from "net";
 import { readFile as readFile2 } from "fs/promises";
-var closeServer = (server) => new Promise((resolve4, reject) => {
+var closeServer = (server) => new Promise((resolve5, reject) => {
   server.close((error) => {
     if (error)
       reject(error);
     else
-      resolve4();
+      resolve5();
   });
-}), listen = (server, port) => new Promise((resolve4, reject) => {
+}), listen = (server, port) => new Promise((resolve5, reject) => {
   server.once("error", reject);
   server.listen(port, "0.0.0.0", () => {
     server.off("error", reject);
@@ -1492,11 +2223,11 @@ var closeServer = (server) => new Promise((resolve4, reject) => {
       reject(new Error("Could not determine the iOS device helper port."));
       return;
     }
-    resolve4(address.port);
+    resolve5(address.port);
   });
 }), findEphemeralPort = async () => {
   const probe = createTcpServer();
-  const port = await new Promise((resolve4, reject) => {
+  const port = await new Promise((resolve5, reject) => {
     probe.once("error", reject);
     probe.listen(0, "127.0.0.1", () => {
       const address = probe.address();
@@ -1504,7 +2235,7 @@ var closeServer = (server) => new Promise((resolve4, reject) => {
         reject(new Error("Could not allocate the iOS CA enrollment port."));
         return;
       }
-      resolve4(address.port);
+      resolve5(address.port);
     });
   });
   await closeServer(probe);
@@ -1519,9 +2250,9 @@ var closeServer = (server) => new Promise((resolve4, reject) => {
   if (!normalized || normalized.length > 256 || /[\0\r\n]/u.test(normalized))
     throw new TypeError("--ios-device requires a valid Xcode device identifier or name.");
   return normalized;
-}, urlForHost = (protocol, host, port) => {
+}, urlForHost = (protocol, host2, port) => {
   const url = new URL(`${protocol}://localhost:${port}`);
-  const normalizedHost = normalizeAbsoluteIosDeviceHost(host);
+  const normalizedHost = normalizeAbsoluteIosDeviceHost(host2);
   url.hostname = isIP(normalizedHost) === 6 ? `[${normalizedHost}]` : normalizedHost;
   return url;
 }, startAbsoluteIosCaEnrollmentServer = async (options) => {
@@ -1544,73 +2275,29 @@ var closeServer = (server) => new Promise((resolve4, reject) => {
       "Content-Length": String(certificateBytes.byteLength),
       "Content-Type": "application/x-x509-ca-cert",
       "X-Content-Type-Options": "nosniff"
-    });
-    response.end(certificateBytes);
-  });
-  const port = await findEphemeralPort();
-  await listen(server, port);
-  const url = urlForHost("http", options.displayHost, port);
-  url.pathname = certificatePath;
-  return {
-    url: url.href,
-    close: () => closeServer(server)
-  };
-};
-var init_iosPhysicalDeviceTransport = () => {};
-
-// src/mobile/nativeAuth.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join7 } from "path";
-var ABSOLUTE_AUTH_PACKAGE = "@absolutejs/auth", ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV = "ABSOLUTE_AUTH_NATIVE_CLIENTS", ABSOLUTE_NATIVE_AUTH_SCOPES, ABSOLUTE_SYNC_PACKAGE = "@absolutejs/sync", readPackageManifest = (projectRoot) => {
-  try {
-    return JSON.parse(readFileSync5(join7(projectRoot, "package.json"), "utf8"));
-  } catch {
-    return;
-  }
-}, packageManifestHas = (manifest, packageName) => {
-  if (typeof manifest !== "object" || manifest === null)
-    return false;
-  return [
-    Reflect.get(manifest, "dependencies"),
-    Reflect.get(manifest, "devDependencies"),
-    Reflect.get(manifest, "optionalDependencies"),
-    Reflect.get(manifest, "peerDependencies")
-  ].some((dependencies) => typeof dependencies === "object" && dependencies !== null && Object.hasOwn(dependencies, packageName));
-}, createAbsoluteMobileAuthManifest = (config) => {
-  const scheme = config.deepLinkScheme ?? config.appId.toLowerCase();
-  return {
-    clientId: `absolutejs-native:${config.appId}`,
-    issuer: config.productionOrigin,
-    redirectUri: `${scheme}://auth/callback`,
-    scopes: [...ABSOLUTE_NATIVE_AUTH_SCOPES]
-  };
-}, installAbsoluteMobileAuthEnvironment = (projectRoot, config) => {
-  const auth = resolveAbsoluteMobileAuthManifest(projectRoot, config);
-  const serialized = serializeAbsoluteMobileAuthEnvironment(config, auth);
-  if (serialized === undefined)
-    delete process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV];
-  else
-    process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV] = serialized;
-  return auth;
-}, projectUsesAbsoluteAuth = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_AUTH_PACKAGE), projectUsesAbsoluteSync = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_SYNC_PACKAGE), resolveAbsoluteMobileAuthManifest = (projectRoot, config) => projectUsesAbsoluteAuth(projectRoot) ? createAbsoluteMobileAuthManifest(config) : undefined, serializeAbsoluteMobileAuthEnvironment = (config, auth) => auth === undefined ? undefined : JSON.stringify([
-  {
-    ...auth,
-    name: `${config.appName} native app`
-  }
-]);
-var init_nativeAuth = __esm(() => {
-  ABSOLUTE_NATIVE_AUTH_SCOPES = ["openid", "profile"];
-});
+    });
+    response.end(certificateBytes);
+  });
+  const port = await findEphemeralPort();
+  await listen(server, port);
+  const url = urlForHost("http", options.displayHost, port);
+  url.pathname = certificatePath;
+  return {
+    url: url.href,
+    close: () => closeServer(server)
+  };
+};
+var init_iosPhysicalDeviceTransport = () => {};
 
 // src/cli/utils.ts
 var {$: $2 } = globalThis.Bun;
 import { execSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
 import { createServer as createServer3 } from "net";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 var COMPOSE_PATH = "db/docker-compose.db.yml", DEFAULT_SERVER_ENTRY = "src/backend/server.ts", isWSLEnvironment = () => {
   try {
-    const release = readFileSync6("/proc/version", "utf-8");
+    const release = readFileSync7("/proc/version", "utf-8");
     return /microsoft|wsl/i.test(release);
   } catch {
     return false;
@@ -1709,7 +2396,7 @@ 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 = resolve4("package.json");
+  const pkgPath = resolve5("package.json");
   if (!existsSync3(pkgPath))
     return null;
   const pkg = await Bun.file(pkgPath).json();
@@ -1744,7 +2431,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 join8 } from "path";
+import { join as join9 } from "path";
 var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command) => {
   try {
     const result = Bun.spawnSync(command, {
@@ -1787,17 +2474,17 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
   } catch {
     return;
   }
-}, absoluteManagedAndroidSdkRoot = (host, env = process.env) => {
-  if (host === "windows") {
-    return join8(env.LOCALAPPDATA ?? join8(homedir3(), "AppData", "Local"), "AbsoluteJS", "Android", "Sdk");
+}, absoluteManagedAndroidSdkRoot = (host2, env = process.env) => {
+  if (host2 === "windows") {
+    return join9(env.LOCALAPPDATA ?? join9(homedir3(), "AppData", "Local"), "AbsoluteJS", "Android", "Sdk");
   }
-  if (host === "wsl") {
+  if (host2 === "wsl") {
     const localAppData = windowsLocalAppDataFromWsl();
     if (localAppData) {
-      return join8(localAppData, "AbsoluteJS", "Android", "Sdk");
+      return join9(localAppData, "AbsoluteJS", "Android", "Sdk");
     }
   }
-  return join8(homedir3(), ".absolutejs", "android-sdk");
+  return join9(homedir3(), ".absolutejs", "android-sdk");
 }, pathExists = async (path) => {
   try {
     await access3(path);
@@ -1813,18 +2500,18 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
   if (platform2 === "linux" && wsl)
     return "wsl";
   return "linux";
-}, executableNames = (host, name) => {
-  if (host === "wsl")
+}, executableNames = (host2, name) => {
+  if (host2 === "wsl")
     return [`${name}.exe`, `${name}.bat`, name];
-  if (host === "windows")
+  if (host2 === "windows")
     return [name, `${name}.exe`, `${name}.bat`];
   return [name];
-}, findExecutable = async (name, paths, options, host) => {
+}, findExecutable = async (name, paths, options, host2) => {
   const existing = await Promise.all(paths.map(async (path) => await options.exists(path) ? path : undefined));
   const configured = existing.find((path) => path !== undefined);
   if (configured)
     return configured;
-  for (const candidate of executableNames(host, name)) {
+  for (const candidate of executableNames(host2, name)) {
     const path = options.which(candidate);
     if (path)
       return path;
@@ -1844,23 +2531,23 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
   status: "fail"
 }, inspectAbsoluteMobileToolchain = async (input = {}) => {
   const env = input.env ?? process.env;
-  const host = input.host ?? detectAbsoluteMobileHost();
+  const host2 = input.host ?? detectAbsoluteMobileHost();
   const exists2 = input.exists ?? pathExists;
   const which = input.which ?? ((command) => Bun.which(command));
   const capture = input.capture ?? captureCommand;
-  const androidRoot = input.androidRoot === null ? undefined : input.androidRoot ?? env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host, env);
-  const windowsAndroidTools = host === "windows" || host === "wsl";
-  const android = (segments) => androidRoot ? join8(androidRoot, ...segments) : undefined;
+  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 paths = (values) => values.filter((value) => Boolean(value));
   const adb = await findExecutable("adb", paths([
     android(["platform-tools", windowsAndroidTools ? "adb.exe" : "adb"])
-  ]), { exists: exists2, which }, host);
+  ]), { exists: exists2, which }, host2);
   const emulator = await findExecutable("emulator", paths([
     android([
       "emulator",
       windowsAndroidTools ? "emulator.exe" : "emulator"
     ])
-  ]), { exists: exists2, which }, host);
+  ]), { exists: exists2, which }, host2);
   const sdkmanager = await findExecutable("sdkmanager", paths([
     android([
       "cmdline-tools",
@@ -1868,7 +2555,7 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
       "bin",
       windowsAndroidTools ? "sdkmanager.bat" : "sdkmanager"
     ])
-  ]), { exists: exists2, which }, host);
+  ]), { exists: exists2, which }, host2);
   const avdmanager = await findExecutable("avdmanager", paths([
     android([
       "cmdline-tools",
@@ -1876,12 +2563,12 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
       "bin",
       windowsAndroidTools ? "avdmanager.bat" : "avdmanager"
     ])
-  ]), { exists: exists2, which }, host);
-  const java = await findExecutable("java", [], { exists: exists2, which }, host);
+  ]), { exists: exists2, which }, host2);
+  const java = await findExecutable("java", [], { exists: exists2, which }, host2);
   const checks = [
     {
       id: "host",
-      label: `Development host: ${host}`,
+      label: `Development host: ${host2}`,
       platform: "host",
       status: "pass"
     },
@@ -1902,7 +2589,7 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
       status: hasManagedAvd ? "pass" : "fail"
     });
   }
-  if (host === "wsl") {
+  if (host2 === "wsl") {
     checks.push({
       id: "android.virtualization",
       label: adb?.endsWith(".exe") ? "Windows-host Android bridge available to WSL" : "WSL requires a Windows-host emulator bridge or Linux KVM",
@@ -1910,7 +2597,7 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
       remediation: adb?.endsWith(".exe") ? undefined : "Expose the Windows Android SDK adb.exe to WSL, or enable /dev/kvm for a Linux SDK.",
       status: adb?.endsWith(".exe") ? "pass" : "warn"
     });
-  } else if (host === "linux") {
+  } else if (host2 === "linux") {
     const hasKvm = await exists2("/dev/kvm");
     checks.push({
       id: "android.virtualization",
@@ -1920,7 +2607,7 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
       status: hasKvm ? "pass" : "warn"
     });
   }
-  if (host !== "macos") {
+  if (host2 !== "macos") {
     checks.push({
       id: "ios.simulator",
       label: "iOS Simulator requires macOS and Xcode",
@@ -1929,8 +2616,8 @@ var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36", captureCommand = (command)
     });
     return checks;
   }
-  const xcrun = await findExecutable("xcrun", [], { exists: exists2, which }, host);
-  const xcodebuild = await findExecutable("xcodebuild", [], { exists: exists2, which }, host);
+  const xcrun = await findExecutable("xcrun", [], { exists: exists2, which }, host2);
+  const xcodebuild = await findExecutable("xcodebuild", [], { exists: exists2, which }, host2);
   checks.push(toolCheck("ios.xcrun", "Xcode command runner", "ios", xcrun, "Install Xcode and select it with xcode-select."), toolCheck("ios.xcodebuild", "Xcode build system", "ios", xcodebuild, "Install Xcode and select it with xcode-select."));
   if (xcrun) {
     const runtimes = capture([
@@ -1957,7 +2644,7 @@ 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 resolve5 } from "path";
+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';
 
 const config: CapacitorConfig = {
@@ -1981,8 +2668,8 @@ export default config;
     return false;
   }
 }, writeAbsoluteCapacitorConfig = async (config, options) => {
-  const projectRoot = resolve5(options.projectRoot);
-  const destination = resolve5(projectRoot, CONFIG_FILE);
+  const projectRoot = resolve6(options.projectRoot);
+  const destination = resolve6(projectRoot, CONFIG_FILE);
   const source = capacitorConfigSource(config, projectRoot);
   if (await exists2(destination)) {
     const current = await readFile3(destination, "utf8");
@@ -2015,11 +2702,11 @@ import {
 } from "fs/promises";
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 import {
-  dirname as dirname4,
+  dirname as dirname5,
   isAbsolute,
-  join as join9,
+  join as join10,
   relative as relative3,
-  resolve as resolve6,
+  resolve as resolve7,
   sep,
   win32
 } from "path";
@@ -2189,21 +2876,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 = join9(projectRoot, ".absolutejs", "mobile", "dev-session");
+  const root = join10(projectRoot, ".absolutejs", "mobile", "dev-session");
   return {
-    backup: join9(root, "capacitor.config.backup.json"),
-    caBackup: join9(root, "absolutejs_dev_ca.backup.pem"),
-    journal: join9(root, "journal.json"),
-    manifestBackup: join9(root, "AndroidManifest.backup.xml"),
-    networkConfigBackup: join9(root, "absolutejs_dev_network_security.backup.xml"),
+    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"),
     root
   };
 }, isInside = (root, path) => {
-  const resolvedRoot = resolve6(root);
-  const resolvedPath = resolve6(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) => join9(projectRoot, ".absolutejs", "mobile", "cache", "android-debug.json"), parseNativeCache = (value) => {
+}, isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), nativeCachePath = (projectRoot) => join10(projectRoot, ".absolutejs", "mobile", "cache", "android-debug.json"), parseNativeCache = (value) => {
   if (!isRecord(value))
     return null;
   const { appId, fingerprint, format, installations } = value;
@@ -2222,7 +2909,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
 }, readNativeCache = async (projectRoot) => readFile4(nativeCachePath(projectRoot), "utf8").then((source) => parseNativeCache(JSON.parse(source))).catch(() => null), writeNativeCache = async (projectRoot, cache) => {
   const destination = nativeCachePath(projectRoot);
   const temporary = `${destination}.${process.pid}.${randomUUID2()}.tmp`;
-  await mkdir2(dirname4(destination), { recursive: true });
+  await mkdir2(dirname5(destination), { recursive: true });
   try {
     await writeFile3(temporary, `${JSON.stringify(cache, null, "\t")}
 `, {
@@ -2235,11 +2922,11 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     });
   }
 }, nativeDependencySources = async (nativeDirectory) => {
-  const settings = await readFile4(join9(nativeDirectory, "capacitor.settings.gradle"), "utf8");
+  const settings = await readFile4(join10(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: resolve6(nativeDirectory, match[2] ?? "")
+    source: resolve7(nativeDirectory, match[2] ?? "")
   }));
   if (dependencies.length === 0) {
     throw new Error("Capacitor Android settings did not declare any native dependencies.");
@@ -2275,7 +2962,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, join9(directory, entry.name), entry.isDirectory(), entry.isFile(), entry.isSymbolicLink(), ignorePublicBundle)));
+  const records = await Promise.all(entries.map((entry) => collectNativePath(root, label, join10(directory, entry.name), entry.isDirectory(), entry.isFile(), entry.isSymbolicLink(), ignorePublicBundle)));
   return records.flat();
 }, hashNativeTree = async (root, label, ignorePublicBundle) => {
   const resolvedRoot = await realpath(root);
@@ -2328,7 +3015,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     await rm2(file.path, { force: true });
     return;
   }
-  await mkdir2(dirname4(file.path), { recursive: true });
+  await mkdir2(dirname5(file.path), { recursive: true });
   await copyFile(file.backupPath, file.path);
 }, repairAbsoluteAndroidDevSession = async (projectRoot) => {
   const paths = journalPaths(projectRoot);
@@ -2341,11 +3028,11 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     throw new Error(`Refusing unsafe or invalid mobile dev journal at ${paths.journal}.`);
   }
   if (await pathExists2(journal.backupPath)) {
-    await mkdir2(dirname4(journal.nativeConfigPath), { recursive: true });
+    await mkdir2(dirname5(journal.nativeConfigPath), { recursive: true });
     await copyFile(journal.backupPath, journal.nativeConfigPath);
   }
   if (journal.manifestBackupPath && journal.nativeManifestPath && await pathExists2(journal.manifestBackupPath)) {
-    await mkdir2(dirname4(journal.nativeManifestPath), { recursive: true });
+    await mkdir2(dirname5(journal.nativeManifestPath), { recursive: true });
     await copyFile(journal.manifestBackupPath, journal.nativeManifestPath);
   }
   await Promise.all((journal.projectedFiles ?? []).map(restoreAndroidProjectedFile));
@@ -2404,11 +3091,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 = join9(dirname4(nativeManifestPath), "res");
-  const caPath = join9(resourceRoot, "raw", "absolutejs_dev_ca.pem");
+  const resourceRoot = join10(dirname5(nativeManifestPath), "res");
+  const caPath = join10(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 = join9(resourceRoot, "xml", `${networkConfigName}.xml`);
+  const networkConfigPath = join10(resourceRoot, "xml", `${networkConfigName}.xml`);
   const backupProjectedFile = async ([path, backupPath]) => {
     if (!await pathExists2(path))
       return { path };
@@ -2445,8 +3132,8 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
 `);
   if (https && certificateAuthorityPath) {
     await Promise.all([
-      mkdir2(dirname4(caPath), { recursive: true }),
-      mkdir2(dirname4(networkConfigPath), { recursive: true })
+      mkdir2(dirname5(caPath), { recursive: true }),
+      mkdir2(dirname5(networkConfigPath), { recursive: true })
     ]);
     await copyFile(certificateAuthorityPath, caPath);
     const existingNetworkConfigSource = existingNetworkConfig ? await readFile4(networkConfigPath, "utf8") : `<?xml version="1.0" encoding="utf-8"?>
@@ -2501,12 +3188,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 = join9(project.nativeDirectory, "capacitor.settings.gradle");
+  const settingsPath = join10(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 = resolve6(project.nativeDirectory, sourcePath);
+    const source = resolve7(project.nativeDirectory, sourcePath);
     dependencies.push({
       name,
       windowsSource: windowsPathFromWsl(source, capture)
@@ -2547,7 +3234,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 : join9;
+  const pathJoin = windows ? win32.join : join10;
   if (task === "assembleDebug") {
     return pathJoin(nativeDirectory, "app", "build", "outputs", "apk", "debug", "app-debug.apk");
   }
@@ -2560,7 +3247,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
   if (task !== "assembleRelease" || await pathExists2(primary)) {
     return primary;
   }
-  return join9(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk");
+  return join10(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk");
 }, buildAbsoluteAndroidGradleArtifact = async (options) => {
   const { project, task } = options;
   const capture = options.capture ?? captureCommand2;
@@ -2570,7 +3257,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 = resolve6(project.androidRoot, "..", "..", "Builds", `${project.config.appId}-${buildId}`);
+    const managedBuildDirectory = resolve7(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);
@@ -2753,10 +3440,10 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     "chromium:I"
   ], { env }, onLine);
 }, prepareAbsoluteAndroidDevProject = async (config, options) => {
-  const projectRoot = resolve6(options.projectRoot);
-  const host = detectAbsoluteMobileHost();
-  const androidRoot = process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host);
-  const checks = await inspectAbsoluteMobileToolchain({ androidRoot, host });
+  const projectRoot = resolve7(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 });
   const deviceOnlyChecks = new Set([
     "android.avd",
     "android.avdmanager",
@@ -2772,18 +3459,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 = join9(projectRoot, "node_modules", ".bin", host === "windows" ? "cap.cmd" : "cap");
+  const cap = join10(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 = join9(config.bundleDirectory, "index.html");
+  const placeholder = join10(config.bundleDirectory, "index.html");
   if (!await pathExists2(placeholder)) {
     await writeFile3(placeholder, `<!doctype html><title>AbsoluteJS mobile development</title>
 `);
   }
-  const nativeDirectory = join9(config.nativeProjectDirectory, "android");
+  const nativeDirectory = join10(config.nativeProjectDirectory, "android");
   if (!await pathExists2(nativeDirectory)) {
     if (!options.createNativeProject) {
       throw new Error("Android native project has not been created.");
@@ -2801,7 +3488,7 @@ var ANDROID_BOOT_TIMEOUT_MS = 180000, ANDROID_BOOT_POLL_MS = 1000, DEV_JOURNAL_F
     cap,
     config,
     ...emulator ? { emulator } : {},
-    host,
+    host: host2,
     nativeDirectory,
     projectRoot
   };
@@ -2844,8 +3531,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 = join9(project.nativeDirectory, "app", "src", "main", "assets", "capacitor.config.json");
-  const nativeManifestPath = join9(project.nativeDirectory, "app", "src", "main", "AndroidManifest.xml");
+  const nativeConfigPath = join10(project.nativeDirectory, "app", "src", "main", "assets", "capacitor.config.json");
+  const nativeManifestPath = join10(project.nativeDirectory, "app", "src", "main", "AndroidManifest.xml");
   let connectedSerial;
   let nativeLogs = null;
   const closeNativeLogs = async () => {
@@ -3004,7 +3691,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 join10 } from "path";
+import { basename as basename3, join as join11 } 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,
@@ -3036,33 +3723,33 @@ var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION
     exitCode: result.exitCode,
     stdout: result.stdout.toString()
   };
-}, commandPath = (root, host, tool) => join10(root, "cmdline-tools", "latest", "bin", host === "windows" || host === "wsl" ? `${tool}.bat` : tool), executablePath = (root, host, directory, tool) => join10(root, directory, host === "windows" || host === "wsl" ? `${tool}.exe` : tool), windowsPath = (path) => {
+}, 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) => {
   const match = /^\/mnt\/([a-z])\/(.*)$/i.exec(path);
   if (!match)
     return path;
   return `${match[1]?.toUpperCase()}:\\${match[2]?.replaceAll("/", "\\")}`;
-}, runnableCommand = (host, path, args) => {
-  if (host !== "wsl" || !path.endsWith(".bat"))
+}, runnableCommand = (host2, path, args) => {
+  if (host2 !== "wsl" || !path.endsWith(".bat"))
     return [path, ...args];
   return ["cmd.exe", "/d", "/c", windowsPath(path), ...args];
-}, systemImageFor = (host, arch2) => {
-  const imageArch = host === "macos" && arch2 === "arm64" ? "arm64-v8a" : "x86_64";
+}, systemImageFor = (host2, arch2) => {
+  const imageArch = host2 === "macos" && arch2 === "arm64" ? "arm64-v8a" : "x86_64";
   return `system-images;android-${ANDROID_API};google_apis;${imageArch}`;
 }, planAbsoluteMobileEmulatorInstall = (platform2, input = {}) => {
-  const host = input.host ?? detectAbsoluteMobileHost();
+  const host2 = input.host ?? detectAbsoluteMobileHost();
   const env = {
     ...process.env,
     ...input.env
   };
-  const androidRoot = env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host, env);
+  const androidRoot = env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host2, env);
   if (platform2 === "ios") {
     return {
       androidRoot,
-      host,
+      host: host2,
       platform: platform2,
       steps: [
         {
-          detail: host === "macos" ? "Use Xcode to download the current iOS Simulator runtime." : "iOS Simulator setup must run on a macOS host.",
+          detail: host2 === "macos" ? "Use Xcode to download the current iOS Simulator runtime." : "iOS Simulator setup must run on a macOS host.",
           id: "ios.runtime",
           label: "Install iOS Simulator runtime"
         }
@@ -3071,7 +3758,7 @@ var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION
   }
   return {
     androidRoot,
-    host,
+    host: host2,
     platform: platform2,
     steps: [
       {
@@ -3091,15 +3778,15 @@ var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION
       }
     ]
   };
-}, releaseFor = (host, arch2) => {
-  let platform2 = host;
-  if (host === "wsl")
+}, releaseFor = (host2, arch2) => {
+  let platform2 = host2;
+  if (host2 === "wsl")
     platform2 = "windows";
-  if (host === "macos")
+  if (host2 === "macos")
     platform2 = "darwin";
   const release = COMMAND_LINE_TOOLS[`${platform2}-${arch2}`];
   if (!release) {
-    throw new Error(`Automatic Android command-line-tools installation is not available for ${host}/${arch2}.`);
+    throw new Error(`Automatic Android command-line-tools installation is not available for ${host2}/${arch2}.`);
   }
   return release;
 }, installCommandLineTools = async (plan, input) => {
@@ -3110,10 +3797,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(join10(tmpdir(), "absolutejs-android-sdk-"));
+  const temporary = await mkdtemp2(join11(tmpdir(), "absolutejs-android-sdk-"));
   try {
-    const archive = join10(temporary, "command-line-tools.zip");
-    const extracted = join10(temporary, "extracted");
+    const archive = join11(temporary, "command-line-tools.zip");
+    const extracted = join11(temporary, "extracted");
     await Bun.write(archive, bytes);
     await mkdir3(extracted, { recursive: true });
     const extraction = plan.host === "windows" ? [
@@ -3130,12 +3817,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 = join10(plan.androidRoot, "cmdline-tools", "latest");
-    await mkdir3(join10(plan.androidRoot, "cmdline-tools"), {
+    const destination = join11(plan.androidRoot, "cmdline-tools", "latest");
+    await mkdir3(join11(plan.androidRoot, "cmdline-tools"), {
       recursive: true
     });
     await rm3(destination, { force: true, recursive: true });
-    await cp2(join10(extracted, "cmdline-tools"), destination, {
+    await cp2(join11(extracted, "cmdline-tools"), destination, {
       recursive: true
     });
   } finally {
@@ -3145,9 +3832,9 @@ var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION
   if (await run(command, options) !== 0) {
     throw new Error(`${label} failed.`);
   }
-}, installJavaRuntime = async (host, run, which) => {
-  if (host === "windows" || host === "wsl") {
-    const winget = host === "wsl" ? "winget.exe" : "winget";
+}, installJavaRuntime = async (host2, run, which) => {
+  if (host2 === "windows" || host2 === "wsl") {
+    const winget = host2 === "wsl" ? "winget.exe" : "winget";
     if (!which(winget)) {
       throw new Error("Java 21 is required. Install Temurin 21 or make winget available, then run mobile doctor --fix again.");
     }
@@ -3160,10 +3847,10 @@ var ANDROID_API = 36, ANDROID_BUILD_TOOLS = "36.0.0", COMMAND_LINE_TOOLS_VERSION
       "--accept-package-agreements",
       "--accept-source-agreements"
     ];
-    await ensureCommand(host === "wsl" ? ["cmd.exe", "/d", "/c", ...command] : command, "Java 21 installation", run);
+    await ensureCommand(host2 === "wsl" ? ["cmd.exe", "/d", "/c", ...command] : command, "Java 21 installation", run);
     return;
   }
-  if (host === "macos") {
+  if (host2 === "macos") {
     if (!which("brew")) {
       throw new Error("Java 21 is required. Install Homebrew or Temurin 21, then run mobile doctor --fix again.");
     }
@@ -3320,7 +4007,7 @@ import {
   stat,
   writeFile as writeFile4
 } from "fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join11, relative as relative4, resolve as resolve7, sep as sep2 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join12, relative as relative4, resolve as resolve8, sep as sep2 } from "path";
 var developmentTeamArgument = (value) => {
   if (value === undefined)
     return;
@@ -3377,7 +4064,7 @@ 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 = join11(current, entry.name);
+    const path = join12(current, entry.name);
     const projectRelative = relative4(root, path).replaceAll("\\", "/");
     const ignored = entry.isDirectory() && (ignoredFingerprintDirectories.has(entry.name) || projectRelative === "App/App/public" && options.includePublicBundle !== true);
     if (ignored)
@@ -3399,8 +4086,8 @@ var developmentTeamArgument = (value) => {
   });
   return hasher.digest("hex");
 }, safeOutputDirectory = (projectRoot, requested) => {
-  const root = resolve7(projectRoot);
-  const output = resolve7(root, requested ?? ".absolutejs/mobile/releases/ios");
+  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)) {
     throw new TypeError("mobile build --outdir must remain inside the project.");
@@ -3411,7 +4098,7 @@ var developmentTeamArgument = (value) => {
     return;
   const entries = await readdir3(root, { withFileTypes: true });
   const matches = await Promise.all(entries.map(async (entry) => {
-    const path = join11(root, entry.name);
+    const path = join12(root, entry.name);
     if (entry.isDirectory() && entry.name.endsWith(extension))
       return path;
     if (entry.isFile() && entry.name.endsWith(extension))
@@ -3434,10 +4121,10 @@ var developmentTeamArgument = (value) => {
     throw new TypeError("iOS build number must be a positive integer.");
   return value;
 }, installRelease = async (artifactPath, metadata, outputRoot) => {
-  const releaseRoot = join11(outputRoot, metadata.releaseId);
-  const destination = join11(releaseRoot, "App.ipa");
+  const releaseRoot = join12(outputRoot, metadata.releaseId);
+  const destination = join12(releaseRoot, "App.ipa");
   if (await pathExists3(releaseRoot)) {
-    const value = JSON.parse(await readFile6(join11(releaseRoot, "release.json"), "utf8"));
+    const value = JSON.parse(await readFile6(join12(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.`);
     }
@@ -3456,15 +4143,15 @@ var developmentTeamArgument = (value) => {
       releaseRoot
     };
   }
-  await mkdir4(dirname5(releaseRoot), { recursive: true });
-  const staging = await mkdtemp3(join11(dirname5(releaseRoot), ".ios-stage-"));
+  await mkdir4(dirname6(releaseRoot), { recursive: true });
+  const staging = await mkdtemp3(join12(dirname6(releaseRoot), ".ios-stage-"));
   try {
-    await copyFile2(artifactPath, join11(staging, "App.ipa"));
+    await copyFile2(artifactPath, join12(staging, "App.ipa"));
     const complete = {
       ...metadata,
       artifact: "App.ipa"
     };
-    await writeFile4(join11(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+    await writeFile4(join12(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
 `, { flag: "wx" });
     await rename4(staging, releaseRoot);
     return { artifactPath: destination, metadata: complete, releaseRoot };
@@ -3481,22 +4168,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(join11(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  const manifest = requireManifest(JSON.parse(await readFile6(join12(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 = join11(options.config.nativeProjectDirectory, "ios");
+  const nativeDirectory = join12(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 = resolve7(options.projectRoot, ".absolutejs/mobile");
+  const stagingParent = resolve8(options.projectRoot, ".absolutejs/mobile");
   await mkdir4(stagingParent, { recursive: true });
-  const staging = await mkdtemp3(join11(stagingParent, ".ios-build-"));
-  const archivePath = join11(staging, "App.xcarchive");
-  const exportPath = join11(staging, "export");
-  const exportPlist = join11(staging, "ExportOptions.plist");
+  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");
   await mkdir4(exportPath, { recursive: true });
   await writeFile4(exportPlist, exportOptions());
   const run = options.run ?? defaultRun2;
@@ -3510,7 +4197,7 @@ var developmentTeamArgument = (value) => {
     const archiveExit = await run([
       "xcodebuild",
       "-workspace",
-      join11(nativeDirectory, "App", "App.xcworkspace"),
+      join12(nativeDirectory, "App", "App.xcworkspace"),
       "-scheme",
       "App",
       "-configuration",
@@ -3524,7 +4211,7 @@ var developmentTeamArgument = (value) => {
     ], { cwd: nativeDirectory });
     if (archiveExit !== 0)
       throw new TypeError("Xcode failed to archive the iOS app.");
-    const archivedApp = await findByExtension(join11(archivePath, "Products", "Applications"), ".app");
+    const archivedApp = await findByExtension(join12(archivePath, "Products", "Applications"), ".app");
     const capture = options.capture ?? defaultCapture2;
     const signed = archivedApp ? capture([
       "codesign",
@@ -3598,7 +4285,7 @@ import {
   writeFile as writeFile5
 } from "fs/promises";
 import { isIP as isIP2 } from "net";
-import { dirname as dirname6, isAbsolute as isAbsolute3, join as join12, relative as relative5, resolve as resolve8, sep as sep3 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute3, join as join13, relative as relative5, resolve as resolve9, sep as sep3 } 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);
@@ -3816,15 +4503,15 @@ 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 = join12(projectRoot, ".absolutejs", "mobile", "ios-dev-session");
+  const root = join13(projectRoot, ".absolutejs", "mobile", "ios-dev-session");
   return {
-    configBackup: join12(root, "capacitor-config.backup"),
-    infoBackup: join12(root, "Info.plist.backup"),
-    journal: join12(root, "journal.json"),
+    configBackup: join13(root, "capacitor-config.backup"),
+    infoBackup: join13(root, "Info.plist.backup"),
+    journal: join13(root, "journal.json"),
     root
   };
-}, nativeCachePath2 = (projectRoot) => join12(projectRoot, ".absolutejs", "mobile", "ios-native-cache.json"), isInside2 = (root, path) => {
-  const value = relative5(resolve8(root), resolve8(path));
+}, 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);
 }, parseJournal2 = (value) => {
   if (!isRecord3(value) || value.format !== DEV_JOURNAL_FORMAT2)
@@ -3880,8 +4567,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 = join12(project.nativeDirectory, "App", "App", "capacitor.config.json");
-  const infoPath = join12(project.nativeDirectory, "App", "App", "Info.plist");
+  const nativeConfigPath = join13(project.nativeDirectory, "App", "App", "capacitor.config.json");
+  const infoPath = join13(project.nativeDirectory, "App", "App", "Info.plist");
   const [configSource, infoSource] = await Promise.all([
     readFile7(nativeConfigPath, "utf8"),
     readFile7(infoPath, "utf8")
@@ -3937,7 +4624,7 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
 }, readNativeCache2 = (projectRoot) => readFile7(nativeCachePath2(projectRoot), "utf8").then((source) => parseNativeCache2(JSON.parse(source))).catch(() => null), writeNativeCache2 = async (projectRoot, cache) => {
   const destination = nativeCachePath2(projectRoot);
   const temporary = `${destination}.${process.pid}.${randomUUID3()}.tmp`;
-  await mkdir5(dirname6(destination), { recursive: true });
+  await mkdir5(dirname7(destination), { recursive: true });
   try {
     await writeFile5(temporary, `${JSON.stringify(cache, null, "\t")}
 `, {
@@ -4042,12 +4729,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 = join12(project.projectRoot, ".absolutejs", "mobile", "ios-derived-data", createHash5("sha256").update(project.config.appId).digest("hex").slice(0, 16));
+  const derivedDataPath = join13(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",
-    join12(project.nativeDirectory, "App", "App.xcworkspace"),
+    join13(project.nativeDirectory, "App", "App.xcworkspace"),
     "-scheme",
     "App",
     "-configuration",
@@ -4058,17 +4745,17 @@ var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone", BOOT_TIMEOUT_MS = 180000,
     derivedDataPath,
     "build"
   ], "iOS simulator build", run, { cwd: project.nativeDirectory, signal });
-  const appPath = join12(derivedDataPath, "Build", "Products", "Debug-iphonesimulator", "App.app");
+  const appPath = join13(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 = join12(project.projectRoot, ".absolutejs", "mobile", "ios-derived-data", createHash5("sha256").update(project.config.appId).digest("hex").slice(0, 16));
+  const derivedDataPath = join13(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",
-    join12(project.nativeDirectory, "App", "App.xcworkspace"),
+    join13(project.nativeDirectory, "App", "App.xcworkspace"),
     "-scheme",
     "App",
     "-configuration",
@@ -4080,7 +4767,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 = join12(derivedDataPath, "Build", "Products", "Debug-iphoneos", "App.app");
+  const appPath = join13(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;
@@ -4191,7 +4878,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 = resolve8(options.projectRoot);
+  const projectRoot = resolve9(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)
@@ -4200,16 +4887,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 = join12(projectRoot, "node_modules", ".bin", "cap");
+  const cap = join13(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 = join12(config.bundleDirectory, "index.html");
+  const placeholder = join13(config.bundleDirectory, "index.html");
   if (!await pathExists4(placeholder))
     await writeFile5(placeholder, `<!doctype html><title>AbsoluteJS mobile development</title>
 `);
-  const nativeDirectory = join12(config.nativeProjectDirectory, "ios");
+  const nativeDirectory = join13(config.nativeProjectDirectory, "ios");
   if (!await pathExists4(nativeDirectory)) {
     if (!options.createNativeProject)
       throw new Error("iOS native project has not been created.");
@@ -4434,10 +5121,10 @@ 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 = resolve8(project.projectRoot, destination);
+        const resolved = resolve9(project.projectRoot, destination);
         if (!isInside2(project.projectRoot, resolved))
           throw new Error("iOS screenshot destination must remain inside the project.");
-        await mkdir5(dirname6(resolved), { recursive: true });
+        await mkdir5(dirname7(resolved), { recursive: true });
         await requireSuccess2([
           project.xcrun,
           "simctl",
@@ -4496,15 +5183,15 @@ import { chmod, mkdir as mkdir6, readFile as readFile8, rename as rename6, write
 import { homedir as homedir4 } from "os";
 import { isIP as isIP3 } from "net";
 import {
-  dirname as dirname7,
+  dirname as dirname8,
   isAbsolute as isAbsolute4,
-  join as join13,
+  join as join14,
   posix,
   relative as relative6,
   resolve as resolvePath,
   sep as sep4
 } from "path";
-var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TIMEOUT_MS = 2000, PROFILE_NAME, SSH_DESTINATION, defaultProfilePath = () => join13(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 = () => join14(homedir4(), ".absolutejs", "mobile", "remote-macs.json"), emptyStore = () => ({
   format: PROFILE_FORMAT,
   profiles: {}
 }), loadStore = async (path = defaultProfilePath()) => {
@@ -4525,7 +5212,7 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
     throw error;
   }
 }, saveStore = async (store, path = defaultProfilePath()) => {
-  await mkdir6(dirname7(path), { recursive: true });
+  await mkdir6(dirname8(path), { recursive: true });
   const temporary = `${path}.${randomUUID4()}.tmp`;
   await writeFile6(temporary, `${JSON.stringify(store, null, 2)}
 `, {
@@ -4627,10 +5314,10 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
     "/bin/sh -lc",
     shellQuote(script)
   ]);
-  const host = requireRemoteSuccess(result, "Remote Mac LAN address discovery").trim();
-  if (isIP3(host) === 0)
+  const host2 = requireRemoteSuccess(result, "Remote Mac LAN address discovery").trim();
+  if (isIP3(host2) === 0)
     throw new Error("The Remote Mac did not report a device-reachable LAN address.");
-  return host;
+  return host2;
 }, listAbsoluteRemoteMacProfiles = async (profilePath) => {
   const store = await loadStore(profilePath);
   return {
@@ -4680,9 +5367,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: join13(resolvePath(projectRoot), "node_modules", ".bin", "cap"),
+  cap: join14(resolvePath(projectRoot), "node_modules", ".bin", "cap"),
   config,
-  nativeDirectory: join13(config.nativeProjectDirectory, "ios"),
+  nativeDirectory: join14(config.nativeProjectDirectory, "ios"),
   profile,
   projectRoot: resolvePath(projectRoot),
   remote: true,
@@ -4729,8 +5416,8 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
   return { ...artifact, remotePath, uploaded: true };
 }, materializeAbsoluteRemoteMacAgent = async (projectRoot) => {
   const shippedCandidates = [
-    join13(import.meta.dir, "remoteMacAgentEntry.js"),
-    join13(import.meta.dir, "..", "mobile", "remoteMacAgentEntry.js")
+    join14(import.meta.dir, "remoteMacAgentEntry.js"),
+    join14(import.meta.dir, "..", "mobile", "remoteMacAgentEntry.js")
   ];
   let path;
   for (const candidate of shippedCandidates) {
@@ -4741,13 +5428,13 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
   }
   if (!path) {
     const sourceCandidates = [
-      join13(import.meta.dir, "remoteMacAgentEntry.ts"),
-      join13(import.meta.dir, "..", "..", "src", "mobile", "remoteMacAgentEntry.ts")
+      join14(import.meta.dir, "remoteMacAgentEntry.ts"),
+      join14(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 = join13(resolvePath(projectRoot), ".absolutejs", "mobile", "remote-agent");
+    const outdir = join14(resolvePath(projectRoot), ".absolutejs", "mobile", "remote-agent");
     await mkdir6(outdir, { recursive: true });
     const result = await Bun.build({
       entrypoints: [source],
@@ -4757,7 +5444,7 @@ 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 = join13(outdir, "remoteMacAgentEntry.js");
+    path = join14(outdir, "remoteMacAgentEntry.js");
   }
   const bytes = await Bun.file(path).arrayBuffer();
   const sha256 = createHash6("sha256").update(new Uint8Array(bytes)).digest("hex");
@@ -4978,8 +5665,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((resolve9, reject) => {
-    resolveReady = resolve9;
+  const readyPromise = new Promise((resolve10, reject) => {
+    resolveReady = resolve10;
     rejectReady = reject;
   });
   const handleEvent = (event) => {
@@ -5080,7 +5767,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((resolve9, reject) => pending.set(id, { reject, resolve: resolve9 }));
+    const response = new Promise((resolve10, reject) => pending.set(id, { reject, resolve: resolve10 }));
     process2.stdin.write(`${JSON.stringify({ command: commandName, id, v: ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION })}
 `);
     const flush = async () => {
@@ -5100,7 +5787,7 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
     if (closed)
       return;
     closed = true;
-    const timeout = () => new Promise((resolve9) => setTimeout(() => resolve9("timeout"), REMOTE_SESSION_CLOSE_TIMEOUT_MS));
+    const timeout = () => new Promise((resolve10) => setTimeout(() => resolve10("timeout"), REMOTE_SESSION_CLOSE_TIMEOUT_MS));
     await Promise.race([
       request("close").catch(() => {
         return;
@@ -5151,7 +5838,7 @@ var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, REMOTE_SESSION_CLOSE_TI
       const targetRelative = relative6(options.project.projectRoot, target);
       if (targetRelative.startsWith("..") || isAbsolute4(targetRelative))
         throw new Error("iOS screenshot must remain inside the project.");
-      await mkdir6(dirname7(target), { recursive: true });
+      await mkdir6(dirname8(target), { recursive: true });
       await writeFile6(target, Buffer.from(result.data, "base64"));
       return target;
     },
@@ -5178,44 +5865,44 @@ var init_remoteMacProtocol = __esm(() => {
 // src/dev/devCert.ts
 var exports_devCert = {};
 __export(exports_devCert, {
-  setupMkcert: () => setupMkcert,
-  normalizeDevCertificateHosts: () => normalizeDevCertificateHosts,
-  loadDevCert: () => loadDevCert,
-  hasMkcert: () => hasMkcert,
-  hasCert: () => hasCert,
+  ensureDevCert: () => ensureDevCert,
   getDevCertificateAuthorityPath: () => getDevCertificateAuthorityPath,
-  ensureDevCert: () => ensureDevCert
+  hasCert: () => hasCert,
+  hasMkcert: () => hasMkcert,
+  loadDevCert: () => loadDevCert,
+  normalizeDevCertificateHosts: () => normalizeDevCertificateHosts,
+  setupMkcert: () => setupMkcert
 });
 import {
   copyFileSync,
   existsSync as existsSync4,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   rmSync
 } from "fs";
 import { X509Certificate as X509Certificate2 } from "crypto";
 import { isIP as isIP4 } from "net";
 import { platform as platform2 } from "os";
-import { join as join14 } from "path";
+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 = []) => {
   const normalized = new Set(DEFAULT_CERTIFICATE_HOSTS);
-  for (const host of hosts) {
-    const value = host.trim().toLowerCase();
+  for (const host2 of hosts) {
+    const value = host2.trim().toLowerCase();
     if (!value || value === "0.0.0.0" || value === "::")
       continue;
     if (isIP4(value) === 0 && !CERTIFICATE_HOSTNAME_PATTERN.test(value)) {
-      throw new TypeError(`Invalid development certificate host: ${host}`);
+      throw new TypeError(`Invalid development certificate host: ${host2}`);
     }
     normalized.add(value);
   }
   return [...normalized];
 }, certificateIsUsable = (hosts) => {
   try {
-    const certPem = readFileSync7(CERT_PATH, "utf-8");
+    const certPem = readFileSync8(CERT_PATH, "utf-8");
     const certificate = new X509Certificate2(certPem);
     if (new Date(certificate.validTo).getTime() <= Date.now())
       return false;
-    return normalizeDevCertificateHosts(hosts).every((host) => isIP4(host) ? certificate.checkIP(host) !== undefined : certificate.checkHost(host) !== undefined);
+    return normalizeDevCertificateHosts(hosts).every((host2) => isIP4(host2) ? certificate.checkIP(host2) !== undefined : certificate.checkHost(host2) !== undefined);
   } catch {
     return false;
   }
@@ -5243,7 +5930,7 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
     throw new Error(`mkcert failed: ${err}`);
   }
 }, generateSelfSigned = (hosts = []) => {
-  const subjectAlternativeNames = normalizeDevCertificateHosts(hosts).map((host) => `${isIP4(host) ? "IP" : "DNS"}:${host}`).join(",");
+  const subjectAlternativeNames = normalizeDevCertificateHosts(hosts).map((host2) => `${isIP4(host2) ? "IP" : "DNS"}:${host2}`).join(",");
   const proc = Bun.spawnSync([
     "openssl",
     "req",
@@ -5296,8 +5983,8 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
     return null;
   try {
     return {
-      cert: readFileSync7(paths.cert, "utf-8"),
-      key: readFileSync7(paths.key, "utf-8")
+      cert: readFileSync8(paths.cert, "utf-8"),
+      key: readFileSync8(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -5393,7 +6080,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(readFileSync7("/proc/version", "utf-8"));
+    return /microsoft|wsl/i.test(readFileSync8("/proc/version", "utf-8"));
   } catch {
     return false;
   }
@@ -5409,7 +6096,7 @@ 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 ? join14(caRoot, "rootCA.pem") : null;
+  const rootCertificate = caRoot ? join15(caRoot, "rootCA.pem") : null;
   if (rootCertificate && existsSync4(rootCertificate))
     return rootCertificate;
   if (certFilesExist())
@@ -5424,13 +6111,13 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
   const caRoot = mkcertCaRoot();
   if (!caRoot)
     return false;
-  const rootCa = join14(caRoot, "rootCA.pem");
+  const rootCa = join15(caRoot, "rootCA.pem");
   if (!existsSync4(rootCa))
     return false;
   const winTemp = windowsTempDir();
   if (!winTemp)
     return false;
-  const staged = join14(winTemp, "absolutejs-mkcert-rootCA.crt");
+  const staged = join15(winTemp, "absolutejs-mkcert-rootCA.crt");
   try {
     copyFileSync(rootCa, staged);
   } catch {
@@ -5466,7 +6153,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(join14(caRoot, "rootCA.pem")) : null;
+      const hint = caRoot ? toWindowsPath(join15(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`);
@@ -5482,9 +6169,9 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, DEFAULT_CERTIFICATE
   return true;
 };
 var init_devCert = __esm(() => {
-  CERT_DIR = join14(process.cwd(), ".absolutejs");
-  CERT_PATH = join14(CERT_DIR, "cert.pem");
-  KEY_PATH = join14(CERT_DIR, "key.pem");
+  CERT_DIR = join15(process.cwd(), ".absolutejs");
+  CERT_PATH = join15(CERT_DIR, "cert.pem");
+  KEY_PATH = join15(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;
 });
@@ -5492,16 +6179,16 @@ var init_devCert = __esm(() => {
 // src/cli/scripts/eslintChunked.ts
 var exports_eslintChunked = {};
 __export(exports_eslintChunked, {
-  upstreamRef: () => upstreamRef,
-  ruleSummary: () => ruleSummary,
-  resolveLintTargets: () => resolveLintTargets,
-  parseChunkedArgs: () => parseChunkedArgs,
-  gitVisibleFiles: () => gitVisibleFiles,
+  eslintChunked: () => eslintChunked,
   gitChangedFiles: () => gitChangedFiles,
-  eslintChunked: () => eslintChunked
+  gitVisibleFiles: () => gitVisibleFiles,
+  parseChunkedArgs: () => parseChunkedArgs,
+  resolveLintTargets: () => resolveLintTargets,
+  ruleSummary: () => ruleSummary,
+  upstreamRef: () => upstreamRef
 });
 import { existsSync as existsSync6 } from "fs";
-import { relative as relative7, resolve as resolve9 } from "path";
+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(`
 `).map((line) => line.trimEnd()).filter(Boolean), applyChangedBase = (parsed, base) => {
   parsed.changedOnly = true;
@@ -5513,7 +6200,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(resolve9(cwd, file))).sort();
+  return matched.filter((file) => existsSync6(resolve10(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)
@@ -5535,7 +6222,7 @@ var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAUL
     "content"
   ];
   const proc = Bun.spawn([
-    resolve9(cwd, "node_modules/.bin/eslint"),
+    resolve10(cwd, "node_modules/.bin/eslint"),
     "--color",
     ...hasMaxWarnings ? [] : ["--max-warnings", "0"],
     ...cacheArgs,
@@ -5582,7 +6269,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, resolve9(cwd, `${cachePrefix}${shard}`)),
+      cacheLocation: relative7(cwd, resolve10(cwd, `${cachePrefix}${shard}`)),
       cwd,
       fingerprint
     });
@@ -5623,7 +6310,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(resolve9(cwd, parsed.outFile), header + report + summary);
+  await Bun.write(resolve10(cwd, parsed.outFile), header + report + summary);
   console.log(summary);
   console.log(`Full report written to ${parsed.outFile}`);
   if (failedChunks > 0) {
@@ -5712,12 +6399,12 @@ import { createHash as createHash7 } from "crypto";
 import {
   existsSync as existsSync7,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   renameSync,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
-import { dirname as dirname8, relative as relative8, resolve as resolve10 } from "path";
+import { dirname as dirname9, relative as relative8, resolve as resolve11 } 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)
@@ -5741,20 +6428,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 = resolve10(cwd, name);
+    const candidate = resolve11(cwd, name);
     if (existsSync7(candidate))
       return candidate;
   }
   return null;
 }, fingerprintLocation = (cacheLocation, cwd) => {
-  const absolute = resolve10(cwd, cacheLocation);
-  return /[\\/]$/.test(cacheLocation) ? resolve10(absolute, CACHE_FINGERPRINT_SUFFIX.slice(1)) : `${absolute}${CACHE_FINGERPRINT_SUFFIX}`;
+  const absolute = resolve11(cwd, cacheLocation);
+  return /[\\/]$/.test(cacheLocation) ? resolve11(absolute, CACHE_FINGERPRINT_SUFFIX.slice(1)) : `${absolute}${CACHE_FINGERPRINT_SUFFIX}`;
 }, addFileToFingerprint = (hash, path, label) => {
   if (!existsSync7(path))
     return;
   hash.update(label);
   hash.update("\x00");
-  hash.update(readFileSync9(path));
+  hash.update(readFileSync10(path));
   hash.update("\x00");
 }, packageNameFor = (specifier) => {
   if (specifier.startsWith("@"))
@@ -5764,7 +6451,7 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
 }, configPackageNames = (configPath2) => {
   if (!configPath2)
     return [];
-  const source = readFileSync9(configPath2, "utf-8");
+  const source = readFileSync10(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;
@@ -5783,11 +6470,11 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
     return Object.keys(value);
   });
 }, lintDependencyNames = (cwd, configPath2) => {
-  const manifestPath = resolve10(cwd, "package.json");
+  const manifestPath = resolve11(cwd, "package.json");
   if (!existsSync7(manifestPath))
     return configPackageNames(configPath2);
   try {
-    const manifest = JSON.parse(readFileSync9(manifestPath, "utf-8"));
+    const manifest = JSON.parse(readFileSync10(manifestPath, "utf-8"));
     const lintPackages = manifestDependencyNames(manifest).filter((name) => /eslint|typescript/.test(name));
     return [
       ...new Set([...lintPackages, ...configPackageNames(configPath2)])
@@ -5798,10 +6485,10 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
 }, findInstalledManifest = (cwd, dependency) => {
   let directory = cwd;
   while (true) {
-    const candidate = resolve10(directory, "node_modules", dependency, "package.json");
+    const candidate = resolve11(directory, "node_modules", dependency, "package.json");
     if (existsSync7(candidate))
       return candidate;
-    const parent = dirname8(directory);
+    const parent = dirname9(directory);
     if (parent === directory)
       return null;
     directory = parent;
@@ -5824,17 +6511,17 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
     addFileToFingerprint(hash, configPath2, relative8(cwd, configPath2));
   return hash.digest("hex");
 }, writeFingerprint = (path, fingerprint) => {
-  mkdirSync5(dirname8(path), { recursive: true });
+  mkdirSync5(dirname9(path), { recursive: true });
   const temporary = `${path}.${process.pid}.tmp`;
   writeFileSync5(temporary, `${fingerprint}
 `);
   renameSync(temporary, path);
 }, prepareEslintCache = (options) => {
   const cwd = options.cwd ?? process.cwd();
-  const cachePath = resolve10(cwd, options.cacheLocation);
+  const cachePath = resolve11(cwd, options.cacheLocation);
   const metadataPath = fingerprintLocation(options.cacheLocation, cwd);
   const fingerprint = options.fingerprint ?? createEslintCacheFingerprint(cwd);
-  const prior = existsSync7(metadataPath) ? readFileSync9(metadataPath, "utf-8").trim() : null;
+  const prior = existsSync7(metadataPath) ? readFileSync10(metadataPath, "utf-8").trim() : null;
   if (prior === fingerprint)
     return false;
   rmSync3(cachePath, { force: true, recursive: true });
@@ -5922,7 +6609,7 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
     return;
   let source;
   try {
-    source = readFileSync9(configPath2, "utf-8");
+    source = readFileSync10(configPath2, "utf-8");
   } catch {
     return;
   }
@@ -5961,7 +6648,7 @@ Detected at: ${configPath2}${reset}`);
   return `${minutes}m ${seconds}s`;
 }, handleClearCache = (cacheLocation, cwd = process.cwd()) => {
   try {
-    const cachePath = resolve10(cwd, cacheLocation);
+    const cachePath = resolve11(cwd, cacheLocation);
     const metadataPath = fingerprintLocation(cacheLocation, cwd);
     rmSync3(cachePath, { force: true, recursive: true });
     rmSync3(metadataPath, { force: true, recursive: true });
@@ -5990,7 +6677,7 @@ Detected at: ${configPath2}${reset}`);
     return;
   }
   if (args.includes("--chunked")) {
-    if (!existsSync7(resolve10("node_modules", ".bin", "eslint"))) {
+    if (!existsSync7(resolve11("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);
     }
@@ -5998,7 +6685,7 @@ Detected at: ${configPath2}${reset}`);
     await eslintChunked2(args);
     return;
   }
-  if (!existsSync7(resolve10("node_modules", ".bin", "eslint"))) {
+  if (!existsSync7(resolve11("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);
   }
@@ -6175,21 +6862,21 @@ var stripStringsAndComments = (source) => {
 };
 
 // src/core/islandManifest.ts
-var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1), getIslandManifestKey = (framework, component) => `Island${toIslandFrameworkSegment(framework)}${component}`;
+var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1), getIslandManifestKey = (framework, component2) => `Island${toIslandFrameworkSegment(framework)}${component2}`;
 
 // src/core/islands.ts
-var isRecord4 = (value) => typeof value === "object" && value !== null, getIslandBuildReference = (component) => {
-  if (!isIslandComponentDefinition(component))
+var isRecord4 = (value) => typeof value === "object" && value !== null, getIslandBuildReference = (component2) => {
+  if (!isIslandComponentDefinition(component2))
     return null;
   return {
-    export: component.export,
-    source: component.source
+    export: component2.export,
+    source: component2.source
   };
 }, isIslandComponentDefinition = (value) => isRecord4(value) && ("component" in value) && ("source" in value) && typeof value.source === "string";
 var init_islands = () => {};
 
 // src/build/islandEntries.ts
-import { dirname as dirname9, extname, join as join17, relative as relative9, resolve as resolve12 } from "path";
+import { dirname as dirname10, extname, join as join18, relative as relative9, resolve as resolve13 } from "path";
 import ts from "typescript";
 var frameworks, isRecord5 = (value) => typeof value === "object" && value !== null, resolveRegistryExport = (mod) => {
   if (isRecord5(mod.islandRegistry))
@@ -6201,7 +6888,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   if (sourcePath.startsWith("file://")) {
     return new URL(sourcePath).pathname;
   }
-  return resolve12(dirname9(registryPath), sourcePath);
+  return resolve13(dirname10(registryPath), sourcePath);
 }, getObjectPropertyName = (name) => {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
     return name.text;
@@ -6244,9 +6931,9 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   component: reference.source,
   export: reference.export,
   source: reference.source
-}), addRegistryEntries = (frameworkNode, framework, imports, definitions, registry) => {
-  const frameworkRegistry = registry[framework] ?? {};
-  registry[framework] = frameworkRegistry;
+}), addRegistryEntries = (frameworkNode, framework, imports, definitions, registry2) => {
+  const frameworkRegistry = registry2[framework] ?? {};
+  registry2[framework] = frameworkRegistry;
   for (const property of frameworkNode.properties) {
     if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property))
       continue;
@@ -6266,7 +6953,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
       framework
     });
   }
-}, processDefineIslandRegistry = (node, imports, definitions, registry) => {
+}, processDefineIslandRegistry = (node, imports, definitions, registry2) => {
   const [firstArg] = node.arguments;
   if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
     return;
@@ -6287,13 +6974,13 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
       continue;
     if (!ts.isObjectLiteralExpression(property.initializer))
       continue;
-    addRegistryEntries(property.initializer, framework, imports, definitions, registry);
+    addRegistryEntries(property.initializer, framework, imports, definitions, registry2);
   }
-}, walkRegistryNode = (node, imports, registryFactoryNames, registryNamespaceNames, definitions, registry) => {
+}, walkRegistryNode = (node, imports, registryFactoryNames, registryNamespaceNames, definitions, registry2) => {
   if (ts.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, registryFactoryNames, registryNamespaceNames)) {
-    processDefineIslandRegistry(node, imports, definitions, registry);
+    processDefineIslandRegistry(node, imports, definitions, registry2);
   }
-  ts.forEachChild(node, (child) => walkRegistryNode(child, imports, registryFactoryNames, registryNamespaceNames, definitions, registry));
+  ts.forEachChild(node, (child) => walkRegistryNode(child, imports, registryFactoryNames, registryNamespaceNames, definitions, registry2));
 }, isDefineIslandRegistryCall = (expression, registryFactoryNames, registryNamespaceNames) => {
   if (ts.isIdentifier(expression)) {
     return registryFactoryNames.has(expression.text);
@@ -6331,34 +7018,34 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   const registryFactoryNames = new Set(["defineIslandRegistry"]);
   const registryNamespaceNames = new Set;
   const definitions = [];
-  const registry = {};
+  const registry2 = {};
   collectImportDeclarations(sourceFile, registryPath, imports, registryFactoryNames, registryNamespaceNames);
-  walkRegistryNode(sourceFile, imports, registryFactoryNames, registryNamespaceNames, definitions, registry);
+  walkRegistryNode(sourceFile, imports, registryFactoryNames, registryNamespaceNames, definitions, registry2);
   return {
     definitions,
     hasNamedExport: hasIslandRegistryNamedExport(sourceFile),
-    registry
+    registry: registry2
   };
 }, loadDynamicIslandRegistryBuildInfo = async (resolvedRegistryPath) => {
   const registryModule = await import(resolvedRegistryPath);
-  const registry = resolveRegistryExport(registryModule);
+  const registry2 = resolveRegistryExport(registryModule);
   const definitions = frameworks.flatMap((framework) => {
-    const frameworkRegistry = registry[framework];
+    const frameworkRegistry = registry2[framework];
     if (!isRecord5(frameworkRegistry))
       return [];
-    return Object.entries(frameworkRegistry).map(([component, value]) => ({
+    return Object.entries(frameworkRegistry).map(([component2, value]) => ({
       buildReference: getIslandBuildReference(value),
-      component,
+      component: component2,
       framework
     }));
   });
   return {
     definitions,
     hasNamedExport: isRecord5(registryModule.islandRegistry),
-    registry
+    registry: registry2
   };
 }, loadIslandRegistryBuildInfo = async (registryPath) => {
-  const resolvedRegistryPath = resolve12(registryPath);
+  const resolvedRegistryPath = resolve13(registryPath);
   const registrySource = Bun.file(resolvedRegistryPath);
   const registrySourceText = await registrySource.text();
   const parsedInfo = parseIslandRegistryBuildInfo(registrySourceText, resolvedRegistryPath);
@@ -6892,7 +7579,7 @@ 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 dirname10, extname as extname3, join as join18, relative as relative10, resolve as resolve13 } from "path";
+import { basename as basename7, dirname as dirname11, extname as extname3, join as join19, relative as relative10, resolve as resolve14 } 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;
@@ -6900,12 +7587,12 @@ var sha256 = (bytes) => createHash9("sha256").update(bytes).digest("hex"), STATI
   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 = resolve13(buildDirectory);
-  const resolvedAsset = resolve13(assetPath);
+  const resolvedBuildDirectory = resolve14(buildDirectory);
+  const resolvedAsset = resolve14(assetPath);
   if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
     return resolvedAsset;
   }
-  return join18(buildDirectory, assetPath.replace(/^\/+/, ""));
+  return join19(buildDirectory, assetPath.replace(/^\/+/, ""));
 }, pageFor = async (metadata, manifest, buildDirectory) => {
   const assetPath = manifest[metadata.bundleKey];
   if (!assetPath) {
@@ -6916,8 +7603,8 @@ 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 = join18(buildDirectory, ".absolutejs", "mobile-pages", `${documentHash}.html`);
-    await mkdir8(dirname10(resolvedAssetPath), { recursive: true });
+    resolvedAssetPath = join19(buildDirectory, ".absolutejs", "mobile-pages", `${documentHash}.html`);
+    await mkdir8(dirname11(resolvedAssetPath), { recursive: true });
     await writeFile7(resolvedAssetPath, rewritten);
   }
   const pageAssetKey = metadata.bundleKey.replace(/Index$/u, "");
@@ -6930,8 +7617,8 @@ var sha256 = (bytes) => createHash9("sha256").update(bytes).digest("hex"), STATI
     readFile9(resolvedAssetPath),
     resolvedStylePath ? readFile9(resolvedStylePath) : undefined
   ]);
-  const bundlePath = `/${relative10(resolve13(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
-  const styleBundlePath = resolvedStylePath ? `/${relative10(resolve13(buildDirectory), resolvedStylePath).replaceAll("\\", "/")}` : undefined;
+  const bundlePath = `/${relative10(resolve14(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const styleBundlePath = resolvedStylePath ? `/${relative10(resolve14(buildDirectory), resolvedStylePath).replaceAll("\\", "/")}` : undefined;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
@@ -7094,7 +7781,7 @@ var init_pageProtocol = __esm(() => {
 
 // src/mobile/client.ts
 var frameworks5, upgradeReasons;
-var init_client = __esm(() => {
+var init_client2 = __esm(() => {
   init_pageProtocol();
   frameworks5 = new Set([
     "angular",
@@ -7116,7 +7803,7 @@ var init_client = __esm(() => {
 // src/mobile/transport.ts
 var ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT = 1;
 var init_transport = __esm(() => {
-  init_client();
+  init_client2();
   init_pageProtocol();
   init_routeMatcher();
 });
@@ -7133,29 +7820,39 @@ import {
   writeFile as writeFile8
 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { basename as basename8, dirname as dirname11, extname as extname4, join as join19, relative as relative11, resolve as resolve14 } from "path";
+import { basename as basename8, dirname as dirname12, extname as extname4, join as join20, relative as relative11, resolve as resolve15 } 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) => join19(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync9);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
 }, shellAuthModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join19(import.meta.dir, `shellAuth.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellAuth.${extension}`)).find(existsSync9);
   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);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS Expo auth bridge module is missing.");
 }, shellSyncModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join19(import.meta.dir, `shellSync.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellSync.${extension}`)).find(existsSync9);
   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);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS Expo Sync bridge module is missing.");
 }, shellPushModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join19(import.meta.dir, `shellPush.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellPush.${extension}`)).find(existsSync9);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile push shell module is missing.");
 }, shellExpoDevicesModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join19(import.meta.dir, `shellExpoDevices.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join20(import.meta.dir, `shellExpoDevices.${extension}`)).find(existsSync9);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS Expo device bridge module is missing.");
@@ -7186,8 +7883,8 @@ var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-
 	</body>
 </html>
 `, sourceAssetPath = (buildDirectory, bundlePath) => {
-  const root = resolve14(buildDirectory);
-  const asset = resolve14(root, bundlePath.replace(/^\/+/, ""));
+  const root = resolve15(buildDirectory);
+  const asset = resolve15(root, bundlePath.replace(/^\/+/, ""));
   if (!asset.startsWith(`${root}/`)) {
     throw new TypeError("Mobile page bundle escaped the build directory.");
   }
@@ -7202,25 +7899,27 @@ 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 = join19(resolve14(projectRoot), "node_modules", packageName);
-  const manifest = JSON.parse(await readFile10(join19(packageDirectory, "package.json"), "utf8"));
+  const packageDirectory = join20(resolve15(projectRoot), "node_modules", packageName);
+  const manifest = JSON.parse(await readFile10(join20(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 = resolve14(packageDirectory, target);
-  if (!resolved.startsWith(`${resolve14(packageDirectory)}/`))
+  const resolved = resolve15(packageDirectory, target);
+  if (!resolved.startsWith(`${resolve15(packageDirectory)}/`))
     throw new TypeError(`${specifier} has an unsafe import entry.`);
   return resolved;
 }, buildShellBootstrap = async (staging, auth, sync, storagePrefix, engine, deviceCapabilities, projectRoot) => {
   const capacitor = engine !== "expo";
   const shellCapabilities = capacitor ? deviceCapabilities.capabilities : [];
   const modulePath = shellBootstrapModule();
-  const authImport = auth ? `import { createAbsoluteMobileShellAuth } from ${JSON.stringify(shellAuthModule())};
+  const authFactory = capacitor ? "createAbsoluteMobileShellAuth" : "createAbsoluteExpoShellAuth";
+  const syncFactory = capacitor ? "installAbsoluteMobileShellSync" : "installAbsoluteExpoShellSync";
+  const authImport = auth ? `import { ${authFactory} } from ${JSON.stringify(capacitor ? shellAuthModule() : shellExpoAuthModule())};
 ` : "";
-  const options = auth ? `{ createAuth: createAbsoluteMobileShellAuth${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }` : "";
-  const syncImport = sync ? `import { installAbsoluteMobileShellSync } from ${JSON.stringify(shellSyncModule())};
+  const options = auth ? `{ createAuth: ${authFactory}${sync ? `, installSync: ${syncFactory}` : ""} }` : "";
+  const syncImport = sync ? `import { ${syncFactory} } from ${JSON.stringify(capacitor ? shellSyncModule() : shellExpoSyncModule())};
 ` : "";
   const pushIndex = shellCapabilities.indexOf("pushNotifications");
   const push = pushIndex !== -1;
@@ -7237,15 +7936,15 @@ 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 = join19(staging, ".absolute-mobile-entry.ts");
+  const entryPath = join20(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();";
-  let shellOptions = "{ createFetch: createAbsoluteExpoBridgeFetch }";
+  let shellOptions = auth ? options : "{ createFetch: createAbsoluteExpoBridgeFetch }";
   if (capacitor)
     shellOptions = options;
   if (push) {
-    shellOptions = `{ createAuth: (config, options) => createAbsoluteMobileShellAuth(config, options), beforeSignOut: absoluteMobilePush.beforeSignOut, connectPush: (auth) => absoluteMobilePush.connect(auth, absoluteMobilePushCapability)${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }`;
+    shellOptions = `{ createAuth: (config, options) => createAbsoluteMobileShellAuth(config, options), beforeSignOut: absoluteMobilePush.beforeSignOut, connectPush: (auth) => absoluteMobilePush.connect(auth, absoluteMobilePushCapability)${sync ? `, installSync: ${syncFactory}` : ""} }`;
   }
   await writeFile8(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
 ${adapterImport}
@@ -7256,751 +7955,329 @@ void startAbsoluteMobileShell(${shellOptions});
   const build = await Bun.build({
     entrypoints: [entryPath],
     minify: true,
-    outdir: staging,
-    target: "browser"
-  });
-  if (!build.success || build.outputs.length !== 1) {
-    throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
-  }
-  await rename7(build.outputs[0]?.path ?? "", join19(staging, BOOTSTRAP_FILE));
-  await rm6(entryPath, { force: true });
-}, removePreviousBundle = async (backup, moved) => {
-  if (!moved)
-    return;
-  await rm6(backup, { force: true, recursive: true });
-}, restorePreviousBundle = async (backup, destination, moved) => {
-  if (!moved)
-    return;
-  await rename7(backup, destination);
-}, installBundle = async (staging, destination) => {
-  const backup = `${destination}.previous-${crypto.randomUUID()}`;
-  let movedPrevious = false;
-  try {
-    await rename7(destination, backup);
-    movedPrevious = true;
-  } catch (error) {
-    if (!errorHasCode(error, "ENOENT"))
-      throw error;
-  }
-  try {
-    await rename7(staging, destination);
-    await removePreviousBundle(backup, movedPrevious);
-  } catch (error) {
-    await restorePreviousBundle(backup, destination, movedPrevious);
-    throw error;
-  }
-}, copyClientPage = async (page, buildDirectory, staging, copiedDependencies) => {
-  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 localBundlePath = `./pages/${page.bundleHash}${extension}`;
-  const source = sourceAssetPath(buildDirectory, page.bundlePath);
-  await copyFile4(source, join19(staging, localBundlePath));
-  await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
-  let localStylePath;
-  if (page.styleBundlePath && page.styleBundleHash) {
-    const styleExtension = extname4(page.styleBundlePath) || ".css";
-    localStylePath = `./styles/${page.styleBundleHash}${styleExtension}`;
-    const styleSource = sourceAssetPath(buildDirectory, page.styleBundlePath);
-    await mkdir9(dirname11(join19(staging, localStylePath)), {
-      recursive: true
-    });
-    await copyFile4(styleSource, join19(staging, localStylePath));
-    await copyAbsoluteClientDependencies(styleSource, buildDirectory, staging, copiedDependencies);
-  }
-  return {
-    ...page,
-    localBundlePath,
-    ...localStylePath ? { localStylePath } : {}
-  };
-}, absoluteClientImports = async (sourcePath, buildDirectory) => {
-  const source = await readFile10(sourcePath, "utf8");
-  const extension = extname4(sourcePath).toLowerCase();
-  let scriptLoader;
-  if (extension === ".tsx")
-    scriptLoader = "tsx";
-  else if (extension === ".ts")
-    scriptLoader = "ts";
-  else if (extension === ".jsx")
-    scriptLoader = "jsx";
-  else if ([".js", ".mjs", ".cjs"].includes(extension))
-    scriptLoader = "js";
-  const scriptImports = scriptLoader ? new Bun.Transpiler({ loader: scriptLoader }).scanImports(source).map(({ path }) => path) : [];
-  const cssImports = extension === ".css" ? [...source.matchAll(CLIENT_CSS_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
-  const markupImports = extension === ".html" ? [...source.matchAll(CLIENT_MARKUP_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
-  return [...scriptImports, ...cssImports, ...markupImports].flatMap((specifier) => {
-    if (!specifier)
-      return [];
-    if (!specifier.startsWith("/") && !specifier.startsWith("./") && !specifier.startsWith("../")) {
-      return [];
-    }
-    const clean = specifier.split(/[?#]/u, 1)[0] ?? specifier;
-    if (clean.startsWith("/"))
-      return [clean];
-    const resolved = resolve14(dirname11(sourcePath), clean);
-    const root = resolve14(buildDirectory);
-    const relativePath = relative11(root, resolved).replaceAll("\\", "/");
-    if (relativePath === ".." || relativePath.startsWith("../")) {
-      throw new TypeError(`Mobile client dependency escaped the build directory: ${specifier}`);
-    }
-    return [`/${relativePath}`];
-  });
-}, copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, copied) => {
-  if (copied.has(specifier))
-    return;
-  copied.add(specifier);
-  const source = sourceAssetPath(buildDirectory, specifier);
-  const destination = join19(staging, specifier.replace(/^\/+/, ""));
-  await mkdir9(dirname11(destination), { recursive: true });
-  await copyFile4(source, destination);
-  await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
-}, copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
-  const dependencies = await absoluteClientImports(sourcePath, buildDirectory);
-  await Promise.all(dependencies.map((specifier) => copyAbsoluteClientDependency(specifier, buildDirectory, staging, copied)));
-}, materializeAbsoluteCapacitorWebBundle = async (options) => {
-  if (!resolveAbsoluteMobileRoute(options.artifact.routes, new URL(options.config.entry, "https://absolute.invalid").pathname)) {
-    throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
-  }
-  const destination = options.config.bundleDirectory;
-  await mkdir9(dirname11(destination), { recursive: true });
-  const staging = await mkdtemp4(join19(dirname11(destination), `.${basename8(destination)}.stage-`));
-  try {
-    const pageDirectory = join19(staging, "pages");
-    await mkdir9(pageDirectory, { recursive: true });
-    await Promise.all(CLIENT_ASSET_DIRECTORIES.map((directory) => ({
-      destination: join19(staging, directory),
-      source: join19(options.buildDirectory, directory)
-    })).filter(({ source }) => existsSync9(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 = {
-      appBuild: options.artifact.appBuild,
-      ...options.auth ? { auth: options.auth } : {},
-      appId: options.config.appId,
-      appName: options.config.appName,
-      deepLinkHosts: options.config.deepLinkHosts,
-      deepLinkScheme: options.config.deepLinkScheme,
-      deviceCapabilities: options.deviceCapabilities.capabilities,
-      entry: options.config.entry,
-      format: ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
-      pages,
-      productionOrigin: options.config.productionOrigin,
-      routes: options.artifact.routes,
-      runtime: options.artifact.runtime,
-      ...options.sync ? {
-        sync: {
-          background: {
-            endpoint: new URL("/__absolute/sync/background", options.config.productionOrigin).href,
-            intervalMinutes: 15
-          },
-          socketTickets: true,
-          storageSchema: options.syncSchema ?? {
-            components: [
-              { id: "@absolutejs/app", version: 1 }
-            ]
-          }
-        }
-      } : {}
-    };
-    await Promise.all([
-      writeFile8(join19(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
-`),
-      writeFile8(join19(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);
-    return manifest;
-  } catch (error) {
-    await rm6(staging, { force: true, recursive: true });
-    throw error;
-  }
-};
-var init_capacitorBundle = __esm(() => {
-  init_routeMatcher();
-  init_transport();
-  CLIENT_CSS_DEPENDENCY_PATTERN = /(?:@import\s+(?:url\(\s*)?|url\(\s*)["']?((?:\/|\.\.\/|\.\/)[^"')\s]+)["']?\s*\)?/gu;
-  CLIENT_MARKUP_DEPENDENCY_PATTERN = /<(?:script\b[^>]*\bsrc|link\b[^>]*\bhref|img\b[^>]*\bsrc|source\b[^>]*\bsrcset)\s*=\s*["']((?:\/|\.\.\/|\.\/)[^"',\s]+)/giu;
-  CAPACITOR_CLIENT_FRAMEWORKS = new Set([
-    "angular",
-    "html",
-    "htmx",
-    "react",
-    "svelte",
-    "vue"
-  ]);
-  CLIENT_ASSET_DIRECTORIES = ["assets", "html", "htmx", "indexes"];
-});
-
-// src/mobile/artifactStore.ts
-import { createHash as createHash10 } from "crypto";
-var DEFAULT_MAX_PRODUCER_BYTES = 134217728, SHA_2562 = "sha256", hashBlob = async (blob) => {
-  const bytes = new Uint8Array(await blob.arrayBuffer());
-  return createHash10(SHA_2562).update(bytes).digest("hex");
-}, verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes = DEFAULT_MAX_PRODUCER_BYTES) => {
-  const { artifact, producer } = release;
-  if (producer.size !== artifact.producer.bytes || producer.size > maxProducerBytes) {
-    throw new TypeError("Mobile compatibility producer size does not match its artifact.");
-  }
-  if (await hashBlob(producer) !== artifact.producer.bundleHash) {
-    throw new TypeError("Mobile compatibility producer hash does not match its artifact.");
-  }
-  return release;
-};
-var init_artifactStore = __esm(() => {
-  init_releaseArtifact();
-});
-
-// src/mobile/materializedBundle.ts
-import { createHash as createHash11 } from "crypto";
-import {
-  access as access8,
-  mkdir as mkdir10,
-  mkdtemp as mkdtemp5,
-  readFile as readFile11,
-  rename as rename8,
-  rm as rm7,
-  writeFile as writeFile9
-} from "fs/promises";
-import { dirname as dirname12, join as join20, 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,
-    releases: releases.map(({ releaseId }) => releaseId)
-  });
-  return `amb_${createHash11("sha256").update(identity).digest("hex")}`;
-}, parseBundleIndex = (value) => {
-  if (!isRecord7(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
-    throw new TypeError("Invalid materialized mobile compatibility bundle.");
-  }
-  const releases = value.releases.map(parseAbsoluteMobileCompatibilityArtifact);
-  const retained = retainAbsoluteMobileCompatibilityArtifacts(releases);
-  if (retained.length !== releases.length || retained.some(({ releaseId }, index) => releaseId !== releases[index]?.releaseId)) {
-    throw new TypeError("Materialized mobile bundle releases are not a retained generation window.");
-  }
-  const expectedBundleId = bundleIdFor(value.currentReleaseId, releases);
-  if (value.bundleId !== expectedBundleId) {
-    throw new TypeError("Materialized mobile bundle integrity failed.");
-  }
-  if (releases[0]?.releaseId !== value.currentReleaseId) {
-    throw new TypeError("Materialized mobile bundle current release is not its newest generation.");
+    outdir: staging,
+    target: "browser"
+  });
+  if (!build.success || build.outputs.length !== 1) {
+    throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
   }
-  return {
-    bundleId: value.bundleId,
-    currentReleaseId: value.currentReleaseId,
-    format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
-    releases
-  };
-}, writeRelease = async (root, release) => {
-  const directory = join20(root, release.artifact.releaseId);
-  const producerPath = join20(directory, release.artifact.producer.module);
-  await mkdir10(dirname12(producerPath), { recursive: true });
-  await Promise.all([
-    writeFile9(join20(directory, ARTIFACT_FILE), `${JSON.stringify(release.artifact, null, "\t")}
-`),
-    writeFile9(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
-  ]);
-}, installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join20(bundlesRoot, bundleId);
+  await rename7(build.outputs[0]?.path ?? "", join20(staging, BOOTSTRAP_FILE));
+  await rm6(entryPath, { force: true });
+}, removePreviousBundle = async (backup, moved) => {
+  if (!moved)
+    return;
+  await rm6(backup, { force: true, recursive: true });
+}, restorePreviousBundle = async (backup, destination, moved) => {
+  if (!moved)
+    return;
+  await rename7(backup, destination);
+}, installBundle = async (staging, destination) => {
+  const backup = `${destination}.previous-${crypto.randomUUID()}`;
+  let movedPrevious = false;
   try {
-    await access8(destination);
-    return destination;
+    await rename7(destination, backup);
+    movedPrevious = true;
   } catch (error) {
-    if (!errorHasCode2(error, "ENOENT"))
+    if (!errorHasCode(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp5(join20(bundlesRoot, ".stage-"));
   try {
-    await Promise.all(releases.map((release) => writeRelease(staging, release)));
-    await rename8(staging, destination);
+    await rename7(staging, destination);
+    await removePreviousBundle(backup, movedPrevious);
   } catch (error) {
-    await rm7(staging, { force: true, recursive: true });
-    if (errorHasCode2(error, "EEXIST") || errorHasCode2(error, "ENOTEMPTY")) {
-      return destination;
-    }
+    await restorePreviousBundle(backup, destination, movedPrevious);
     throw error;
   }
-  return destination;
-}, materializeAbsoluteMobileCompatibilityBundle = async (input) => {
-  const releases = await Promise.all(input.releases.map((release) => verifyAbsoluteMobileCompatibilityProducer(release)));
-  const artifacts = retainAbsoluteMobileCompatibilityArtifacts(releases.map(({ artifact }) => artifact));
-  if (artifacts.length !== releases.length) {
-    throw new TypeError("Materialization input must already contain only retained releases.");
+}, copyClientPage = async (page, buildDirectory, staging, copiedDependencies) => {
+  if (!CAPACITOR_CLIENT_FRAMEWORKS.has(page.framework)) {
+    throw new TypeError(`Capacitor client rendering does not yet support ${page.framework} page ${page.pageId}.`);
   }
-  if (artifacts[0]?.releaseId !== input.currentReleaseId) {
-    throw new TypeError("Materialization current release must be the newest generation.");
+  const extension = extname4(page.bundlePath) || ".js";
+  const localBundlePath = `./pages/${page.bundleHash}${extension}`;
+  const source = sourceAssetPath(buildDirectory, page.bundlePath);
+  await copyFile4(source, join20(staging, localBundlePath));
+  await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
+  let localStylePath;
+  if (page.styleBundlePath && page.styleBundleHash) {
+    const styleExtension = extname4(page.styleBundlePath) || ".css";
+    localStylePath = `./styles/${page.styleBundleHash}${styleExtension}`;
+    const styleSource = sourceAssetPath(buildDirectory, page.styleBundlePath);
+    await mkdir9(dirname12(join20(staging, localStylePath)), {
+      recursive: true
+    });
+    await copyFile4(styleSource, join20(staging, localStylePath));
+    await copyAbsoluteClientDependencies(styleSource, buildDirectory, staging, copiedDependencies);
   }
-  const orderedReleases = artifacts.map((artifact) => {
-    const release = releases.find((candidate) => candidate.artifact.releaseId === artifact.releaseId);
-    if (!release) {
-      throw new TypeError("Materialization input is missing a producer.");
-    }
-    return release;
-  });
-  const root = resolvePath3(input.root);
-  const bundlesRoot = join20(root, BUNDLES_DIRECTORY);
-  await mkdir10(bundlesRoot, { recursive: true });
-  const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
-  await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
-  const index = {
-    bundleId,
-    currentReleaseId: input.currentReleaseId,
-    format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
-    releases: artifacts
+  return {
+    ...page,
+    localBundlePath,
+    ...localStylePath ? { localStylePath } : {}
   };
-  const pointerPath = join20(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join20(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile9(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
-`, { flag: "wx" });
-  await rename8(temporaryPointerPath, pointerPath);
-  return index;
-}, readAbsoluteMobileMaterializedReleases = async (root) => {
-  const resolvedRoot = resolvePath3(root);
-  try {
-    const serialized = await readFile11(join20(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
-    const parsed = JSON.parse(serialized);
-    const index = parseBundleIndex(parsed);
-    const bundleRoot = join20(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
-    return Promise.all(index.releases.map(async (artifact) => {
-      const producer = Bun.file(join20(bundleRoot, artifact.releaseId, artifact.producer.module));
-      await verifyAbsoluteMobileCompatibilityProducer({
-        artifact,
-        producer
-      });
-      return { artifact, producer };
-    }));
-  } catch (error) {
-    if (errorHasCode2(error, "ENOENT"))
+}, absoluteClientImports = async (sourcePath, buildDirectory) => {
+  const source = await readFile10(sourcePath, "utf8");
+  const extension = extname4(sourcePath).toLowerCase();
+  let scriptLoader;
+  if (extension === ".tsx")
+    scriptLoader = "tsx";
+  else if (extension === ".ts")
+    scriptLoader = "ts";
+  else if (extension === ".jsx")
+    scriptLoader = "jsx";
+  else if ([".js", ".mjs", ".cjs"].includes(extension))
+    scriptLoader = "js";
+  const scriptImports = scriptLoader ? new Bun.Transpiler({ loader: scriptLoader }).scanImports(source).map(({ path }) => path) : [];
+  const cssImports = extension === ".css" ? [...source.matchAll(CLIENT_CSS_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  const markupImports = extension === ".html" ? [...source.matchAll(CLIENT_MARKUP_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  return [...scriptImports, ...cssImports, ...markupImports].flatMap((specifier) => {
+    if (!specifier)
+      return [];
+    if (!specifier.startsWith("/") && !specifier.startsWith("./") && !specifier.startsWith("../")) {
       return [];
-    throw error;
-  }
-};
-var init_materializedBundle = __esm(() => {
-  init_artifactStore();
-  init_releaseArtifact();
-  BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
-});
-
-// node_modules/@absolutejs/sync/dist/client/index.js
-var RUNTIME_TRANSPORT, host, isRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations")) && Array.isArray(Reflect.get(value, "clients")), registry, SyncLocalDataPolicyError, SyncLocalStoreSchemaError, positiveVersion = (value, label) => {
-  if (!Number.isSafeInteger(value) || value < 1)
-    throw new SyncLocalStoreSchemaError("INVALID_PLAN", `${label} must be a positive safe integer`);
-  return value;
-}, isSchemaBundle = (schema) => ("components" in schema), validatePolicyMatch = (match, label) => {
-  if (match.length === 0 || match.trim() !== match || /^\*+$/.test(match) || match.includes("**"))
-    throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.match must be an exact name or a non-empty glob without adjacent wildcards.`);
-}, validateSyncLocalDataPolicy = (policy, label = "localData") => {
-  if (policy.maxBytesPerNamespace !== undefined && (!Number.isSafeInteger(policy.maxBytesPerNamespace) || policy.maxBytesPerNamespace < 1))
-    throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.maxBytesPerNamespace must be a positive safe integer.`);
-  for (const [index, rule] of (policy.collections ?? []).entries()) {
-    validatePolicyMatch(rule.match, `${label}.collections[${index}]`);
-    if (rule.maxAgeMs !== undefined && (!Number.isSafeInteger(rule.maxAgeMs) || rule.maxAgeMs < 1))
-      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}].maxAgeMs must be a positive safe integer.`);
-    if (rule.persistence === "memory-only" && rule.protection === "required")
-      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}] cannot require at-rest protection when it is memory-only.`);
-    if (rule.sensitivity !== undefined && rule.sensitivity !== "public" && rule.protection !== "required" && rule.persistence !== "memory-only")
-      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}] declares ${rule.sensitivity} data without required protection or memory-only persistence.`);
-  }
-  for (const [index, rule] of (policy.mutations ?? []).entries()) {
-    validatePolicyMatch(rule.match, `${label}.mutations[${index}]`);
-    if (rule.conflict !== undefined && rule.conflict.strategy !== "client-wins" && rule.conflict.strategy !== "manual" && rule.conflict.strategy !== "server-wins")
-      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.strategy is invalid.`);
-    if (rule.conflict?.maxAttempts !== undefined && (!Number.isSafeInteger(rule.conflict.maxAttempts) || rule.conflict.maxAttempts < 1))
-      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.maxAttempts must be a positive safe integer.`);
-    if (rule.conflict?.maxAttempts !== undefined && rule.conflict.strategy !== "client-wins")
-      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.maxAttempts is only valid for client-wins.`);
-    if (rule.persistence === "memory-only" && rule.protection === "required")
-      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}] cannot require at-rest protection when it is memory-only.`);
-    if (rule.sensitivity !== undefined && rule.sensitivity !== "public" && rule.protection !== "required" && rule.persistence !== "memory-only")
-      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}] declares ${rule.sensitivity} arguments without required protection.`);
-  }
-  return policy;
-}, normalizeSyncLocalSchemaComponents = (schema = { version: 1 }) => {
-  const components = isSchemaBundle(schema) ? [...schema.components] : [{ ...schema, id: "@absolutejs/app" }];
-  const ids = new Set;
-  for (const component of components) {
-    if (typeof component.id !== "string" || component.id.trim() !== component.id || component.id.length === 0)
-      throw new SyncLocalStoreSchemaError("INVALID_PLAN", "Sync schema component id must be non-empty and trimmed");
-    if (ids.has(component.id))
-      throw new SyncLocalStoreSchemaError("INVALID_PLAN", `Sync schema component "${component.id}" is declared more than once`);
-    ids.add(component.id);
-    if (component.localData)
-      validateSyncLocalDataPolicy(component.localData, `${component.id}.localData`);
-  }
-  return components.sort((a, b) => a.id.localeCompare(b.id));
-}, resolveSyncLocalSchemaComponents = (storedVersions, schema = { version: 1 }) => {
-  const components = normalizeSyncLocalSchemaComponents(schema).map((component) => {
-    const current = resolveSyncLocalMigrations(component.version, component);
-    return {
-      id: component.id,
-      ...resolveSyncLocalMigrations(storedVersions[component.id] ?? current.minimumCompatibleVersion, component)
-    };
-  });
-  const active = new Set(components.map((component) => component.id));
-  const orphanedComponents = Object.keys(storedVersions).filter((id) => !active.has(id)).sort();
-  return { components, orphanedComponents };
-}, resolveSyncLocalMigrations = (storedVersion, schema = { version: 1 }) => {
-  positiveVersion(storedVersion, "Stored Sync schema version");
-  const targetVersion = positiveVersion(schema.version, "Target Sync schema version");
-  const migrations = [...schema.migrations ?? []].sort((a, b) => a.toVersion - b.toVersion);
-  const versions = new Set;
-  for (const migration of migrations) {
-    positiveVersion(migration.toVersion, "Sync migration toVersion");
-    if (versions.has(migration.toVersion))
-      throw new SyncLocalStoreSchemaError("INVALID_PLAN", `Sync migration ${migration.toVersion} is declared more than once`);
-    versions.add(migration.toVersion);
-  }
-  const inferredMinimum = migrations[0] ? migrations[0].toVersion - 1 : targetVersion;
-  const minimumCompatibleVersion = positiveVersion(schema.minimumCompatibleVersion ?? inferredMinimum, "Minimum compatible Sync schema version");
-  if (minimumCompatibleVersion > targetVersion)
-    throw new SyncLocalStoreSchemaError("INVALID_PLAN", "Minimum compatible Sync schema version cannot exceed its target");
-  if (storedVersion > targetVersion)
-    throw new SyncLocalStoreSchemaError("SCHEMA_TOO_NEW", `Stored Sync schema ${storedVersion} is newer than this runtime's schema ${targetVersion}`, { storedVersion, targetVersion });
-  if (storedVersion < minimumCompatibleVersion)
-    throw new SyncLocalStoreSchemaError("SCHEMA_TOO_OLD", `Stored Sync schema ${storedVersion} is older than the minimum compatible schema ${minimumCompatibleVersion}`, { storedVersion, targetVersion });
-  const steps = [];
-  for (let version2 = storedVersion + 1;version2 <= targetVersion; version2++) {
-    const migration = migrations.find((candidate) => candidate.toVersion === version2);
-    if (migration === undefined)
-      throw new SyncLocalStoreSchemaError("MIGRATION_MISSING", `Sync migration ${version2 - 1} -> ${version2} is missing`, { storedVersion, targetVersion });
-    steps.push(migration);
-  }
-  return { minimumCompatibleVersion, steps, targetVersion };
-};
-var init_client2 = __esm(() => {
-  RUNTIME_TRANSPORT = Symbol.for("@absolutejs/sync/client-runtime-transport");
-  host = globalThis;
-  registry = (() => {
-    const existing = host[RUNTIME_TRANSPORT];
-    if (isRegistry(existing))
-      return existing;
-    if (typeof existing === "object" && existing !== null && Array.isArray(Reflect.get(existing, "installations"))) {
-      Reflect.set(existing, "clients", []);
-      return existing;
-    }
-    const created = { clients: [], installations: [] };
-    Object.defineProperty(host, RUNTIME_TRANSPORT, {
-      configurable: false,
-      enumerable: false,
-      value: created,
-      writable: false
-    });
-    return created;
-  })();
-  SyncLocalDataPolicyError = class SyncLocalDataPolicyError extends Error {
-    code;
-    constructor(code, message) {
-      super(message);
-      this.name = "SyncLocalDataPolicyError";
-      this.code = code;
     }
-  };
-  SyncLocalStoreSchemaError = class SyncLocalStoreSchemaError extends Error {
-    code;
-    storedVersion;
-    targetVersion;
-    constructor(code, message, versions = {}) {
-      super(message);
-      this.name = "SyncLocalStoreSchemaError";
-      this.code = code;
-      this.storedVersion = versions.storedVersion;
-      this.targetVersion = versions.targetVersion;
+    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("\\", "/");
+    if (relativePath === ".." || relativePath.startsWith("../")) {
+      throw new TypeError(`Mobile client dependency escaped the build directory: ${specifier}`);
     }
-  };
-});
-
-// src/mobile/syncSchema.ts
-import { readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname13, join as join21, resolve as resolve15 } from "path";
-var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value), manifestAt = (path) => {
-  try {
-    const value = JSON.parse(readFileSync11(path, "utf8"));
-    return object(value) ? value : undefined;
-  } catch {
-    return;
-  }
-}, localSchemaMetadata = (manifest) => {
-  const absolutejs = Reflect.get(manifest, "absolutejs");
-  if (!object(absolutejs))
-    return;
-  const sync = Reflect.get(absolutejs, "sync");
-  if (!object(sync))
+    return [`/${relativePath}`];
+  });
+}, copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, copied) => {
+  if (copied.has(specifier))
     return;
-  return Reflect.get(sync, "localSchema");
-}, packageManifestPath = (projectRoot, packageName) => {
-  let directory = resolve15(projectRoot);
-  while (true) {
-    const candidate = join21(directory, "node_modules", packageName, "package.json");
-    const manifest = manifestAt(candidate);
-    if (manifest && Reflect.get(manifest, "name") === packageName)
-      return candidate;
-    const parent = dirname13(directory);
-    if (parent === directory)
-      return;
-    directory = parent;
+  copied.add(specifier);
+  const source = sourceAssetPath(buildDirectory, specifier);
+  const destination = join20(staging, specifier.replace(/^\/+/, ""));
+  await mkdir9(dirname12(destination), { recursive: true });
+  await copyFile4(source, destination);
+  await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
+}, copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
+  const dependencies = await absoluteClientImports(sourcePath, buildDirectory);
+  await Promise.all(dependencies.map((specifier) => copyAbsoluteClientDependency(specifier, buildDirectory, staging, copied)));
+}, materializeAbsoluteCapacitorWebBundle = async (options) => {
+  if (!resolveAbsoluteMobileRoute(options.artifact.routes, new URL(options.config.entry, "https://absolute.invalid").pathname)) {
+    throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
   }
-}, metadataError = (id, detail) => new TypeError(`Invalid AbsoluteJS Sync schema metadata for ${id}: ${detail}`), positiveVersion2 = (value, id, field) => {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
-    throw metadataError(id, `${field} must be a positive safe integer.`);
-  return value;
-}, nonEmpty = (value, id, field) => {
-  if (typeof value !== "string" || value.trim() !== value || value.length === 0)
-    throw metadataError(id, `${field} must be a non-empty trimmed string.`);
-  return value;
-}, requireObject = (value, id, detail) => {
-  if (!object(value))
-    throw metadataError(id, detail);
-  return value;
-}, unknownField = (record, key) => record[key], normalizeJsonValue = (value, id, field) => {
-  if (value === null || typeof value === "string" || typeof value === "boolean")
-    return value;
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (Array.isArray(value))
-    return value.map((entry) => normalizeJsonValue(entry, id, field));
-  if (object(value))
-    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
-      key,
-      normalizeJsonValue(entry, id, field)
-    ]));
-  throw metadataError(id, `${field} must be JSON-safe.`);
-}, operation = (value, id, index) => {
-  const record = requireObject(value, id, `migration operation ${index} must be an object.`);
-  const type = Reflect.get(record, "type");
-  const collection = nonEmpty(Reflect.get(record, "collection"), id, `operation ${index}.collection`);
-  if (type === "delete-collection")
-    return { collection, type };
-  if (type === "rename-field")
-    return {
-      collection,
-      from: nonEmpty(Reflect.get(record, "from"), id, `operation ${index}.from`),
-      to: nonEmpty(Reflect.get(record, "to"), id, `operation ${index}.to`),
-      type
-    };
-  const field = nonEmpty(Reflect.get(record, "field"), id, `operation ${index}.field`);
-  if (type === "remove-field")
-    return { collection, field, type };
-  if (type === "set-default")
-    return {
-      collection,
-      field,
-      type,
-      value: normalizeJsonValue(Reflect.get(record, "value"), id, `operation ${index}.value`)
-    };
-  throw metadataError(id, `operation ${index}.type is not supported.`);
-}, migration = (value, id, index) => {
-  const record = requireObject(value, id, `migration ${index} must be an object.`);
-  const allowed = new Set(["operations", "toVersion"]);
-  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
-  if (unsupported)
-    throw metadataError(id, `migration ${index}.${unsupported} is not declarative metadata.`);
-  const declaredOperations = Reflect.get(record, "operations");
-  if (declaredOperations !== undefined && !Array.isArray(declaredOperations))
-    throw metadataError(id, `migration ${index}.operations must be an array.`);
-  const operations = Array.isArray(declaredOperations) ? declaredOperations : [];
-  return {
-    operations: operations.map((entry, operationIndex) => operation(entry, id, operationIndex)),
-    toVersion: positiveVersion2(Reflect.get(record, "toVersion"), id, `migration ${index}.toVersion`)
-  };
-}, localDataPolicy = (value, id) => {
-  const record = requireObject(value, id, "localData must be an object.");
-  const allowed = new Set([
-    "collections",
-    "maxBytesPerNamespace",
-    "mutations"
-  ]);
-  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
-  if (unsupported)
-    throw metadataError(id, `localData.${unsupported} is not supported.`);
-  const collectionRules = Reflect.get(record, "collections");
-  const mutationRules = Reflect.get(record, "mutations");
-  if (collectionRules !== undefined && !Array.isArray(collectionRules))
-    throw metadataError(id, "localData.collections must be an array.");
-  if (mutationRules !== undefined && !Array.isArray(mutationRules))
-    throw metadataError(id, "localData.mutations must be an array.");
-  const collections = Array.isArray(collectionRules) ? collectionRules.map((entry, index) => {
-    const rule = requireObject(entry, id, `localData.collections[${index}] must be an object.`);
-    const allowedRuleKeys = new Set([
-      "evictionPriority",
-      "match",
-      "maxAgeMs",
-      "onProtectionUnavailable",
-      "persistence",
-      "protection",
-      "sensitivity"
-    ]);
-    const unsupportedRuleKey = Object.keys(rule).find((key) => !allowedRuleKeys.has(key));
-    if (unsupportedRuleKey)
-      throw metadataError(id, `localData.collections[${index}].${unsupportedRuleKey} is not supported.`);
-    const match = nonEmpty(Reflect.get(rule, "match"), id, `localData.collections[${index}].match`);
-    const persistence = unknownField(rule, "persistence");
-    const sensitivity = unknownField(rule, "sensitivity");
-    const protection = unknownField(rule, "protection");
-    const onProtectionUnavailable = unknownField(rule, "onProtectionUnavailable");
-    const evictionPriority = unknownField(rule, "evictionPriority");
-    const maxAge = unknownField(rule, "maxAgeMs");
-    if (persistence !== undefined && persistence !== "durable" && persistence !== "memory-only")
-      throw metadataError(id, `localData.collections[${index}].persistence is invalid.`);
-    if (sensitivity !== undefined && sensitivity !== "public" && sensitivity !== "private" && sensitivity !== "secret")
-      throw metadataError(id, `localData.collections[${index}].sensitivity is invalid.`);
-    if (protection !== undefined && protection !== "none" && protection !== "required")
-      throw metadataError(id, `localData.collections[${index}].protection is invalid.`);
-    if (onProtectionUnavailable !== undefined && onProtectionUnavailable !== "error" && onProtectionUnavailable !== "memory-only")
-      throw metadataError(id, `localData.collections[${index}].onProtectionUnavailable is invalid.`);
-    if (evictionPriority !== undefined && evictionPriority !== "critical" && evictionPriority !== "normal" && evictionPriority !== "disposable")
-      throw metadataError(id, `localData.collections[${index}].evictionPriority is invalid.`);
-    return {
-      match,
-      ...sensitivity ? { sensitivity } : {},
-      ...persistence ? { persistence } : {},
-      ...protection ? { protection } : {},
-      ...onProtectionUnavailable ? {
-        onProtectionUnavailable
-      } : {},
-      ...evictionPriority ? { evictionPriority } : {},
-      ...maxAge === undefined ? {} : {
-        maxAgeMs: positiveVersion2(maxAge, id, `localData.collections[${index}].maxAgeMs`)
-      }
-    };
-  }) : undefined;
-  const mutations = Array.isArray(mutationRules) ? mutationRules.map((entry, index) => {
-    const rule = requireObject(entry, id, `localData.mutations[${index}] must be an object.`);
-    const allowedRuleKeys = new Set([
-      "conflict",
-      "match",
-      "onProtectionUnavailable",
-      "persistence",
-      "protection",
-      "sensitivity"
-    ]);
-    const unsupportedRuleKey = Object.keys(rule).find((key) => !allowedRuleKeys.has(key));
-    if (unsupportedRuleKey)
-      throw metadataError(id, `localData.mutations[${index}].${unsupportedRuleKey} is not supported.`);
-    const protection = unknownField(rule, "protection");
-    const sensitivity = unknownField(rule, "sensitivity");
-    const persistence = unknownField(rule, "persistence");
-    const onProtectionUnavailable = unknownField(rule, "onProtectionUnavailable");
-    const declaredConflict = unknownField(rule, "conflict");
-    let conflict;
-    if (declaredConflict !== undefined) {
-      const conflictRecord = requireObject(declaredConflict, id, `localData.mutations[${index}].conflict must be an object.`);
-      const unsupportedConflictKey = Object.keys(conflictRecord).find((key) => key !== "maxAttempts" && key !== "strategy");
-      if (unsupportedConflictKey)
-        throw metadataError(id, `localData.mutations[${index}].conflict.${unsupportedConflictKey} is not supported.`);
-      const strategy = unknownField(conflictRecord, "strategy");
-      if (strategy !== "client-wins" && strategy !== "manual" && strategy !== "server-wins")
-        throw metadataError(id, `localData.mutations[${index}].conflict.strategy is invalid.`);
-      const maxAttempts = unknownField(conflictRecord, "maxAttempts");
-      if (maxAttempts !== undefined && strategy !== "client-wins")
-        throw metadataError(id, `localData.mutations[${index}].conflict.maxAttempts requires client-wins.`);
-      conflict = {
-        strategy,
-        ...maxAttempts === undefined ? {} : {
-          maxAttempts: positiveVersion2(maxAttempts, id, `localData.mutations[${index}].conflict.maxAttempts`)
+  const destination = options.config.bundleDirectory;
+  await mkdir9(dirname12(destination), { recursive: true });
+  const staging = await mkdtemp4(join20(dirname12(destination), `.${basename8(destination)}.stage-`));
+  try {
+    const pageDirectory = join20(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 })));
+    const copiedDependencies = new Set;
+    const pages = await Promise.all(options.artifact.pages.map((page) => copyClientPage(page, options.buildDirectory, staging, copiedDependencies)));
+    const manifest = {
+      appBuild: options.artifact.appBuild,
+      ...options.auth ? { auth: options.auth } : {},
+      appId: options.config.appId,
+      appName: options.config.appName,
+      deepLinkHosts: options.config.deepLinkHosts,
+      deepLinkScheme: options.config.deepLinkScheme,
+      deviceCapabilities: options.deviceCapabilities.capabilities,
+      entry: options.config.entry,
+      format: ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+      pages,
+      productionOrigin: options.config.productionOrigin,
+      routes: options.artifact.routes,
+      runtime: options.artifact.runtime,
+      ...options.sync ? {
+        sync: {
+          background: {
+            endpoint: new URL("/__absolute/sync/background", options.config.productionOrigin).href,
+            intervalMinutes: 15
+          },
+          socketTickets: true,
+          storageSchema: options.syncSchema ?? {
+            components: [
+              { id: "@absolutejs/app", version: 1 }
+            ]
+          }
         }
-      };
-    }
-    if (protection !== undefined && protection !== "none" && protection !== "required")
-      throw metadataError(id, `localData.mutations[${index}].protection is invalid.`);
-    if (sensitivity !== undefined && sensitivity !== "public" && sensitivity !== "private" && sensitivity !== "secret")
-      throw metadataError(id, `localData.mutations[${index}].sensitivity is invalid.`);
-    if (onProtectionUnavailable !== undefined && onProtectionUnavailable !== "error" && onProtectionUnavailable !== "memory-only")
-      throw metadataError(id, `localData.mutations[${index}].onProtectionUnavailable is invalid.`);
-    if (persistence !== undefined && persistence !== "durable" && persistence !== "memory-only")
-      throw metadataError(id, `localData.mutations[${index}].persistence is invalid.`);
-    return {
-      match: nonEmpty(Reflect.get(rule, "match"), id, `localData.mutations[${index}].match`),
-      ...conflict ? { conflict } : {},
-      ...sensitivity ? { sensitivity } : {},
-      ...onProtectionUnavailable ? { onProtectionUnavailable } : {},
-      ...persistence ? {
-        persistence
-      } : {},
-      ...protection ? { protection } : {}
+      } : {}
     };
-  }) : undefined;
-  const quota = Reflect.get(record, "maxBytesPerNamespace");
+    await Promise.all([
+      writeFile8(join20(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+`),
+      writeFile8(join20(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);
+    return manifest;
+  } catch (error) {
+    await rm6(staging, { force: true, recursive: true });
+    throw error;
+  }
+};
+var init_capacitorBundle = __esm(() => {
+  init_routeMatcher();
+  init_transport();
+  CLIENT_CSS_DEPENDENCY_PATTERN = /(?:@import\s+(?:url\(\s*)?|url\(\s*)["']?((?:\/|\.\.\/|\.\/)[^"')\s]+)["']?\s*\)?/gu;
+  CLIENT_MARKUP_DEPENDENCY_PATTERN = /<(?:script\b[^>]*\bsrc|link\b[^>]*\bhref|img\b[^>]*\bsrc|source\b[^>]*\bsrcset)\s*=\s*["']((?:\/|\.\.\/|\.\/)[^"',\s]+)/giu;
+  CAPACITOR_CLIENT_FRAMEWORKS = new Set([
+    "angular",
+    "html",
+    "htmx",
+    "react",
+    "svelte",
+    "vue"
+  ]);
+  CLIENT_ASSET_DIRECTORIES = ["assets", "html", "htmx", "indexes"];
+});
+
+// src/mobile/artifactStore.ts
+import { createHash as createHash10 } from "crypto";
+var DEFAULT_MAX_PRODUCER_BYTES = 134217728, SHA_2562 = "sha256", hashBlob = async (blob) => {
+  const bytes = new Uint8Array(await blob.arrayBuffer());
+  return createHash10(SHA_2562).update(bytes).digest("hex");
+}, verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes = DEFAULT_MAX_PRODUCER_BYTES) => {
+  const { artifact, producer } = release;
+  if (producer.size !== artifact.producer.bytes || producer.size > maxProducerBytes) {
+    throw new TypeError("Mobile compatibility producer size does not match its artifact.");
+  }
+  if (await hashBlob(producer) !== artifact.producer.bundleHash) {
+    throw new TypeError("Mobile compatibility producer hash does not match its artifact.");
+  }
+  return release;
+};
+var init_artifactStore = __esm(() => {
+  init_releaseArtifact();
+});
+
+// src/mobile/materializedBundle.ts
+import { createHash as createHash11 } from "crypto";
+import {
+  access as access8,
+  mkdir as mkdir10,
+  mkdtemp as mkdtemp5,
+  readFile as readFile11,
+  rename as rename8,
+  rm as rm7,
+  writeFile as writeFile9
+} from "fs/promises";
+import { dirname as dirname13, join as join21, 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,
+    releases: releases.map(({ releaseId }) => releaseId)
+  });
+  return `amb_${createHash11("sha256").update(identity).digest("hex")}`;
+}, parseBundleIndex = (value) => {
+  if (!isRecord7(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
+    throw new TypeError("Invalid materialized mobile compatibility bundle.");
+  }
+  const releases = value.releases.map(parseAbsoluteMobileCompatibilityArtifact);
+  const retained = retainAbsoluteMobileCompatibilityArtifacts(releases);
+  if (retained.length !== releases.length || retained.some(({ releaseId }, index) => releaseId !== releases[index]?.releaseId)) {
+    throw new TypeError("Materialized mobile bundle releases are not a retained generation window.");
+  }
+  const expectedBundleId = bundleIdFor(value.currentReleaseId, releases);
+  if (value.bundleId !== expectedBundleId) {
+    throw new TypeError("Materialized mobile bundle integrity failed.");
+  }
+  if (releases[0]?.releaseId !== value.currentReleaseId) {
+    throw new TypeError("Materialized mobile bundle current release is not its newest generation.");
+  }
   return {
-    ...collections ? { collections } : {},
-    ...mutations ? { mutations } : {},
-    ...quota === undefined ? {} : {
-      maxBytesPerNamespace: positiveVersion2(quota, id, "localData.maxBytesPerNamespace")
-    }
+    bundleId: value.bundleId,
+    currentReleaseId: value.currentReleaseId,
+    format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
+    releases
   };
-}, component = (id, value) => {
-  const record = requireObject(value, id, "localSchema must be an object.");
-  const allowed = new Set([
-    "localData",
-    "migrations",
-    "minimumCompatibleVersion",
-    "version"
+}, writeRelease = async (root, release) => {
+  const directory = join21(root, release.artifact.releaseId);
+  const producerPath = join21(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(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
-  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
-  if (unsupported)
-    throw metadataError(id, `${unsupported} is not supported.`);
-  const version2 = positiveVersion2(Reflect.get(record, "version"), id, "version");
-  const declaredMinimum = Reflect.get(record, "minimumCompatibleVersion");
-  const minimumCompatibleVersion = declaredMinimum === undefined ? Math.max(1, version2 - 2) : positiveVersion2(declaredMinimum, id, "minimumCompatibleVersion");
-  const declaredMigrations = Reflect.get(record, "migrations");
-  const declaredLocalData = Reflect.get(record, "localData");
-  if (declaredMigrations !== undefined && !Array.isArray(declaredMigrations))
-    throw metadataError(id, "migrations must be an array.");
-  const migrations = Array.isArray(declaredMigrations) ? declaredMigrations : undefined;
-  return {
-    id,
-    ...declaredLocalData === undefined ? {} : { localData: localDataPolicy(declaredLocalData, id) },
-    minimumCompatibleVersion,
-    ...Array.isArray(migrations) ? {
-      migrations: migrations.map((entry, index) => migration(entry, id, index))
-    } : {},
-    version: version2
+}, installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
+  const destination = join21(bundlesRoot, bundleId);
+  try {
+    await access8(destination);
+    return destination;
+  } catch (error) {
+    if (!errorHasCode2(error, "ENOENT"))
+      throw error;
+  }
+  const staging = await mkdtemp5(join21(bundlesRoot, ".stage-"));
+  try {
+    await Promise.all(releases.map((release) => writeRelease(staging, release)));
+    await rename8(staging, destination);
+  } catch (error) {
+    await rm7(staging, { force: true, recursive: true });
+    if (errorHasCode2(error, "EEXIST") || errorHasCode2(error, "ENOTEMPTY")) {
+      return destination;
+    }
+    throw error;
+  }
+  return destination;
+}, materializeAbsoluteMobileCompatibilityBundle = async (input) => {
+  const releases = await Promise.all(input.releases.map((release) => verifyAbsoluteMobileCompatibilityProducer(release)));
+  const artifacts = retainAbsoluteMobileCompatibilityArtifacts(releases.map(({ artifact }) => artifact));
+  if (artifacts.length !== releases.length) {
+    throw new TypeError("Materialization input must already contain only retained releases.");
+  }
+  if (artifacts[0]?.releaseId !== input.currentReleaseId) {
+    throw new TypeError("Materialization current release must be the newest generation.");
+  }
+  const orderedReleases = artifacts.map((artifact) => {
+    const release = releases.find((candidate) => candidate.artifact.releaseId === artifact.releaseId);
+    if (!release) {
+      throw new TypeError("Materialization input is missing a producer.");
+    }
+    return release;
+  });
+  const root = resolvePath3(input.root);
+  const bundlesRoot = join21(root, BUNDLES_DIRECTORY);
+  await mkdir10(bundlesRoot, { recursive: true });
+  const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
+  await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
+  const index = {
+    bundleId,
+    currentReleaseId: input.currentReleaseId,
+    format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
+    releases: artifacts
   };
-}, dependencyNames = (manifest) => [
-  Reflect.get(manifest, "dependencies"),
-  Reflect.get(manifest, "optionalDependencies"),
-  Reflect.get(manifest, "devDependencies"),
-  Reflect.get(manifest, "peerDependencies")
-].flatMap((dependencies) => object(dependencies) ? Object.keys(dependencies) : []).filter((name, index, names) => names.indexOf(name) === index).sort(), discoverAbsoluteSyncSchema = (projectRoot) => {
-  const appManifestPath = join21(resolve15(projectRoot), "package.json");
-  const appManifest = manifestAt(appManifestPath);
-  if (!appManifest)
-    return {
-      components: [
-        {
-          id: "@absolutejs/app",
-          minimumCompatibleVersion: 1,
-          version: 1
-        }
-      ],
-      sources: []
-    };
-  const appMetadata = localSchemaMetadata(appManifest);
-  const components = [
-    appMetadata === undefined ? { id: "@absolutejs/app", minimumCompatibleVersion: 1, version: 1 } : component("@absolutejs/app", appMetadata)
-  ];
-  const sources = [
-    { id: "@absolutejs/app", manifestPath: appManifestPath }
-  ];
-  for (const name of dependencyNames(appManifest)) {
-    const manifestPath = packageManifestPath(projectRoot, name);
-    if (!manifestPath)
-      continue;
-    const manifest = manifestAt(manifestPath);
-    if (!manifest)
-      continue;
-    const metadata = localSchemaMetadata(manifest);
-    if (metadata === undefined)
-      continue;
-    components.push(component(name, metadata));
-    sources.push({ id: name, manifestPath });
+  const pointerPath = join21(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join21(root, `.current-${crypto.randomUUID()}.json`);
+  await writeFile9(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+`, { flag: "wx" });
+  await rename8(temporaryPointerPath, pointerPath);
+  return index;
+}, readAbsoluteMobileMaterializedReleases = async (root) => {
+  const resolvedRoot = resolvePath3(root);
+  try {
+    const serialized = await readFile11(join21(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const parsed = JSON.parse(serialized);
+    const index = parseBundleIndex(parsed);
+    const bundleRoot = join21(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    return Promise.all(index.releases.map(async (artifact) => {
+      const producer = Bun.file(join21(bundleRoot, artifact.releaseId, artifact.producer.module));
+      await verifyAbsoluteMobileCompatibilityProducer({
+        artifact,
+        producer
+      });
+      return { artifact, producer };
+    }));
+  } catch (error) {
+    if (errorHasCode2(error, "ENOENT"))
+      return [];
+    throw error;
   }
-  components.sort((left, right) => left.id.localeCompare(right.id));
-  sources.sort((left, right) => left.id.localeCompare(right.id));
-  resolveSyncLocalSchemaComponents({}, { components });
-  return { components, sources };
 };
-var init_syncSchema = __esm(() => {
-  init_client2();
+var init_materializedBundle = __esm(() => {
+  init_artifactStore();
+  init_releaseArtifact();
+  BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
 });
 
 // src/mobile/deviceCapabilities.ts
@@ -8327,9 +8604,6 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
     runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
   });
   const auth = resolveAbsoluteMobileAuthManifest(options.projectRoot, mobile);
-  if (mobile.engine === "expo" && auth) {
-    throw new TypeError("Expo mobile Auth is not released yet. The experimental Expo shell cannot safely substitute Capacitor credentials; remove engine: 'expo' or wait for @absolutejs/auth-expo.");
-  }
   const sync = auth !== undefined && projectUsesAbsoluteSync(options.projectRoot);
   const syncSchema = sync ? discoverAbsoluteSyncSchema(options.projectRoot) : undefined;
   const deviceCapabilities = resolveAbsoluteDeviceCapabilityPlan(options.projectRoot);
@@ -8956,12 +9230,12 @@ var init_serverBundleExternals = __esm(() => {
 // src/core/prerender.ts
 var exports_prerender = {};
 __export(exports_prerender, {
-  routeToFilename: () => routeToFilename,
-  rerenderRoute: () => rerenderRoute,
-  readTimestamp: () => readTimestamp,
-  prerenderWithServer: () => prerenderWithServer,
+  PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER,
   prerender: () => prerender,
-  PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
+  prerenderWithServer: () => prerenderWithServer,
+  readTimestamp: () => readTimestamp,
+  rerenderRoute: () => rerenderRoute,
+  routeToFilename: () => routeToFilename
 });
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync14 } from "fs";
 import { join as join24 } from "path";
@@ -9621,8 +9895,8 @@ var init_rewriteImportsPlugin = __esm(() => {
 // src/build/rewriteImports.ts
 var exports_rewriteImports = {};
 __export(exports_rewriteImports, {
-  rewriteVendorDirectories: () => rewriteVendorDirectories2,
-  rewriteImports: () => rewriteImports
+  rewriteImports: () => rewriteImports,
+  rewriteVendorDirectories: () => rewriteVendorDirectories2
 });
 var rewriteImports = async (outputPaths, vendorPaths) => {
   const jsFiles = outputPaths.filter((path) => path.endsWith(".js"));
@@ -10285,11 +10559,11 @@ var init_build = __esm(() => {
 // src/cli/scripts/lintProof.ts
 var exports_lintProof = {};
 __export(exports_lintProof, {
-  writeLintProof: () => writeLintProof,
-  verifyLintProof: () => verifyLintProof,
-  runLintProof: () => runLintProof,
+  createLintProof: () => createLintProof,
   createLintSourceTree: () => createLintSourceTree,
-  createLintProof: () => createLintProof
+  runLintProof: () => runLintProof,
+  verifyLintProof: () => verifyLintProof,
+  writeLintProof: () => writeLintProof
 });
 import {
   createHash as createHash12,
@@ -15063,9 +15337,9 @@ var init_htmx = __esm(() => {
 // src/cli/scripts/env.ts
 var exports_env = {};
 __export(exports_env, {
-  scanEnvUsage: () => scanEnvUsage,
+  collectEnvVars: () => collectEnvVars,
   runEnv: () => runEnv,
-  collectEnvVars: () => collectEnvVars
+  scanEnvUsage: () => scanEnvUsage
 });
 import { existsSync as existsSync33, readFileSync as readFileSync33 } from "fs";
 import { join as join41 } from "path";
@@ -15129,12 +15403,12 @@ var init_env = __esm(() => {
 // src/cli/scripts/db.ts
 var exports_db = {};
 __export(exports_db, {
-  runDb: () => runDb,
-  quoteIdent: () => quoteIdent,
-  encodeValue: () => encodeValue,
-  dependencyOrder: () => dependencyOrder,
+  chunkRows: () => chunkRows,
   conflictClause: () => conflictClause,
-  chunkRows: () => chunkRows
+  dependencyOrder: () => dependencyOrder,
+  encodeValue: () => encodeValue,
+  quoteIdent: () => quoteIdent,
+  runDb: () => runDb
 });
 import { existsSync as existsSync34, mkdirSync as mkdirSync15, readFileSync as readFileSync34, writeFileSync as writeFileSync18 } from "fs";
 import { join as join42 } from "path";
@@ -16474,8 +16748,8 @@ var init_externalAssetPlugin = () => {};
 // src/cli/scripts/compile.ts
 var exports_compile = {};
 __export(exports_compile, {
-  shouldEmbedCompiledAsset: () => shouldEmbedCompiledAsset,
-  compile: () => compile
+  compile: () => compile,
+  shouldEmbedCompiledAsset: () => shouldEmbedCompiledAsset
 });
 var {env: env5 } = globalThis.Bun;
 import {
@@ -18434,12 +18708,38 @@ import { mkdir as mkdir12, writeFile as writeFile14 } from "fs/promises";
 import { dirname as dirname29, resolve as resolve38 } from "path";
 
 class CdpConnection {
-  diagnostics = [];
-  socket;
-  #closed = false;
-  #nextId = 1;
-  #pending = new Map;
+  #closed;
+  #nextId;
+  #pending;
   constructor(socket) {
+    this.diagnostics = [];
+    this.#closed = false;
+    this.#nextId = 1;
+    this.#pending = new Map;
+    this.command = (method, params = {}, timeoutMs = CDP_COMMAND_TIMEOUT_MS) => {
+      if (this.#closed) {
+        return Promise.reject(new Error("Android WebView debugger is closed."));
+      }
+      const id = this.#nextId++;
+      return new Promise((_resolve, reject) => {
+        const timer = setTimeout(() => {
+          this.#pending.delete(id);
+          reject(new Error(`CDP ${method} timed out after ${timeoutMs}ms.`));
+        }, timeoutMs);
+        this.#pending.set(id, {
+          reject,
+          resolve: _resolve,
+          timer
+        });
+        this.socket.send(JSON.stringify({ id, method, params }));
+      });
+    };
+    this.close = async () => {
+      if (this.#closed)
+        return;
+      this.#closed = true;
+      this.socket.close();
+    };
     this.socket = socket;
     socket.addEventListener("message", (event) => {
       this.onMessage(event.data);
@@ -18518,30 +18818,6 @@ class CdpConnection {
     }
     pending.resolve(message.result);
   }
-  command = (method, params = {}, timeoutMs = CDP_COMMAND_TIMEOUT_MS) => {
-    if (this.#closed) {
-      return Promise.reject(new Error("Android WebView debugger is closed."));
-    }
-    const id = this.#nextId++;
-    return new Promise((_resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.#pending.delete(id);
-        reject(new Error(`CDP ${method} timed out after ${timeoutMs}ms.`));
-      }, timeoutMs);
-      this.#pending.set(id, {
-        reject,
-        resolve: _resolve,
-        timer
-      });
-      this.socket.send(JSON.stringify({ id, method, params }));
-    });
-  };
-  close = async () => {
-    if (this.#closed)
-      return;
-    this.#closed = true;
-    this.socket.close();
-  };
 }
 var CDP_COMMAND_TIMEOUT_MS = 1e4, WEBVIEW_ATTACH_TIMEOUT_MS = 30000, WEBVIEW_POLL_MS = 200, captureCommand3 = (command) => {
   const result = Bun.spawnSync(command, {
@@ -21019,7 +21295,7 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
 }, initialize = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
   if (mobile.engine === "expo") {
-    console.warn("Experimental: Expo Auth, Sync, release publishing, and physical-device acceptance are not complete.");
+    console.warn("Experimental: Expo Auth and authenticated HTTP are available; Sync, release publishing, and physical-device acceptance are not complete.");
     const generated2 = await writeAbsoluteExpoProject(mobile, {
       force: args.includes("--force"),
       projectRoot
@@ -22940,12 +23216,12 @@ import { spawn as nodeSpawn } from "child_process";
 import {
   createWriteStream,
   existsSync as existsSync5,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   rmSync as rmSync2,
   writeFileSync as writeFileSync4
 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join15, resolve as resolvePath2 } from "path";
+import { join as join16, resolve as resolvePath2 } from "path";
 
 // src/dev/tunnel/client.ts
 var RECONNECT_DELAY_MS = 2000;
@@ -23455,7 +23731,7 @@ init_expoProject();
 init_iosPhysicalDeviceTransport();
 import { spawn } from "child_process";
 import { access as access2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 var METRO_READY_TIMEOUT_MS = 60000;
 var PROCESS_CLOSE_TIMEOUT_MS = 2000;
 var commandEnvironment = (options) => ({
@@ -23468,7 +23744,7 @@ var commandEnvironment = (options) => ({
   ...options.metroHost ? { REACT_NATIVE_PACKAGER_HOSTNAME: options.metroHost } : {}
 });
 var absoluteExpoExecutable = async (project) => {
-  const executable = join6(project, "node_modules", ".bin", "expo");
+  const executable = join8(project, "node_modules", ".bin", "expo");
   try {
     await access2(executable);
     return executable;
@@ -23564,18 +23840,18 @@ var stopProcess = async (process2) => {
     return;
   process2.kill("SIGTERM");
   await Promise.race([
-    new Promise((resolve4) => process2.once("exit", () => resolve4())),
-    new Promise((resolve4) => setTimeout(resolve4, PROCESS_CLOSE_TIMEOUT_MS))
+    new Promise((resolve5) => process2.once("exit", () => resolve5())),
+    new Promise((resolve5) => setTimeout(resolve5, PROCESS_CLOSE_TIMEOUT_MS))
   ]);
   if (process2.exitCode === null)
     process2.kill("SIGKILL");
 };
-var waitForExit = (process2) => new Promise((resolve4) => {
+var waitForExit = (process2) => new Promise((resolve5) => {
   if (process2.exitCode !== null) {
-    resolve4(process2.exitCode);
+    resolve5(process2.exitCode);
     return;
   }
-  process2.once("exit", (code) => resolve4(code ?? 1));
+  process2.once("exit", (code) => resolve5(code ?? 1));
 });
 var runUtilityCommand = async (run, command, args, options) => {
   const child = run(command, args, {
@@ -23655,9 +23931,9 @@ var startAbsoluteExpoDevSession = async (options) => {
   }) : undefined;
   let metroReady = false;
   let resolveMetro;
-  const metroPromise = new Promise((resolve4, reject) => {
+  const metroPromise = new Promise((resolve5, reject) => {
     if (!metro) {
-      resolve4();
+      resolve5();
       return;
     }
     const timeout = setTimeout(() => {
@@ -23665,7 +23941,7 @@ var startAbsoluteExpoDevSession = async (options) => {
     }, METRO_READY_TIMEOUT_MS);
     resolveMetro = () => {
       clearTimeout(timeout);
-      resolve4();
+      resolve5();
     };
     metro.once("exit", (code) => {
       if (!metroReady) {
@@ -24123,9 +24399,9 @@ var setupHttpsCert = async (hosts = []) => {
   await setupCertWithPrompt(ensureDevCert2, setupMkcert2, hosts);
   return getDevCertificateAuthorityPath2();
 };
-var mobileReachableHost = (host) => {
-  if (host !== "0.0.0.0" && host !== "::")
-    return host;
+var mobileReachableHost = (host2) => {
+  if (host2 !== "0.0.0.0" && host2 !== "::")
+    return host2;
   const address = getLocalIPAddress();
   if (address === "localhost") {
     throw new Error("No LAN address is available for the selected physical device. Connect this computer to the device network or set dev.host explicitly.");
@@ -24220,7 +24496,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
         const generated = await writeAbsoluteExpoProject(normalized, {
           projectRoot: process.cwd()
         });
-        const dependenciesReady = existsSync5(join15(generated.path, "node_modules", "expo", "package.json")) && existsSync5(join15(generated.path, "node_modules", "expo-dev-client", "package.json"));
+        const dependenciesReady = existsSync5(join16(generated.path, "node_modules", "expo", "package.json")) && existsSync5(join16(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) {
@@ -24230,7 +24506,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
             cwd: generated.path,
             stdio: "inherit"
           });
-          const installExit = await new Promise((resolve9) => installProcess.once("exit", (code) => resolve9(code ?? 1)));
+          const installExit = await new Promise((resolve10) => installProcess.once("exit", (code) => resolve10(code ?? 1)));
           if (installExit !== 0) {
             throw new TypeError(`Expo dependency installation exited with status ${installExit}.`);
           }
@@ -24299,7 +24575,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           }
         }
         if (ready) {
-          const nativeDirectory = join15(normalized.nativeProjectDirectory, "android");
+          const nativeDirectory = join16(normalized.nativeProjectDirectory, "android");
           let createNativeProject = false;
           if (!existsSync5(nativeDirectory)) {
             createNativeProject = await confirmPrompt("Create the managed Capacitor Android project now?");
@@ -24319,7 +24595,7 @@ 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 = join15(normalized.nativeProjectDirectory, "ios");
+            const nativeDirectory = join16(normalized.nativeProjectDirectory, "ios");
             if (!existsSync5(nativeDirectory)) {
               console.log(cliTag("\x1B[33m", "The iOS project is missing. Run `absolute mobile init` before remote development."));
             } else {
@@ -24340,7 +24616,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
             }
           }
           if (ready) {
-            const nativeDirectory = join15(normalized.nativeProjectDirectory, "ios");
+            const nativeDirectory = join16(normalized.nativeProjectDirectory, "ios");
             let createNativeProject = false;
             if (!existsSync5(nativeDirectory)) {
               createNativeProject = await confirmPrompt("Create the managed Capacitor iOS project now?");
@@ -24692,9 +24968,9 @@ var dev = async (serverEntry, configPath2, options = {}) => {
       iosDevStart = null;
     });
   };
-  const absoluteDevOrigin = (host) => {
+  const absoluteDevOrigin = (host2) => {
     const url = new URL(`${httpsEnabled ? "https" : "http"}://localhost`);
-    url.hostname = host;
+    url.hostname = host2;
     url.port = String(port);
     return url.origin;
   };
@@ -24960,8 +25236,8 @@ var dev = async (serverEntry, configPath2, options = {}) => {
       });
       if (probe && probe.port !== port) {
         const { port: nextPort } = probe;
-        const { host } = refreshedDevConfig;
-        const displayHost = host === "0.0.0.0" ? "localhost" : host;
+        const { host: host2 } = refreshedDevConfig;
+        const displayHost = host2 === "0.0.0.0" ? "localhost" : host2;
         console.log(cliTag("\x1B[36m", `Port changed in config \u2014 switching to http://${displayHost}:${nextPort}/`));
         port = nextPort;
         updateLockMetadata(buildDirectory, { port });
@@ -24976,7 +25252,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
     for (const name of candidates) {
       let text;
       try {
-        text = readFileSync8(resolvePath2(process.cwd(), name), "utf8");
+        text = readFileSync9(resolvePath2(process.cwd(), name), "utf8");
       } catch {
         continue;
       }
@@ -24998,7 +25274,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
     }
     return merged;
   };
-  const heapPreloadPath = join15(tmpdir2(), `absolute-heap-${process.pid}.ts`);
+  const heapPreloadPath = join16(tmpdir2(), `absolute-heap-${process.pid}.ts`);
   let heapSnapshotEnabled = false;
   try {
     writeFileSync4(heapPreloadPath, DEV_CHILD_PRELOAD);
@@ -25097,9 +25373,9 @@ var dev = async (serverEntry, configPath2, options = {}) => {
   };
   try {
     const { watch: watch3 } = await import("fs");
-    const { dirname: dirname8 } = await import("path");
+    const { dirname: dirname9 } = await import("path");
     const absServerEntry = resolvePath2(serverEntry);
-    const serverEntryDir = dirname8(absServerEntry);
+    const serverEntryDir = dirname9(absServerEntry);
     const ROOT_RESTART_DENY = new Set([
       "build",
       "dist",
@@ -25131,7 +25407,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
       if (now - last < 100)
         return;
       recentlyHandled.set(filename, now);
-      scheduleServerRestart(join15(serverEntryDir, filename));
+      scheduleServerRestart(join16(serverEntryDir, filename));
     };
     const recoveryScan = async () => {
       let entries;
@@ -25150,7 +25426,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           continue;
         let fileStat;
         try {
-          fileStat = statSync(join15(serverEntryDir, entry.name));
+          fileStat = statSync(join16(serverEntryDir, entry.name));
         } catch {
           continue;
         }
@@ -25538,9 +25814,9 @@ init_eslint();
 init_constants();
 init_utils();
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync11 } from "fs";
 import { arch as arch2, cpus, platform as platform3, totalmem, version } from "os";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 var bold = (str) => `\x1B[1m${str}\x1B[0m`;
 var getBinaryVersion = (binary, flag = "--version") => {
   try {
@@ -25560,7 +25836,7 @@ var getPackageVersion = (packageName) => {
     const pkgPath = __require.resolve(`${packageName}/package.json`, {
       paths: [process.cwd()]
     });
-    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
     const ver = pkg.version;
     return ver;
   } catch {
@@ -25570,8 +25846,8 @@ var getPackageVersion = (packageName) => {
 var getAbsoluteVersion = () => {
   try {
     const candidates = [
-      resolve11(import.meta.dir, "..", "..", "package.json"),
-      resolve11(import.meta.dir, "..", "..", "..", "package.json")
+      resolve12(import.meta.dir, "..", "..", "package.json"),
+      resolve12(import.meta.dir, "..", "..", "..", "package.json")
     ];
     const pkgPath = candidates.find((candidate) => existsSync8(candidate));
     if (pkgPath)
@@ -25582,7 +25858,7 @@ var getAbsoluteVersion = () => {
   return getPackageVersion("@absolutejs/absolute");
 };
 var readPackageVersion = (pkgPath) => {
-  const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
   const ver = pkg.version;
   return ver;
 };
@@ -25684,7 +25960,7 @@ var info = () => {
 // src/cli/cache.ts
 init_constants();
 import { mkdir as mkdir7 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var {Glob } = globalThis.Bun;
 var CACHE_DIR = ".absolutejs";
 var MAX_FILES_PER_BATCH = 200;
@@ -25736,7 +26012,7 @@ var hashFiles = async (paths) => {
 };
 var loadCache = async (tool) => {
   try {
-    const path = join16(CACHE_DIR, `${tool}.cache.json`);
+    const path = join17(CACHE_DIR, `${tool}.cache.json`);
     const data = await Bun.file(path).json();
     const result = data;
     return result;
@@ -25783,7 +26059,7 @@ var runTool = async (adapter, args) => {
 };
 var saveCache = async (tool, data) => {
   await mkdir7(CACHE_DIR, { recursive: true });
-  const path = join16(CACHE_DIR, `${tool}.cache.json`);
+  const path = join17(CACHE_DIR, `${tool}.cache.json`);
   await Bun.write(path, JSON.stringify(data, null, "\t"));
 };