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

package/dist/mobile/index.js

@@ -159,6 +159,436 @@ var init_startupBanner = __esm(() => {
   ];
 });
 
+// src/utils/stringModifiers.ts
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+};
+
+// 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 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;
+  })();
+  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;
+    }
+  };
+});
+
+// src/mobile/syncSchema.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname9, join as join12, resolve as resolve10 } from "path";
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value), manifestAt = (path) => {
+  try {
+    const value = JSON.parse(readFileSync3(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 = resolve10(projectRoot);
+  while (true) {
+    const candidate = join12(directory, "node_modules", packageName, "package.json");
+    const manifest = manifestAt(candidate);
+    if (manifest && Reflect.get(manifest, "name") === packageName)
+      return candidate;
+    const parent = dirname9(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], normalizeJsonValue2 = (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) => normalizeJsonValue2(entry, id, field));
+  if (object(value))
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      normalizeJsonValue2(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: normalizeJsonValue2(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 = join12(resolve10(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/artifactStore.ts
 import { createHash as createHash2 } from "crypto";
 import {
@@ -249,13 +679,19 @@ var parseCompatibilityPage = (value) => {
   if (!isCanonicalRecord(value) || !isPageFramework(value.framework)) {
     throw new TypeError("Compatibility artifact contains an invalid page.");
   }
+  const styleBundleHash = typeof value.styleBundleHash === "string" ? value.styleBundleHash : undefined;
+  const styleBundlePath = typeof value.styleBundlePath === "string" ? value.styleBundlePath : undefined;
+  if (Boolean(styleBundleHash) !== Boolean(styleBundlePath)) {
+    throw new TypeError("Compatibility page style hash and path must be provided together.");
+  }
   return {
     bundleHash: readString(value.bundleHash, "page.bundleHash"),
     bundlePath: readString(value.bundlePath, "page.bundlePath"),
     contract: readString(value.contract, "page.contract"),
     framework: value.framework,
     pageId: readString(value.pageId, "page.pageId"),
-    propsSchemaHash: readString(value.propsSchemaHash, "page.propsSchemaHash")
+    propsSchemaHash: readString(value.propsSchemaHash, "page.propsSchemaHash"),
+    ...styleBundleHash && styleBundlePath ? { styleBundleHash, styleBundlePath } : {}
   };
 };
 var parseCompatibilityRoute = (value) => {
@@ -287,14 +723,23 @@ var validateProducerModule = (module) => {
   }
   return module;
 };
-var normalizePage = (page) => ({
-  bundleHash: requireNonEmpty(page.bundleHash, "page.bundleHash"),
-  bundlePath: requireNonEmpty(page.bundlePath, "page.bundlePath"),
-  contract: requireNonEmpty(page.contract, "page.contract"),
-  framework: page.framework,
-  pageId: requireNonEmpty(page.pageId, "page.pageId"),
-  propsSchemaHash: requireNonEmpty(page.propsSchemaHash, "page.propsSchemaHash")
-});
+var normalizePage = (page) => {
+  if (Boolean(page.styleBundleHash) !== Boolean(page.styleBundlePath)) {
+    throw new TypeError("Compatibility page style hash and path must be provided together.");
+  }
+  return {
+    bundleHash: requireNonEmpty(page.bundleHash, "page.bundleHash"),
+    bundlePath: requireNonEmpty(page.bundlePath, "page.bundlePath"),
+    contract: requireNonEmpty(page.contract, "page.contract"),
+    framework: page.framework,
+    pageId: requireNonEmpty(page.pageId, "page.pageId"),
+    propsSchemaHash: requireNonEmpty(page.propsSchemaHash, "page.propsSchemaHash"),
+    ...page.styleBundleHash && page.styleBundlePath ? {
+      styleBundleHash: requireNonEmpty(page.styleBundleHash, "page.styleBundleHash"),
+      styleBundlePath: requireNonEmpty(page.styleBundlePath, "page.styleBundlePath")
+    } : {}
+  };
+};
 var normalizeRoute = (route) => {
   if (!route.pattern.startsWith("/")) {
     throw new TypeError("route.pattern must start with /.");
@@ -617,7 +1062,7 @@ var verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes
 // src/mobile/androidRelease.ts
 import { createHash as createHash4 } from "crypto";
 import {
-  access as access3,
+  access as access4,
   copyFile as copyFile2,
   mkdir as mkdir3,
   mkdtemp as mkdtemp2,
@@ -630,6 +1075,7 @@ import {
 import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, relative as relative3, resolve as resolve3, sep as sep2 } from "path";
 
 // src/mobile/emulatorDoctor.ts
+import { access } from "fs/promises";
 import { homedir } from "os";
 import { join as join2 } from "path";
 
@@ -647,6 +1093,34 @@ var isWSLEnvironment = () => {
 };
 
 // src/mobile/emulatorDoctor.ts
+var ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36";
+var captureCommand = (command) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      stderr: "ignore",
+      stdout: "pipe"
+    });
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout.toString()
+    };
+  } catch {
+    return { exitCode: 1, stdout: "" };
+  }
+};
+var hasAvailableIosRuntime = (output) => {
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed !== "object" || parsed === null)
+      return false;
+    const runtimes = Reflect.get(parsed, "runtimes");
+    if (!Array.isArray(runtimes))
+      return false;
+    return runtimes.some((runtime) => typeof runtime === "object" && runtime !== null && Reflect.get(runtime, "isAvailable") === true && typeof Reflect.get(runtime, "identifier") === "string" && String(Reflect.get(runtime, "identifier")).includes("iOS"));
+  } catch {
+    return false;
+  }
+};
 var windowsPathToWsl = (path) => {
   const match = /^([a-z]):[\\/](.*)$/i.exec(path.trim());
   if (!match)
@@ -678,6 +1152,14 @@ var absoluteManagedAndroidSdkRoot = (host, env = process.env) => {
   }
   return join2(homedir(), ".absolutejs", "android-sdk");
 };
+var pathExists = async (path) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
 var detectAbsoluteMobileHost = (platform = process.platform, wsl = isWSLEnvironment()) => {
   if (platform === "darwin")
     return "macos";
@@ -687,10 +1169,151 @@ var detectAbsoluteMobileHost = (platform = process.platform, wsl = isWSLEnvironm
     return "wsl";
   return "linux";
 };
+var executableNames = (host, name) => {
+  if (host === "wsl")
+    return [`${name}.exe`, `${name}.bat`, name];
+  if (host === "windows")
+    return [name, `${name}.exe`, `${name}.bat`];
+  return [name];
+};
+var findExecutable = async (name, paths, options, host) => {
+  const existing = await Promise.all(paths.map(async (path) => await options.exists(path) ? path : undefined));
+  const configured = existing.find((path) => path !== undefined);
+  if (configured)
+    return configured;
+  for (const candidate of executableNames(host, name)) {
+    const path = options.which(candidate);
+    if (path)
+      return path;
+  }
+  return;
+};
+var toolCheck = (id, label, platform, path, remediation) => path ? {
+  id,
+  label,
+  path,
+  platform,
+  status: "pass"
+} : {
+  id,
+  label,
+  platform,
+  remediation,
+  status: "fail"
+};
+var inspectAbsoluteMobileToolchain = async (input = {}) => {
+  const env = input.env ?? process.env;
+  const host = input.host ?? detectAbsoluteMobileHost();
+  const exists = input.exists ?? pathExists;
+  const which = input.which ?? ((command) => Bun.which(command));
+  const capture = input.capture ?? captureCommand;
+  const androidRoot = input.androidRoot === null ? undefined : input.androidRoot ?? env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host, env);
+  const windowsAndroidTools = host === "windows" || host === "wsl";
+  const android = (segments) => androidRoot ? join2(androidRoot, ...segments) : undefined;
+  const paths = (values) => values.filter((value) => Boolean(value));
+  const adb = await findExecutable("adb", paths([
+    android(["platform-tools", windowsAndroidTools ? "adb.exe" : "adb"])
+  ]), { exists, which }, host);
+  const emulator = await findExecutable("emulator", paths([
+    android([
+      "emulator",
+      windowsAndroidTools ? "emulator.exe" : "emulator"
+    ])
+  ]), { exists, which }, host);
+  const sdkmanager = await findExecutable("sdkmanager", paths([
+    android([
+      "cmdline-tools",
+      "latest",
+      "bin",
+      windowsAndroidTools ? "sdkmanager.bat" : "sdkmanager"
+    ])
+  ]), { exists, which }, host);
+  const avdmanager = await findExecutable("avdmanager", paths([
+    android([
+      "cmdline-tools",
+      "latest",
+      "bin",
+      windowsAndroidTools ? "avdmanager.bat" : "avdmanager"
+    ])
+  ]), { exists, which }, host);
+  const java = await findExecutable("java", [], { exists, which }, host);
+  const checks = [
+    {
+      id: "host",
+      label: `Development host: ${host}`,
+      platform: "host",
+      status: "pass"
+    },
+    toolCheck("android.adb", "Android Debug Bridge", "android", adb, "Install Android SDK Platform Tools or expose adb on PATH."),
+    toolCheck("android.emulator", "Android Emulator", "android", emulator, "Install the Android Emulator from Android Studio SDK Manager."),
+    toolCheck("android.sdkmanager", "Android SDK Manager", "android", sdkmanager, "Install Android SDK Command-line Tools (latest)."),
+    toolCheck("android.avdmanager", "Android Virtual Device Manager", "android", avdmanager, "Install Android SDK Command-line Tools (latest)."),
+    toolCheck("android.java", "Java runtime", "android", java, "Install the JDK required by the configured Android Gradle plugin.")
+  ];
+  if (emulator) {
+    const avds = capture([emulator, "-list-avds"]);
+    const hasManagedAvd = avds.exitCode === 0 && avds.stdout.split(/\r?\n/).includes(ABSOLUTE_ANDROID_AVD_NAME);
+    checks.push({
+      id: "android.avd",
+      label: `AbsoluteJS Android emulator (${ABSOLUTE_ANDROID_AVD_NAME})`,
+      platform: "android",
+      remediation: hasManagedAvd ? undefined : "Run absolute mobile doctor android --fix to provision the managed emulator.",
+      status: hasManagedAvd ? "pass" : "fail"
+    });
+  }
+  if (host === "wsl") {
+    checks.push({
+      id: "android.virtualization",
+      label: adb?.endsWith(".exe") ? "Windows-host Android bridge available to WSL" : "WSL requires a Windows-host emulator bridge or Linux KVM",
+      platform: "android",
+      remediation: adb?.endsWith(".exe") ? undefined : "Expose the Windows Android SDK adb.exe to WSL, or enable /dev/kvm for a Linux SDK.",
+      status: adb?.endsWith(".exe") ? "pass" : "warn"
+    });
+  } else if (host === "linux") {
+    const hasKvm = await exists("/dev/kvm");
+    checks.push({
+      id: "android.virtualization",
+      label: "Linux KVM acceleration",
+      platform: "android",
+      remediation: hasKvm ? undefined : "Enable KVM and grant the current user access to /dev/kvm.",
+      status: hasKvm ? "pass" : "warn"
+    });
+  }
+  if (host !== "macos") {
+    checks.push({
+      id: "ios.simulator",
+      label: "iOS Simulator requires macOS and Xcode",
+      platform: "ios",
+      status: "skip"
+    });
+    return checks;
+  }
+  const xcrun = await findExecutable("xcrun", [], { exists, which }, host);
+  const xcodebuild = await findExecutable("xcodebuild", [], { exists, which }, host);
+  checks.push(toolCheck("ios.xcrun", "Xcode command runner", "ios", xcrun, "Install Xcode and select it with xcode-select."), toolCheck("ios.xcodebuild", "Xcode build system", "ios", xcodebuild, "Install Xcode and select it with xcode-select."));
+  if (xcrun) {
+    const runtimes = capture([
+      xcrun,
+      "simctl",
+      "list",
+      "runtimes",
+      "--json"
+    ]);
+    const hasRuntime = runtimes.exitCode === 0 && hasAvailableIosRuntime(runtimes.stdout);
+    checks.push({
+      id: "ios.runtime",
+      label: "iOS Simulator runtime",
+      platform: "ios",
+      remediation: hasRuntime ? undefined : "Run absolute mobile doctor ios --fix to download an iOS Simulator runtime.",
+      status: hasRuntime ? "pass" : "fail"
+    });
+  }
+  return checks;
+};
 
 // src/mobile/androidEmulatorController.ts
 import {
-  access as access2,
+  access as access3,
   copyFile,
   lstat,
   mkdir as mkdir2,
@@ -714,7 +1337,7 @@ import {
 } from "path";
 
 // src/mobile/capacitorProject.ts
-import { access, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { access as access2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
 import { relative, resolve } from "path";
 var CONFIG_FILE = "capacitor.config.ts";
 var portableRelative = (root, path) => relative(root, path).replaceAll("\\", "/");
@@ -736,7 +1359,7 @@ export default config;
 `;
 var exists = async (path) => {
   try {
-    await access(path);
+    await access2(path);
     return true;
   } catch {
     return false;
@@ -766,9 +1389,9 @@ var HASH_RADIX = 16;
 var EXECUTABLE_MODE_MASK = 73;
 var NATIVE_PUBLIC_PATH_SEGMENTS = 5;
 var CAPACITOR_PROJECT_DIRECTORY_PATTERN = /project\(['"](:[^'"]+)['"]\)\.projectDir\s*=\s*new File\(['"]([^'"]+)['"]\)/gu;
-var pathExists = async (path) => {
+var pathExists2 = async (path) => {
   try {
-    await access2(path);
+    await access3(path);
     return true;
   } catch {
     return false;
@@ -795,7 +1418,7 @@ var runCommand = async (command, options = {}) => {
   ]);
   return exitCode;
 };
-var captureCommand = (command, options = {}) => {
+var captureCommand2 = (command, options = {}) => {
   try {
     const result = Bun.spawnSync(command, {
       cwd: options.cwd,
@@ -881,11 +1504,11 @@ var hashNativeTree = async (root, label, ignorePublicBundle) => {
   const records = await collectNativeDirectory(resolvedRoot, label, resolvedRoot, ignorePublicBundle);
   return createHash3("sha256").update(records.join("")).digest("hex");
 };
-var fingerprintAbsoluteAndroidNativeProject = async (project) => {
+var fingerprintAbsoluteAndroidNativeProject = async (project, options = {}) => {
   const { dependencies } = await nativeDependencySources(project.nativeDirectory);
   const roots = [
     {
-      ignorePublicBundle: true,
+      ignorePublicBundle: options.includePublicBundle !== true,
       label: "android",
       source: project.nativeDirectory
     },
@@ -965,14 +1588,14 @@ var gradleArtifactPath = (nativeDirectory, task, windows = false) => {
 };
 var resolveGradleArtifactPath = async (nativeDirectory, task) => {
   const primary = gradleArtifactPath(nativeDirectory, task);
-  if (task !== "assembleRelease" || await pathExists(primary)) {
+  if (task !== "assembleRelease" || await pathExists2(primary)) {
     return primary;
   }
   return join3(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk");
 };
 var buildAbsoluteAndroidGradleArtifact = async (options) => {
   const { project, task } = options;
-  const capture = options.capture ?? captureCommand;
+  const capture = options.capture ?? captureCommand2;
   const run = options.run ?? runCommand;
   const env = options.env ?? process.env;
   const gradleArguments = options.gradleArguments ?? [];
@@ -1015,9 +1638,9 @@ var requireManifest = (value) => {
     runtime: value.runtime
   };
 };
-var pathExists2 = async (path) => {
+var pathExists3 = async (path) => {
   try {
-    await access3(path);
+    await access4(path);
     return true;
   } catch {
     return false;
@@ -1072,7 +1695,7 @@ var installRelease = async (artifactPath, metadata, outputRoot) => {
   const releaseRoot = join4(outputRoot, metadata.releaseId);
   const artifactName = "app-release.aab";
   const destination = join4(releaseRoot, artifactName);
-  if (await pathExists2(releaseRoot)) {
+  if (await pathExists3(releaseRoot)) {
     const existing = requireManifestIdentity(JSON.parse(await readFile4(join4(releaseRoot, "release.json"), "utf8")), metadata);
     const [installedBytes, installedSha256] = await Promise.all([
       stat(destination).then(({ size }) => size),
@@ -1148,7 +1771,7 @@ var buildAbsoluteAndroidRelease = async (options) => {
     run: options.run,
     task: "bundleRelease"
   });
-  if (!await pathExists2(artifactPath)) {
+  if (!await pathExists3(artifactPath)) {
     throw new TypeError(`Android Gradle did not produce the expected App Bundle: ${artifactPath}`);
   }
   const capture = options.capture ?? defaultCapture;
@@ -1183,7 +1806,7 @@ var buildAbsoluteAndroidRelease = async (options) => {
 // src/mobile/iosRelease.ts
 import { createHash as createHash5 } from "crypto";
 import {
-  access as access4,
+  access as access5,
   copyFile as copyFile3,
   mkdir as mkdir4,
   mkdtemp as mkdtemp3,
@@ -1207,9 +1830,9 @@ var requireManifest2 = (value) => {
     runtime: value.runtime
   };
 };
-var pathExists3 = async (path) => {
+var pathExists4 = async (path) => {
   try {
-    await access4(path);
+    await access5(path);
     return true;
   } catch {
     return false;
@@ -1290,7 +1913,7 @@ var safeOutputDirectory2 = (projectRoot, requested) => {
 };
 var sha256File2 = async (path) => createHash5("sha256").update(await readFile5(path)).digest("hex");
 var findByExtension = async (root, extension) => {
-  if (!await pathExists3(root))
+  if (!await pathExists4(root))
     return;
   const entries = await readdir3(root, { withFileTypes: true });
   const matches = await Promise.all(entries.map(async (entry) => {
@@ -1322,7 +1945,7 @@ var requireBuildNumber = (value) => {
 var installRelease2 = async (artifactPath, metadata, outputRoot) => {
   const releaseRoot = join5(outputRoot, metadata.releaseId);
   const destination = join5(releaseRoot, "App.ipa");
-  if (await pathExists3(releaseRoot)) {
+  if (await pathExists4(releaseRoot)) {
     const value = JSON.parse(await readFile5(join5(releaseRoot, "release.json"), "utf8"));
     if (!isRecord2(value) || value.artifact !== "App.ipa" || Object.entries(metadata).some(([key, expected]) => Reflect.get(value, key) !== expected)) {
       throw new TypeError(`Immutable iOS release ${metadata.releaseId} does not match its content.`);
@@ -1459,30 +2082,1502 @@ var buildAbsoluteIosRelease = async (options) => {
     await rm4(staging, { force: true, recursive: true }).catch(() => {
       return;
     });
-  }
+  }
+};
+// src/mobile/iosConformance.ts
+import { readFile as readFile6, stat as stat3 } from "fs/promises";
+var HMR_LINE = new RegExp(String.raw`\[hmr:ios\]\s+([^\n]*?)\s+(applied in|falling back to reload after|failed after)\s+(\d+)ms(?:; server\s+(\d+)ms, client\s+(\d+)ms)?`, "u");
+var parseAbsoluteIosHmrLog = (line) => {
+  const match = HMR_LINE.exec(line);
+  if (!match)
+    return null;
+  const [, , action, durationValue, serverValue, clientValue] = match;
+  let outcome = "reloaded";
+  if (action === "applied in")
+    outcome = "applied";
+  if (action === "failed after")
+    outcome = "failed";
+  const serverMs = serverValue === undefined ? undefined : Number(serverValue);
+  const clientMs = clientValue === undefined ? undefined : Number(clientValue);
+  return {
+    ...clientMs === undefined ? {} : { clientMs },
+    duration: Number(durationValue),
+    line: match[0],
+    outcome,
+    ...serverMs === undefined ? {} : { serverMs }
+  };
+};
+var findHmrApply = (lines) => {
+  const apply = lines.map((line) => parseAbsoluteIosHmrLog(line)).find((candidate) => candidate !== null);
+  if (apply?.outcome === "failed")
+    throw new Error(`iOS HMR client reported a failed apply: ${apply.line}`);
+  return apply;
+};
+var waitForAbsoluteIosHmrLog = async (options) => {
+  const sleep = options.sleep ?? Bun.sleep;
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const deadline = Date.now() + timeoutMs;
+  let offset = options.startOffset ?? await stat3(options.logPath).then(({ size }) => size).catch(() => 0);
+  let buffered = "";
+  const poll = async () => {
+    if (Date.now() > deadline)
+      throw new Error(`No iOS native HMR acknowledgement was observed within ${timeoutMs}ms.`);
+    options.signal?.throwIfAborted();
+    const contents = await readFile6(options.logPath).catch(() => Buffer.alloc(0));
+    if (contents.byteLength < offset) {
+      offset = 0;
+      buffered = "";
+    }
+    if (contents.byteLength > offset) {
+      buffered += contents.subarray(offset).toString("utf8");
+      offset = contents.byteLength;
+      const lines = buffered.split(/\r?\n/u);
+      buffered = lines.pop() ?? "";
+      const apply = findHmrApply(lines);
+      if (apply)
+        return apply;
+    }
+    await sleep(100);
+    return poll();
+  };
+  return poll();
+};
+// src/mobile/iosSimulatorController.ts
+import { createHash as createHash6, randomUUID as randomUUID2 } from "crypto";
+import {
+  access as access6,
+  copyFile as copyFile4,
+  mkdir as mkdir5,
+  readFile as readFile7,
+  rename as rename6,
+  rm as rm5,
+  writeFile as writeFile6
+} from "fs/promises";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join6, relative as relative5, resolve as resolve5, sep as sep4 } from "path";
+init_getDurationString();
+var ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone";
+var BOOT_TIMEOUT_MS = 180000;
+var BOOT_POLL_MS = 1000;
+var DEV_JOURNAL_FORMAT = 1;
+var NATIVE_CACHE_FORMAT = 1;
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pathExists5 = async (path) => {
+  try {
+    await access6(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var throwIfAborted2 = (signal) => signal?.throwIfAborted();
+var defaultCapture3 = (command, options = {}) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      cwd: options.cwd,
+      env: options.env,
+      stderr: "pipe",
+      stdin: "ignore",
+      stdout: "pipe"
+    });
+    return {
+      exitCode: result.exitCode,
+      stderr: result.stderr.toString(),
+      stdout: result.stdout.toString()
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : String(error),
+      stdout: ""
+    };
+  }
+};
+var defaultRun2 = async (command, options = {}) => {
+  const process2 = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  return process2.exited;
+};
+var defaultSpawn = (command, options = {}) => {
+  Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+    stderr: "ignore",
+    stdin: "ignore",
+    stdout: "ignore"
+  });
+};
+var consumeLines = async (stream, onLine) => {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  const pump = async () => {
+    const { done, value } = await reader.read();
+    if (done)
+      return;
+    buffered += decoder.decode(value, { stream: true });
+    const lines = buffered.split(/\r?\n/u);
+    buffered = lines.pop() ?? "";
+    lines.forEach(onLine);
+    await pump();
+  };
+  try {
+    await pump();
+    buffered += decoder.decode();
+    if (buffered)
+      onLine(buffered);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var defaultStartNativeLogs = (command, options, onLine) => {
+  const process2 = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  consumeLines(process2.stdout, onLine);
+  consumeLines(process2.stderr, onLine);
+  return {
+    close: async () => {
+      try {
+        process2.kill();
+      } catch {}
+      await process2.exited.catch(() => {
+        return;
+      });
+    }
+  };
+};
+var requireSuccess2 = async (command, label, run, options) => {
+  const exitCode = await run(command, options);
+  if (exitCode !== 0)
+    throw new Error(`${label} failed with status ${exitCode}.`);
+};
+var requireCapturedSuccess = (result, label) => {
+  if (result.exitCode !== 0) {
+    throw new Error(`${label} failed: ${result.stderr.trim() || result.stdout.trim() || `status ${result.exitCode}`}`);
+  }
+  return result.stdout.trim();
+};
+var parseJson = (source, label) => {
+  try {
+    const parsed = JSON.parse(source);
+    if (isRecord3(parsed))
+      return parsed;
+  } catch {}
+  throw new Error(`Invalid ${label} JSON from simctl.`);
+};
+var parseIosDeviceTypes = (source) => {
+  const parsed = parseJson(source, "device type");
+  const types = parsed.devicetypes;
+  if (!Array.isArray(types))
+    return [];
+  return types.flatMap((type) => {
+    if (!isRecord3(type))
+      return [];
+    const { identifier } = type;
+    const { name } = type;
+    return typeof identifier === "string" && typeof name === "string" ? [{ identifier, name }] : [];
+  });
+};
+var parseIosRuntimes = (source) => {
+  const parsed = parseJson(source, "runtime");
+  const { runtimes } = parsed;
+  if (!Array.isArray(runtimes))
+    return [];
+  return runtimes.flatMap((runtime) => {
+    if (!isRecord3(runtime))
+      return [];
+    const { identifier } = runtime;
+    const { name } = runtime;
+    const { version } = runtime;
+    if (typeof identifier !== "string" || typeof name !== "string" || typeof version !== "string")
+      return [];
+    return [
+      {
+        identifier,
+        isAvailable: runtime.isAvailable !== false,
+        name,
+        version
+      }
+    ];
+  });
+};
+var parseIosSimulators = (source) => {
+  const parsed = parseJson(source, "device");
+  const { devices } = parsed;
+  if (!isRecord3(devices))
+    return [];
+  return Object.entries(devices).flatMap(([runtime, values]) => {
+    if (!Array.isArray(values))
+      return [];
+    return values.flatMap((device) => {
+      if (!isRecord3(device))
+        return [];
+      const { name } = device;
+      const { state } = device;
+      const { udid } = device;
+      if (typeof name !== "string" || typeof state !== "string" || typeof udid !== "string")
+        return [];
+      return [
+        {
+          isAvailable: device.isAvailable !== false,
+          name,
+          runtime,
+          state,
+          udid
+        }
+      ];
+    });
+  });
+};
+var versionParts = (version) => version.split(".").map((part) => Number(part));
+var compareVersions = (left, right) => {
+  const leftParts = versionParts(left);
+  const rightParts = versionParts(right);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0;index < length; index++) {
+    const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (difference !== 0)
+      return difference;
+  }
+  return 0;
+};
+var latestIosRuntime = (runtimes) => runtimes.filter((runtime) => runtime.isAvailable && runtime.identifier.includes("SimRuntime.iOS-")).sort((left, right) => compareVersions(right.version, left.version))[0];
+var iphoneGeneration = (name) => Number(/iPhone\s+(\d+)/u.exec(name)?.[1] ?? 0);
+var preferredIphoneType = (types) => types.filter((type) => type.name.startsWith("iPhone")).sort((left, right) => {
+  const generation = iphoneGeneration(right.name) - iphoneGeneration(left.name);
+  if (generation !== 0)
+    return generation;
+  const rightPro = right.name.includes("Pro") ? 1 : 0;
+  const leftPro = left.name.includes("Pro") ? 1 : 0;
+  return rightPro - leftPro;
+})[0];
+var journalPaths = (projectRoot) => {
+  const root = join6(projectRoot, ".absolutejs", "mobile", "ios-dev-session");
+  return {
+    configBackup: join6(root, "capacitor-config.backup"),
+    infoBackup: join6(root, "Info.plist.backup"),
+    journal: join6(root, "journal.json"),
+    root
+  };
+};
+var nativeCachePath = (projectRoot) => join6(projectRoot, ".absolutejs", "mobile", "ios-native-cache.json");
+var isInside = (root, path) => {
+  const value = relative5(resolve5(root), resolve5(path));
+  return value === "" || !value.startsWith(`..${sep4}`) && value !== ".." && !isAbsolute4(value);
+};
+var parseJournal = (value) => {
+  if (!isRecord3(value) || value.format !== DEV_JOURNAL_FORMAT)
+    return null;
+  const { configBackupPath } = value;
+  const { infoBackupPath } = value;
+  const { infoPath } = value;
+  const { nativeConfigPath } = value;
+  if (typeof configBackupPath !== "string" || typeof infoBackupPath !== "string" || typeof infoPath !== "string" || typeof nativeConfigPath !== "string")
+    return null;
+  return {
+    configBackupPath,
+    format: DEV_JOURNAL_FORMAT,
+    infoBackupPath,
+    infoPath,
+    nativeConfigPath
+  };
+};
+var repairAbsoluteIosDevSession = async (projectRoot) => {
+  const paths = journalPaths(projectRoot);
+  if (!await pathExists5(paths.journal)) {
+    await rm5(paths.root, { force: true, recursive: true });
+    return false;
+  }
+  const journal = await readFile7(paths.journal, "utf8").then((source) => parseJournal(JSON.parse(source))).catch(() => null);
+  if (!journal || !isInside(projectRoot, journal.nativeConfigPath) || !isInside(projectRoot, journal.infoPath) || !isInside(paths.root, journal.configBackupPath) || !isInside(paths.root, journal.infoBackupPath)) {
+    throw new Error(`Refusing unsafe or invalid iOS dev journal at ${paths.journal}.`);
+  }
+  if (await pathExists5(journal.configBackupPath))
+    await copyFile4(journal.configBackupPath, journal.nativeConfigPath);
+  if (await pathExists5(journal.infoBackupPath))
+    await copyFile4(journal.infoBackupPath, journal.infoPath);
+  await rm5(paths.root, { force: true, recursive: true });
+  return true;
+};
+var iosDevelopmentInfoPlist = (source, cleartext) => {
+  if (!cleartext)
+    return source;
+  const arbitraryLoads = /(<key>NSAllowsArbitraryLoads<\/key>\s*)<false\s*\/>/u;
+  if (arbitraryLoads.test(source))
+    return source.replace(arbitraryLoads, "$1<true/>");
+  if (/<key>NSAllowsArbitraryLoads<\/key>\s*<true\s*\/>/u.test(source))
+    return source;
+  const transport = /(<key>NSAppTransportSecurity<\/key>\s*<dict>)/u;
+  if (transport.test(source))
+    return source.replace(transport, `$1
+		<key>NSAllowsArbitraryLoads</key>
+		<true/>`);
+  return source.replace(/<dict>/u, `<dict>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsArbitraryLoads</key>
+		<true/>
+	</dict>`);
+};
+var writeDevProjection = async (project, port, https) => {
+  const paths = journalPaths(project.projectRoot);
+  await repairAbsoluteIosDevSession(project.projectRoot);
+  const nativeConfigPath = join6(project.nativeDirectory, "App", "App", "capacitor.config.json");
+  const infoPath = join6(project.nativeDirectory, "App", "App", "Info.plist");
+  const [configSource, infoSource] = await Promise.all([
+    readFile7(nativeConfigPath, "utf8"),
+    readFile7(infoPath, "utf8")
+  ]);
+  const parsed = JSON.parse(configSource);
+  if (!isRecord3(parsed))
+    throw new Error(`Invalid Capacitor native config at ${nativeConfigPath}.`);
+  await mkdir5(paths.root, { recursive: true });
+  await Promise.all([
+    writeFile6(paths.configBackup, configSource, { flag: "wx" }),
+    writeFile6(paths.infoBackup, infoSource, { flag: "wx" })
+  ]);
+  const journal = {
+    configBackupPath: paths.configBackup,
+    format: DEV_JOURNAL_FORMAT,
+    infoBackupPath: paths.infoBackup,
+    infoPath,
+    nativeConfigPath
+  };
+  await writeFile6(paths.journal, `${JSON.stringify(journal, null, "\t")}
+`, {
+    flag: "wx"
+  });
+  const developmentUrl = new URL(`${https ? "https" : "http"}://localhost:${port}${project.config.entry}`);
+  developmentUrl.searchParams.set("__absolute_target", "capacitor-ios");
+  const existingServer = parsed.server;
+  parsed.server = {
+    ...isRecord3(existingServer) ? existingServer : {},
+    cleartext: !https,
+    url: developmentUrl.href
+  };
+  await Promise.all([
+    writeFile6(nativeConfigPath, `${JSON.stringify(parsed, null, "\t")}
+`),
+    writeFile6(infoPath, iosDevelopmentInfoPlist(infoSource, !https))
+  ]);
+};
+var parseNativeCache = (value) => {
+  if (!isRecord3(value))
+    return null;
+  const { appId, fingerprint, format, installations } = value;
+  if (format !== NATIVE_CACHE_FORMAT || typeof appId !== "string" || typeof fingerprint !== "string" || !isRecord3(installations) || !Object.values(installations).every((identity) => typeof identity === "string"))
+    return null;
+  return {
+    appId,
+    fingerprint,
+    format,
+    installations: Object.fromEntries(Object.entries(installations).map(([udid, identity]) => [
+      udid,
+      String(identity)
+    ]))
+  };
+};
+var readNativeCache = (projectRoot) => readFile7(nativeCachePath(projectRoot), "utf8").then((source) => parseNativeCache(JSON.parse(source))).catch(() => null);
+var writeNativeCache = async (projectRoot, cache) => {
+  const destination = nativeCachePath(projectRoot);
+  const temporary = `${destination}.${process.pid}.${randomUUID2()}.tmp`;
+  await mkdir5(dirname4(destination), { recursive: true });
+  try {
+    await writeFile6(temporary, `${JSON.stringify(cache, null, "\t")}
+`, {
+      flag: "wx"
+    });
+    await rename6(temporary, destination);
+  } finally {
+    await rm5(temporary, { force: true }).catch(() => {
+      return;
+    });
+  }
+};
+var fingerprintAbsoluteIosDevProject = async (project) => fingerprintAbsoluteIosNativeProject(project.nativeDirectory);
+var simulatorInventory = (xcrun, capture) => {
+  const result = capture([
+    xcrun,
+    "simctl",
+    "list",
+    "devices",
+    "available",
+    "-j"
+  ]);
+  return parseIosSimulators(requireCapturedSuccess(result, "iOS simulator discovery"));
+};
+var ensureManagedSimulator = async (project, capture) => {
+  const runtimes = parseIosRuntimes(requireCapturedSuccess(capture([project.xcrun, "simctl", "list", "runtimes", "-j"]), "iOS runtime discovery"));
+  const runtime = latestIosRuntime(runtimes);
+  if (!runtime)
+    throw new Error("No available iOS Simulator runtime. Run absolute mobile doctor ios --fix.");
+  const [existing] = simulatorInventory(project.xcrun, capture).filter((device) => device.isAvailable && device.name === ABSOLUTE_IOS_SIMULATOR_NAME && device.runtime === runtime.identifier).sort((left, right) => Number(right.state === "Booted") - Number(left.state === "Booted"));
+  if (existing)
+    return { created: false, device: existing };
+  const types = parseIosDeviceTypes(requireCapturedSuccess(capture([project.xcrun, "simctl", "list", "devicetypes", "-j"]), "iOS device-type discovery"));
+  const type = preferredIphoneType(types);
+  if (!type)
+    throw new Error("Xcode did not report an iPhone simulator type.");
+  const [udid] = requireCapturedSuccess(capture([
+    project.xcrun,
+    "simctl",
+    "create",
+    ABSOLUTE_IOS_SIMULATOR_NAME,
+    type.identifier,
+    runtime.identifier
+  ]), "iOS simulator creation").split(/\s/u);
+  if (!udid)
+    throw new Error("simctl did not return the created simulator UDID.");
+  return {
+    created: true,
+    device: {
+      isAvailable: true,
+      name: ABSOLUTE_IOS_SIMULATOR_NAME,
+      runtime: runtime.identifier,
+      state: "Shutdown",
+      udid
+    }
+  };
+};
+var waitForBootedSimulator = async (project, udid, capture, sleep, signal) => {
+  const deadline = Date.now() + BOOT_TIMEOUT_MS;
+  const poll = async () => {
+    throwIfAborted2(signal);
+    const device = simulatorInventory(project.xcrun, capture).find((candidate) => candidate.udid === udid);
+    if (device?.state === "Booted")
+      return;
+    if (Date.now() > deadline)
+      throw new Error(`iOS simulator ${udid} did not finish booting within ${BOOT_TIMEOUT_MS / 1000}s.`);
+    await sleep(BOOT_POLL_MS);
+    await poll();
+  };
+  return poll();
+};
+var bootSimulator = (project, device, capture) => {
+  if (device.state === "Booted")
+    return;
+  requireCapturedSuccess(capture([project.xcrun, "simctl", "boot", device.udid]), "iOS simulator boot");
+};
+var installedAppIdentity = (project, udid, capture) => {
+  const result = capture([
+    project.xcrun,
+    "simctl",
+    "get_app_container",
+    udid,
+    project.config.appId,
+    "app"
+  ]);
+  return result.exitCode === 0 && result.stdout.trim() ? result.stdout.trim() : undefined;
+};
+var buildIosDebugApp = async (project, udid, fingerprint, run, signal) => {
+  const derivedDataPath = join6(project.projectRoot, ".absolutejs", "mobile", "ios-derived-data", createHash6("sha256").update(project.config.appId).digest("hex").slice(0, 16));
+  await mkdir5(derivedDataPath, { recursive: true });
+  await requireSuccess2([
+    project.xcodebuild,
+    "-workspace",
+    join6(project.nativeDirectory, "App", "App.xcworkspace"),
+    "-scheme",
+    "App",
+    "-configuration",
+    "Debug",
+    "-destination",
+    `platform=iOS Simulator,id=${udid}`,
+    "-derivedDataPath",
+    derivedDataPath,
+    "build"
+  ], "iOS simulator build", run, { cwd: project.nativeDirectory, signal });
+  const appPath = join6(derivedDataPath, "Build", "Products", "Debug-iphonesimulator", "App.app");
+  if (!await pathExists5(appPath))
+    throw new Error(`Xcode did not produce the simulator app at ${appPath}.`);
+  return appPath;
+};
+var ensureIosDebugApp = async (options) => {
+  const installed = installedAppIdentity(options.project, options.udid, options.capture);
+  const cacheHit = options.cache?.appId === options.project.config.appId && options.cache.fingerprint === options.fingerprint && installed !== undefined && options.cache.installations[options.udid] === installed;
+  if (cacheHit) {
+    options.log(`iOS native app is unchanged on ${options.udid}; skipped Xcode build and install.`);
+    return true;
+  }
+  options.log("iOS native inputs changed or the installed app is stale; rebuilding.");
+  options.transition("building");
+  const appPath = await buildIosDebugApp(options.project, options.udid, options.fingerprint, options.run, options.signal);
+  throwIfAborted2(options.signal);
+  options.transition("installing");
+  await requireSuccess2([options.project.xcrun, "simctl", "install", options.udid, appPath], "iOS simulator app installation", options.run, { signal: options.signal });
+  const updated = installedAppIdentity(options.project, options.udid, options.capture);
+  if (updated) {
+    await writeNativeCache(options.project.projectRoot, {
+      appId: options.project.config.appId,
+      fingerprint: options.fingerprint,
+      format: NATIVE_CACHE_FORMAT,
+      installations: { [options.udid]: updated }
+    }).catch((error) => options.log(`iOS native cache could not be saved: ${error instanceof Error ? error.message : String(error)}`));
+  }
+  return false;
+};
+var SECRET_VALUE = /((?:authorization|cookie|password|secret|token|oauth[_-]?code)\s*[:=]\s*)([^\s,;]+)/giu;
+var BEARER_VALUE = new RegExp(String.raw`\bBearer\s+[A-Za-z0-9._~+/-]+=*`, "giu");
+var JWT_VALUE = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu;
+var IOS_LOG_PATTERN = new RegExp(String.raw`\s(Debug|Info|Notice|Error|Fault)\s+.*?\[[^\]]+\]\s+\[([^\]]+)\]\s*(.*)$`, "iu");
+var parseAbsoluteIosLogLine = (line) => {
+  const sanitized = redactAbsoluteIosLog(line).trim();
+  if (!sanitized)
+    return null;
+  const match = IOS_LOG_PATTERN.exec(sanitized);
+  const candidate = match?.[1]?.toLowerCase();
+  const level = candidate === "debug" || candidate === "error" || candidate === "fault" || candidate === "notice" ? candidate : "info";
+  return {
+    level,
+    message: match?.[3]?.trim() || sanitized,
+    tag: match?.[2]?.trim() || "App"
+  };
+};
+var redactAbsoluteIosLog = (value) => value.replaceAll(BEARER_VALUE, "Bearer [REDACTED]").replaceAll(JWT_VALUE, "[REDACTED_JWT]").replaceAll(SECRET_VALUE, "$1[REDACTED]").replaceAll(/\p{C}/gu, "");
+var attachNativeLogs = (project, udid, options) => {
+  if (!options.nativeLog)
+    return null;
+  const start = options.startNativeLogs ?? defaultStartNativeLogs;
+  return start([
+    project.xcrun,
+    "simctl",
+    "spawn",
+    udid,
+    "log",
+    "stream",
+    "--style",
+    "compact",
+    "--level",
+    "debug",
+    "--predicate",
+    'process == "App"'
+  ], { signal: options.signal }, (line) => {
+    const entry = parseAbsoluteIosLogLine(line);
+    if (entry)
+      options.nativeLog?.(entry);
+  });
+};
+var IOS_TIMING_PHASES = [
+  ["syncing", "Capacitor sync"],
+  ["configuring", "dev config"],
+  ["fingerprinting", "fingerprint"],
+  ["booting", "simulator"],
+  ["connecting", "device ready"],
+  ["checking-native", "app check"],
+  ["building", "Xcode"],
+  ["installing", "install"],
+  ["launching", "launch"],
+  ["streaming-logs", "logs"]
+];
+var timingSummary = (timings) => IOS_TIMING_PHASES.map(([phase, label]) => {
+  const duration = timings[phase];
+  return duration === undefined ? null : `${label} ${getDurationString(duration)}`;
+}).filter((value) => value !== null).join(", ");
+var prepareAbsoluteIosDevProject = async (config, options) => {
+  if (detectAbsoluteMobileHost() !== "macos")
+    throw new Error("iOS simulation requires macOS and Xcode.");
+  const projectRoot = resolve5(options.projectRoot);
+  const checks = await inspectAbsoluteMobileToolchain({ host: "macos" });
+  const failed = checks.filter((check) => check.platform === "ios" && (check.status === "fail" || check.status === "warn"));
+  if (failed.length > 0)
+    throw new Error(`iOS simulation is not ready: ${failed.map(({ label }) => label).join(", ")}.`);
+  const xcrun = checks.find((check) => check.id === "ios.xcrun")?.path;
+  const xcodebuild = checks.find((check) => check.id === "ios.xcodebuild")?.path;
+  if (!xcrun || !xcodebuild)
+    throw new Error("Xcode tools disappeared after readiness checks.");
+  const cap = join6(projectRoot, "node_modules", ".bin", "cap");
+  if (!await pathExists5(cap))
+    throw new Error("Capacitor CLI is not installed. Run absolute mobile init first.");
+  await writeAbsoluteCapacitorConfig(config, { projectRoot });
+  await mkdir5(config.bundleDirectory, { recursive: true });
+  const placeholder = join6(config.bundleDirectory, "index.html");
+  if (!await pathExists5(placeholder))
+    await writeFile6(placeholder, `<!doctype html><title>AbsoluteJS mobile development</title>
+`);
+  const nativeDirectory = join6(config.nativeProjectDirectory, "ios");
+  if (!await pathExists5(nativeDirectory)) {
+    if (!options.createNativeProject)
+      throw new Error("iOS native project has not been created.");
+    const run = options.run ?? defaultRun2;
+    if (await run([cap, "add", "ios"], { cwd: projectRoot }) !== 0)
+      throw new Error("Capacitor iOS project creation failed.");
+  }
+  return {
+    cap,
+    config,
+    nativeDirectory,
+    projectRoot,
+    xcodebuild,
+    xcrun
+  };
+};
+var startAbsoluteIosDevSession = async (options) => {
+  const { project } = options;
+  const capture = options.capture ?? defaultCapture3;
+  const run = options.run ?? defaultRun2;
+  const sleep = options.sleep ?? Bun.sleep;
+  const spawn = options.spawn ?? defaultSpawn;
+  const log = options.log ?? console.log;
+  const startedAt = performance.now();
+  let phaseStartedAt = performance.now();
+  const timings = {};
+  let state = "syncing";
+  const transition = (next) => {
+    if (next === state) {
+      options.onStateChange?.(next);
+      return;
+    }
+    const now = performance.now();
+    const durationMs = now - phaseStartedAt;
+    timings[state] = (timings[state] ?? 0) + durationMs;
+    options.onPhaseTiming?.({
+      durationMs,
+      phase: state,
+      totalMs: now - startedAt
+    });
+    state = next;
+    phaseStartedAt = now;
+    options.onStateChange?.(next);
+  };
+  let nativeLogs = null;
+  const closeLogs = async () => {
+    const stream = nativeLogs;
+    nativeLogs = null;
+    await stream?.close().catch(() => {
+      return;
+    });
+  };
+  try {
+    await repairAbsoluteIosDevSession(project.projectRoot);
+    throwIfAborted2(options.signal);
+    transition("syncing");
+    await requireSuccess2([project.cap, "sync", "ios"], "Capacitor iOS synchronization", run, { cwd: project.projectRoot, signal: options.signal });
+    transition("configuring");
+    await writeDevProjection(project, options.port, options.https === true);
+    throwIfAborted2(options.signal);
+    const fingerprintStartedAt = performance.now();
+    const fingerprintPromise = fingerprintAbsoluteIosDevProject(project).then((fingerprint2) => {
+      timings.fingerprinting = performance.now() - fingerprintStartedAt;
+      return fingerprint2;
+    });
+    transition("booting");
+    const { created, device } = await ensureManagedSimulator(project, capture);
+    const startedSimulator = created || device.state !== "Booted";
+    bootSimulator(project, device, capture);
+    spawn([
+      "open",
+      "-a",
+      "Simulator",
+      "--args",
+      "-CurrentDeviceUDID",
+      device.udid
+    ]);
+    transition("connecting");
+    await waitForBootedSimulator(project, device.udid, capture, sleep, options.signal);
+    await requireSuccess2([project.xcrun, "simctl", "bootstatus", device.udid, "-b"], "iOS simulator boot readiness", run, { signal: options.signal });
+    const fingerprint = await fingerprintPromise;
+    transition("checking-native");
+    const nativeCacheHit = await ensureIosDebugApp({
+      cache: await readNativeCache(project.projectRoot),
+      capture,
+      fingerprint,
+      log,
+      project,
+      run,
+      signal: options.signal,
+      transition,
+      udid: device.udid
+    });
+    throwIfAborted2(options.signal);
+    if (options.nativeLog)
+      transition("streaming-logs");
+    nativeLogs = attachNativeLogs(project, device.udid, options);
+    transition("launching");
+    await requireSuccess2([
+      project.xcrun,
+      "simctl",
+      "launch",
+      "--terminate-running-process",
+      device.udid,
+      project.config.appId
+    ], "iOS app launch", run, { signal: options.signal });
+    transition("ready");
+    timings.total = performance.now() - startedAt;
+    log(`iOS simulator connected (${device.udid}) with HMR on port ${options.port} in ${getDurationString(timings.total)} (${nativeCacheHit ? "native cache hit" : "native build installed"}).`);
+    log(`iOS startup: ${timingSummary(timings)}.`);
+    let closed = false;
+    const close = async () => {
+      if (closed)
+        return;
+      closed = true;
+      transition("closing");
+      await closeLogs();
+      await repairAbsoluteIosDevSession(project.projectRoot);
+      transition("closed");
+    };
+    return {
+      close,
+      nativeCacheHit,
+      startedSimulator,
+      timings: { ...timings },
+      udid: device.udid,
+      rebuild: async () => {
+        if (closed)
+          throw new Error("iOS development session is closed.");
+        log("iOS native inputs changed; rebuilding without restarting the dev server.");
+        await close();
+        return startAbsoluteIosDevSession(options);
+      },
+      relaunch: async () => {
+        if (closed)
+          throw new Error("iOS development session is closed.");
+        transition("launching");
+        try {
+          await requireSuccess2([
+            project.xcrun,
+            "simctl",
+            "launch",
+            "--terminate-running-process",
+            device.udid,
+            project.config.appId
+          ], "iOS app relaunch", run, { signal: options.signal });
+          transition("ready");
+          log(`iOS app relaunched on ${device.udid}.`);
+        } catch (error) {
+          transition("failed");
+          throw error;
+        }
+      },
+      screenshot: async (destination) => {
+        const resolved = resolve5(project.projectRoot, destination);
+        if (!isInside(project.projectRoot, resolved))
+          throw new Error("iOS screenshot destination must remain inside the project.");
+        await mkdir5(dirname4(resolved), { recursive: true });
+        await requireSuccess2([
+          project.xcrun,
+          "simctl",
+          "io",
+          device.udid,
+          "screenshot",
+          resolved
+        ], "iOS simulator screenshot", run, { signal: options.signal });
+        return resolved;
+      },
+      get state() {
+        return state;
+      }
+    };
+  } catch (error) {
+    transition("failed");
+    await closeLogs();
+    await repairAbsoluteIosDevSession(project.projectRoot);
+    throw error;
+  }
+};
+// src/mobile/iosNativeWatcher.ts
+import { watch } from "fs";
+import { basename } from "path";
+var NATIVE_CHANGE_DEBOUNCE_MS = 500;
+var ROOT_NATIVE_INPUTS = new Set([
+  "absolute.config.js",
+  "absolute.config.mjs",
+  "absolute.config.ts",
+  "absolutejs.config.js",
+  "absolutejs.config.mjs",
+  "absolutejs.config.ts",
+  "bun.lock",
+  "bun.lockb",
+  "capacitor.config.js",
+  "capacitor.config.ts",
+  "package.json"
+]);
+var createAbsoluteIosNativeWatcher = async (options) => {
+  let fingerprint = await fingerprintAbsoluteIosDevProject(options.project);
+  let closed = false;
+  let running = false;
+  let timer;
+  let rootInputChanged = false;
+  const changedPaths = new Set;
+  const watchers = [];
+  const debounceMs = options.debounceMs ?? NATIVE_CHANGE_DEBOUNCE_MS;
+  const close = () => {
+    if (closed)
+      return;
+    closed = true;
+    if (timer)
+      clearTimeout(timer);
+    watchers.forEach((watcher) => watcher.close());
+    options.signal?.removeEventListener("abort", close);
+  };
+  const schedule = () => {
+    if (closed || running)
+      return;
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(() => void flush(), debounceMs);
+  };
+  const flush = async () => {
+    timer = undefined;
+    if (closed || running || changedPaths.size === 0)
+      return;
+    running = true;
+    const paths = [...changedPaths].sort();
+    const forced = rootInputChanged;
+    changedPaths.clear();
+    rootInputChanged = false;
+    try {
+      const next = await fingerprintAbsoluteIosDevProject(options.project);
+      if (!forced && next === fingerprint)
+        return;
+      await options.onChange({
+        afterFingerprint: next,
+        beforeFingerprint: fingerprint,
+        paths,
+        rootInputChanged: forced
+      });
+      fingerprint = await fingerprintAbsoluteIosDevProject(options.project);
+    } catch (error) {
+      options.onError?.(error);
+    } finally {
+      running = false;
+      if (changedPaths.size > 0)
+        schedule();
+    }
+  };
+  const record = (path, force) => {
+    if (closed)
+      return;
+    changedPaths.add(path);
+    rootInputChanged ||= force;
+    schedule();
+  };
+  watchers.push(watch(options.project.nativeDirectory, { recursive: true }, (_event, filename) => {
+    if (filename)
+      record(String(filename), false);
+  }));
+  watchers.push(watch(options.project.projectRoot, (_event, filename) => {
+    if (!filename)
+      return;
+    const path = String(filename);
+    if (isAbsoluteIosNativeRootInput(path))
+      record(path, true);
+  }));
+  watchers.forEach((watcher) => watcher.on("error", (error) => options.onError?.(error)));
+  options.signal?.addEventListener("abort", close, { once: true });
+  return { close };
+};
+var isAbsoluteIosNativeRootInput = (path) => ROOT_NATIVE_INPUTS.has(basename(path));
+// src/mobile/remoteMacProtocol.ts
+import { createHash as createHash7, randomUUID as randomUUID3 } from "crypto";
+import { chmod, mkdir as mkdir6, readFile as readFile8, rename as rename7, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import {
+  dirname as dirname5,
+  isAbsolute as isAbsolute5,
+  join as join7,
+  posix,
+  relative as relative6,
+  resolve as resolvePath2,
+  sep as sep5
+} from "path";
+
+// src/mobile/remoteMacWire.ts
+var ABSOLUTE_REMOTE_MAC_EVENT_PREFIX = "ABSOLUTE_REMOTE_MAC\t";
+var ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION = 1;
+
+// src/mobile/remoteMacProtocol.ts
+var PROFILE_FORMAT = 1;
+var REMOTE_STDIN_FLUSH_ATTEMPTS = 3;
+var PROFILE_NAME = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/u;
+var SSH_DESTINATION = /^(?:[A-Za-z0-9._-]+@)?[A-Za-z0-9._:-]+$/u;
+var defaultProfilePath = () => join7(homedir2(), ".absolutejs", "mobile", "remote-macs.json");
+var emptyStore = () => ({
+  format: PROFILE_FORMAT,
+  profiles: {}
+});
+var loadStore = async (path = defaultProfilePath()) => {
+  try {
+    const parsed = JSON.parse(await readFile8(path, "utf8"));
+    if (parsed.format !== PROFILE_FORMAT || typeof parsed.profiles !== "object" || parsed.profiles === null || Array.isArray(parsed.profiles))
+      throw new Error("Unsupported remote Mac profile format.");
+    for (const [key, profile] of Object.entries(parsed.profiles)) {
+      if (typeof profile !== "object" || profile === null || validateAbsoluteRemoteMacProfileName(key) !== key || profile.name !== key || validateAbsoluteSshDestination(profile.destination) !== profile.destination || validatePort(profile.port) !== profile.port || typeof profile.createdAt !== "string" || !profile.createdAt || typeof profile.bunPath !== "string" || !profile.bunPath.startsWith("/") || /[\r\n\0]/u.test(profile.bunPath) || typeof profile.workspaceRoot !== "string" || !profile.workspaceRoot.startsWith("/") || profile.workspaceRoot === "/" || /[\r\n\0]/u.test(profile.workspaceRoot) || typeof profile.xcodeVersion !== "string" || !profile.xcodeVersion.startsWith("Xcode "))
+        throw new Error(`Remote Mac profile ${JSON.stringify(key)} is invalid.`);
+    }
+    if (parsed.defaultProfile !== undefined && !parsed.profiles[parsed.defaultProfile])
+      throw new Error("The default remote Mac profile does not exist.");
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return emptyStore();
+    throw error;
+  }
+};
+var saveStore = async (store, path = defaultProfilePath()) => {
+  await mkdir6(dirname5(path), { recursive: true });
+  const temporary = `${path}.${randomUUID3()}.tmp`;
+  await writeFile7(temporary, `${JSON.stringify(store, null, 2)}
+`, {
+    mode: 384
+  });
+  await rename7(temporary, path);
+  await chmod(path, 384);
+};
+var validateAbsoluteRemoteMacProfileName = (name) => {
+  const normalized = name.trim().toLowerCase();
+  if (!PROFILE_NAME.test(normalized))
+    throw new TypeError("Remote Mac profile names must use 1-64 lowercase letters, digits, dots, dashes, or underscores.");
+  return normalized;
+};
+var validateAbsoluteSshDestination = (destination) => {
+  const normalized = destination.trim();
+  if (!SSH_DESTINATION.test(normalized) || normalized.startsWith("-"))
+    throw new TypeError("Remote Mac SSH destination must be a host, SSH alias, or user@host without command-line options.");
+  return normalized;
+};
+var validatePort = (port) => {
+  if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
+    throw new TypeError("Remote Mac SSH port must be between 1 and 65535.");
+  return port;
+};
+var shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+var absoluteRemoteMacSshBase = (profile, options = {}) => [
+  "ssh",
+  "-o",
+  "BatchMode=yes",
+  "-o",
+  "ConnectTimeout=10",
+  "-o",
+  "ServerAliveInterval=15",
+  "-o",
+  "ServerAliveCountMax=3",
+  "-o",
+  `StrictHostKeyChecking=${options.acceptNew ? "accept-new" : "yes"}`,
+  ...profile.port ? ["-p", String(profile.port)] : [],
+  profile.destination
+];
+var localCapture = async (command) => {
+  const process2 = Bun.spawn(command, {
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    process2.exited,
+    new Response(process2.stdout).text(),
+    new Response(process2.stderr).text()
+  ]);
+  return { exitCode, stderr, stdout };
+};
+var defaultTransport = {
+  capture: localCapture,
+  spawn: (command, options) => Bun.spawn(command, {
+    signal: options.signal,
+    stderr: "pipe",
+    stdin: "pipe",
+    stdout: "pipe"
+  })
+};
+var requireRemoteSuccess = (result, label) => {
+  if (result.exitCode !== 0)
+    throw new Error(`${label} failed: ${(result.stderr || result.stdout).trim() || `status ${result.exitCode}`}`);
+  return result.stdout.trim();
+};
+var getAbsoluteRemoteMacProfile = async (name, profilePath) => {
+  const store = await loadStore(profilePath);
+  const selected = name ?? process.env.ABSOLUTE_IOS_REMOTE ?? store.defaultProfile;
+  if (!selected)
+    return;
+  const profile = store.profiles[selected];
+  if (!profile)
+    throw new Error(`Remote Mac profile ${JSON.stringify(selected)} was not found.`);
+  return profile;
+};
+var inspectAbsoluteRemoteMac = async (destination, options = {}) => {
+  const profile = {
+    destination: validateAbsoluteSshDestination(destination),
+    port: validatePort(options.port)
+  };
+  const capture = options.transport?.capture ?? defaultTransport.capture;
+  const command = [
+    ...absoluteRemoteMacSshBase(profile, {
+      acceptNew: options.acceptNew === true
+    }),
+    "/bin/sh -lc",
+    shellQuote(`bun_path="$(command -v bun || true)"; if [ -z "$bun_path" ] && [ -x "$HOME/.bun/bin/bun" ]; then bun_path="$HOME/.bun/bin/bun"; fi; printf '%s\\n' "$(uname -s)" "$HOME" "$bun_path" "$(/usr/bin/xcodebuild -version 2>/dev/null | tr '\\n' ' ' || true)"`)
+  ];
+  const lines = requireRemoteSuccess(await capture(command), "Remote Mac handshake").split(/\r?\n/u);
+  const [operatingSystem, home, bunPath, xcodeVersion] = lines;
+  if (operatingSystem !== "Darwin")
+    throw new Error("The SSH target is not a Mac.");
+  if (!home?.startsWith("/") || !bunPath?.startsWith("/"))
+    throw new Error("The remote Mac must have Bun installed and available to SSH.");
+  if (!xcodeVersion?.startsWith("Xcode "))
+    throw new Error("The remote Mac must have full Xcode installed and selected.");
+  return { bunPath, home, os: operatingSystem, xcodeVersion };
+};
+var listAbsoluteRemoteMacProfiles = async (profilePath) => {
+  const store = await loadStore(profilePath);
+  return {
+    defaultProfile: store.defaultProfile,
+    profiles: Object.values(store.profiles).sort((left, right) => left.name.localeCompare(right.name))
+  };
+};
+var pairAbsoluteRemoteMac = async (options) => {
+  const name = validateAbsoluteRemoteMacProfileName(options.name);
+  const destination = validateAbsoluteSshDestination(options.destination);
+  const port = validatePort(options.port);
+  const inspection = await inspectAbsoluteRemoteMac(destination, {
+    acceptNew: true,
+    port,
+    transport: options.transport
+  });
+  const workspaceRoot = options.workspaceRoot ? options.workspaceRoot.trim() : posix.join(inspection.home, ".absolutejs", "remote-ios");
+  if (!workspaceRoot.startsWith("/") || workspaceRoot === "/" || /[\r\n\0]/u.test(workspaceRoot))
+    throw new TypeError("Remote Mac workspace must be an absolute macOS path.");
+  const profile = {
+    bunPath: inspection.bunPath,
+    createdAt: new Date().toISOString(),
+    destination,
+    name,
+    ...port ? { port } : {},
+    workspaceRoot,
+    xcodeVersion: inspection.xcodeVersion
+  };
+  const store = await loadStore(options.profilePath);
+  store.profiles[name] = profile;
+  store.defaultProfile = name;
+  await saveStore(store, options.profilePath);
+  return profile;
+};
+var removeAbsoluteRemoteMacProfile = async (name, profilePath) => {
+  const normalized = validateAbsoluteRemoteMacProfileName(name);
+  const store = await loadStore(profilePath);
+  if (!store.profiles[normalized])
+    return false;
+  delete store.profiles[normalized];
+  if (store.defaultProfile === normalized) {
+    const [nextDefault] = Object.keys(store.profiles).sort();
+    store.defaultProfile = nextDefault;
+  }
+  await saveStore(store, profilePath);
+  return true;
+};
+var projectIdentity = (projectRoot, appId) => createHash7("sha256").update(`${resolvePath2(projectRoot)}\x00${appId}`).digest("hex").slice(0, 20);
+var createAbsoluteRemoteIosDevProject = (config, projectRoot, profile) => ({
+  cap: join7(resolvePath2(projectRoot), "node_modules", ".bin", "cap"),
+  config,
+  nativeDirectory: join7(config.nativeProjectDirectory, "ios"),
+  profile,
+  projectRoot: resolvePath2(projectRoot),
+  remote: true,
+  remoteProjectRoot: posix.join(profile.workspaceRoot, "projects", projectIdentity(projectRoot, config.appId), "current"),
+  xcodebuild: "remote:xcodebuild",
+  xcrun: "remote:xcrun"
+});
+var installAbsoluteRemoteMacAgent = async (project) => {
+  const artifact = await materializeAbsoluteRemoteMacAgent(project.projectRoot);
+  const directory = posix.join(project.profile.workspaceRoot, "agents", `protocol-${ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION}`, artifact.sha256);
+  const remotePath = posix.join(directory, "agent.js");
+  const verifyScript = `test -f ${shellQuote(remotePath)} && ` + `test "$(shasum -a 256 ${shellQuote(remotePath)} | awk '{print $1}')" = ${shellQuote(artifact.sha256)}`;
+  const verified = await defaultTransport.capture([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(verifyScript)
+  ]);
+  if (verified.exitCode === 0)
+    return { ...artifact, remotePath, uploaded: false };
+  const temporary = posix.join(directory, `.agent-${randomUUID3()}.tmp`);
+  const installScript = [
+    "set -eu",
+    "umask 077",
+    `mkdir -p ${shellQuote(directory)}`,
+    `cat > ${shellQuote(temporary)}`,
+    `test "$(shasum -a 256 ${shellQuote(temporary)} | awk '{print $1}')" = ${shellQuote(artifact.sha256)}`,
+    `chmod 600 ${shellQuote(temporary)}`,
+    `mv ${shellQuote(temporary)} ${shellQuote(remotePath)}`
+  ].join("; ");
+  const upload = Bun.spawn([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(installScript)
+  ], {
+    stderr: "pipe",
+    stdin: Bun.file(artifact.path),
+    stdout: "pipe"
+  });
+  const [exitCode, stderr] = await Promise.all([
+    upload.exited,
+    new Response(upload.stderr).text()
+  ]);
+  if (exitCode !== 0)
+    throw new Error(`Remote Mac agent installation failed: ${stderr.trim() || `status ${exitCode}`}`);
+  return { ...artifact, remotePath, uploaded: true };
+};
+var materializeAbsoluteRemoteMacAgent = async (projectRoot) => {
+  const shippedCandidates = [
+    join7(import.meta.dir, "remoteMacAgentEntry.js"),
+    join7(import.meta.dir, "..", "mobile", "remoteMacAgentEntry.js")
+  ];
+  let path;
+  for (const candidate of shippedCandidates) {
+    if (await Bun.file(candidate).exists()) {
+      path = candidate;
+      break;
+    }
+  }
+  if (!path) {
+    const sourceCandidates = [
+      join7(import.meta.dir, "remoteMacAgentEntry.ts"),
+      join7(import.meta.dir, "..", "..", "src", "mobile", "remoteMacAgentEntry.ts")
+    ];
+    const source = await sourceCandidates.reduce(async (found, candidate) => await found ?? (await Bun.file(candidate).exists() ? candidate : undefined), Promise.resolve(undefined));
+    if (!source)
+      throw new Error("The AbsoluteJS installation does not contain its remote Mac agent artifact.");
+    const outdir = join7(resolvePath2(projectRoot), ".absolutejs", "mobile", "remote-agent");
+    await mkdir6(outdir, { recursive: true });
+    const result = await Bun.build({
+      entrypoints: [source],
+      minify: true,
+      outdir,
+      target: "bun"
+    });
+    if (!result.success)
+      throw new AggregateError(result.logs, "Failed to build the AbsoluteJS remote Mac agent.");
+    path = join7(outdir, "remoteMacAgentEntry.js");
+  }
+  const bytes = await Bun.file(path).arrayBuffer();
+  const sha256 = createHash7("sha256").update(new Uint8Array(bytes)).digest("hex");
+  return { bytes: bytes.byteLength, path, sha256 };
+};
+var portableRelativePath = (root, path) => relative6(root, path).split(sep5).join(posix.sep);
+var portableMobileConfig = (project) => ({
+  appId: project.config.appId,
+  appName: project.config.appName,
+  bundleDirectory: portableRelativePath(project.projectRoot, project.config.bundleDirectory),
+  ...project.config.deepLinkScheme || project.config.deepLinkHosts.length > 1 || project.config.appleAppIdPrefix ? {
+    deepLinks: {
+      ...project.config.deepLinkScheme ? { scheme: project.config.deepLinkScheme } : {},
+      hosts: project.config.deepLinkHosts,
+      ...project.config.appleAppIdPrefix ? {
+        apple: {
+          appIdPrefix: project.config.appleAppIdPrefix
+        }
+      } : {}
+    }
+  } : {},
+  entry: project.config.entry,
+  ...project.config.iosVersion ? { ios: { version: project.config.iosVersion } } : {},
+  nativeProject: {
+    directory: portableRelativePath(project.projectRoot, project.config.nativeProjectDirectory),
+    mode: "source"
+  },
+  platforms: ["ios"],
+  server: { productionOrigin: project.config.productionOrigin }
+});
+var absoluteRemoteProjectSyncCommands = (project) => {
+  const current = project.remoteProjectRoot;
+  const parent = posix.dirname(current);
+  const staging = posix.join(parent, `.incoming-${randomUUID3()}`);
+  const previous = posix.join(parent, ".previous");
+  const script = [
+    "set -eu",
+    `mkdir -p ${shellQuote(staging)}`,
+    `tar -xf - -C ${shellQuote(staging)}`,
+    `if [ -d ${shellQuote(posix.join(current, "node_modules"))} ]; then mv ${shellQuote(posix.join(current, "node_modules"))} ${shellQuote(posix.join(staging, "node_modules"))}; fi`,
+    `if [ -d ${shellQuote(posix.join(current, ".absolutejs"))} ]; then mv ${shellQuote(posix.join(current, ".absolutejs"))} ${shellQuote(posix.join(staging, ".absolutejs"))}; fi`,
+    `rm -rf ${shellQuote(previous)}`,
+    `if [ -d ${shellQuote(current)} ]; then mv ${shellQuote(current)} ${shellQuote(previous)}; fi`,
+    `mv ${shellQuote(staging)} ${shellQuote(current)}`,
+    `rm -rf ${shellQuote(previous)}`
+  ].join("; ");
+  return {
+    remote: [
+      ...absoluteRemoteMacSshBase(project.profile),
+      "/bin/sh -lc",
+      shellQuote(script)
+    ],
+    tar: [
+      "tar",
+      "--exclude=.git",
+      "--exclude=node_modules",
+      "--exclude=build",
+      "--exclude=.absolutejs",
+      "-cf",
+      "-",
+      "-C",
+      project.projectRoot,
+      "."
+    ]
+  };
+};
+var syncAbsoluteRemoteMacProject = async (project) => {
+  const commands = absoluteRemoteProjectSyncCommands(project);
+  const archive = Bun.spawn(commands.tar, {
+    stderr: "pipe",
+    stdout: "pipe"
+  });
+  const upload = Bun.spawn(commands.remote, {
+    stderr: "pipe",
+    stdin: archive.stdout,
+    stdout: "pipe"
+  });
+  const [archiveExit, uploadExit, archiveError, uploadError] = await Promise.all([
+    archive.exited,
+    upload.exited,
+    new Response(archive.stderr).text(),
+    new Response(upload.stderr).text()
+  ]);
+  if (archiveExit !== 0 || uploadExit !== 0)
+    throw new Error(`Remote Mac project synchronization failed: ${(archiveError || uploadError).trim()}`);
+  const install = await defaultTransport.capture([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(`cd ${shellQuote(project.remoteProjectRoot)} && ${shellQuote(project.profile.bunPath)} install --frozen-lockfile`)
+  ]);
+  requireRemoteSuccess(install, "Remote Mac dependency installation");
+};
+var consumeLines2 = async (stream, onLine) => {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffered += decoder.decode(value, { stream: true });
+      const lines = buffered.split(/\r?\n/u);
+      buffered = lines.pop() ?? "";
+      lines.forEach(onLine);
+    }
+    buffered += decoder.decode();
+    if (buffered)
+      onLine(buffered);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var startAbsoluteRemoteIosDevSession = async (options) => {
+  const startedAt = performance.now();
+  const transport = options.transport ?? defaultTransport;
+  const installAgent = options.installAgent ?? installAbsoluteRemoteMacAgent;
+  const syncProject = options.syncProject ?? syncAbsoluteRemoteMacProject;
+  const agentStartedAt = performance.now();
+  const agent = await installAgent(options.project);
+  const agentDuration = performance.now() - agentStartedAt;
+  const syncStartedAt = performance.now();
+  await syncProject(options.project);
+  const syncDuration = performance.now() - syncStartedAt;
+  const encodedConfig = Buffer.from(JSON.stringify(portableMobileConfig(options.project))).toString("base64url");
+  const remoteCommand = [
+    `cd ${shellQuote(options.project.remoteProjectRoot)}`,
+    "&&",
+    "exec",
+    shellQuote(options.project.profile.bunPath),
+    shellQuote(agent.remotePath),
+    "--port",
+    String(options.port),
+    "--mobile-config",
+    shellQuote(encodedConfig),
+    ...options.https ? ["--https"] : []
+  ].join(" ");
+  const command = [
+    ...absoluteRemoteMacSshBase(options.project.profile),
+    "-o",
+    "ExitOnForwardFailure=yes",
+    "-R",
+    `${options.port}:127.0.0.1:${options.port}`,
+    "/bin/sh -lc",
+    shellQuote(remoteCommand)
+  ];
+  const connectStartedAt = performance.now();
+  const process2 = transport.spawn(command, { signal: options.signal });
+  let state = "syncing";
+  let ready;
+  let fatal;
+  const pending = new Map;
+  let resolveReady;
+  let rejectReady;
+  const readyPromise = new Promise((resolve6, reject) => {
+    resolveReady = resolve6;
+    rejectReady = reject;
+  });
+  const handleEvent = (event) => {
+    if (event.v !== ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION) {
+      rejectReady(new Error("Remote Mac protocol version mismatch."));
+      return;
+    }
+    if (event.type === "log")
+      options.log?.(event.message);
+    if (event.type === "native-log")
+      options.nativeLog?.(event.entry);
+    if (event.type === "state") {
+      ({ state } = event);
+      options.onStateChange?.(state);
+    }
+    if (event.type === "timing")
+      options.onPhaseTiming?.(event);
+    if (event.type === "ready") {
+      ready = event;
+      resolveReady();
+    }
+    if (event.type === "fatal") {
+      fatal = new Error(event.error);
+      rejectReady(fatal);
+    }
+    if (event.type === "response") {
+      const request2 = pending.get(event.id);
+      if (!request2)
+        return;
+      pending.delete(event.id);
+      if (event.ok)
+        request2.resolve(event.result);
+      else
+        request2.reject(new Error(event.error ?? "Remote command failed."));
+    }
+  };
+  const stdoutDone = consumeLines2(process2.stdout, (line) => {
+    if (!line.startsWith(ABSOLUTE_REMOTE_MAC_EVENT_PREFIX))
+      return;
+    try {
+      handleEvent(JSON.parse(line.slice(ABSOLUTE_REMOTE_MAC_EVENT_PREFIX.length)));
+    } catch {
+      options.log?.(`Remote Mac emitted an invalid protocol event.`);
+    }
+  }).catch((error) => {
+    fatal = error instanceof Error ? error : new Error("Failed to read the remote Mac protocol stream.");
+    rejectReady(fatal);
+  });
+  const stderrDone = consumeLines2(process2.stderr, (line) => options.log?.(`[remote] ${line}`)).catch((error) => options.log?.(`[remote] ${error instanceof Error ? error.message : "Failed to read SSH stderr."}`));
+  process2.exited.then(async (exitCode) => {
+    await Promise.all([stdoutDone, stderrDone]);
+    const error = fatal ?? new Error(`Remote Mac connection closed with status ${exitCode}.`);
+    if (!ready)
+      rejectReady(error);
+    pending.forEach(({ reject }) => reject(error));
+    pending.clear();
+    return;
+  });
+  await readyPromise;
+  if (!ready)
+    throw fatal ?? new Error("Remote Mac did not become ready.");
+  const totalDuration = performance.now() - startedAt;
+  let currentReady = {
+    ...ready,
+    timings: {
+      ...ready.timings,
+      "remote-agent": agentDuration,
+      "remote-connect": performance.now() - connectStartedAt,
+      "remote-sync": syncDuration,
+      total: totalDuration
+    }
+  };
+  options.log?.(`Remote Mac connected (${options.project.profile.name}); agent ${agent.uploaded ? "uploaded" : "cache hit"}, project synced, and iOS ready in ${totalDuration.toFixed(2)}ms.`);
+  const request = (commandName) => {
+    const id = randomUUID3();
+    const response = new Promise((resolve6, reject) => pending.set(id, { reject, resolve: resolve6 }));
+    process2.stdin.write(`${JSON.stringify({ command: commandName, id, v: 1 })}
+`);
+    const flush = async () => {
+      for (let attempt = 0;attempt < REMOTE_STDIN_FLUSH_ATTEMPTS; attempt++) {
+        try {
+          await process2.stdin.flush();
+          return;
+        } catch {
+          await Promise.resolve();
+        }
+      }
+    };
+    return flush().then(() => response);
+  };
+  let closed = false;
+  const close = async () => {
+    if (closed)
+      return;
+    closed = true;
+    await request("close").catch(() => {
+      return;
+    });
+    process2.stdin.end();
+    await process2.exited.catch(() => {
+      return;
+    });
+  };
+  const makeSession = () => ({
+    close,
+    nativeCacheHit: currentReady.nativeCacheHit,
+    startedSimulator: currentReady.startedSimulator,
+    timings: currentReady.timings,
+    udid: currentReady.udid,
+    rebuild: async () => {
+      const rebuildStartedAt = performance.now();
+      const rebuildSyncStartedAt = performance.now();
+      await syncProject(options.project);
+      const rebuildSyncDuration = performance.now() - rebuildSyncStartedAt;
+      const result = await request("rebuild");
+      currentReady = {
+        ...result,
+        timings: {
+          ...result.timings,
+          "remote-sync": rebuildSyncDuration,
+          total: performance.now() - rebuildStartedAt
+        }
+      };
+      return makeSession();
+    },
+    relaunch: async () => {
+      await request("relaunch");
+    },
+    screenshot: async (destination) => {
+      const result = await request("screenshot");
+      const target = resolvePath2(options.project.projectRoot, destination);
+      const targetRelative = relative6(options.project.projectRoot, target);
+      if (targetRelative.startsWith("..") || isAbsolute5(targetRelative))
+        throw new Error("iOS screenshot must remain inside the project.");
+      await mkdir6(dirname5(target), { recursive: true });
+      await writeFile7(target, Buffer.from(result.data, "base64"));
+      return target;
+    },
+    get state() {
+      return state;
+    }
+  });
+  return makeSession();
 };
 // src/mobile/associationFiles.ts
 import {
-  access as access5,
-  mkdir as mkdir5,
-  readFile as readFile6,
-  rename as rename6,
-  rm as rm5,
-  writeFile as writeFile6
+  access as access7,
+  mkdir as mkdir7,
+  readFile as readFile9,
+  rename as rename8,
+  rm as rm6,
+  writeFile as writeFile8
 } from "fs/promises";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import { Elysia } from "elysia";
 
 // src/mobile/config.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 var APP_ID_PATTERN = /^[A-Za-z][\w]*(?:\.[A-Za-z][\w]*)+$/;
 var SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*$/;
 var APPLE_APP_ID_PREFIX_PATTERN = /^[A-Z0-9]{10}$/;
 var CERTIFICATE_FINGERPRINT_PATTERN = /^[0-9A-F]{64}$/;
 var HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/;
 var resolveProjectPath = (projectRoot, value, field) => {
-  const root = resolve5(projectRoot);
-  const path = resolve5(root, value);
+  const root = resolve6(projectRoot);
+  const path = resolve6(root, value);
   if (path !== root && !path.startsWith(`${root}/`)) {
     throw new TypeError(`${field} must remain inside the project root.`);
   }
@@ -1503,8 +3598,9 @@ var normalizeEntry = (entry) => {
 };
 var normalizeProductionOrigin = (value) => {
   const parsed = new URL(requireText(value, "mobile.server.productionOrigin"));
-  if (parsed.protocol !== "https:") {
-    throw new TypeError("mobile.server.productionOrigin must use HTTPS in production.");
+  const isLoopbackHttp = parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]");
+  if (parsed.protocol !== "https:" && !isLoopbackHttp) {
+    throw new TypeError("mobile.server.productionOrigin must use HTTPS, except for a loopback development origin.");
   }
   if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
     throw new TypeError("mobile.server.productionOrigin must be an origin without credentials, path, query, or hash.");
@@ -1528,9 +3624,8 @@ var normalizeHosts = (hosts, productionOrigin) => {
     }
     return value;
   };
-  const normalized = new Set([
-    normalizeHostname(new URL(productionOrigin).hostname)
-  ]);
+  const productionHostname = new URL(productionOrigin).hostname;
+  const normalized = new Set(productionHostname === "[::1]" ? [] : [normalizeHostname(productionHostname)]);
   for (const host of hosts ?? []) {
     normalized.add(normalizeHostname(host));
   }
@@ -1568,7 +3663,7 @@ var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
     throw new TypeError("mobile.appId must use reverse-domain notation, for example com.example.app.");
   }
   const productionOrigin = normalizeProductionOrigin(config.server.productionOrigin);
-  const deepLinkScheme = config.deepLinks?.scheme?.trim().toLowerCase();
+  const deepLinkScheme = (config.deepLinks?.scheme ?? appId).trim().toLowerCase();
   if (deepLinkScheme && !SCHEME_PATTERN.test(deepLinkScheme)) {
     throw new TypeError("mobile.deepLinks.scheme is not a valid URL scheme.");
   }
@@ -1670,7 +3765,7 @@ var createAbsoluteMobileAssociationPlugin = (mobile, projectRoot, options = {})
 var writeAtomic = async (path, source) => {
   let current;
   try {
-    current = await readFile6(path, "utf8");
+    current = await readFile9(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -1679,23 +3774,23 @@ var writeAtomic = async (path, source) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile6(temporary, source, { flag: "wx" });
-  await rename6(temporary, path);
+  await writeFile8(temporary, source, { flag: "wx" });
+  await rename8(temporary, path);
   return true;
 };
 var exists2 = async (path) => {
   try {
-    await access5(path);
+    await access7(path);
     return true;
   } catch {
     return false;
   }
 };
 var assertOwnedOutput = async (root) => {
-  const path = resolve6(root, OWNERSHIP_FILE);
+  const path = resolve7(root, OWNERSHIP_FILE);
   let ownership;
   try {
-    ownership = JSON.parse(await readFile6(path, "utf8"));
+    ownership = JSON.parse(await readFile9(path, "utf8"));
   } catch {
     throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
   }
@@ -1709,22 +3804,22 @@ var publishGeneratedDirectory = async (temporary, root) => {
     await assertOwnedOutput(root);
   const backup = `${root}.${crypto.randomUUID()}.previous`;
   if (hasCurrent)
-    await rename6(root, backup);
+    await rename8(root, backup);
   try {
-    await rename6(temporary, root);
+    await rename8(temporary, root);
   } catch (error) {
     if (hasCurrent)
-      await rename6(backup, root);
+      await rename8(backup, root);
     throw error;
   }
   if (hasCurrent)
-    await rm5(backup, { force: true, recursive: true });
+    await rm6(backup, { force: true, recursive: true });
 };
 var materializeHost = async (root, host, files) => {
-  const directory = resolve6(root, host, ".well-known");
-  await mkdir5(directory, { recursive: true });
+  const directory = resolve7(root, host, ".well-known");
+  await mkdir7(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document]) => {
-    const path = resolve6(directory, name);
+    const path = resolve7(directory, name);
     await writeAtomic(path, `${JSON.stringify(document, null, 2)}
 `);
     return path;
@@ -1749,7 +3844,7 @@ var associationEndpoints = (config, documents) => config.deepLinkHosts.flatMap((
   return endpoints;
 });
 var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
-  const root = resolve6(outputDirectory);
+  const root = resolve7(outputDirectory);
   const temporary = `${root}.${crypto.randomUUID()}.tmp`;
   const documents = createAbsoluteMobileAssociationDocuments(config, {
     requireAll: true
@@ -1760,16 +3855,16 @@ var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory)
   if (documents.apple) {
     files.push(["apple-app-site-association", documents.apple]);
   }
-  await mkdir5(temporary, { recursive: true });
+  await mkdir7(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
-    await writeAtomic(resolve6(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+    await writeAtomic(resolve7(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
 `);
     await publishGeneratedDirectory(temporary, root);
-    const written = temporaryPaths.map((path) => resolve6(root, path.slice(temporary.length + 1)));
+    const written = temporaryPaths.map((path) => resolve7(root, path.slice(temporary.length + 1)));
     return { root, written };
   } catch (error) {
-    await rm5(temporary, { force: true, recursive: true });
+    await rm6(temporary, { force: true, recursive: true });
     throw error;
   }
 };
@@ -1814,10 +3909,10 @@ var frameworks2 = new Set([
   "svelte",
   "vue"
 ]);
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isPageFramework2 = (value) => typeof value === "string" && frameworks2.has(value);
 var parseAbsoluteMobileBuildPageMetadata = (value) => {
-  if (!isRecord3(value))
+  if (!isRecord4(value))
     return;
   if (typeof value.bundleKey !== "string" || typeof value.contract !== "string" || !isPageFramework2(value.framework) || typeof value.pageId !== "string" || typeof value.propsSchemaHash !== "string") {
     return;
@@ -1831,45 +3926,75 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
   };
 };
 // src/mobile/buildPipeline.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join9, resolve as resolve9 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join14, resolve as resolve12 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
-import { createHash as createHash6 } from "crypto";
-import { readFile as readFile7 } from "fs/promises";
-import { join as join6, relative as relative5, resolve as resolve7 } from "path";
-var sha256 = (bytes) => createHash6("sha256").update(bytes).digest("hex");
+import { createHash as createHash8 } from "crypto";
+import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
+import { basename as basename2, dirname as dirname6, extname, join as join8, relative as relative7, resolve as resolve8 } from "path";
+var sha256 = (bytes) => createHash8("sha256").update(bytes).digest("hex");
+var STATIC_SCRIPT_PATTERN = /(<script\b[^>]*?\bsrc\s*=\s*["'])(\/[^"']+\.(?:js|ts))(["'][^>]*>)/giu;
+var rewriteStaticScriptPaths = (source, manifest) => source.replace(STATIC_SCRIPT_PATTERN, (match, prefix, path, suffix) => {
+  if (path.endsWith("/htmx.min.js"))
+    return match;
+  const key = toPascal(basename2(path, extname(path)));
+  const builtPath = manifest[key];
+  return builtPath ? `${prefix}${builtPath}${suffix}` : match;
+});
 var readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]);
 var resolveAssetPath = (buildDirectory, assetPath) => {
-  const resolvedBuildDirectory = resolve7(buildDirectory);
-  const resolvedAsset = resolve7(assetPath);
+  const resolvedBuildDirectory = resolve8(buildDirectory);
+  const resolvedAsset = resolve8(assetPath);
   if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
     return resolvedAsset;
   }
-  return join6(buildDirectory, assetPath.replace(/^\/+/, ""));
+  return join8(buildDirectory, assetPath.replace(/^\/+/, ""));
 };
 var pageFor = async (metadata, manifest, buildDirectory) => {
   const assetPath = manifest[metadata.bundleKey];
   if (!assetPath) {
     throw new TypeError(`Mobile page ${metadata.pageId} references missing manifest asset ${metadata.bundleKey}.`);
   }
-  const resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
-  const bytes = await readFile7(resolvedAssetPath);
-  const bundlePath = `/${relative5(resolve7(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  let resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
+  if (metadata.framework === "html" || metadata.framework === "htmx") {
+    const source = await readFile10(resolvedAssetPath, "utf8");
+    const rewritten = rewriteStaticScriptPaths(source, manifest);
+    const documentHash = sha256(new TextEncoder().encode(rewritten));
+    resolvedAssetPath = join8(buildDirectory, ".absolutejs", "mobile-pages", `${documentHash}.html`);
+    await mkdir8(dirname6(resolvedAssetPath), { recursive: true });
+    await writeFile9(resolvedAssetPath, rewritten);
+  }
+  const pageAssetKey = metadata.bundleKey.replace(/Index$/u, "");
+  const styleAssetPath = [
+    `${pageAssetKey}BundledCSS`,
+    `${pageAssetKey}CompiledCSS`
+  ].map((key) => manifest[key]).find((path) => typeof path === "string");
+  const resolvedStylePath = styleAssetPath ? resolveAssetPath(buildDirectory, styleAssetPath) : undefined;
+  const [bytes, styleBytes] = await Promise.all([
+    readFile10(resolvedAssetPath),
+    resolvedStylePath ? readFile10(resolvedStylePath) : undefined
+  ]);
+  const bundlePath = `/${relative7(resolve8(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const styleBundlePath = resolvedStylePath ? `/${relative7(resolve8(buildDirectory), resolvedStylePath).replaceAll("\\", "/")}` : undefined;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
     contract: metadata.contract,
     framework: metadata.framework,
     pageId: metadata.pageId,
-    propsSchemaHash: metadata.propsSchemaHash
+    propsSchemaHash: metadata.propsSchemaHash,
+    ...styleBytes && styleBundlePath ? {
+      styleBundleHash: sha256(styleBytes),
+      styleBundlePath
+    } : {}
   };
 };
 var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   const [captured, producerBytes] = await Promise.all([
     captureAbsoluteMobileRouteGraph(options.app),
-    readFile7(options.producerPath)
+    readFile10(options.producerPath)
   ]);
   if (captured.length === 0) {
     throw new TypeError("No instrumented AbsoluteJS mobile page routes were found in the finalized Elysia route graph.");
@@ -1885,11 +4010,19 @@ var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   const pages = await Promise.all([...metadataByPage.values()].map((metadata) => pageFor(metadata, options.manifest, options.buildDirectory)));
   const producerHash = sha256(producerBytes);
   const appBuild = `ambuild_${sha256(new TextEncoder().encode(JSON.stringify({
-    pages: pages.map(({ bundleHash, bundlePath, contract, pageId }) => ({
+    pages: pages.map(({
+      bundleHash,
+      bundlePath,
+      contract,
+      pageId,
+      styleBundleHash,
+      styleBundlePath
+    }) => ({
       bundleHash,
       bundlePath,
       contract,
-      pageId
+      pageId,
+      ...styleBundleHash && styleBundlePath ? { styleBundleHash, styleBundlePath } : {}
     })),
     producerHash,
     runtime: options.runtime
@@ -1949,16 +4082,17 @@ var captureAbsoluteMobileRouteGraph = async (app) => {
 
 // src/mobile/capacitorBundle.ts
 import {
-  copyFile as copyFile4,
-  mkdir as mkdir6,
+  cp,
+  copyFile as copyFile5,
+  mkdir as mkdir9,
   mkdtemp as mkdtemp4,
-  readFile as readFile8,
-  rename as rename7,
-  rm as rm6,
-  writeFile as writeFile7
+  readFile as readFile11,
+  rename as rename9,
+  rm as rm7,
+  writeFile as writeFile10
 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { basename, dirname as dirname4, extname, join as join7, resolve as resolve8 } from "path";
+import { basename as basename3, dirname as dirname7, extname as extname2, join as join9, relative as relative8, resolve as resolve9 } from "path";
 
 // src/mobile/routeMatcher.ts
 var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
@@ -2114,14 +4248,14 @@ var envelopeResponse = (response, status) => new Response(JSON.stringify({
   protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
   response
 }), { headers: responseHeaders(), status });
-var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var normalizeJsonValue = (value) => {
   const serialized = JSON.stringify(value);
   if (serialized === undefined) {
     throw new TypeError("Mobile page props must be JSON-serializable.");
   }
   const parsed = JSON.parse(serialized);
-  if (!isRecord4(parsed)) {
+  if (!isRecord5(parsed)) {
     throw new TypeError("Mobile page props must serialize to an object.");
   }
   return parsed;
@@ -2231,6 +4365,13 @@ class AbsoluteMobilePageProtocolError extends Error {
     this.code = code;
   }
 }
+var disposeAbsoluteMobilePage = async (target = window) => {
+  const dispose = target.__ABSOLUTE_PAGE_DISPOSE__;
+  target.__ABSOLUTE_PAGE_DISPOSE__ = undefined;
+  target.__ABSOLUTE_PAGE_READY__ = undefined;
+  if (dispose)
+    await dispose();
+};
 var frameworks4 = new Set([
   "angular",
   "ember",
@@ -2246,14 +4387,14 @@ var upgradeReasons = new Set([
   "protocol",
   "runtime"
 ]);
-var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isFramework = (value) => typeof value === "string" && frameworks4.has(value);
 var isUpgradeReason = (value) => typeof value === "string" && upgradeReasons.has(value);
 var parsePageResult = (value) => {
   if (typeof value.contract !== "string" || !isFramework(value.framework) || typeof value.pageId !== "string" || typeof value.status !== "number") {
     throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The mobile page response is missing required page metadata.");
   }
-  if (!isRecord5(value.props)) {
+  if (!isRecord6(value.props)) {
     throw new AbsoluteMobilePageProtocolError("invalid-props", "The mobile page response must contain an object props value.");
   }
   return {
@@ -2286,12 +4427,17 @@ var activateAbsoluteMobilePage = async (value, options) => {
     throw new AbsoluteMobilePageProtocolError("invalid-envelope", "Expected a renderable mobile page response.");
   }
   const target = options.target ?? window;
+  await disposeAbsoluteMobilePage(target);
   target.__INITIAL_PROPS__ = envelope.response.props;
+  target.__ABS_ANGULAR_REQUEST_CONTEXT__ = envelope.response.props;
   target.__ABSOLUTE_PAGE_RENDER_MODE__ = "client";
   await options.loadPage({
     contract: envelope.response.contract,
     pageId: envelope.response.pageId
   });
+  if (target.__ABSOLUTE_PAGE_READY__) {
+    await target.__ABSOLUTE_PAGE_READY__;
+  }
   return {
     contract: envelope.response.contract,
     kind: "rendered",
@@ -2299,7 +4445,7 @@ var activateAbsoluteMobilePage = async (value, options) => {
   };
 };
 var parseAbsoluteMobilePageEnvelope = (value) => {
-  if (!isRecord5(value) || !isRecord5(value.response)) {
+  if (!isRecord6(value) || !isRecord6(value.response)) {
     throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The server did not return an AbsoluteJS mobile page envelope.");
   }
   if (value.protocol !== ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION) {
@@ -2384,19 +4530,51 @@ var resolveAbsoluteMobileDeepLink = (manifest, value) => {
   }
   return `${url.pathname || "/"}${url.search}${url.hash}`;
 };
+var resolveAbsoluteMobileNavigation = (manifest, value, localOrigin) => {
+  const url = new URL(value, `${localOrigin}/`);
+  const local = new URL(localOrigin);
+  const production = new URL(manifest.productionOrigin);
+  const matches = (candidate, allowed) => candidate.protocol === allowed.protocol && candidate.host === allowed.host;
+  if (!matches(url, local) && !matches(url, production)) {
+    return;
+  }
+  return `${url.pathname}${url.search}${url.hash}`;
+};
 
 // src/mobile/capacitorBundle.ts
 var MANIFEST_FILE = "absolute-mobile-manifest.json";
 var BOOTSTRAP_FILE = "absolute-mobile-bootstrap.js";
 var INDEX_FILE = "index.html";
-var CLIENT_IMPORT_PATTERN = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s*)["'](\/[^"']+)["']/gu;
+var CLIENT_CSS_DEPENDENCY_PATTERN = /(?:@import\s+(?:url\(\s*)?|url\(\s*)["']?((?:\/|\.\.\/|\.\/)[^"')\s]+)["']?\s*\)?/gu;
+var CLIENT_MARKUP_DEPENDENCY_PATTERN = /<(?:script\b[^>]*\bsrc|link\b[^>]*\bhref|img\b[^>]*\bsrc|source\b[^>]*\bsrcset)\s*=\s*["']((?:\/|\.\.\/|\.\/)[^"',\s]+)/giu;
+var CAPACITOR_CLIENT_FRAMEWORKS = new Set([
+  "angular",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var CLIENT_ASSET_DIRECTORIES = ["assets", "html", "htmx", "indexes"];
 var errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var shellBootstrapModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join7(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
 };
+var shellAuthModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellAuth.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile auth shell module is missing.");
+};
+var shellSyncModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellSync.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile Sync shell module is missing.");
+};
 var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 var indexHtml = (appName) => `<!doctype html>
 <html>
@@ -2413,18 +4591,58 @@ var indexHtml = (appName) => `<!doctype html>
 </html>
 `;
 var sourceAssetPath = (buildDirectory, bundlePath) => {
-  const root = resolve8(buildDirectory);
-  const asset = resolve8(root, bundlePath.replace(/^\/+/, ""));
+  const root = resolve9(buildDirectory);
+  const asset = resolve9(root, bundlePath.replace(/^\/+/, ""));
   if (!asset.startsWith(`${root}/`)) {
     throw new TypeError("Mobile page bundle escaped the build directory.");
   }
   return asset;
 };
-var buildShellBootstrap = async (staging) => {
+var importEntryTarget = (entry) => {
+  if (typeof entry === "string")
+    return entry;
+  if (typeof entry === "object" && entry !== null)
+    return Reflect.get(entry, "import");
+  return;
+};
+var resolveProjectImport = async (projectRoot, specifier) => {
+  const segments = specifier.split("/");
+  const packageName = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0] ?? "";
+  const subpath = specifier.slice(packageName.length);
+  const packageDirectory = join9(resolve9(projectRoot), "node_modules", packageName);
+  const manifest = JSON.parse(await readFile11(join9(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 = resolve9(packageDirectory, target);
+  if (!resolved.startsWith(`${resolve9(packageDirectory)}/`))
+    throw new TypeError(`${specifier} has an unsafe import entry.`);
+  return resolved;
+};
+var buildShellBootstrap = async (staging, auth, sync, storagePrefix, deviceCapabilities, projectRoot) => {
   const modulePath = shellBootstrapModule();
-  const entryPath = join7(staging, ".absolute-mobile-entry.ts");
-  await writeFile7(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
-void startAbsoluteMobileShell();
+  const authImport = auth ? `import { createAbsoluteMobileShellAuth } from ${JSON.stringify(shellAuthModule())};
+` : "";
+  const options = auth ? `{ createAuth: createAbsoluteMobileShellAuth${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }` : "";
+  const syncImport = sync ? `import { installAbsoluteMobileShellSync } from ${JSON.stringify(shellSyncModule())};
+` : "";
+  const capabilityImports = (await Promise.all(deviceCapabilities.capabilities.map(async (name, index) => {
+    const provider = deviceCapabilities.providers[name];
+    if (!provider)
+      throw new TypeError(`Missing device capability provider ${name}.`);
+    return `import { ${provider.factory} as absoluteDeviceCapability${index} } from ${JSON.stringify(await resolveProjectImport(projectRoot, provider.module))};`;
+  }))).join(`
+`);
+  const capabilityOptions = deviceCapabilities.capabilities.map((name, index) => `${JSON.stringify(name)}: absoluteDeviceCapability${index}()`).join(", ");
+  const entryPath = join9(staging, ".absolute-mobile-entry.ts");
+  const baseAdapterModule = await resolveProjectImport(projectRoot, "@absolutejs/devices-capacitor");
+  await writeFile10(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+import { installCapacitorDeviceAdapterIfNative } from ${JSON.stringify(baseAdapterModule)};
+${authImport}${syncImport}${capabilityImports}
+installCapacitorDeviceAdapterIfNative({ storagePrefix: ${JSON.stringify(storagePrefix)}${capabilityOptions ? `, ${capabilityOptions}` : ""} });
+void startAbsoluteMobileShell(${options});
 `);
   const build = await Bun.build({
     entrypoints: [entryPath],
@@ -2435,31 +4653,31 @@ void startAbsoluteMobileShell();
   if (!build.success || build.outputs.length !== 1) {
     throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
   }
-  await rename7(build.outputs[0]?.path ?? "", join7(staging, BOOTSTRAP_FILE));
-  await rm6(entryPath, { force: true });
+  await rename9(build.outputs[0]?.path ?? "", join9(staging, BOOTSTRAP_FILE));
+  await rm7(entryPath, { force: true });
 };
 var removePreviousBundle = async (backup, moved) => {
   if (!moved)
     return;
-  await rm6(backup, { force: true, recursive: true });
+  await rm7(backup, { force: true, recursive: true });
 };
 var restorePreviousBundle = async (backup, destination, moved) => {
   if (!moved)
     return;
-  await rename7(backup, destination);
+  await rename9(backup, destination);
 };
 var installBundle = async (staging, destination) => {
   const backup = `${destination}.previous-${crypto.randomUUID()}`;
   let movedPrevious = false;
   try {
-    await rename7(destination, backup);
+    await rename9(destination, backup);
     movedPrevious = true;
   } catch (error) {
     if (!errorHasCode2(error, "ENOENT"))
       throw error;
   }
   try {
-    await rename7(staging, destination);
+    await rename9(staging, destination);
     await removePreviousBundle(backup, movedPrevious);
   } catch (error) {
     await restorePreviousBundle(backup, destination, movedPrevious);
@@ -2467,21 +4685,62 @@ var installBundle = async (staging, destination) => {
   }
 };
 var copyClientPage = async (page, buildDirectory, staging, copiedDependencies) => {
-  if (page.framework !== "react") {
-    throw new TypeError(`Capacitor spike currently supports React pages; ${page.pageId} is ${page.framework}.`);
+  if (!CAPACITOR_CLIENT_FRAMEWORKS.has(page.framework)) {
+    throw new TypeError(`Capacitor client rendering does not yet support ${page.framework} page ${page.pageId}.`);
   }
-  const extension = extname(page.bundlePath) || ".js";
+  const extension = extname2(page.bundlePath) || ".js";
   const localBundlePath = `./pages/${page.bundleHash}${extension}`;
   const source = sourceAssetPath(buildDirectory, page.bundlePath);
-  await copyFile4(source, join7(staging, localBundlePath));
+  await copyFile5(source, join9(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
-  return { ...page, localBundlePath };
+  let localStylePath;
+  if (page.styleBundlePath && page.styleBundleHash) {
+    const styleExtension = extname2(page.styleBundlePath) || ".css";
+    localStylePath = `./styles/${page.styleBundleHash}${styleExtension}`;
+    const styleSource = sourceAssetPath(buildDirectory, page.styleBundlePath);
+    await mkdir9(dirname7(join9(staging, localStylePath)), {
+      recursive: true
+    });
+    await copyFile5(styleSource, join9(staging, localStylePath));
+    await copyAbsoluteClientDependencies(styleSource, buildDirectory, staging, copiedDependencies);
+  }
+  return {
+    ...page,
+    localBundlePath,
+    ...localStylePath ? { localStylePath } : {}
+  };
 };
-var absoluteClientImports = async (sourcePath) => {
-  const source = await readFile8(sourcePath, "utf8");
-  return [...source.matchAll(CLIENT_IMPORT_PATTERN)].flatMap((match) => {
-    const [specifier] = match.slice(1);
-    return specifier ? [specifier.split(/[?#]/u, 1)[0] ?? specifier] : [];
+var absoluteClientImports = async (sourcePath, buildDirectory) => {
+  const source = await readFile11(sourcePath, "utf8");
+  const extension = extname2(sourcePath).toLowerCase();
+  let scriptLoader;
+  if (extension === ".tsx")
+    scriptLoader = "tsx";
+  else if (extension === ".ts")
+    scriptLoader = "ts";
+  else if (extension === ".jsx")
+    scriptLoader = "jsx";
+  else if ([".js", ".mjs", ".cjs"].includes(extension))
+    scriptLoader = "js";
+  const scriptImports = scriptLoader ? new Bun.Transpiler({ loader: scriptLoader }).scanImports(source).map(({ path }) => path) : [];
+  const cssImports = extension === ".css" ? [...source.matchAll(CLIENT_CSS_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  const markupImports = extension === ".html" ? [...source.matchAll(CLIENT_MARKUP_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  return [...scriptImports, ...cssImports, ...markupImports].flatMap((specifier) => {
+    if (!specifier)
+      return [];
+    if (!specifier.startsWith("/") && !specifier.startsWith("./") && !specifier.startsWith("../")) {
+      return [];
+    }
+    const clean = specifier.split(/[?#]/u, 1)[0] ?? specifier;
+    if (clean.startsWith("/"))
+      return [clean];
+    const resolved = resolve9(dirname7(sourcePath), clean);
+    const root = resolve9(buildDirectory);
+    const relativePath = relative8(root, resolved).replaceAll("\\", "/");
+    if (relativePath === ".." || relativePath.startsWith("../")) {
+      throw new TypeError(`Mobile client dependency escaped the build directory: ${specifier}`);
+    }
+    return [`/${relativePath}`];
   });
 };
 var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, copied) => {
@@ -2489,13 +4748,13 @@ var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, co
     return;
   copied.add(specifier);
   const source = sourceAssetPath(buildDirectory, specifier);
-  const destination = join7(staging, specifier.replace(/^\/+/, ""));
-  await mkdir6(dirname4(destination), { recursive: true });
-  await copyFile4(source, destination);
+  const destination = join9(staging, specifier.replace(/^\/+/, ""));
+  await mkdir9(dirname7(destination), { recursive: true });
+  await copyFile5(source, destination);
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
 };
 var copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
-  const dependencies = await absoluteClientImports(sourcePath);
+  const dependencies = await absoluteClientImports(sourcePath, buildDirectory);
   await Promise.all(dependencies.map((specifier) => copyAbsoluteClientDependency(specifier, buildDirectory, staging, copied)));
 };
 var materializeAbsoluteCapacitorWebBundle = async (options) => {
@@ -2503,69 +4762,89 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
     throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
   }
   const destination = options.config.bundleDirectory;
-  await mkdir6(dirname4(destination), { recursive: true });
-  const staging = await mkdtemp4(join7(dirname4(destination), `.${basename(destination)}.stage-`));
+  await mkdir9(dirname7(destination), { recursive: true });
+  const staging = await mkdtemp4(join9(dirname7(destination), `.${basename3(destination)}.stage-`));
   try {
-    const pageDirectory = join7(staging, "pages");
-    await mkdir6(pageDirectory, { recursive: true });
+    const pageDirectory = join9(staging, "pages");
+    await mkdir9(pageDirectory, { recursive: true });
+    await Promise.all(CLIENT_ASSET_DIRECTORIES.map((directory) => ({
+      destination: join9(staging, directory),
+      source: join9(options.buildDirectory, directory)
+    })).filter(({ source }) => existsSync2(source)).map(({ destination: assetDestination, source }) => cp(source, assetDestination, { recursive: true })));
     const copiedDependencies = new Set;
     const pages = await Promise.all(options.artifact.pages.map((page) => copyClientPage(page, options.buildDirectory, staging, copiedDependencies)));
     const manifest = {
       appBuild: options.artifact.appBuild,
+      ...options.auth ? { auth: options.auth } : {},
       appId: options.config.appId,
       appName: options.config.appName,
       deepLinkHosts: options.config.deepLinkHosts,
       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
+      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([
-      writeFile7(join7(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+      writeFile10(join9(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
-      writeFile7(join7(staging, INDEX_FILE), indexHtml(options.config.appName)),
-      buildShellBootstrap(staging)
+      writeFile10(join9(staging, INDEX_FILE), indexHtml(options.config.appName)),
+      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true, `absolutejs.${options.auth?.clientId ?? options.config.appId}.`, options.deviceCapabilities, options.projectRoot)
     ]);
     await installBundle(staging, destination);
     return manifest;
   } catch (error) {
-    await rm6(staging, { force: true, recursive: true });
+    await rm7(staging, { force: true, recursive: true });
     throw error;
   }
 };
 
 // src/mobile/materializedBundle.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import {
-  access as access6,
-  mkdir as mkdir7,
+  access as access8,
+  mkdir as mkdir10,
   mkdtemp as mkdtemp5,
-  readFile as readFile9,
-  rename as rename8,
-  rm as rm7,
-  writeFile as writeFile8
+  readFile as readFile12,
+  rename as rename10,
+  rm as rm8,
+  writeFile as writeFile11
 } from "fs/promises";
-import { dirname as dirname5, join as join8, resolve as resolvePath2 } from "path";
+import { dirname as dirname8, join as join10, resolve as resolvePath3 } from "path";
 import { pathToFileURL } from "url";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1;
 var CURRENT_BUNDLE_FILE = "current.json";
 var BUNDLES_DIRECTORY = "bundles";
 var ARTIFACT_FILE2 = "artifact.json";
 var BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
-var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var errorHasCode3 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var bundleIdFor = (currentReleaseId, releases) => {
   const identity = JSON.stringify({
     currentReleaseId,
     releases: releases.map(({ releaseId }) => releaseId)
   });
-  return `amb_${createHash7("sha256").update(identity).digest("hex")}`;
+  return `amb_${createHash9("sha256").update(identity).digest("hex")}`;
 };
 var parseBundleIndex = (value) => {
-  if (!isRecord6(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
+  if (!isRecord7(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
     throw new TypeError("Invalid materialized mobile compatibility bundle.");
   }
   const releases = value.releases.map(parseAbsoluteMobileCompatibilityArtifact);
@@ -2588,30 +4867,30 @@ var parseBundleIndex = (value) => {
   };
 };
 var writeRelease = async (root, release) => {
-  const directory = join8(root, release.artifact.releaseId);
-  const producerPath = join8(directory, release.artifact.producer.module);
-  await mkdir7(dirname5(producerPath), { recursive: true });
+  const directory = join10(root, release.artifact.releaseId);
+  const producerPath = join10(directory, release.artifact.producer.module);
+  await mkdir10(dirname8(producerPath), { recursive: true });
   await Promise.all([
-    writeFile8(join8(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile11(join10(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
-    writeFile8(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+    writeFile11(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 };
 var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join8(bundlesRoot, bundleId);
+  const destination = join10(bundlesRoot, bundleId);
   try {
-    await access6(destination);
+    await access8(destination);
     return destination;
   } catch (error) {
     if (!errorHasCode3(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp5(join8(bundlesRoot, ".stage-"));
+  const staging = await mkdtemp5(join10(bundlesRoot, ".stage-"));
   try {
     await Promise.all(releases.map((release) => writeRelease(staging, release)));
-    await rename8(staging, destination);
+    await rename10(staging, destination);
   } catch (error) {
-    await rm7(staging, { force: true, recursive: true });
+    await rm8(staging, { force: true, recursive: true });
     if (errorHasCode3(error, "EEXIST") || errorHasCode3(error, "ENOTEMPTY")) {
       return destination;
     }
@@ -2622,7 +4901,7 @@ var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
 var readCompatibilityModule = (modulePath) => import(pathToFileURL(modulePath).href);
 var resolveProducerHandler = (loaded, exportName) => {
   const value = loaded[exportName];
-  if (!isRecord6(value) || typeof value.handle !== "function") {
+  if (!isRecord7(value) || typeof value.handle !== "function") {
     throw new TypeError(`Compatibility producer export ${exportName} must expose handle(request).`);
   }
   const { handle } = value;
@@ -2639,16 +4918,16 @@ var resolveProducerHandler = (loaded, exportName) => {
   };
 };
 var loadAbsoluteMobileMaterializedBundle = async (root) => {
-  const resolvedRoot = resolvePath2(root);
-  const serialized = await readFile9(join8(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+  const resolvedRoot = resolvePath3(root);
+  const serialized = await readFile12(join10(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
   const parsed = JSON.parse(serialized);
   const index = parseBundleIndex(parsed);
-  const bundleRoot = join8(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+  const bundleRoot = join10(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
   return {
     artifacts: index.releases,
     currentReleaseId: index.currentReleaseId,
     loadProducer: async (artifact) => {
-      const modulePath = join8(bundleRoot, artifact.releaseId, artifact.producer.module);
+      const modulePath = join10(bundleRoot, artifact.releaseId, artifact.producer.module);
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer: Bun.file(modulePath)
@@ -2674,9 +4953,9 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     }
     return release;
   });
-  const root = resolvePath2(input.root);
-  const bundlesRoot = join8(root, BUNDLES_DIRECTORY);
-  await mkdir7(bundlesRoot, { recursive: true });
+  const root = resolvePath3(input.root);
+  const bundlesRoot = join10(root, BUNDLES_DIRECTORY);
+  await mkdir10(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
   const index = {
@@ -2685,22 +4964,22 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
     releases: artifacts
   };
-  const pointerPath = join8(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join8(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile8(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+  const pointerPath = join10(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join10(root, `.current-${crypto.randomUUID()}.json`);
+  await writeFile11(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
 `, { flag: "wx" });
-  await rename8(temporaryPointerPath, pointerPath);
+  await rename10(temporaryPointerPath, pointerPath);
   return index;
 };
 var readAbsoluteMobileMaterializedReleases = async (root) => {
-  const resolvedRoot = resolvePath2(root);
+  const resolvedRoot = resolvePath3(root);
   try {
-    const serialized = await readFile9(join8(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const serialized = await readFile12(join10(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
     const parsed = JSON.parse(serialized);
     const index = parseBundleIndex(parsed);
-    const bundleRoot = join8(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    const bundleRoot = join10(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
     return Promise.all(index.releases.map(async (artifact) => {
-      const producer = Bun.file(join8(bundleRoot, artifact.releaseId, artifact.producer.module));
+      const producer = Bun.file(join10(bundleRoot, artifact.releaseId, artifact.producer.module));
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer
@@ -2714,6 +4993,269 @@ var readAbsoluteMobileMaterializedReleases = async (root) => {
   }
 };
 
+// src/mobile/nativeAuth.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join11 } from "path";
+var ABSOLUTE_AUTH_PACKAGE = "@absolutejs/auth";
+var ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV = "ABSOLUTE_AUTH_NATIVE_CLIENTS";
+var ABSOLUTE_NATIVE_AUTH_SCOPES = ["openid", "profile"];
+var ABSOLUTE_SYNC_PACKAGE = "@absolutejs/sync";
+var readPackageManifest = (projectRoot) => {
+  try {
+    return JSON.parse(readFileSync2(join11(projectRoot, "package.json"), "utf8"));
+  } catch {
+    return;
+  }
+};
+var packageManifestHas = (manifest, packageName) => {
+  if (typeof manifest !== "object" || manifest === null)
+    return false;
+  return [
+    Reflect.get(manifest, "dependencies"),
+    Reflect.get(manifest, "devDependencies"),
+    Reflect.get(manifest, "optionalDependencies"),
+    Reflect.get(manifest, "peerDependencies")
+  ].some((dependencies) => typeof dependencies === "object" && dependencies !== null && Object.hasOwn(dependencies, packageName));
+};
+var createAbsoluteMobileAuthManifest = (config) => {
+  const scheme = config.deepLinkScheme ?? config.appId.toLowerCase();
+  return {
+    clientId: `absolutejs-native:${config.appId}`,
+    issuer: config.productionOrigin,
+    redirectUri: `${scheme}://auth/callback`,
+    scopes: [...ABSOLUTE_NATIVE_AUTH_SCOPES]
+  };
+};
+var installAbsoluteMobileAuthEnvironment = (projectRoot, config) => {
+  const auth = resolveAbsoluteMobileAuthManifest(projectRoot, config);
+  const serialized = serializeAbsoluteMobileAuthEnvironment(config, auth);
+  if (serialized === undefined)
+    delete process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV];
+  else
+    process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV] = serialized;
+  return auth;
+};
+var projectUsesAbsoluteAuth = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_AUTH_PACKAGE);
+var projectUsesAbsoluteSync = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_SYNC_PACKAGE);
+var resolveAbsoluteMobileAuthManifest = (projectRoot, config) => projectUsesAbsoluteAuth(projectRoot) ? createAbsoluteMobileAuthManifest(config) : undefined;
+var serializeAbsoluteMobileAuthEnvironment = (config, auth) => auth === undefined ? undefined : JSON.stringify([
+  {
+    ...auth,
+    name: `${config.appName} native app`
+  }
+]);
+
+// src/mobile/buildPipeline.ts
+init_syncSchema();
+
+// src/mobile/deviceCapabilities.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { extname as extname3, join as join13, relative as relative9, resolve as resolve11 } from "path";
+import ts from "typescript";
+var DEVICES_PACKAGE = "@absolutejs/devices";
+var CAPACITOR_ADAPTER = "@absolutejs/devices-capacitor";
+var SOURCE_GLOB = new Bun.Glob("**/*.{js,jsx,ts,tsx,svelte,vue}");
+var IGNORED_DIRECTORIES = new Set([
+  ".absolutejs",
+  ".git",
+  ".test-builds",
+  ".test-shards",
+  "build",
+  "dist",
+  "node_modules",
+  "test",
+  "tests"
+]);
+var IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/u;
+var CAPACITOR_MODULE_PATTERN = /^@absolutejs\/devices-capacitor\/[a-z][a-z0-9-]*$/u;
+var CAPACITOR_PACKAGE_PATTERN = /^@capacitor\/[a-z][a-z0-9-]*@\d+\.\d+\.\d+$/u;
+var ANDROID_PERMISSION_PATTERN = /^android\.permission\.[A-Z][A-Z0-9_]*$/u;
+var IOS_USAGE_DESCRIPTIONS = new Set([
+  "camera",
+  "photo-library",
+  "photo-library-add"
+]);
+var object2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readJson = (path) => {
+  const value = JSON.parse(readFileSync4(path, "utf8"));
+  if (!object2(value))
+    throw new TypeError(`${path} must contain an object.`);
+  return value;
+};
+var text = (value, field) => {
+  if (typeof value !== "string" || value.length === 0)
+    throw new TypeError(`${field} must be a non-empty string.`);
+  return value;
+};
+var androidPermissions = (value, field) => {
+  if (value === undefined)
+    return;
+  if (!object2(value))
+    throw new TypeError(`${field} must be an object.`);
+  const { permissions } = value;
+  if (!Array.isArray(permissions) || !permissions.every((permission) => typeof permission === "string" && ANDROID_PERMISSION_PATTERN.test(permission)))
+    throw new TypeError(`${field}.permissions must contain Android permission names.`);
+  return [...permissions];
+};
+var iosUsageDescriptions = (value, field) => {
+  if (value === undefined)
+    return;
+  if (!object2(value))
+    throw new TypeError(`${field} must be an object.`);
+  const { usageDescriptions } = value;
+  if (!Array.isArray(usageDescriptions) || !usageDescriptions.every((purpose) => typeof purpose === "string" && IOS_USAGE_DESCRIPTIONS.has(purpose)))
+    throw new TypeError(`${field}.usageDescriptions contains an unsupported purpose.`);
+  return [...usageDescriptions];
+};
+var parseProvider = (name, value) => {
+  if (!IDENTIFIER_PATTERN.test(name))
+    throw new TypeError("Device capability names must be identifiers.");
+  if (!object2(value))
+    throw new TypeError(`Device capability ${name} must be an object.`);
+  const factory = text(value.factory, `${name}.factory`);
+  const module = text(value.module, `${name}.module`);
+  if (!IDENTIFIER_PATTERN.test(factory))
+    throw new TypeError(`${name}.factory must be a JavaScript identifier.`);
+  if (!CAPACITOR_MODULE_PATTERN.test(module))
+    throw new TypeError(`${name}.module must be an official devices-capacitor subpath.`);
+  if (!Array.isArray(value.packages) || !value.packages.every((spec) => typeof spec === "string" && CAPACITOR_PACKAGE_PATTERN.test(spec)))
+    throw new TypeError(`${name}.packages must contain exact official Capacitor package versions.`);
+  let native;
+  const { native: nativeMetadata } = value;
+  if (nativeMetadata !== undefined) {
+    if (!object2(nativeMetadata))
+      throw new TypeError(`${name}.native must be an object.`);
+    const { android, ios } = nativeMetadata;
+    const permissions = androidPermissions(android, `${name}.native.android`);
+    const usageDescriptions = iosUsageDescriptions(ios, `${name}.native.ios`);
+    native = {
+      ...permissions === undefined ? {} : { android: { permissions } },
+      ...usageDescriptions === undefined ? {} : { ios: { usageDescriptions } }
+    };
+  }
+  return {
+    factory,
+    module,
+    ...native === undefined ? {} : { native },
+    packages: [...value.packages]
+  };
+};
+var absoluteDeviceNativeRequirements = (plan) => ({
+  androidPermissions: [
+    ...new Set(plan.capabilities.flatMap((name) => plan.providers[name]?.native?.android?.permissions ?? []))
+  ].sort(),
+  iosUsageDescriptions: [
+    ...new Set(plan.capabilities.flatMap((name) => plan.providers[name]?.native?.ios?.usageDescriptions ?? []))
+  ].sort()
+});
+var loadAbsoluteDeviceCapabilityProviders = (projectRoot) => {
+  const path = join13(resolve11(projectRoot), "node_modules", CAPACITOR_ADAPTER, "package.json");
+  const manifest = readJson(path);
+  const { absolutejs } = manifest;
+  const devices = object2(absolutejs) ? absolutejs.devices : undefined;
+  if (!object2(devices) || devices.format !== 1 || devices.provider !== "capacitor" || !object2(devices.capabilities))
+    throw new TypeError(`${CAPACITOR_ADAPTER} does not publish supported capability metadata.`);
+  const entries = Object.entries(devices.capabilities).map(([name, provider]) => ({
+    name,
+    provider: parseProvider(name, provider)
+  }));
+  return Object.fromEntries(entries.sort((left, right) => left.name.localeCompare(right.name)).map(({ name, provider }) => [name, provider]));
+};
+var isIgnored = (path) => path.split("/").some((segment) => IGNORED_DIRECTORIES.has(segment));
+var importedCapabilities = (source, file) => {
+  const names = new Set;
+  const namespaces = new Set;
+  const visit = (node) => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && !node.importClause?.isTypeOnly) {
+      const bindings = node.importClause?.namedBindings;
+      if (bindings && ts.isNamedImports(bindings)) {
+        for (const element of bindings.elements)
+          if (!element.isTypeOnly)
+            names.add((element.propertyName ?? element.name).text);
+      }
+      if (bindings && ts.isNamespaceImport(bindings))
+        namespaces.add(bindings.name.text);
+    }
+    if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const element of node.exportClause.elements)
+        if (!element.isTypeOnly)
+          names.add((element.propertyName ?? element.name).text);
+    }
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && namespaces.has(node.expression.text))
+      names.add(node.name.text);
+    ts.forEachChild(node, visit);
+  };
+  const extension = extname3(file).toLowerCase();
+  const sources = extension === ".svelte" || extension === ".vue" ? [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/giu)].map((match) => match[1]).filter((value) => value !== undefined) : [source];
+  for (const [index, script] of sources.entries())
+    visit(ts.createSourceFile(`${file}#script-${index}`, script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX));
+  return names;
+};
+var assertAbsoluteDeviceCapabilityPackages = (projectRoot, plan) => {
+  const missing = missingAbsoluteDeviceCapabilityPackages(plan, directAbsoluteProjectPackages(projectRoot));
+  const mismatched = plan.requiredPackages.filter((spec) => {
+    const separator = spec.lastIndexOf("@");
+    const packageName = spec.slice(0, separator);
+    if (missing.includes(spec))
+      return false;
+    try {
+      return readJson(join13(resolve11(projectRoot), "node_modules", packageName, "package.json")).version !== spec.slice(separator + 1);
+    } catch {
+      return true;
+    }
+  });
+  const unmet = [...missing, ...mismatched];
+  if (unmet.length > 0)
+    throw new TypeError(`Device capabilities ${plan.capabilities.join(", ")} require ${unmet.join(", ")}. Run absolute mobile sync and approve the detected capability plugins.`);
+};
+var directAbsoluteProjectPackages = (projectRoot) => {
+  const manifest = readJson(join13(resolve11(projectRoot), "package.json"));
+  const packages = new Set;
+  for (const field of ["dependencies", "devDependencies"]) {
+    const dependencies = manifest[field];
+    if (object2(dependencies))
+      for (const name of Object.keys(dependencies))
+        packages.add(name);
+  }
+  return packages;
+};
+var discoverAbsoluteDeviceCapabilities = (projectRoot, providers = loadAbsoluteDeviceCapabilityProviders(projectRoot)) => {
+  const root = resolve11(projectRoot);
+  const known = new Set(Object.keys(providers));
+  const capabilities = new Set;
+  for (const path of SOURCE_GLOB.scanSync({ cwd: root })) {
+    const portable = relative9(root, resolve11(root, path)).replaceAll("\\", "/");
+    if (isIgnored(portable))
+      continue;
+    const source = readFileSync4(resolve11(root, portable), "utf8");
+    for (const name of importedCapabilities(source, portable))
+      if (known.has(name))
+        capabilities.add(name);
+  }
+  return [...capabilities].sort();
+};
+var missingAbsoluteDeviceCapabilityPackages = (plan, directPackages) => plan.requiredPackages.filter((spec) => {
+  const packageName = spec.slice(0, spec.lastIndexOf("@"));
+  return !directPackages.has(packageName);
+});
+var resolveAbsoluteDeviceCapabilityPlan = (projectRoot) => {
+  const allProviders = loadAbsoluteDeviceCapabilityProviders(projectRoot);
+  const capabilities = discoverAbsoluteDeviceCapabilities(projectRoot, allProviders);
+  const providers = {};
+  for (const name of capabilities) {
+    const provider = allProviders[name];
+    if (provider)
+      providers[name] = provider;
+  }
+  return {
+    capabilities,
+    providers,
+    requiredPackages: [
+      ...new Set(capabilities.flatMap((name) => providers[name]?.packages ?? []))
+    ].sort()
+  };
+};
+
 // src/mobile/buildPipeline.ts
 var isElysiaApp = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "compile") === "function" && Array.isArray(Reflect.get(value, "routes"));
 var isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
@@ -2724,12 +5266,11 @@ var serverExportName = (loaded, app) => {
     return "app";
   return "default";
 };
-var restoreBuildDirectory = (previous) => {
-  if (previous !== undefined) {
-    process.env.ABSOLUTE_BUILD_DIR = previous;
-    return;
-  }
-  delete process.env.ABSOLUTE_BUILD_DIR;
+var restoreEnvironmentVariable = (name, previous) => {
+  if (previous !== undefined)
+    process.env[name] = previous;
+  else
+    delete process.env[name];
 };
 var requireRelease = (releases, releaseId) => {
   const release = releases.get(releaseId);
@@ -2749,11 +5290,11 @@ var loadServerApp = async (producerPath) => {
   return { app, exportName };
 };
 var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve9(options.buildDirectory);
+  const buildDirectory = resolve12(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join9(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join14(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile10(join9(buildDirectory, "manifest.json"), "utf8"),
+    readFile13(join14(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -2761,12 +5302,20 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     throw new TypeError("Invalid AbsoluteJS build manifest for mobile capture.");
   }
   const previousBuildDirectory = process.env.ABSOLUTE_BUILD_DIR;
+  const previousCompiledRuntime = process.env.ABSOLUTE_COMPILED_RUNTIME;
+  const previousConfigPath = process.env.ABSOLUTE_CONFIG;
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
+  process.env.ABSOLUTE_COMPILED_RUNTIME = "1";
+  if (options.configPath) {
+    process.env.ABSOLUTE_CONFIG = resolve12(options.projectRoot, options.configPath);
+  }
   let loaded;
   try {
-    loaded = await loadServerApp(resolve9(options.producerPath));
+    loaded = await loadServerApp(resolve12(options.producerPath));
   } finally {
-    restoreBuildDirectory(previousBuildDirectory);
+    restoreEnvironmentVariable("ABSOLUTE_BUILD_DIR", previousBuildDirectory);
+    restoreEnvironmentVariable("ABSOLUTE_COMPILED_RUNTIME", previousCompiledRuntime);
+    restoreEnvironmentVariable("ABSOLUTE_CONFIG", previousConfigPath);
   }
   const current = await buildAbsoluteMobileCompatibilityRelease({
     app: loaded.app,
@@ -2775,9 +5324,17 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve9(options.producerPath),
+    producerPath: resolve12(options.producerPath),
     runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
   });
+  const auth = resolveAbsoluteMobileAuthManifest(options.projectRoot, mobile);
+  const sync = auth !== undefined && projectUsesAbsoluteSync(options.projectRoot);
+  const syncSchema = sync ? discoverAbsoluteSyncSchema(options.projectRoot) : undefined;
+  const deviceCapabilities = resolveAbsoluteDeviceCapabilityPlan(options.projectRoot);
+  assertAbsoluteDeviceCapabilityPackages(options.projectRoot, deviceCapabilities);
+  if (auth && !loaded.app.routes.some((route) => route.path === "/.well-known/openid-configuration")) {
+    throw new TypeError("@absolutejs/auth is installed, but its OIDC provider is not mounted. Native authentication requires the auth oidc configuration so AbsoluteJS can provision a public PKCE client.");
+  }
   const releasesById = new Map([current, ...previous].map((release) => [
     release.artifact.releaseId,
     release
@@ -2790,11 +5347,127 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   });
   await materializeAbsoluteCapacitorWebBundle({
     artifact: current.artifact,
+    ...auth ? { auth } : {},
     buildDirectory,
-    config: mobile
+    config: mobile,
+    deviceCapabilities,
+    projectRoot: options.projectRoot,
+    ...sync ? { sync: true } : {},
+    ...syncSchema ? { syncSchema: { components: syncSchema.components } } : {}
   });
   return current.artifact;
 };
+
+// src/mobile/index.ts
+init_syncSchema();
+
+// node_modules/@absolutejs/sync/dist/client/runtimeTransport.js
+var RUNTIME_TRANSPORT2 = Symbol.for("@absolutejs/sync/client-runtime-transport");
+var host2 = globalThis;
+var isRegistry2 = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations")) && Array.isArray(Reflect.get(value, "clients"));
+var registry2 = (() => {
+  const existing = host2[RUNTIME_TRANSPORT2];
+  if (isRegistry2(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(host2, RUNTIME_TRANSPORT2, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+})();
+var maximum = (values) => {
+  const present = values.filter((value) => value !== undefined);
+  return present.length === 0 ? undefined : Math.max(...present);
+};
+var minimum = (values) => {
+  const present = values.filter((value) => value !== undefined);
+  return present.length === 0 ? undefined : Math.min(...present);
+};
+var inspectSyncRuntime = async () => {
+  const clients = [...registry2.clients];
+  const statuses = clients.map((client) => client.status());
+  const deadLetters = (await Promise.all(clients.map((client) => client.listDeadLetters()))).flat().map((record) => ({
+    attempts: record.attempts,
+    ...record.rejection?.code ? { code: record.rejection.code } : {},
+    createdAt: record.createdAt,
+    ...record.deadLetteredAt === undefined ? {} : { deadLetteredAt: record.deadLetteredAt },
+    ...record.rejection?.kind ? { kind: record.rejection.kind } : {},
+    ...record.rejection?.message ? { message: record.rejection.message } : {},
+    name: record.name,
+    operationId: record.operationId
+  })).sort((left, right) => (left.deadLetteredAt ?? left.createdAt) - (right.deadLetteredAt ?? right.createdAt) || left.operationId.localeCompare(right.operationId));
+  const lastError = statuses.findLast((status) => status.lastError)?.lastError;
+  return {
+    automaticResolutions: statuses.reduce((total, status) => total + status.automaticResolutions, 0),
+    clients: clients.length,
+    conflicts: deadLetters.filter((record) => record.kind === "conflict").length,
+    deadLetters,
+    ...lastError ? { lastError } : {},
+    ...maximum(statuses.map((status) => status.lastSuccessfulPullAt)) === undefined ? {} : {
+      lastSuccessfulPullAt: maximum(statuses.map((status) => status.lastSuccessfulPullAt))
+    },
+    ...maximum(statuses.map((status) => status.lastSuccessfulPushAt)) === undefined ? {} : {
+      lastSuccessfulPushAt: maximum(statuses.map((status) => status.lastSuccessfulPushAt))
+    },
+    ...minimum(statuses.map((status) => status.oldestDeadLetterAt)) === undefined ? {} : {
+      oldestDeadLetterAt: minimum(statuses.map((status) => status.oldestDeadLetterAt))
+    },
+    ...minimum(statuses.map((status) => status.oldestPendingAt)) === undefined ? {} : {
+      oldestPendingAt: minimum(statuses.map((status) => status.oldestPendingAt))
+    },
+    pending: statuses.reduce((total, status) => total + status.pending, 0)
+  };
+};
+var clientWithDeadLetter = async (operationId) => {
+  for (const client of registry2.clients)
+    if ((await client.listDeadLetters()).some((record) => record.operationId === operationId))
+      return client;
+  throw new Error(`Unknown Sync dead letter "${operationId}"`);
+};
+var retrySyncRuntimeDeadLetter = async (operationId) => (await clientWithDeadLetter(operationId)).retryDeadLetter(operationId);
+var discardSyncRuntimeDeadLetter = async (operationId) => (await clientWithDeadLetter(operationId)).discardDeadLetter(operationId);
+var rebaseSyncRuntimeDeadLetter = async (operationId, args) => (await clientWithDeadLetter(operationId)).rebaseDeadLetter(operationId, args);
+
+// src/mobile/syncRemediation.ts
+var REMEDIATION_REGISTRY = Symbol.for("@absolutejs/mobile-sync-remediation");
+var LAST_INSTALLATION_OFFSET = -1;
+var isRegistry3 = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations"));
+var resolveRegistry = () => {
+  const existing = Reflect.get(globalThis, REMEDIATION_REGISTRY);
+  if (isRegistry3(existing))
+    return existing;
+  const created = { installations: [] };
+  Object.defineProperty(globalThis, REMEDIATION_REGISTRY, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+};
+var registry3 = resolveRegistry();
+var getAbsoluteMobileSyncRemediation = () => registry3.installations.at(LAST_INSTALLATION_OFFSET)?.bridge;
+var installAbsoluteMobileSyncRemediation = (bridge = {
+  discard: discardSyncRuntimeDeadLetter,
+  inspect: inspectSyncRuntime,
+  rebase: rebaseSyncRuntimeDeadLetter,
+  retry: retrySyncRuntimeDeadLetter
+}) => {
+  const installation = { bridge };
+  registry3.installations.push(installation);
+  return () => {
+    const index = registry3.installations.indexOf(installation);
+    if (index >= 0)
+      registry3.installations.splice(index, 1);
+  };
+};
 // src/mobile/compatibilityDispatcher.ts
 import { Elysia as Elysia2 } from "elysia";
 
@@ -2816,6 +5489,64 @@ var ensureProducerStorage = () => {
 var runWithAbsoluteMobileProducer = (context, callback) => ensureProducerStorage().run(context, callback);
 
 // src/mobile/compatibilityDispatcher.ts
+var MOBILE_WEBVIEW_ORIGINS = new Set([
+  "capacitor://localhost",
+  "http://localhost",
+  "https://localhost"
+]);
+var MOBILE_REQUEST_HEADER_NAMES = Object.values(MOBILE_PAGE_REQUEST_HEADERS);
+var MOBILE_CORS_ALLOW_HEADERS = [
+  "accept",
+  "content-type",
+  "authorization",
+  "hx-current-url",
+  "hx-request",
+  "hx-target",
+  "hx-trigger",
+  "hx-trigger-name",
+  ...MOBILE_REQUEST_HEADER_NAMES
+].join(", ");
+var MOBILE_CORS_METHODS = new Set([
+  "DELETE",
+  "GET",
+  "HEAD",
+  "OPTIONS",
+  "PATCH",
+  "POST",
+  "PUT"
+]);
+var mobileWebViewOrigin = (request) => {
+  const origin = request.headers.get("origin");
+  return origin && MOBILE_WEBVIEW_ORIGINS.has(origin) ? origin : undefined;
+};
+var applyMobileCorsHeaders = (response, origin) => {
+  response.headers.set("access-control-allow-credentials", "true");
+  response.headers.set("access-control-allow-origin", origin);
+  response.headers.append("vary", "Origin");
+  return response;
+};
+var mobilePreflightResponse = (request) => {
+  if (request.method !== "OPTIONS")
+    return;
+  const origin = mobileWebViewOrigin(request);
+  if (!origin)
+    return;
+  const requestedHeaders = request.headers.get("access-control-request-headers");
+  const requestedMethod = request.headers.get("access-control-request-method")?.toUpperCase() ?? "";
+  if (!MOBILE_CORS_METHODS.has(requestedMethod))
+    return;
+  return new Response(null, {
+    headers: {
+      "access-control-allow-credentials": "true",
+      "access-control-allow-headers": requestedHeaders || MOBILE_CORS_ALLOW_HEADERS,
+      "access-control-allow-methods": [...MOBILE_CORS_METHODS].join(", "),
+      "access-control-allow-origin": origin,
+      "access-control-max-age": "600",
+      vary: "Origin, Access-Control-Request-Headers"
+    },
+    status: 204
+  });
+};
 var artifactOwnsRequest = (artifact, pageId, request) => {
   const { pathname } = new URL(request.url);
   return artifact.routes.some((route) => route.pageId === pageId && route.method === request.method && matchesAbsoluteMobileRoutePattern(route.pattern, pathname));
@@ -2843,6 +5574,9 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
   return new Elysia2({ name: "absolutejs-mobile-compatibility-dispatcher" }).request(async ({ request }) => {
     if (getCurrentAbsoluteMobileProducerContext())
       return;
+    const preflight = mobilePreflightResponse(request);
+    if (preflight)
+      return preflight;
     const parsed = parseAbsoluteMobilePageRequest(request);
     if (parsed.kind !== "mobile")
       return;
@@ -2866,23 +5600,28 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
       console.error(`[Mobile] Failed to load retained producer ${resolved.artifact.releaseId}:`, error);
       return createAbsoluteMobilePageErrorResponse(parsed.client.pageId);
     }
+  }).afterHandle("global", ({ request, responseValue }) => {
+    const origin = mobileWebViewOrigin(request);
+    if (!origin || !(responseValue instanceof Response))
+      return;
+    applyMobileCorsHeaders(responseValue, origin);
   }).as("global");
 };
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile11, rename as rename9, writeFile as writeFile9 } from "fs/promises";
-import { join as join10 } from "path";
+import { readFile as readFile14, rename as rename11, writeFile as writeFile12 } from "fs/promises";
+import { join as join15 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->";
 var END_MARKER = "<!-- absolutejs:deep-links:end -->";
 var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
 var NOT_FOUND = -1;
 var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var writeChangedFile = async (path, source) => {
-  const current = await readFile11(path, "utf8");
+  const current = await readFile14(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile9(temporary, source, { flag: "wx" });
-  await rename9(temporary, path);
+  await writeFile12(temporary, source, { flag: "wx" });
+  await rename11(temporary, path);
   return true;
 };
 var replaceManagedRegion = (source, region, insertAt) => {
@@ -2906,7 +5645,7 @@ var replaceManagedRegion = (source, region, insertAt) => {
   return `${source.slice(0, index)}${region}${source.slice(index)}`;
 };
 var androidRegion = (config) => {
-  const hosts = config.deepLinkHosts.map((host) => `                <data android:scheme="https" android:host="${escapeXml(host)}" />`).join(`
+  const hosts = config.deepLinkHosts.map((host3) => `                <data android:scheme="https" android:host="${escapeXml(host3)}" />`).join(`
 `);
   const customScheme = config.deepLinkScheme ? `
 
@@ -2927,8 +5666,8 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join10(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile11(path, "utf8");
+  const path = join15(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile14(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
     throw new TypeError("Android MainActivity was not found.");
@@ -2953,8 +5692,8 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join10(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile11(path, "utf8");
+  const path = join15(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile14(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
 `;
@@ -2962,7 +5701,7 @@ var configureIosInfo = async (config) => {
   return writeChangedFile(path, updated);
 };
 var iosEntitlementsSource = (config) => {
-  const domains = config.deepLinkHosts.map((host) => `		<string>applinks:${escapeXml(host)}</string>`).join(`
+  const domains = config.deepLinkHosts.map((host3) => `		<string>applinks:${escapeXml(host3)}</string>`).join(`
 `);
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -2977,10 +5716,10 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join10(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join15(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
-    current = await readFile11(path, "utf8");
+    current = await readFile14(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -2990,13 +5729,13 @@ var configureIosEntitlements = async (config) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile9(temporary, source, { flag: "wx" });
-  await rename9(temporary, path);
+  await writeFile12(temporary, source, { flag: "wx" });
+  await rename11(temporary, path);
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join10(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const source = await readFile11(path, "utf8");
+  const path = join15(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const source = await readFile14(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
   ].map((match) => match[1]);
@@ -3033,9 +5772,93 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
     changed: results.filter(({ didChange }) => didChange).map(({ platform }) => platform)
   };
 };
+// src/mobile/nativeDeviceCapabilities.ts
+import { readFile as readFile15, rename as rename12, writeFile as writeFile13 } from "fs/promises";
+import { join as join16 } from "path";
+var START_MARKER2 = "<!-- absolutejs:device-capabilities:start -->";
+var END_MARKER2 = "<!-- absolutejs:device-capabilities:end -->";
+var NOT_FOUND2 = -1;
+var escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var writeChangedFile2 = async (path, source) => {
+  const current = await readFile15(path, "utf8");
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile13(temporary, source, { flag: "wx" });
+  await rename12(temporary, path);
+  return true;
+};
+var managed = (source, region, insertion) => {
+  const start = source.indexOf(START_MARKER2);
+  const end = source.indexOf(END_MARKER2);
+  if (start === NOT_FOUND2 !== (end === NOT_FOUND2) || start !== NOT_FOUND2 && end < start)
+    throw new TypeError("AbsoluteJS device-capability ownership markers are malformed.");
+  if (start !== NOT_FOUND2) {
+    const lineStart = source.lastIndexOf(`
+`, start) + 1;
+    const nextLine = source.indexOf(`
+`, end + END_MARKER2.length);
+    const lineEnd = nextLine === NOT_FOUND2 ? source.length : nextLine + 1;
+    return `${source.slice(0, lineStart)}${region}${source.slice(lineEnd)}`;
+  }
+  if (region.length === 0)
+    return source;
+  if (insertion === NOT_FOUND2)
+    throw new TypeError("Could not find a safe native project location for device permissions.");
+  return `${source.slice(0, insertion)}${region}${source.slice(insertion)}`;
+};
+var IOS_KEYS = {
+  camera: "NSCameraUsageDescription",
+  "photo-library": "NSPhotoLibraryUsageDescription",
+  "photo-library-add": "NSPhotoLibraryAddUsageDescription"
+};
+var iosDescription = (appName, purpose) => {
+  if (purpose === "camera")
+    return `${appName} uses your camera when you choose to take a photo.`;
+  if (purpose === "photo-library")
+    return `${appName} accesses your photo library only for photo actions you choose.`;
+  return `${appName} adds to your photo library only for photo actions you choose.`;
+};
+var configureIos2 = async (config, plan) => {
+  const path = join16(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile15(path, "utf8");
+  const requirements = absoluteDeviceNativeRequirements(plan);
+  const content = requirements.iosUsageDescriptions.map((purpose) => `	<key>${IOS_KEYS[purpose]}</key>
+	<string>${escapeXml2(iosDescription(config.appName, purpose))}</string>`).join(`
+`);
+  const region = content ? `	${START_MARKER2}
+${content}
+	${END_MARKER2}
+` : "";
+  return writeChangedFile2(path, managed(source, region, source.lastIndexOf("</dict>")));
+};
+var configureAndroid2 = async (config, plan) => {
+  const path = join16(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile15(path, "utf8");
+  const permissions = absoluteDeviceNativeRequirements(plan).androidPermissions;
+  const content = permissions.map((permission) => `    <uses-permission android:name="${escapeXml2(permission)}" />`).join(`
+`);
+  const region = content ? `    ${START_MARKER2}
+${content}
+    ${END_MARKER2}
+` : "";
+  const application = source.indexOf("<application");
+  const insertion = application === NOT_FOUND2 ? NOT_FOUND2 : source.lastIndexOf(`
+`, application) + 1;
+  return writeChangedFile2(path, managed(source, region, insertion));
+};
+var applyAbsoluteNativeDeviceCapabilities = async (projectRoot, config, platforms = config.platforms, plan = resolveAbsoluteDeviceCapabilityPlan(projectRoot)) => {
+  const results = await Promise.all(platforms.map(async (platform) => ({
+    didChange: platform === "ios" ? await configureIos2(config, plan) : await configureAndroid2(config, plan),
+    platform
+  })));
+  return {
+    changed: results.filter(({ didChange }) => didChange).map(({ platform }) => platform)
+  };
+};
 // src/mobile/releasePublisher.ts
-import { access as access7 } from "fs/promises";
-import { isAbsolute as isAbsolute4, relative as relative6, resolve as resolve10, sep as sep4 } from "path";
+import { access as access9 } from "fs/promises";
+import { isAbsolute as isAbsolute6, relative as relative10, resolve as resolve13, sep as sep6 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -3058,24 +5881,24 @@ var prepareAbsoluteAndroidRelease = async (publisher, options) => {
   }
   return versionCode;
 };
-var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isPublisher = (value) => isRecord7(value) && typeof value.publish === "function";
+var isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPublisher = (value) => isRecord8(value) && typeof value.publish === "function";
 var publisherModulePath = (projectRoot, requested) => {
-  const root = resolve10(projectRoot);
-  const path = resolve10(root, requested);
-  const projectRelative = relative6(root, path);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep4}`) || isAbsolute4(projectRelative)) {
+  const root = resolve13(projectRoot);
+  const path = resolve13(root, requested);
+  const projectRelative = relative10(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute6(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
   return path;
 };
 var loadAbsoluteNativeReleasePublisher = async (projectRoot, requestedModulePath) => {
   const modulePath = publisherModulePath(projectRoot, requestedModulePath);
-  await access7(modulePath).catch(() => {
+  await access9(modulePath).catch(() => {
     throw new TypeError(`Native release registry module does not exist: ${modulePath}`);
   });
   const loaded = await import(pathToFileURL3(modulePath).href);
-  const publisher = isRecord7(loaded) ? loaded.default ?? loaded.registry : undefined;
+  const publisher = isRecord8(loaded) ? loaded.default ?? loaded.registry : undefined;
   if (!isPublisher(publisher)) {
     throw new TypeError("Native release registry module must default-export a registry with publish(options).");
   }
@@ -3132,67 +5955,112 @@ var publishAbsoluteIosRelease = async (options) => {
   return publication;
 };
 // src/mobile/routeMetadataTransform.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname6, extname as extname2, relative as relative7, resolve as resolve11 } from "path";
-import ts from "typescript";
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname10, extname as extname4, relative as relative11, resolve as resolve14 } from "path";
+import ts2 from "typescript";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
-var PAGE_HANDLER = "handleReactPageRequest";
+var PAGE_HANDLERS = new Map([
+  [
+    "handleHTMLPageRequest",
+    { framework: "html", inputKind: "static", propsProperty: "props" }
+  ],
+  [
+    "handleHTMXPageRequest",
+    { framework: "htmx", inputKind: "static", propsProperty: "props" }
+  ],
+  [
+    "handleAngularPageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "angular",
+      propsProperty: "requestContext",
+      sourceProperty: "pagePath"
+    }
+  ],
+  [
+    "handleReactPageRequest",
+    {
+      bundleProperty: "index",
+      framework: "react",
+      pageProperty: "Page",
+      propsProperty: "props"
+    }
+  ],
+  [
+    "handleSveltePageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "svelte",
+      propsProperty: "props",
+      sourceProperty: "pagePath"
+    }
+  ],
+  [
+    "handleVuePageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "vue",
+      propsProperty: "props",
+      sourceProperty: "pagePath"
+    }
+  ]
+]);
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname6(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => ts2.findConfigFile(dirname10(entry), existsSync3, "tsconfig.json") ?? ts2.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
-    return ts.createProgram([entry], {
+    return ts2.createProgram([entry], {
       allowJs: true,
-      jsx: ts.JsxEmit.ReactJSX,
-      module: ts.ModuleKind.ESNext,
-      moduleResolution: ts.ModuleResolutionKind.Bundler,
-      target: ts.ScriptTarget.ESNext
+      jsx: ts2.JsxEmit.ReactJSX,
+      module: ts2.ModuleKind.ESNext,
+      moduleResolution: ts2.ModuleResolutionKind.Bundler,
+      target: ts2.ScriptTarget.ESNext
     });
   }
-  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync2(path, "utf8")).config, ts.sys, dirname6(configPath));
+  const parsed = ts2.parseJsonConfigFileContent(ts2.readConfigFile(configPath, (path) => readFileSync5(path, "utf8")).config, ts2.sys, dirname10(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
-  return ts.createProgram(parsed.fileNames, parsed.options);
+  return ts2.createProgram(parsed.fileNames, parsed.options);
 };
 var propertyName = (property) => {
   if (!("name" in property) || !property.name)
     return;
-  if (ts.isIdentifier(property.name))
+  if (ts2.isIdentifier(property.name))
     return property.name.text;
-  if (ts.isStringLiteralLike(property.name))
+  if (ts2.isStringLiteralLike(property.name))
     return property.name.text;
   return;
 };
-var objectPropertyExpression = (object, name) => {
-  const property = object.properties.find((candidate) => propertyName(candidate) === name);
-  if (property && ts.isPropertyAssignment(property)) {
+var objectPropertyExpression = (object3, name) => {
+  const property = object3.properties.find((candidate) => propertyName(candidate) === name);
+  if (property && ts2.isPropertyAssignment(property)) {
     return property.initializer;
   }
-  if (property && ts.isShorthandPropertyAssignment(property)) {
+  if (property && ts2.isShorthandPropertyAssignment(property)) {
     return property.name;
   }
   return;
 };
 var serializeType = (type, checker, ancestors = new Set) => {
-  if (type.flags & ts.TypeFlags.Any)
+  if (type.flags & ts2.TypeFlags.Any)
     return { type: "any" };
-  if (type.flags & ts.TypeFlags.Unknown)
+  if (type.flags & ts2.TypeFlags.Unknown)
     return { type: "unknown" };
-  if (type.flags & ts.TypeFlags.Never)
+  if (type.flags & ts2.TypeFlags.Never)
     return { type: "never" };
-  if (type.flags & ts.TypeFlags.StringLike)
+  if (type.flags & ts2.TypeFlags.StringLike)
     return { type: "string" };
-  if (type.flags & ts.TypeFlags.NumberLike)
+  if (type.flags & ts2.TypeFlags.NumberLike)
     return { type: "number" };
-  if (type.flags & ts.TypeFlags.BooleanLike)
+  if (type.flags & ts2.TypeFlags.BooleanLike)
     return { type: "boolean" };
-  if (type.flags & ts.TypeFlags.BigIntLike)
+  if (type.flags & ts2.TypeFlags.BigIntLike)
     return { type: "bigint" };
-  if (type.flags & ts.TypeFlags.Null)
+  if (type.flags & ts2.TypeFlags.Null)
     return { type: "null" };
-  if (type.flags & ts.TypeFlags.Undefined)
+  if (type.flags & ts2.TypeFlags.Undefined)
     return { type: "undefined" };
   if (type.isUnion()) {
     return {
@@ -3206,11 +6074,11 @@ var serializeType = (type, checker, ancestors = new Set) => {
   }
   if (ancestors.has(type)) {
     return {
-      ref: checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)
+      ref: checker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation)
     };
   }
   ancestors.add(type);
-  const arrayElement = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+  const arrayElement = checker.getIndexTypeOfType(type, ts2.IndexKind.Number);
   const properties = checker.getPropertiesOfType(type);
   let schema;
   if (arrayElement && properties.some(({ name }) => name === "length")) {
@@ -3225,7 +6093,7 @@ var serializeType = (type, checker, ancestors = new Set) => {
       return [
         property.name,
         {
-          optional: Boolean(property.flags & ts.SymbolFlags.Optional),
+          optional: Boolean(property.flags & ts2.SymbolFlags.Optional),
           schema: serializeType(propertyType, checker, ancestors)
         }
       ];
@@ -3233,7 +6101,7 @@ var serializeType = (type, checker, ancestors = new Set) => {
     schema = { properties: Object.fromEntries(entries), type: "object" };
   } else {
     schema = {
-      type: checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)
+      type: checker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation)
     };
   }
   ancestors.delete(type);
@@ -3251,25 +6119,25 @@ var pagePropsType = (pageExpression, propsExpression, checker) => {
 };
 var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   let symbol = checker.getSymbolAtLocation(expression);
-  if (symbol?.flags && symbol.flags & ts.SymbolFlags.Alias) {
+  if (symbol?.flags && symbol.flags & ts2.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   const declaration = symbol?.declarations?.[0];
   const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
   const exportedName = symbol?.name ?? expression.getText(sourceFile);
-  const source = posixPath(relative7(projectRoot, file));
+  const source = posixPath(relative11(projectRoot, file));
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
-  if (!(symbol.flags & ts.SymbolFlags.Alias))
+  if (!(symbol.flags & ts2.SymbolFlags.Alias))
     return symbol;
   return checker.getAliasedSymbol(symbol);
 };
 var assetKey = (expression, checker, seen = new Set) => {
   if (!expression)
     return;
-  if (ts.isIdentifier(expression)) {
-    const unresolved = ts.isShorthandPropertyAssignment(expression.parent) ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
+  if (ts2.isIdentifier(expression)) {
+    const unresolved = ts2.isShorthandPropertyAssignment(expression.parent) ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
     if (!unresolved)
       return;
     const symbol = resolveAlias(unresolved, checker);
@@ -3277,28 +6145,123 @@ var assetKey = (expression, checker, seen = new Set) => {
       return;
     seen.add(symbol);
     const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
-    if (!declaration || !ts.isVariableDeclaration(declaration))
+    if (!declaration || !ts2.isVariableDeclaration(declaration))
       return;
     return assetKey(declaration.initializer, checker, seen);
   }
-  if (!ts.isCallExpression(expression))
+  if (!ts2.isCallExpression(expression))
     return;
-  if (!ts.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
+  if (!ts2.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
     return;
   }
   const [, key] = expression.arguments;
-  return key && ts.isStringLiteralLike(key) ? key.text : undefined;
+  return key && ts2.isStringLiteralLike(key) ? key.text : undefined;
+};
+var staticString = (expression, bindings) => {
+  if (ts2.isStringLiteralLike(expression))
+    return expression.text;
+  if (ts2.isIdentifier(expression))
+    return bindings.get(expression.text);
+  if (ts2.isNoSubstitutionTemplateLiteral(expression))
+    return expression.text;
+  if (!ts2.isTemplateExpression(expression))
+    return;
+  let value = expression.head.text;
+  for (const span of expression.templateSpans) {
+    const substitution = staticString(span.expression, bindings);
+    if (substitution === undefined)
+      return;
+    value += substitution + span.literal.text;
+  }
+  return value;
+};
+var assetKeyWithBindings = (expression, checker, bindings = new Map) => {
+  if (!expression)
+    return;
+  if (ts2.isCallExpression(expression) && ts2.isIdentifier(expression.expression) && expression.expression.text === "asset") {
+    const [, key] = expression.arguments;
+    return key ? staticString(key, bindings) : undefined;
+  }
+  return assetKey(expression, checker);
+};
+var callableObject = (call, checker) => {
+  const symbol = checker.getSymbolAtLocation(call.expression);
+  const resolved = symbol ? resolveAlias(symbol, checker) : undefined;
+  const declaration = resolved?.valueDeclaration ?? resolved?.declarations?.[0];
+  let callable;
+  if (declaration && ts2.isFunctionDeclaration(declaration)) {
+    callable = declaration;
+  } else if (declaration && ts2.isVariableDeclaration(declaration) && declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer))) {
+    callable = declaration.initializer;
+  }
+  if (!callable)
+    return;
+  const bindings = new Map;
+  callable.parameters.forEach((parameter, index) => {
+    if (!ts2.isIdentifier(parameter.name))
+      return;
+    const argument = call.arguments[index];
+    if (!argument)
+      return;
+    const value = staticString(argument, new Map);
+    if (value !== undefined)
+      bindings.set(parameter.name.text, value);
+  });
+  const { body } = callable;
+  if (!body)
+    return;
+  const expressionBody = ts2.isParenthesizedExpression(body) ? body.expression : body;
+  if (ts2.isObjectLiteralExpression(expressionBody)) {
+    return { bindings, object: expressionBody };
+  }
+  if (ts2.isBlock(body)) {
+    const returned = body.statements.find(ts2.isReturnStatement)?.expression;
+    if (returned && ts2.isObjectLiteralExpression(returned)) {
+      return { bindings, object: returned };
+    }
+  }
+  return;
+};
+var spreadObject = (expression, checker, bindings) => {
+  if (ts2.isObjectLiteralExpression(expression)) {
+    return { bindings, object: expression };
+  }
+  if (!ts2.isCallExpression(expression))
+    return;
+  return callableObject(expression, checker);
+};
+var objectAssetKey = (object3, name, checker, bindings = new Map) => {
+  for (const property of [...object3.properties].reverse()) {
+    if (propertyName(property) === name && ts2.isShorthandPropertyAssignment(property)) {
+      return assetKeyWithBindings(property.name, checker, bindings);
+    }
+    if (propertyName(property) === name && ts2.isPropertyAssignment(property)) {
+      return assetKeyWithBindings(property.initializer, checker, bindings);
+    }
+    if (!ts2.isSpreadAssignment(property))
+      continue;
+    const nestedObject = spreadObject(property.expression, checker, bindings);
+    if (!nestedObject)
+      continue;
+    const nested = objectAssetKey(nestedObject.object, name, checker, nestedObject.bindings);
+    if (nested)
+      return nested;
+  }
+  return;
 };
 var findPageCall = (nodes) => {
   let found;
   const visit = (candidate) => {
     if (found)
       return;
-    if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && candidate.expression.text === PAGE_HANDLER) {
-      found = candidate;
+    if (ts2.isCallExpression(candidate) && ts2.isIdentifier(candidate.expression) && PAGE_HANDLERS.has(candidate.expression.text)) {
+      const definition = PAGE_HANDLERS.get(candidate.expression.text);
+      if (!definition)
+        return;
+      found = { definition, node: candidate };
       return;
     }
-    ts.forEachChild(candidate, visit);
+    ts2.forEachChild(candidate, visit);
   };
   for (const node of nodes)
     visit(node);
@@ -3307,37 +6270,74 @@ var findPageCall = (nodes) => {
 var isProjectSource = (sourceFile, resolvedFile, projectRoot) => !sourceFile.isDeclarationFile && !resolvedFile.includes("/node_modules/") && resolvedFile.startsWith(`${projectRoot}/`);
 var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
   const callee = node.expression;
-  if (!ts.isPropertyAccessExpression(callee))
+  if (!ts2.isPropertyAccessExpression(callee))
     return;
   if (!ROUTE_METHODS.has(callee.name.text))
     return;
   const [routePath] = node.arguments;
-  if (!routePath || !ts.isStringLiteralLike(routePath))
+  if (!routePath || !ts2.isStringLiteralLike(routePath))
     return;
-  const pageCall = findPageCall(node.arguments.slice(1));
+  const foundPageCall = findPageCall(node.arguments.slice(1));
+  const pageCall = foundPageCall?.node;
+  const definition = foundPageCall?.definition;
   const [input] = pageCall?.arguments ?? [];
-  if (!pageCall || !input || !ts.isObjectLiteralExpression(input)) {
+  if (!pageCall || !input) {
     return;
   }
-  const page = objectPropertyExpression(input, "Page");
-  if (!page)
+  if (!definition)
+    return;
+  if (definition.inputKind === "static") {
+    const bundleKey2 = assetKey(input, checker);
+    if (!bundleKey2)
+      return;
+    const pageId2 = `${definition.framework}:${bundleKey2}`;
+    const propsSchemaHash2 = hashAbsoluteMobilePropsSchema({
+      properties: {},
+      type: "object"
+    });
+    return {
+      inputKind: "static",
+      metadata: {
+        bundleKey: bundleKey2,
+        contract: `${definition.framework}:${pageId2}:${propsSchemaHash2}`,
+        framework: definition.framework,
+        pageId: pageId2,
+        propsSchemaHash: propsSchemaHash2
+      },
+      pageCallStart: pageCall.getStart(sourceFile),
+      routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
+    };
+  }
+  if (!ts2.isObjectLiteralExpression(input) || !definition.bundleProperty) {
+    return;
+  }
+  const page = definition.pageProperty ? objectPropertyExpression(input, definition.pageProperty) : undefined;
+  const source = definition.sourceProperty ? objectAssetKey(input, definition.sourceProperty, checker) : undefined;
+  if (definition.pageProperty && !page)
+    return;
+  if (definition.sourceProperty && !source)
     return;
-  const props = objectPropertyExpression(input, "props");
-  const index = objectPropertyExpression(input, "index");
-  const bundleKey = assetKey(index, checker);
+  const props = objectPropertyExpression(input, definition.propsProperty);
+  const bundleKey = objectAssetKey(input, definition.bundleProperty, checker);
   if (!bundleKey)
     return;
-  const pageId = resolvePageIdentity(page, sourceFile, checker, projectRoot);
-  const schema = serializeType(pagePropsType(page, props, checker), checker);
+  const pageId = page ? resolvePageIdentity(page, sourceFile, checker, projectRoot) : `${definition.framework}:${source}`;
+  let propsType;
+  if (page)
+    propsType = pagePropsType(page, props, checker);
+  else if (props)
+    propsType = checker.getTypeAtLocation(props);
+  const schema = propsType ? serializeType(propsType, checker) : { properties: {}, type: "object" };
   const propsSchemaHash = hashAbsoluteMobilePropsSchema(schema);
   const metadata = {
     bundleKey,
-    contract: `react:${pageId}:${propsSchemaHash}`,
-    framework: "react",
+    contract: `${definition.framework}:${pageId}:${propsSchemaHash}`,
+    framework: definition.framework,
     pageId,
     propsSchemaHash
   };
   const result = {
+    inputKind: "object",
     metadata,
     pageCallStart: pageCall.getStart(sourceFile),
     routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
@@ -3350,21 +6350,21 @@ var analyzeSourceFile = (sourceFile, checker, projectRoot) => {
     byRouteCall: new Map
   };
   const visit = (node) => {
-    const result = ts.isCallExpression(node) ? analyzeRouteCall(node, sourceFile, checker, projectRoot) : undefined;
+    const result = ts2.isCallExpression(node) ? analyzeRouteCall(node, sourceFile, checker, projectRoot) : undefined;
     if (result) {
       analysis.byPageCall.set(result.pageCallStart, result);
       analysis.byRouteCall.set(result.routeCallSpan, result);
     }
-    ts.forEachChild(node, visit);
+    ts2.forEachChild(node, visit);
   };
-  ts.forEachChild(sourceFile, visit);
+  ts2.forEachChild(sourceFile, visit);
   return analysis;
 };
 var analyzeProgram = (program, projectRoot) => {
   const checker = program.getTypeChecker();
   const analyzed = new Map;
   for (const sourceFile of program.getSourceFiles()) {
-    const resolvedFile = resolve11(sourceFile.fileName);
+    const resolvedFile = resolve14(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -3373,34 +6373,44 @@ var analyzeProgram = (program, projectRoot) => {
   }
   return analyzed;
 };
-var metadataExpression = (metadata) => ts.factory.createObjectLiteralExpression(Object.entries(metadata).map(([key, item]) => ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(key), ts.factory.createStringLiteral(item))), false);
+var metadataExpression = (metadata) => ts2.factory.createObjectLiteralExpression(Object.entries(metadata).map(([key, item]) => ts2.factory.createPropertyAssignment(ts2.factory.createStringLiteral(key), ts2.factory.createStringLiteral(item))), false);
 var routeOptions = (existing, metadata) => {
-  const detail = ts.factory.createObjectLiteralExpression([
-    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
+  const detail = ts2.factory.createObjectLiteralExpression([
+    ts2.factory.createPropertyAssignment(ts2.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
   ]);
   if (!existing) {
-    return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("detail", detail)
+    return ts2.factory.createObjectLiteralExpression([
+      ts2.factory.createPropertyAssignment("detail", detail)
     ]);
   }
-  return ts.factory.createObjectLiteralExpression([
-    ts.factory.createSpreadAssignment(existing),
-    ts.factory.createPropertyAssignment("detail", ts.factory.createObjectLiteralExpression([
-      ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(existing, "detail")),
-      ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
+  return ts2.factory.createObjectLiteralExpression([
+    ts2.factory.createSpreadAssignment(existing),
+    ts2.factory.createPropertyAssignment("detail", ts2.factory.createObjectLiteralExpression([
+      ts2.factory.createSpreadAssignment(ts2.factory.createPropertyAccessExpression(existing, "detail")),
+      ts2.factory.createPropertyAssignment(ts2.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
     ]))
   ]);
 };
 var transformPageCall = (node, page) => {
   if (!page)
     return;
+  if (page.inputKind === "static") {
+    const [pagePath, existingOptions, ...rest] = node.arguments;
+    if (!pagePath)
+      return;
+    const options = ts2.factory.createObjectLiteralExpression([
+      ...existingOptions ? [ts2.factory.createSpreadAssignment(existingOptions)] : [],
+      ts2.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+    ]);
+    return ts2.factory.updateCallExpression(node, node.expression, node.typeArguments, [pagePath, options, ...rest]);
+  }
   const [input] = node.arguments;
-  if (!input || !ts.isObjectLiteralExpression(input))
+  if (!input || !ts2.isObjectLiteralExpression(input))
     return;
-  return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [
-    ts.factory.updateObjectLiteralExpression(input, [
+  return ts2.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+    ts2.factory.updateObjectLiteralExpression(input, [
       ...input.properties,
-      ts.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+      ts2.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
     ]),
     ...node.arguments.slice(1)
   ]);
@@ -3413,16 +6423,16 @@ var transformRouteCall = (node, route) => {
     return;
   const options = maybeHandler ? maybeOptions : undefined;
   const handler = maybeHandler ?? maybeOptions;
-  return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [path, routeOptions(options, route.metadata), handler, ...rest]);
+  return ts2.factory.updateCallExpression(node, node.expression, node.typeArguments, [path, routeOptions(options, route.metadata), handler, ...rest]);
 };
 var transformFile = (source, fileName, analysis) => {
-  const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const sourceFile = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS);
   const transformer = (context) => {
     const visit = (node) => {
-      if (!ts.isCallExpression(node)) {
-        return ts.visitEachChild(node, visit, context);
+      if (!ts2.isCallExpression(node)) {
+        return ts2.visitEachChild(node, visit, context);
       }
-      const transformedChildren = ts.visitEachChild(node, visit, context);
+      const transformedChildren = ts2.visitEachChild(node, visit, context);
       const page = analysis.byPageCall.get(node.getStart(sourceFile));
       const transformedPage = transformPageCall(transformedChildren, page);
       if (transformedPage)
@@ -3433,81 +6443,120 @@ var transformFile = (source, fileName, analysis) => {
         return transformedRoute;
       return transformedChildren;
     };
-    return (node) => ts.visitNode(node, visit, ts.isSourceFile) ?? node;
+    return (node) => ts2.visitNode(node, visit, ts2.isSourceFile) ?? node;
   };
-  const result = ts.transform(sourceFile, [transformer]);
+  const result = ts2.transform(sourceFile, [transformer]);
   try {
     const [transformed] = result.transformed;
     if (!transformed)
       throw new TypeError("Mobile route transform failed.");
-    return ts.createPrinter().printFile(transformed);
+    return ts2.createPrinter().printFile(transformed);
   } finally {
     result.dispose();
   }
 };
 var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
 var createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve11(options.projectRoot ?? process.cwd());
-  const entry = resolve11(options.entry);
+  const projectRoot = resolve14(options.projectRoot ?? process.cwd());
+  const entry = resolve14(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return {
     name: "absolute-mobile-route-metadata",
     setup(build) {
       build.onLoad({ filter: SOURCE_FILTER }, async ({ path }) => {
-        const analysis = analyzed.get(resolve11(path));
+        const analysis = analyzed.get(resolve14(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
         return {
           contents: transformFile(source, path, analysis),
-          loader: extname2(path).endsWith("x") ? "tsx" : "ts"
+          loader: extname4(path).endsWith("x") ? "tsx" : "ts"
         };
       });
     }
   };
 };
 var inspectAbsoluteMobileRouteMetadata = (options) => {
-  const projectRoot = resolve11(options.projectRoot ?? process.cwd());
-  const entry = resolve11(options.entry);
+  const projectRoot = resolve14(options.projectRoot ?? process.cwd());
+  const entry = resolve14(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return [...analyzed.entries()].flatMap(([file, analysis]) => [...analysis.byRouteCall.values()].map(({ metadata }) => ({
-    file: posixPath(relative7(projectRoot, file)),
+    file: posixPath(relative11(projectRoot, file)),
     metadata
   })));
 };
 export {
   writeAbsoluteCapacitorConfig,
+  waitForAbsoluteIosHmrLog,
   verifyAbsoluteMobileCompatibilityProducer,
   verifyAbsoluteMobileAssociationFiles,
+  validateAbsoluteSshDestination,
+  validateAbsoluteRemoteMacProfileName,
+  syncAbsoluteRemoteMacProject,
+  startAbsoluteRemoteIosDevSession,
+  startAbsoluteIosDevSession,
+  serializeAbsoluteMobileAuthEnvironment,
   runWithAbsoluteMobileProducer,
   retainAbsoluteMobileCompatibilityArtifacts,
   resolveAbsoluteMobileRoute,
+  resolveAbsoluteMobileNavigation,
   resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
+  resolveAbsoluteMobileAuthManifest,
+  resolveAbsoluteDeviceCapabilityPlan,
+  repairAbsoluteIosDevSession,
+  removeAbsoluteRemoteMacProfile,
+  redactAbsoluteIosLog,
   readAbsoluteMobileMaterializedReleases,
   publishAbsoluteIosRelease,
   publishAbsoluteAndroidRelease,
+  projectUsesAbsoluteSync,
+  projectUsesAbsoluteAuth,
   prepareAbsoluteIosRelease,
+  prepareAbsoluteIosDevProject,
   prepareAbsoluteAndroidRelease,
+  parseIosSimulators,
+  parseIosRuntimes,
+  parseIosDeviceTypes,
   parseAbsoluteMobilePageRequest,
   parseAbsoluteMobilePageEnvelope,
   parseAbsoluteMobileCompatibilityArtifact,
   parseAbsoluteMobileBuildPageMetadata,
+  parseAbsoluteIosLogLine,
+  parseAbsoluteIosHmrLog,
+  pairAbsoluteRemoteMac,
   normalizeAbsoluteMobileConfig,
   navigateAbsoluteMobilePage,
+  missingAbsoluteDeviceCapabilityPackages,
+  materializeAbsoluteRemoteMacAgent,
   materializeAbsoluteMobileCompatibilityBundle,
   materializeAbsoluteMobileAssociationFiles,
   materializeAbsoluteCapacitorWebBundle,
   matchesAbsoluteMobileRoutePattern,
   loadAbsoluteNativeReleasePublisher,
   loadAbsoluteMobileMaterializedBundle,
+  loadAbsoluteDeviceCapabilityProviders,
+  listAbsoluteRemoteMacProfiles,
+  isAbsoluteIosNativeRootInput,
+  installAbsoluteRemoteMacAgent,
+  installAbsoluteMobileSyncRemediation,
+  installAbsoluteMobileAuthEnvironment,
+  inspectAbsoluteRemoteMac,
   inspectAbsoluteMobileRouteMetadata,
   hashAbsoluteMobilePropsSchema,
   getCurrentAbsoluteMobileProducerContext,
+  getAbsoluteRemoteMacProfile,
+  getAbsoluteMobileSyncRemediation,
   fingerprintAbsoluteIosNativeProject,
+  fingerprintAbsoluteIosDevProject,
   finalizeAbsoluteMobilePage,
   finalizeAbsoluteMobileCompatibilityBuild,
   fetchAbsoluteMobilePage,
+  disposeAbsoluteMobilePage,
+  discoverAbsoluteSyncSchema,
+  discoverAbsoluteDeviceCapabilities,
+  directAbsoluteProjectPackages,
+  createAbsoluteRemoteIosDevProject,
   createAbsoluteMobileUpgradeResponse,
   createAbsoluteMobileRouteMetadataPlugin,
   createAbsoluteMobilePageRequest,
@@ -3517,20 +6566,32 @@ export {
   createAbsoluteMobileCompatibilityDispatcher,
   createAbsoluteMobileCompatibilityArtifact,
   createAbsoluteMobileBlobArtifactStore,
+  createAbsoluteMobileAuthManifest,
   createAbsoluteMobileAssociationPlugin,
   createAbsoluteMobileAssociationDocuments,
+  createAbsoluteIosNativeWatcher,
   carryForwardAbsoluteMobileCompatibilityReleases,
   captureAbsoluteMobileRouteGraph,
   buildAbsoluteMobileCompatibilityRelease,
   buildAbsoluteIosRelease,
   buildAbsoluteAndroidRelease,
+  assertAbsoluteDeviceCapabilityPackages,
+  applyAbsoluteNativeDeviceCapabilities,
   applyAbsoluteNativeDeepLinks,
   activateAbsoluteMobilePage,
   acceptsAbsoluteMobilePage,
+  absoluteRemoteProjectSyncCommands,
+  absoluteRemoteMacSshBase,
+  absoluteDeviceNativeRequirements,
   MOBILE_PAGE_REQUEST_HEADERS,
   AbsoluteMobilePageProtocolError,
   APPLE_ASSOCIATION_PATH,
   ANDROID_ASSOCIATION_PATH,
+  ABSOLUTE_SYNC_PACKAGE,
+  ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION,
+  ABSOLUTE_REMOTE_MAC_EVENT_PREFIX,
+  ABSOLUTE_NATIVE_AUTH_SCOPES,
+  ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV,
   ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL,
   ABSOLUTE_MOBILE_ROUTE_DETAIL,
   ABSOLUTE_MOBILE_RETAINED_GENERATIONS,
@@ -3539,9 +6600,11 @@ export {
   ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
   ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT,
   ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+  ABSOLUTE_IOS_SIMULATOR_NAME,
   ABSOLUTE_IOS_RELEASE_FORMAT,
+  ABSOLUTE_AUTH_PACKAGE,
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=8F6E00755BF98A2E64756E2164756E21
+//# debugId=8F3479AD17C2968F64756E2164756E21
 //# sourceMappingURL=index.js.map