@absolutejs/absolute 0.20.0-beta.55 → 0.20.0-beta.56

package/dist/mobile/index.js

@@ -815,7 +815,7 @@ import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
 import { extname as extname3, join as join13, relative as relative9, resolve as resolve11 } from "path";
 import { fileURLToPath } from "url";
 import ts from "typescript";
-var DEVICES_PACKAGE = "@absolutejs/devices", ADAPTERS, SOURCE_GLOB, IGNORED_DIRECTORIES, IDENTIFIER_PATTERN, providerModulePattern = (provider) => new RegExp(`^@absolutejs/devices-${provider}/[a-z][a-z0-9-]*$`, "u"), providerPackagePattern = (provider) => provider === "capacitor" ? /^@capacitor\/[a-z][a-z0-9-]*@\d+\.\d+\.\d+$/u : /^(?:expo-[a-z][a-z0-9-]*|@react-native-[a-z0-9-]+\/[a-z][a-z0-9-]*)@\d+\.\d+\.\d+$/u, providerLabel = (provider) => provider === "capacitor" ? "Capacitor" : "Expo", ANDROID_PERMISSION_PATTERN, IOS_USAGE_DESCRIPTIONS, IOS_PRIVACY_ACCESSED_API_REASONS, IOS_PRIVACY_ACCESSED_APIS, object2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
+var DEVICES_PACKAGE = "@absolutejs/devices", ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABILITIES, ADAPTERS, SOURCE_GLOB, IGNORED_DIRECTORIES, IDENTIFIER_PATTERN, providerModulePattern = (provider) => new RegExp(`^@absolutejs/devices-${provider}/[a-z][a-z0-9-]*$`, "u"), providerPackagePattern = (provider) => provider === "capacitor" ? /^@capacitor\/[a-z][a-z0-9-]*@\d+\.\d+\.\d+$/u : /^(?:expo-[a-z][a-z0-9-]*|@react-native-[a-z0-9-]+\/[a-z][a-z0-9-]*)@\d+\.\d+\.\d+$/u, providerLabel = (provider) => provider === "capacitor" ? "Capacitor" : "Expo", ANDROID_PERMISSION_PATTERN, IOS_USAGE_DESCRIPTIONS, IOS_PRIVACY_ACCESSED_API_REASONS, IOS_PRIVACY_ACCESSED_APIS, object2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
   const value = JSON.parse(readFileSync4(path, "utf8"));
   if (!object2(value))
     throw new TypeError(`${path} must contain an object.`);
@@ -859,12 +859,12 @@ var DEVICES_PACKAGE = "@absolutejs/devices", ADAPTERS, SOURCE_GLOB, IGNORED_DIRE
   const {
     privacyAccessedApis,
     pushNotifications,
-    systemBars,
+    systemBars: systemBars2,
     usageDescriptions
   } = value;
   if (pushNotifications !== undefined && pushNotifications !== true)
     throw new TypeError(`${field2}.pushNotifications must be true.`);
-  if (systemBars !== undefined && systemBars !== true)
+  if (systemBars2 !== undefined && systemBars2 !== true)
     throw new TypeError(`${field2}.systemBars must be true.`);
   if (usageDescriptions !== undefined && (!Array.isArray(usageDescriptions) || !usageDescriptions.every((purpose) => typeof purpose === "string" && IOS_USAGE_DESCRIPTIONS.has(purpose))))
     throw new TypeError(`${field2}.usageDescriptions contains an unsupported purpose.`);
@@ -872,7 +872,7 @@ var DEVICES_PACKAGE = "@absolutejs/devices", ADAPTERS, SOURCE_GLOB, IGNORED_DIRE
   return {
     ...privacy === undefined ? {} : { privacyAccessedApis: privacy },
     ...pushNotifications === true ? { pushNotifications: true } : {},
-    ...systemBars === true ? { systemBars: true } : {},
+    ...systemBars2 === true ? { systemBars: true } : {},
     ...usageDescriptions === undefined ? {} : { usageDescriptions: [...usageDescriptions] }
   };
 }, parseProvider = (name, value, providerName) => {
@@ -1046,6 +1046,11 @@ var DEVICES_PACKAGE = "@absolutejs/devices", ADAPTERS, SOURCE_GLOB, IGNORED_DIRE
 }, resolveAbsoluteDeviceCapabilityPlan = (projectRoot, provider = "capacitor") => {
   const allProviders = loadAbsoluteDeviceCapabilityProviders(projectRoot, provider);
   const capabilities = discoverAbsoluteDeviceCapabilities(projectRoot, allProviders);
+  for (const capability of ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABILITIES) {
+    if (allProviders[capability] && !capabilities.includes(capability))
+      capabilities.push(capability);
+  }
+  capabilities.sort();
   const providers = {};
   for (const name of capabilities) {
     const capabilityProvider = allProviders[name];
@@ -1061,6 +1066,10 @@ var DEVICES_PACKAGE = "@absolutejs/devices", ADAPTERS, SOURCE_GLOB, IGNORED_DIRE
   };
 };
 var init_deviceCapabilities = __esm(() => {
+  ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABILITIES = [
+    "keyboard",
+    "systemBars"
+  ];
   ADAPTERS = {
     capacitor: "@absolutejs/devices-capacitor",
     expo: "@absolutejs/devices-expo"
@@ -1116,7 +1125,7 @@ var init_telemetry = __esm(() => {
 
 // src/cli/telemetryEvent.ts
 import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
-import { arch, platform } from "os";
+import { arch, platform as platform2 } from "os";
 import { dirname as dirname12, join as join18, parse } from "path";
 var checkCandidate = (candidate) => {
   if (!existsSync6(candidate)) {
@@ -1157,7 +1166,7 @@ var checkCandidate = (candidate) => {
       arch: arch(),
       bunVersion: Bun.version,
       event,
-      os: platform(),
+      os: platform2(),
       payload,
       timestamp: new Date().toISOString(),
       version: getVersion()
@@ -1645,6 +1654,1254 @@ var verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes
   }
   return release;
 };
+// node_modules/@absolutejs/devices/dist/index.js
+class DeviceError extends Error {
+  code;
+  cause;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "DeviceError";
+    this.code = code;
+    this.cause = options?.cause;
+  }
+}
+var DEFAULT_DEVICE_DOCUMENT_MAX_BYTES = 64 * 1024 * 1024;
+var SHARE_PROTOCOLS = new Set(["http:", "https:"]);
+var MAX_NOTIFICATION_ID = 2147483647;
+var MAX_NOTIFICATION_DATA_BYTES = 16 * 1024;
+var availableCapability = (fidelity, native) => ({
+  available: true,
+  fidelity,
+  ...native === undefined ? {} : { native }
+});
+var unavailableCapability = (reason, message, native) => ({
+  available: false,
+  reason,
+  ...message === undefined ? {} : { message },
+  ...native === undefined ? {} : { native }
+});
+var requireFiniteNonNegative = (value, field) => {
+  if (!Number.isFinite(value) || value < 0)
+    throw new TypeError(`${field} must be a finite non-negative number.`);
+};
+var requireFinitePositive = (value, field) => {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new TypeError(`${field} must be a finite positive number.`);
+};
+var validateDeviceLocationOptions = (options) => {
+  const watchOptions = options;
+  if (options?.maximumAgeMs !== undefined)
+    requireFiniteNonNegative(options.maximumAgeMs, "Location maximumAgeMs");
+  if (options?.timeoutMs !== undefined)
+    requireFinitePositive(options.timeoutMs, "Location timeoutMs");
+  if (watchOptions?.intervalMs !== undefined)
+    requireFinitePositive(watchOptions.intervalMs, "Location intervalMs");
+  if (watchOptions?.minimumUpdateIntervalMs !== undefined)
+    requireFinitePositive(watchOptions.minimumUpdateIntervalMs, "Location minimumUpdateIntervalMs");
+  return options;
+};
+var normalizeDeviceLocalNotification = (notification) => {
+  if (!Number.isSafeInteger(notification.id) || notification.id < 1 || notification.id > MAX_NOTIFICATION_ID)
+    throw new TypeError(`Local notification id must be an integer from 1 to ${MAX_NOTIFICATION_ID}.`);
+  if (typeof notification.title !== "string" || notification.title.trim().length === 0 || notification.title.length > 200)
+    throw new TypeError("Local notification title must contain 1 to 200 characters.");
+  if (typeof notification.body !== "string" || notification.body.trim().length === 0 || notification.body.length > 4000)
+    throw new TypeError("Local notification body must contain 1 to 4000 characters.");
+  if (notification.scheduledAtMs !== undefined && (!Number.isFinite(notification.scheduledAtMs) || Number.isNaN(new Date(notification.scheduledAtMs).getTime())))
+    throw new TypeError("Local notification scheduledAtMs must be a valid Unix timestamp.");
+  let data;
+  if (notification.data !== undefined) {
+    const prototype = Object.getPrototypeOf(notification.data);
+    if (typeof notification.data !== "object" || notification.data === null || prototype !== Object.prototype && prototype !== null)
+      throw new TypeError("Local notification data must be a plain string record.");
+    const entries = Object.entries(notification.data);
+    if (entries.length > 32 || entries.some(([key, value]) => key.length === 0 || key.length > 128 || typeof value !== "string" || value.length > 4000))
+      throw new TypeError("Local notification data supports up to 32 non-empty keys and string values up to 4000 characters.");
+    data = Object.fromEntries(entries);
+    if (new TextEncoder().encode(JSON.stringify(data)).byteLength > MAX_NOTIFICATION_DATA_BYTES)
+      throw new TypeError("Local notification data cannot exceed 16 KiB.");
+  }
+  return {
+    body: notification.body,
+    ...data === undefined ? {} : { data },
+    id: notification.id,
+    ...notification.scheduledAtMs === undefined ? {} : { scheduledAtMs: notification.scheduledAtMs },
+    title: notification.title
+  };
+};
+var runtimeCapability = (runtime) => {
+  if (runtime === "ssr")
+    return unavailableCapability("unavailable", "Device capabilities are unavailable during server rendering.");
+  if (runtime === "web")
+    return availableCapability("web");
+  if (runtime === "test")
+    return availableCapability("emulated");
+  return availableCapability("native");
+};
+var normalizeDeviceShareContent = (content) => {
+  const normalized = Object.fromEntries(Object.entries(content).filter(([, value]) => typeof value === "string" && value.length > 0));
+  if (Object.keys(normalized).length === 0)
+    throw new TypeError("Device share content cannot be empty.");
+  if (normalized.url) {
+    const url = new URL(normalized.url);
+    if (url.username || url.password || !SHARE_PROTOCOLS.has(url.protocol))
+      throw new TypeError("Device share URLs must be credential-free HTTP(S) URLs.");
+    normalized.url = url.href;
+  }
+  return normalized;
+};
+var noopSubscription = () => () => {
+  return;
+};
+var unavailable = (capability) => new DeviceError("unavailable", `${capability} is unavailable during server rendering.`);
+var createSsrDeviceAdapter = () => ({
+  runtime: "ssr",
+  camera: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Camera is unavailable during server rendering."
+    }),
+    queryPermission: async () => ({ canRequest: false, state: "unavailable" }),
+    requestPermission: async () => ({
+      canRequest: false,
+      state: "unavailable"
+    }),
+    takePhoto: async () => {
+      throw unavailable("Camera");
+    }
+  },
+  clipboard: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Clipboard is unavailable during server rendering."
+    }),
+    readText: async () => {
+      throw unavailable("Clipboard");
+    },
+    writeText: async () => {
+      throw unavailable("Clipboard");
+    }
+  },
+  documents: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Documents are unavailable during server rendering."
+    }),
+    export: async () => {
+      throw unavailable("Documents");
+    },
+    open: async () => {
+      throw unavailable("Documents");
+    },
+    pick: async () => {
+      throw unavailable("Documents");
+    }
+  },
+  haptics: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Haptics are unavailable during server rendering."
+    }),
+    impact: async () => {
+      return;
+    },
+    notification: async () => {
+      return;
+    },
+    selectionChanged: async () => {
+      return;
+    },
+    vibrate: async () => {
+      return;
+    }
+  },
+  keyboard: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Keyboard state is unavailable during server rendering."
+    }),
+    dismiss: async () => {
+      throw unavailable("Keyboard");
+    },
+    getState: async () => ({ heightPx: 0, visible: false }),
+    onChange: async () => noopSubscription()
+  },
+  localNotifications: {
+    cancel: async () => {
+      throw unavailable("Local notifications");
+    },
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Local notifications are unavailable during server rendering."
+    }),
+    onAction: async () => noopSubscription(),
+    onReceived: async () => noopSubscription(),
+    pending: async () => [],
+    queryPermission: async () => ({
+      canRequest: false,
+      state: "unavailable"
+    }),
+    requestPermission: async () => ({
+      canRequest: false,
+      state: "unavailable"
+    }),
+    schedule: async () => {
+      throw unavailable("Local notifications");
+    }
+  },
+  pushNotifications: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Push notifications are unavailable during server rendering."
+    }),
+    disable: async () => {
+      return;
+    },
+    enable: async () => {
+      throw unavailable("Push notifications");
+    },
+    onAction: async () => noopSubscription(),
+    onReceived: async () => noopSubscription(),
+    queryPermission: async () => ({
+      canRequest: false,
+      state: "unavailable"
+    }),
+    requestPermission: async () => ({
+      canRequest: false,
+      state: "unavailable"
+    })
+  },
+  platform: {
+    getInfo: async () => ({
+      formFactor: "unknown",
+      isNative: false,
+      os: "unknown",
+      prefersReducedMotion: false,
+      runtime: "ssr",
+      safeAreaInsets: { bottom: 0, left: 0, right: 0, top: 0 }
+    })
+  },
+  lifecycle: {
+    getState: async () => "inactive",
+    onChange: async () => noopSubscription(),
+    onRestoredOperation: async () => noopSubscription(),
+    onResume: async () => noopSubscription()
+  },
+  links: {
+    getLaunchUrl: async () => null,
+    onOpen: async () => noopSubscription(),
+    openExternal: async () => {
+      throw unavailable("External links");
+    }
+  },
+  location: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Location is unavailable during server rendering."
+    }),
+    current: async () => {
+      throw unavailable("Location");
+    },
+    queryPermission: async () => ({
+      canRequest: false,
+      precision: "unknown",
+      state: "unavailable"
+    }),
+    requestPermission: async () => ({
+      canRequest: false,
+      precision: "unknown",
+      state: "unavailable"
+    }),
+    watch: async () => {
+      throw unavailable("Location");
+    }
+  },
+  network: {
+    getStatus: async () => ({ connected: false, connectionType: "unknown" }),
+    onChange: async () => noopSubscription()
+  },
+  photos: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Photo picker is unavailable during server rendering."
+    }),
+    pick: async () => {
+      throw unavailable("Photo picker");
+    }
+  },
+  share: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "Sharing is unavailable during server rendering."
+    }),
+    share: async () => {
+      throw unavailable("Sharing");
+    }
+  },
+  storage: {
+    clear: async () => {
+      throw unavailable("Storage");
+    },
+    get: async () => null,
+    keys: async () => [],
+    remove: async () => {
+      throw unavailable("Storage");
+    },
+    set: async () => {
+      throw unavailable("Storage");
+    }
+  },
+  systemBars: {
+    capability: async () => ({
+      available: false,
+      reason: "unavailable",
+      message: "System bars are unavailable during server rendering."
+    }),
+    setAppearance: async () => {
+      throw unavailable("System bars");
+    },
+    setVisible: async () => {
+      throw unavailable("System bars");
+    }
+  }
+});
+var COARSE_TABLET_MIN_WIDTH = 768;
+var detectOs = () => {
+  const platform = navigator.userAgent.toLowerCase();
+  if (platform.includes("android"))
+    return "android";
+  if (/iphone|ipad|ipod/.test(platform))
+    return "ios";
+  if (platform.includes("win"))
+    return "windows";
+  if (platform.includes("mac"))
+    return "macos";
+  if (platform.includes("linux"))
+    return "linux";
+  return "unknown";
+};
+var networkStatus = () => {
+  const connection = Reflect.get(navigator, "connection");
+  const type = connection?.type;
+  const connectionType = type === "wifi" || type === "cellular" || type === "ethernet" ? type : navigator.onLine ? "unknown" : "none";
+  return { connected: navigator.onLine, connectionType };
+};
+var safeAreaInsets = () => {
+  if (!document.body)
+    return { bottom: 0, left: 0, right: 0, top: 0 };
+  const probe = document.createElement("div");
+  probe.style.cssText = [
+    "position:fixed",
+    "visibility:hidden",
+    "pointer-events:none",
+    "padding-top:env(safe-area-inset-top, 0px)",
+    "padding-right:env(safe-area-inset-right, 0px)",
+    "padding-bottom:env(safe-area-inset-bottom, 0px)",
+    "padding-left:env(safe-area-inset-left, 0px)"
+  ].join(";");
+  document.body.append(probe);
+  const style = getComputedStyle(probe);
+  const insets = {
+    bottom: Number.parseFloat(style.paddingBottom) || 0,
+    left: Number.parseFloat(style.paddingLeft) || 0,
+    right: Number.parseFloat(style.paddingRight) || 0,
+    top: Number.parseFloat(style.paddingTop) || 0
+  };
+  probe.remove();
+  return insets;
+};
+var matches = (query) => typeof matchMedia === "function" && matchMedia(query).matches;
+var editableElement = (value) => value instanceof HTMLInputElement || value instanceof HTMLTextAreaElement || value instanceof HTMLElement && value.isContentEditable;
+var webKeyboardState = () => {
+  const viewport = window.visualViewport;
+  const heightPx = viewport ? Math.max(0, Math.round(window.innerHeight - viewport.height - viewport.offsetTop)) : 0;
+  return {
+    heightPx,
+    visible: editableElement(document.activeElement) && heightPx > 50
+  };
+};
+var requireStorage = () => {
+  try {
+    return window.localStorage;
+  } catch (cause) {
+    throw new DeviceError("unavailable", "Browser storage is unavailable.", {
+      cause
+    });
+  }
+};
+var webFailure = (error, message) => {
+  const name = typeof error === "object" && error !== null ? Reflect.get(error, "name") : undefined;
+  if (name === "AbortError")
+    return new DeviceError("cancelled", "The device action was cancelled.", {
+      cause: error
+    });
+  if (name === "NotAllowedError")
+    return new DeviceError("permission-denied", message, { cause: error });
+  return new DeviceError("failed", message, { cause: error });
+};
+var webOperation = async (message, operation) => {
+  try {
+    return await operation();
+  } catch (error) {
+    throw webFailure(error, message);
+  }
+};
+var requireMaximumBytes = (value) => {
+  const maximumBytes = value ?? DEFAULT_DEVICE_DOCUMENT_MAX_BYTES;
+  if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 1)
+    throw new TypeError("Document maximumBytes must be a positive safe integer.");
+  return maximumBytes;
+};
+var requireDocumentName = (name) => {
+  if (name.length === 0 || name === "." || name === ".." || /[/\\\u0000-\u001f\u007f]/.test(name))
+    throw new TypeError("Document names must be safe leaf filenames.");
+  return name;
+};
+var requireDocumentAccept = (accept) => {
+  if (accept === undefined)
+    return;
+  if (accept.length === 0 || accept.some((value) => !/^\.[a-z0-9]+$/i.test(value) && !/^[a-z0-9!#$&^_.+-]+\/(?:[a-z0-9!#$&^_.+*-]+)$/i.test(value)))
+    throw new TypeError("Document accept entries must be MIME types or file extensions.");
+  return accept.join(",");
+};
+var requireDocumentLimit = (limit) => {
+  const value = limit ?? 1;
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new TypeError("Document limit must be a positive safe integer.");
+  return value;
+};
+var documentBlob = (options) => {
+  requireDocumentName(options.name);
+  const mimeType = options.mimeType ?? (options.content instanceof Blob && options.content.type ? options.content.type : typeof options.content === "string" ? "text/plain;charset=utf-8" : "application/octet-stream");
+  const blob = options.content instanceof Blob ? options.content : new Blob([options.content], { type: mimeType });
+  if (blob.size > requireMaximumBytes(options.maximumBytes))
+    throw new DeviceError("failed", `Document ${options.name} exceeds the configured byte limit.`);
+  return { blob, mimeType, name: options.name, sizeBytes: blob.size };
+};
+var releaseObjectUrl = (url) => setTimeout(() => URL.revokeObjectURL(url), 0);
+var pickDocuments = async (options = {}) => {
+  if (typeof document === "undefined" || !document.body)
+    throw new DeviceError("unsupported", "Browser document selection is unavailable.");
+  const limit = requireDocumentLimit(options.limit);
+  const maximumBytes = requireMaximumBytes(options.maximumBytes);
+  const input = document.createElement("input");
+  input.type = "file";
+  input.multiple = limit > 1;
+  input.style.display = "none";
+  const accept = requireDocumentAccept(options.accept);
+  if (accept)
+    input.accept = accept;
+  document.body.append(input);
+  try {
+    const files = await new Promise((resolve, reject) => {
+      const cleanup = () => {
+        input.removeEventListener("change", changed);
+        input.removeEventListener("cancel", cancelled);
+      };
+      const changed = () => {
+        cleanup();
+        resolve(Array.from(input.files ?? []));
+      };
+      const cancelled = () => {
+        cleanup();
+        resolve([]);
+      };
+      input.addEventListener("change", changed, { once: true });
+      input.addEventListener("cancel", cancelled, { once: true });
+      try {
+        input.click();
+      } catch (error) {
+        cleanup();
+        reject(error);
+      }
+    });
+    if (files.length === 0)
+      throw new DeviceError("cancelled", "Document selection was cancelled.");
+    const selected = files.slice(0, limit);
+    const oversized = selected.find((file) => file.size > maximumBytes);
+    if (oversized)
+      throw new DeviceError("failed", `Document ${oversized.name} exceeds the configured byte limit.`);
+    return selected.map((file) => ({
+      blob: file,
+      ...Number.isFinite(file.lastModified) ? { lastModifiedMs: file.lastModified } : {},
+      mimeType: file.type || "application/octet-stream",
+      name: file.name,
+      sizeBytes: file.size
+    }));
+  } finally {
+    input.remove();
+  }
+};
+var locationFailure = (error) => {
+  const code = typeof error === "object" && error !== null ? Reflect.get(error, "code") : undefined;
+  if (code === 1)
+    return new DeviceError("permission-denied", "Browser location permission was denied.", { cause: error });
+  if (code === 2)
+    return new DeviceError("temporarily-unavailable", "The browser could not determine the current location.", { cause: error });
+  if (code === 3)
+    return new DeviceError("temporarily-unavailable", "The browser location request timed out.", { cause: error });
+  return webFailure(error, "Browser location failed.");
+};
+var locationPosition = (value) => {
+  const { coords } = value;
+  if (!Number.isFinite(coords.latitude) || !Number.isFinite(coords.longitude) || !Number.isFinite(coords.accuracy) || !Number.isFinite(value.timestamp))
+    throw new DeviceError("failed", "The browser returned an invalid location position.");
+  return {
+    accuracyMeters: coords.accuracy,
+    ...coords.altitudeAccuracy === null ? {} : { altitudeAccuracyMeters: coords.altitudeAccuracy },
+    ...coords.altitude === null ? {} : { altitudeMeters: coords.altitude },
+    ...coords.heading === null ? {} : { headingDegrees: coords.heading },
+    latitude: coords.latitude,
+    longitude: coords.longitude,
+    native: value,
+    ...coords.speed === null ? {} : { speedMetersPerSecond: coords.speed },
+    timestampMs: value.timestamp
+  };
+};
+var webLocationOptions = (options) => ({
+  enableHighAccuracy: options?.accuracy === "high",
+  ...options?.maximumAgeMs === undefined ? {} : { maximumAge: options.maximumAgeMs },
+  ...options?.timeoutMs === undefined ? {} : { timeout: options.timeoutMs }
+});
+var clipboardStatus = (operation) => {
+  const method = operation === "read" ? "readText" : "writeText";
+  return typeof navigator.clipboard?.[method] === "function" ? availableCapability("web") : unavailableCapability("unsupported", `Clipboard ${operation} is not supported by this browser context.`);
+};
+var shareStatus = (content) => {
+  if (typeof navigator.share !== "function")
+    return unavailableCapability("unsupported", "The Web Share API is not supported by this browser.");
+  if (content && typeof navigator.canShare === "function") {
+    const normalized = normalizeDeviceShareContent(content);
+    if (!navigator.canShare(normalized))
+      return unavailableCapability("unsupported", "This browser cannot share the requested content.");
+  }
+  return availableCapability("web");
+};
+var vibrate = (durationMs) => {
+  if (typeof navigator.vibrate === "function")
+    navigator.vibrate(durationMs);
+};
+var requirePhotoOptions = (options) => {
+  if (options?.limit !== undefined && (!Number.isInteger(options.limit) || options.limit < 1))
+    throw new TypeError("Photo picker limit must be a positive integer.");
+  const transform = options?.transform;
+  if (transform && (!Number.isInteger(transform.width) || transform.width < 1 || !Number.isInteger(transform.height) || transform.height < 1 || transform.quality !== undefined && (!Number.isInteger(transform.quality) || transform.quality < 0 || transform.quality > 100)))
+    throw new TypeError("Photo transforms require positive integer dimensions and quality from 0 to 100.");
+};
+var pickImages = async (options) => {
+  if (typeof document === "undefined" || typeof URL.createObjectURL !== "function")
+    throw new DeviceError("unsupported", "Browser photo selection is unavailable.");
+  const input = document.createElement("input");
+  input.type = "file";
+  input.accept = "image/*";
+  input.multiple = options.multiple ?? false;
+  if (options.capture)
+    input.setAttribute("capture", options.capture);
+  input.style.display = "none";
+  document.body?.append(input);
+  try {
+    const files = await new Promise((resolve, reject) => {
+      const finish = (selected) => {
+        input.removeEventListener("change", changed);
+        input.removeEventListener("cancel", cancelled);
+        resolve(selected);
+      };
+      const changed = () => finish(Array.from(input.files ?? []));
+      const cancelled = () => finish([]);
+      input.addEventListener("change", changed, { once: true });
+      input.addEventListener("cancel", cancelled, { once: true });
+      try {
+        input.click();
+      } catch (error) {
+        reject(error);
+      }
+    });
+    if (files.length === 0)
+      throw new DeviceError("cancelled", "Photo selection was cancelled.");
+    return files.slice(0, options.limit).map((file) => ({
+      ...file.type ? { format: file.type.replace(/^image\//, "") } : {},
+      name: file.name,
+      sizeBytes: file.size,
+      webPath: URL.createObjectURL(file)
+    }));
+  } finally {
+    input.remove();
+  }
+};
+var createWebDeviceAdapter = () => {
+  let cameraAuthorized = false;
+  let locationAuthorized = false;
+  const notificationActions = new Set;
+  const notificationReceived = new Set;
+  const pendingNotifications = new Map;
+  const notificationPermission = () => {
+    if (typeof Notification === "undefined")
+      return { canRequest: false, state: "unavailable" };
+    return Notification.permission === "granted" ? { canRequest: false, state: "granted" } : Notification.permission === "denied" ? { canRequest: false, state: "denied" } : { canRequest: true, state: "prompt" };
+  };
+  const showNotification = (notification) => {
+    let displayed;
+    try {
+      displayed = new Notification(notification.title, {
+        body: notification.body,
+        data: notification.data,
+        tag: `absolutejs:${notification.id}`
+      });
+    } catch (error) {
+      throw webFailure(error, "Browser notification display failed.");
+    }
+    for (const listener of notificationReceived)
+      listener(notification);
+    displayed.onclick = () => {
+      for (const listener of notificationActions)
+        listener({ actionId: "tap", notification });
+      window.focus();
+    };
+  };
+  const queryLocationPermission = async () => {
+    if (typeof navigator.geolocation === "undefined")
+      return {
+        canRequest: false,
+        precision: "unknown",
+        state: "unavailable"
+      };
+    if (locationAuthorized)
+      return { canRequest: false, precision: "unknown", state: "granted" };
+    if (typeof navigator.permissions?.query !== "function")
+      return { canRequest: true, precision: "unknown", state: "prompt" };
+    try {
+      const status = await navigator.permissions.query({
+        name: "geolocation"
+      });
+      return {
+        canRequest: status.state === "prompt",
+        precision: "unknown",
+        state: status.state
+      };
+    } catch {
+      return { canRequest: true, precision: "unknown", state: "prompt" };
+    }
+  };
+  const currentLocation = async (options) => {
+    validateDeviceLocationOptions(options);
+    if (typeof navigator.geolocation === "undefined")
+      throw new DeviceError("unsupported", "Browser geolocation is unavailable.");
+    return new Promise((resolve, reject) => navigator.geolocation.getCurrentPosition((position) => {
+      try {
+        resolve(locationPosition(position));
+      } catch (error) {
+        reject(error);
+      }
+    }, (error) => reject(locationFailure(error)), webLocationOptions(options)));
+  };
+  return {
+    runtime: "web",
+    camera: {
+      capability: async () => typeof document !== "undefined" ? availableCapability("web") : unavailableCapability("unsupported", "Browser camera capture is unavailable."),
+      queryPermission: async () => ({
+        canRequest: !cameraAuthorized,
+        state: cameraAuthorized ? "granted" : "prompt"
+      }),
+      requestPermission: async () => {
+        cameraAuthorized = true;
+        return { canRequest: false, state: "granted" };
+      },
+      takePhoto: async (options) => {
+        requirePhotoOptions(options);
+        return (await pickImages({
+          capture: options?.direction === "front" ? "user" : "environment"
+        }))[0];
+      }
+    },
+    clipboard: {
+      capability: async (operation = "write") => clipboardStatus(operation),
+      readText: async () => {
+        if (!clipboardStatus("read").available)
+          throw new DeviceError("unsupported", "Clipboard read is unavailable.");
+        return webOperation("Browser clipboard read was denied.", () => navigator.clipboard.readText());
+      },
+      writeText: async (value) => {
+        if (!clipboardStatus("write").available)
+          throw new DeviceError("unsupported", "Clipboard write is unavailable.");
+        await webOperation("Browser clipboard write was denied.", () => navigator.clipboard.writeText(value));
+      }
+    },
+    documents: {
+      capability: async () => typeof document !== "undefined" && typeof URL.createObjectURL === "function" ? availableCapability("web") : unavailableCapability("unsupported", "Browser document handling is unavailable."),
+      export: async (options) => {
+        const result = documentBlob(options);
+        const url = URL.createObjectURL(result.blob);
+        try {
+          const anchor = document.createElement("a");
+          anchor.href = url;
+          anchor.download = result.name;
+          anchor.rel = "noopener";
+          anchor.click();
+          return {
+            mimeType: result.mimeType,
+            name: result.name,
+            sizeBytes: result.sizeBytes
+          };
+        } finally {
+          releaseObjectUrl(url);
+        }
+      },
+      open: async (options) => {
+        const result = documentBlob(options);
+        const url = URL.createObjectURL(result.blob);
+        const opened = window.open(url, "_blank", "noopener,noreferrer");
+        if (opened === null) {
+          URL.revokeObjectURL(url);
+          throw new DeviceError("failed", "The browser blocked the document preview window.");
+        }
+        releaseObjectUrl(url);
+      },
+      pick: pickDocuments
+    },
+    haptics: {
+      capability: async () => typeof navigator.vibrate === "function" ? availableCapability("web") : unavailableCapability("unsupported", "Vibration feedback is not supported by this browser."),
+      impact: async (style = "medium") => vibrate(style === "light" ? 8 : style === "heavy" ? 24 : 14),
+      notification: async (type = "success") => vibrate(type === "error" ? 40 : type === "warning" ? 28 : 18),
+      selectionChanged: async () => vibrate(6),
+      vibrate: async (durationMs = 300) => vibrate(durationMs)
+    },
+    keyboard: {
+      capability: async () => typeof window.visualViewport === "undefined" ? unavailableCapability("unsupported", "This browser does not expose keyboard viewport changes.") : availableCapability("web"),
+      dismiss: async () => {
+        const active = document.activeElement;
+        if (active instanceof HTMLElement)
+          active.blur();
+      },
+      getState: async () => webKeyboardState(),
+      onChange: async (listener) => {
+        let previous = webKeyboardState();
+        const emit = () => {
+          const next = webKeyboardState();
+          if (next.visible === previous.visible && next.heightPx === previous.heightPx)
+            return;
+          previous = next;
+          listener(next);
+        };
+        window.visualViewport?.addEventListener("resize", emit);
+        document.addEventListener("focusin", emit);
+        document.addEventListener("focusout", emit);
+        return () => {
+          window.visualViewport?.removeEventListener("resize", emit);
+          document.removeEventListener("focusin", emit);
+          document.removeEventListener("focusout", emit);
+        };
+      }
+    },
+    localNotifications: {
+      cancel: async (ids) => {
+        for (const id of ids) {
+          const pending = pendingNotifications.get(id);
+          if (!pending)
+            continue;
+          clearTimeout(pending.timer);
+          pendingNotifications.delete(id);
+        }
+      },
+      capability: async () => typeof Notification === "undefined" ? unavailableCapability("unsupported", "Browser notifications are unavailable.") : availableCapability("emulated", {
+        durableScheduling: false,
+        maximumDelayMs: 2147483647
+      }),
+      onAction: async (listener) => {
+        notificationActions.add(listener);
+        return () => {
+          notificationActions.delete(listener);
+        };
+      },
+      onReceived: async (listener) => {
+        notificationReceived.add(listener);
+        return () => {
+          notificationReceived.delete(listener);
+        };
+      },
+      pending: async () => Array.from(pendingNotifications.values(), ({ notification }) => notification),
+      queryPermission: async () => notificationPermission(),
+      requestPermission: async () => {
+        if (typeof Notification === "undefined")
+          return { canRequest: false, state: "unavailable" };
+        try {
+          await Notification.requestPermission();
+          return notificationPermission();
+        } catch (error) {
+          throw webFailure(error, "Browser notification permission failed.");
+        }
+      },
+      schedule: async (input) => {
+        const permission = notificationPermission();
+        if (permission.state !== "granted")
+          throw new DeviceError(permission.state === "denied" ? "permission-denied" : permission.state === "unavailable" ? "unavailable" : "permission-required", "Notification permission must be explicitly granted before scheduling.");
+        const notification = normalizeDeviceLocalNotification(input);
+        const delay = Math.max(0, (notification.scheduledAtMs ?? Date.now()) - Date.now());
+        if (delay > 2147483647)
+          throw new DeviceError("unsupported", "Browser notification scheduling cannot exceed 24 days and is not durable across reloads.");
+        const existing = pendingNotifications.get(notification.id);
+        if (existing)
+          clearTimeout(existing.timer);
+        if (delay === 0) {
+          pendingNotifications.delete(notification.id);
+          showNotification(notification);
+          return notification;
+        }
+        const timer = setTimeout(() => {
+          pendingNotifications.delete(notification.id);
+          showNotification(notification);
+        }, delay);
+        pendingNotifications.set(notification.id, { notification, timer });
+        return notification;
+      }
+    },
+    platform: {
+      getInfo: async () => ({
+        formFactor: matches("(pointer: coarse)") ? innerWidth >= COARSE_TABLET_MIN_WIDTH ? "tablet" : "phone" : "desktop",
+        isNative: false,
+        language: navigator.language,
+        locale: Intl.DateTimeFormat().resolvedOptions().locale,
+        os: detectOs(),
+        prefersReducedMotion: matches("(prefers-reduced-motion: reduce)"),
+        runtime: "web",
+        safeAreaInsets: safeAreaInsets()
+      })
+    },
+    lifecycle: {
+      getState: async () => document.visibilityState === "visible" ? "active" : "background",
+      onChange: async (listener) => {
+        const handler = () => listener(document.visibilityState === "visible" ? "active" : "background");
+        document.addEventListener("visibilitychange", handler);
+        return () => document.removeEventListener("visibilitychange", handler);
+      },
+      onRestoredOperation: async () => () => {
+        return;
+      },
+      onResume: async (listener) => {
+        const handler = () => {
+          if (document.visibilityState === "visible")
+            listener();
+        };
+        document.addEventListener("visibilitychange", handler);
+        return () => document.removeEventListener("visibilitychange", handler);
+      }
+    },
+    links: {
+      getLaunchUrl: async () => location.href,
+      onOpen: async (listener) => {
+        let lastUrl = location.href;
+        const handler = () => {
+          if (location.href === lastUrl)
+            return;
+          lastUrl = location.href;
+          listener(lastUrl);
+        };
+        addEventListener("popstate", handler);
+        addEventListener("hashchange", handler);
+        return () => {
+          removeEventListener("popstate", handler);
+          removeEventListener("hashchange", handler);
+        };
+      },
+      openExternal: async (url) => {
+        const parsed = new URL(url);
+        if (!["http:", "https:", "mailto:", "tel:"].includes(parsed.protocol)) {
+          throw new DeviceError("failed", `External URL protocol ${parsed.protocol} is not allowed.`);
+        }
+        window.open(parsed.href, "_blank", "noopener,noreferrer");
+      }
+    },
+    location: {
+      capability: async () => typeof navigator.geolocation === "undefined" ? unavailableCapability("unsupported", "Browser geolocation is unavailable.") : availableCapability("web"),
+      current: currentLocation,
+      queryPermission: queryLocationPermission,
+      requestPermission: async () => {
+        await currentLocation();
+        locationAuthorized = true;
+        const status = await queryLocationPermission();
+        return { ...status, state: "granted" };
+      },
+      watch: async (listener, options) => {
+        validateDeviceLocationOptions(options);
+        if (typeof navigator.geolocation === "undefined")
+          throw new DeviceError("unsupported", "Browser geolocation is unavailable.");
+        let active = true;
+        const id = navigator.geolocation.watchPosition((position) => {
+          if (!active)
+            return;
+          try {
+            listener({
+              position: locationPosition(position),
+              type: "position"
+            });
+          } catch (error) {
+            listener({ error: locationFailure(error), type: "error" });
+          }
+        }, (error) => {
+          if (active)
+            listener({ error: locationFailure(error), type: "error" });
+        }, webLocationOptions(options));
+        return () => {
+          if (!active)
+            return;
+          active = false;
+          navigator.geolocation.clearWatch(id);
+        };
+      }
+    },
+    network: {
+      getStatus: async () => networkStatus(),
+      onChange: async (listener) => {
+        const handler = () => listener(networkStatus());
+        addEventListener("online", handler);
+        addEventListener("offline", handler);
+        return () => {
+          removeEventListener("online", handler);
+          removeEventListener("offline", handler);
+        };
+      }
+    },
+    photos: {
+      capability: async () => typeof document !== "undefined" ? availableCapability("web") : unavailableCapability("unsupported", "Browser photo selection is unavailable."),
+      pick: async (options) => {
+        requirePhotoOptions(options);
+        return pickImages({
+          limit: options?.limit,
+          multiple: options?.limit !== 1
+        });
+      }
+    },
+    share: {
+      capability: async (content) => shareStatus(content),
+      share: async (content) => {
+        const normalized = normalizeDeviceShareContent(content);
+        if (!shareStatus(normalized).available)
+          throw new DeviceError("unsupported", "Web sharing is unavailable.");
+        await webOperation("Browser sharing failed.", () => navigator.share(normalized));
+        return {};
+      }
+    },
+    storage: {
+      clear: async () => requireStorage().clear(),
+      get: async (key) => requireStorage().getItem(key),
+      keys: async () => {
+        const storage = requireStorage();
+        return Array.from({ length: storage.length }, (_, index) => storage.key(index)).filter((key) => key !== null);
+      },
+      remove: async (key) => requireStorage().removeItem(key),
+      set: async (key, value) => requireStorage().setItem(key, value)
+    },
+    systemBars: {
+      capability: async (operation = "appearance") => operation === "appearance" ? availableCapability("emulated", {
+        targetedBars: false
+      }) : unavailableCapability("unsupported", "Browser chrome visibility cannot be controlled reliably."),
+      setAppearance: async (appearance) => {
+        document.documentElement.style.colorScheme = appearance === "automatic" ? "normal" : appearance === "light" ? "dark" : "light";
+      },
+      setVisible: async () => {
+        throw new DeviceError("unsupported", "Browser chrome visibility cannot be controlled reliably.");
+      }
+    }
+  };
+};
+var RUNTIME_REGISTRY = Symbol.for("@absolutejs/devices/runtime");
+var registryHost = globalThis;
+var isRuntimeRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations"));
+var runtimeRegistry = (() => {
+  const existing = registryHost[RUNTIME_REGISTRY];
+  if (isRuntimeRegistry(existing))
+    return existing;
+  const created = { installations: [] };
+  Object.defineProperty(registryHost, RUNTIME_REGISTRY, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+})();
+var defaultAdapter = () => typeof window === "undefined" || typeof navigator === "undefined" ? createSsrDeviceAdapter() : createWebDeviceAdapter();
+var getDeviceAdapter = () => runtimeRegistry.installations.at(-1)?.adapter ?? (runtimeRegistry.fallbackAdapter ??= defaultAdapter());
+var unavailableOptional = (capability) => unavailableCapability("unsupported", `${capability} is not installed for this runtime.`);
+var requireOptional = (value, capability) => {
+  if (value !== undefined)
+    return value;
+  throw new DeviceError("unsupported", `${capability} is not installed for this runtime.`);
+};
+var keyboard = {
+  capability: () => getDeviceAdapter().keyboard?.capability() ?? Promise.resolve(unavailableOptional("Keyboard")),
+  dismiss: () => requireOptional(getDeviceAdapter().keyboard, "Keyboard").dismiss(),
+  getState: () => requireOptional(getDeviceAdapter().keyboard, "Keyboard").getState(),
+  onChange: (listener) => requireOptional(getDeviceAdapter().keyboard, "Keyboard").onChange(listener),
+  state: () => requireOptional(getDeviceAdapter().keyboard, "Keyboard").getState()
+};
+var platform = {
+  capability: () => Promise.resolve(runtimeCapability(getDeviceAdapter().runtime)),
+  getInfo: () => getDeviceAdapter().platform.getInfo(),
+  info: () => getDeviceAdapter().platform.getInfo()
+};
+var network = {
+  capability: () => Promise.resolve(runtimeCapability(getDeviceAdapter().runtime)),
+  getStatus: () => getDeviceAdapter().network.getStatus(),
+  status: () => getDeviceAdapter().network.getStatus(),
+  onChange: (...args) => getDeviceAdapter().network.onChange(...args)
+};
+var systemBars = {
+  capability: (operation) => getDeviceAdapter().systemBars?.capability(operation) ?? Promise.resolve(unavailableOptional("System bars")),
+  setAppearance: (appearance, bar) => requireOptional(getDeviceAdapter().systemBars, "System bars").setAppearance(appearance, bar),
+  setVisible: (visible, bar) => requireOptional(getDeviceAdapter().systemBars, "System bars").setVisible(visible, bar)
+};
+
+// src/mobile/adaptiveShell.ts
+var STYLE_ID = "absolute-mobile-adaptive-shell";
+var ANNOUNCER_ID = "absolute-mobile-announcer";
+var HOST_METRICS_EVENT = "absolute:native-host-metrics";
+var STATUS_STYLE = `
+[data-absolute-mobile-status] {
+	display: grid;
+	min-height: var(--absolute-available-height, 100dvh);
+	place-items: center;
+	padding: max(1.5rem, var(--absolute-safe-area-inset-top, 0px)) max(1.5rem, var(--absolute-safe-area-inset-right, 0px)) max(1.5rem, var(--absolute-safe-area-inset-bottom, 0px)) max(1.5rem, var(--absolute-safe-area-inset-left, 0px));
+	box-sizing: border-box;
+	color: CanvasText;
+	background: Canvas;
+	font: 500 1rem/1.5 system-ui, sans-serif;
+	text-align: center;
+}
+[data-absolute-mobile-announcer] {
+	position: fixed;
+	width: 1px;
+	height: 1px;
+	padding: 0;
+	margin: -1px;
+	overflow: hidden;
+	clip: rect(0, 0, 0, 0);
+	white-space: nowrap;
+	border: 0;
+}
+`;
+var DEFAULT_KEYBOARD = {
+  heightPx: 0,
+  visible: false
+};
+var DEFAULT_NETWORK = {
+  connected: true,
+  connectionType: "unknown"
+};
+var DEFAULT_PLATFORM = {
+  formFactor: "unknown",
+  isNative: true,
+  os: "unknown",
+  runtime: "capacitor"
+};
+var finitePixels = (value) => Number.isFinite(value) ? Math.max(0, Math.round(value ?? 0)) : 0;
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var viewportSize = () => ({
+  height: finitePixels(globalThis.visualViewport?.height ?? innerHeight),
+  width: finitePixels(globalThis.visualViewport?.width ?? innerWidth)
+});
+var setPixels = (name, value) => document.documentElement.style.setProperty(name, `${finitePixels(value)}px`);
+var ensureStyle = () => {
+  let style = document.getElementById(STYLE_ID);
+  if (!(style instanceof HTMLStyleElement)) {
+    style = document.createElement("style");
+    style.id = STYLE_ID;
+    style.textContent = STATUS_STYLE;
+    document.head.append(style);
+  }
+};
+var ensureViewport = () => {
+  let viewport = document.head.querySelector('meta[name="viewport"]');
+  if (!viewport) {
+    viewport = document.createElement("meta");
+    viewport.name = "viewport";
+    document.head.prepend(viewport);
+  }
+  const values = new Set(viewport.content.split(",").map((value) => value.trim()).filter(Boolean));
+  values.add("width=device-width");
+  values.add("initial-scale=1");
+  values.add("viewport-fit=cover");
+  viewport.content = [...values].join(",");
+};
+var ensureAnnouncer = () => {
+  let announcer = document.getElementById(ANNOUNCER_ID);
+  if (!(announcer instanceof HTMLElement)) {
+    announcer = document.createElement("div");
+    announcer.id = ANNOUNCER_ID;
+    announcer.dataset.absoluteMobileAnnouncer = "";
+    announcer.setAttribute("aria-atomic", "true");
+    announcer.setAttribute("aria-live", "polite");
+    announcer.setAttribute("role", "status");
+    document.body.append(announcer);
+  }
+  return announcer;
+};
+var dispatchState = (state) => dispatchEvent(new CustomEvent("absolute:adaptive-shell-change", { detail: state }));
+var defaultDevices = {
+  keyboard,
+  network,
+  platform,
+  systemBars
+};
+var hostSafeAreaInsets = (value) => {
+  if (typeof value !== "object" || value === null)
+    return;
+  const candidate = Reflect.get(value, "safeAreaInsets");
+  if (typeof candidate !== "object" || candidate === null)
+    return;
+  const insets = {
+    bottom: Reflect.get(candidate, "bottom"),
+    left: Reflect.get(candidate, "left"),
+    right: Reflect.get(candidate, "right"),
+    top: Reflect.get(candidate, "top")
+  };
+  if (!isFiniteNumber(insets.bottom) || !isFiniteNumber(insets.left) || !isFiniteNumber(insets.right) || !isFiniteNumber(insets.top))
+    return;
+  return {
+    bottom: finitePixels(insets.bottom),
+    left: finitePixels(insets.left),
+    right: finitePixels(insets.right),
+    top: finitePixels(insets.top)
+  };
+};
+var installAbsoluteMobileAdaptiveShell = async (devices = defaultDevices) => {
+  let disposed = false;
+  let keyboardState = { ...DEFAULT_KEYBOARD };
+  let networkState = { ...DEFAULT_NETWORK };
+  let platformInfo = { ...DEFAULT_PLATFORM };
+  let viewport = viewportSize();
+  const subscriptions = [];
+  const state = () => ({
+    availableHeight: globalThis.visualViewport ? viewport.height : Math.max(0, viewport.height - keyboardState.heightPx),
+    keyboard: keyboardState,
+    network: networkState,
+    platform: platformInfo,
+    viewportHeight: viewport.height,
+    viewportWidth: viewport.width
+  });
+  const refreshDocument = () => {
+    if (disposed || !document.head || !document.body)
+      return;
+    ensureViewport();
+    ensureStyle();
+    const root = document.documentElement;
+    const current = state();
+    root.dataset.absoluteMobile = "";
+    root.dataset.absoluteRuntime = current.platform.runtime;
+    root.dataset.absolutePlatform = current.platform.os;
+    root.dataset.absoluteFormFactor = current.platform.formFactor;
+    root.dataset.absoluteKeyboard = current.keyboard.visible ? "visible" : "hidden";
+    root.dataset.absoluteNetwork = current.network.connected ? "online" : "offline";
+    root.dataset.absoluteConnection = current.network.connectionType;
+    root.dataset.absoluteReducedMotion = current.platform.prefersReducedMotion ? "reduce" : "no-preference";
+    const insets = current.platform.safeAreaInsets ?? {
+      bottom: 0,
+      left: 0,
+      right: 0,
+      top: 0
+    };
+    setPixels("--absolute-safe-area-inset-top", insets.top);
+    setPixels("--absolute-safe-area-inset-right", insets.right);
+    setPixels("--absolute-safe-area-inset-bottom", insets.bottom);
+    setPixels("--absolute-safe-area-inset-left", insets.left);
+    setPixels("--absolute-keyboard-height", current.keyboard.heightPx);
+    setPixels("--absolute-viewport-height", current.viewportHeight);
+    setPixels("--absolute-viewport-width", current.viewportWidth);
+    setPixels("--absolute-available-height", current.availableHeight);
+    ensureAnnouncer();
+  };
+  const publish = () => {
+    refreshDocument();
+    dispatchState(state());
+  };
+  const updateViewport = () => {
+    viewport = viewportSize();
+    devices.platform.getInfo().then((info) => {
+      platformInfo = info;
+      publish();
+      return;
+    }).catch(() => publish());
+  };
+  const updateKeyboard = (next) => {
+    keyboardState = {
+      heightPx: finitePixels(next.heightPx),
+      visible: next.visible
+    };
+    publish();
+  };
+  const updateNetwork = (next) => {
+    const changed = networkState.connected !== next.connected;
+    networkState = next;
+    publish();
+    if (changed || !next.connected)
+      ensureAnnouncer().textContent = next.connected ? "Connection restored." : "You are offline.";
+  };
+  const updateHostMetrics = (event) => {
+    const insets = hostSafeAreaInsets(Reflect.get(event, "detail"));
+    if (!insets)
+      return;
+    platformInfo = { ...platformInfo, safeAreaInsets: insets };
+    publish();
+  };
+  const installKeyboard = async () => {
+    const capability = await devices.keyboard.capability();
+    if (!capability.available)
+      return;
+    keyboardState = await devices.keyboard.getState();
+    subscriptions.push(await devices.keyboard.onChange(updateKeyboard));
+  };
+  try {
+    platformInfo = await devices.platform.getInfo();
+  } catch {}
+  const initialHostInsets = hostSafeAreaInsets(Reflect.get(globalThis, "__absoluteNativeHostMetrics"));
+  if (initialHostInsets)
+    platformInfo = {
+      ...platformInfo,
+      safeAreaInsets: initialHostInsets
+    };
+  try {
+    networkState = await devices.network.getStatus();
+    subscriptions.push(await devices.network.onChange(updateNetwork));
+  } catch {}
+  try {
+    await installKeyboard();
+  } catch {}
+  try {
+    const capability = await devices.systemBars.capability("appearance");
+    if (capability.available)
+      await devices.systemBars.setAppearance("automatic");
+  } catch {}
+  addEventListener("resize", updateViewport);
+  addEventListener(HOST_METRICS_EVENT, updateHostMetrics);
+  globalThis.visualViewport?.addEventListener("resize", updateViewport);
+  globalThis.visualViewport?.addEventListener("scroll", updateViewport);
+  publish();
+  if (!networkState.connected)
+    ensureAnnouncer().textContent = "You are offline.";
+  return {
+    refreshDocument,
+    state,
+    dispose: async () => {
+      if (disposed)
+        return;
+      disposed = true;
+      removeEventListener("resize", updateViewport);
+      removeEventListener(HOST_METRICS_EVENT, updateHostMetrics);
+      globalThis.visualViewport?.removeEventListener("resize", updateViewport);
+      globalThis.visualViewport?.removeEventListener("scroll", updateViewport);
+      await Promise.all(subscriptions.map((unsubscribe) => unsubscribe()));
+    }
+  };
+};
 // src/mobile/androidRelease.ts
 import { createHash as createHash4 } from "crypto";
 import {
@@ -1747,12 +3004,12 @@ var pathExists = async (path) => {
     return false;
   }
 };
-var detectAbsoluteMobileHost = (platform = process.platform, wsl = isWSLEnvironment()) => {
-  if (platform === "darwin")
+var detectAbsoluteMobileHost = (platform2 = process.platform, wsl = isWSLEnvironment()) => {
+  if (platform2 === "darwin")
     return "macos";
-  if (platform === "win32")
+  if (platform2 === "win32")
     return "windows";
-  if (platform === "linux" && wsl)
+  if (platform2 === "linux" && wsl)
     return "wsl";
   return "linux";
 };
@@ -1775,16 +3032,16 @@ var findExecutable = async (name, paths, options, host) => {
   }
   return;
 };
-var toolCheck = (id, label, platform, path, remediation) => path ? {
+var toolCheck = (id, label, platform2, path, remediation) => path ? {
   id,
   label,
   path,
-  platform,
+  platform: platform2,
   status: "pass"
 } : {
   id,
   label,
-  platform,
+  platform: platform2,
   remediation,
   status: "fail"
 };
@@ -2639,7 +3896,7 @@ var findByExtension = async (root, extension) => {
   if (!await pathExists4(root))
     return;
   const entries = await readdir3(root, { withFileTypes: true });
-  const matches = await Promise.all(entries.map(async (entry) => {
+  const matches2 = await Promise.all(entries.map(async (entry) => {
     const path = join5(root, entry.name);
     if (entry.isDirectory() && entry.name.endsWith(extension))
       return path;
@@ -2647,13 +3904,13 @@ var findByExtension = async (root, extension) => {
       return path;
     return entry.isDirectory() ? findByExtension(path, extension) : undefined;
   }));
-  return matches.find((match) => match !== undefined);
+  return matches2.find((match) => match !== undefined);
 };
 var findAllByExtension = async (root, extension, options = {}) => {
   if (!await pathExists4(root))
     return [];
   const entries = await readdir3(root, { withFileTypes: true });
-  const matches = await Promise.all(entries.map(async (entry) => {
+  const matches2 = await Promise.all(entries.map(async (entry) => {
     const path = join5(root, entry.name);
     if (entry.name.endsWith(extension))
       return [path];
@@ -2661,7 +3918,7 @@ var findAllByExtension = async (root, extension, options = {}) => {
       return [];
     return findAllByExtension(path, extension, options);
   }));
-  return matches.flat().sort();
+  return matches2.flat().sort();
 };
 var resolveAbsoluteIosXcodeProject = async (nativeDirectory, options = {}) => {
   const requestedWorkspace = options.workspacePath ? resolve4(nativeDirectory, options.workspacePath) : undefined;
@@ -5295,7 +6552,7 @@ var HTTP_OK = 200;
 var VERIFY_TIMEOUT_MS = 1e4;
 var ANDROID_ASSOCIATION_PATH = "/.well-known/assetlinks.json";
 var APPLE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association";
-var missingIdentity = (field2, platform) => new TypeError(`${field2} is required to publish ${platform} deep-link association files.`);
+var missingIdentity = (field2, platform2) => new TypeError(`${field2} is required to publish ${platform2} deep-link association files.`);
 var createAppleDocument = (config, requireAll) => {
   if (!config.platforms.includes("ios"))
     return;
@@ -5419,9 +6676,9 @@ var publishGeneratedDirectory = async (temporary, root) => {
 var materializeHost = async (root, host, files) => {
   const directory = resolve7(root, host, ".well-known");
   await mkdir7(directory, { recursive: true });
-  return Promise.all(files.map(async ([name, document]) => {
+  return Promise.all(files.map(async ([name, document2]) => {
     const path = resolve7(directory, name);
-    await writeAtomic(path, `${JSON.stringify(document, null, 2)}
+    await writeAtomic(path, `${JSON.stringify(document2, null, 2)}
 `);
     return path;
   }));
@@ -5486,13 +6743,13 @@ var verifyAbsoluteMobileAssociationFiles = async (config, request = globalThis.f
     if (!contentType.toLowerCase().startsWith("application/json")) {
       throw new TypeError(`${endpoint.platform} association verification failed for ${url}: expected application/json.`);
     }
-    let document;
+    let document2;
     try {
-      document = await response.json();
+      document2 = await response.json();
     } catch {
       throw new TypeError(`${endpoint.platform} association verification failed for ${url}: invalid JSON.`);
     }
-    if (JSON.stringify(document) !== JSON.stringify(endpoint.document)) {
+    if (JSON.stringify(document2) !== JSON.stringify(endpoint.document)) {
       throw new TypeError(`${endpoint.platform} association verification failed for ${url}: the hosted identity does not match mobile config.`);
     }
     return { platform: endpoint.platform, url };
@@ -6169,8 +7426,8 @@ 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)) {
+  const matches2 = (candidate, allowed) => candidate.protocol === allowed.protocol && candidate.host === allowed.host;
+  if (!matches2(url, local) && !matches2(url, production)) {
     return;
   }
   return `${url.pathname}${url.search}${url.hash}`;
@@ -7263,6 +8520,7 @@ var webHostSource = (config, auth, sync) => {
 import { router, usePathname } from 'expo-router';
 import { useEffect, useRef, useState } from 'react';
 import { ActivityIndicator, BackHandler, Platform, StyleSheet, View } from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import { WebView, type WebViewMessageEvent } from 'react-native-webview';
 import { materializeAbsoluteWebBundle } from './webAssets';
 import { createExpoDevicesBridgeHost } from '@absolutejs/devices-expo/bridge';
@@ -7295,7 +8553,10 @@ const isNativeRoute = (pathname: string) => {
 	});
 };
 
-const bridgeBootstrap = (path: string) => {
+const hostMetricsScript = (safeAreaInsets: { bottom: number; left: number; right: number; top: number }) =>
+	\`globalThis.__absoluteNativeHostMetrics = \${JSON.stringify({ safeAreaInsets })}; dispatchEvent(new CustomEvent('absolute:native-host-metrics', { detail: globalThis.__absoluteNativeHostMetrics })); true;\`;
+
+const bridgeBootstrap = (path: string, safeAreaInsets: { bottom: number; left: number; right: number; top: number }) => {
 	const initialPath = DEV_ORIGIN
 		? 'location.pathname + location.search + location.hash'
 		: JSON.stringify(path);
@@ -7304,6 +8565,7 @@ const bridgeBootstrap = (path: string) => {
 	const listeners = new Map();
 	let sequence = 0;
 	let currentPath = \${initialPath};
+	globalThis.__absoluteNativeHostMetrics = \${JSON.stringify({ safeAreaInsets })};
 	const send = value => {
 		const source = JSON.stringify(value);
 		if (new TextEncoder().encode(source).byteLength > 65536) throw new Error('Expo bridge message exceeds 64 KiB.');
@@ -7408,6 +8670,7 @@ const authStatus = async () => {
 
 export function AbsoluteWebHost() {
 	const pathname = usePathname() || '/';
+	const safeAreaInsets = useSafeAreaInsets();
 	const webView = useRef<WebView>(null);
 	const devicesBridge = useRef<{ close(): void | Promise<void>; request(method: string, params: Record<string, unknown>): Promise<unknown> } | undefined>(undefined);
 	const syncBridge = useRef<{ close(): void | Promise<void>; request(method: string, params: Record<string, unknown>): Promise<unknown> } | undefined>(undefined);
@@ -7450,6 +8713,9 @@ export function AbsoluteWebHost() {
 		}
 		void materializeAbsoluteWebBundle().then(uri => setIndexUri(uri + '?absolutePath=' + encodeURIComponent(pathname)));
 	}, [pathname]);
+	useEffect(() => {
+		webView.current?.injectJavaScript(hostMetricsScript(safeAreaInsets));
+	}, [safeAreaInsets.bottom, safeAreaInsets.left, safeAreaInsets.right, safeAreaInsets.top]);
 	useEffect(() => {
 		const subscription = BackHandler.addEventListener('hardwareBackPress', () => {
 			if (!canGoBack) return false;
@@ -7533,7 +8799,7 @@ export function AbsoluteWebHost() {
 		allowFileAccessFromFileURLs
 		allowUniversalAccessFromFileURLs={false}
 		allowingReadAccessToURL={indexUri.slice(0, indexUri.lastIndexOf('/') + 1)}
-		injectedJavaScriptBeforeContentLoaded={bridgeBootstrap(pathname)}
+		injectedJavaScriptBeforeContentLoaded={bridgeBootstrap(pathname, safeAreaInsets)}
 		onMessage={onMessage}
 		onNavigationStateChange={state => setCanGoBack(state.canGoBack)}
 		onShouldStartLoadWithRequest={request => {
@@ -8495,18 +9761,18 @@ var planAbsoluteExpoDevSession = (config, options) => {
     env,
     role: "native-prepare"
   };
-  const native = options.platforms.map((platform) => {
-    const device = platform === "android" ? options.androidDevice : options.iosDevice;
+  const native = options.platforms.map((platform2) => {
+    const device = platform2 === "android" ? options.androidDevice : options.iosDevice;
     const command = {
       args: [
-        `run:${platform}`,
+        `run:${platform2}`,
         "--no-bundler",
         "--port",
         String(options.metroPort),
         ...device ? ["--device", device] : []
       ],
       env,
-      platform,
+      platform: platform2,
       role: "native-build"
     };
     return command;
@@ -8678,10 +9944,10 @@ var startAbsoluteExpoDevSession = async (options) => {
   const runNativeCommand = async (command) => {
     if (options.signal?.aborted)
       throw abortError();
-    const { platform } = command;
-    if (!platform)
+    const { platform: platform2 } = command;
+    if (!platform2)
       throw new TypeError("Expo native build command is missing a platform.");
-    const state = platform === "android" ? "building-android" : "building-ios";
+    const state = platform2 === "android" ? "building-android" : "building-ios";
     setState(state);
     const started = performance.now();
     const child = run(executable, command.args, {
@@ -8691,7 +9957,7 @@ var startAbsoluteExpoDevSession = async (options) => {
     });
     forwardLines(child, (line) => {
       if (line)
-        log(`[${platform}] ${line}`);
+        log(`[${platform2}] ${line}`);
     });
     const abortChild = () => void stopProcess(child);
     options.signal?.addEventListener("abort", abortChild, { once: true });
@@ -8700,9 +9966,9 @@ var startAbsoluteExpoDevSession = async (options) => {
     if (options.signal?.aborted)
       throw abortError();
     if (exitCode !== 0) {
-      throw new Error(`Expo ${platform} development build exited with status ${exitCode}.`);
+      throw new Error(`Expo ${platform2} development build exited with status ${exitCode}.`);
     }
-    if (platform === "ios" && options.certificateAuthorityPath && options.iosOrigin && new URL(options.iosOrigin).protocol === "https:" && !options.iosDevice) {
+    if (platform2 === "ios" && options.certificateAuthorityPath && options.iosOrigin && new URL(options.iosOrigin).protocol === "https:" && !options.iosDevice) {
       setState("enrolling-trust");
       const trustStarted = performance.now();
       const utilityOptions = {
@@ -8889,13 +10155,13 @@ var bundleAuditSteps = `      - name: Prepare production mobile bundle
       - name: Enforce mobile bundle audit
         if: steps.mobile-bundle-audit.outcome != 'success'
         run: exit 1`;
-var releaseAuditSteps = (platform) => `      - name: Run redacted mobile release audit
+var releaseAuditSteps = (platform2) => `      - name: Run redacted mobile release audit
         id: mobile-release-audit
         continue-on-error: true
         shell: bash
         run: |
           mkdir -p .absolutejs/mobile-ci
-          args=(bunx absolute mobile doctor release ${platform} --json)
+          args=(bunx absolute mobile doctor release ${platform2} --json)
           ${appendConfigArgument}
           "\${args[@]}" > .absolutejs/mobile-ci/compliance.json
       - name: Upload mobile compliance report
@@ -8962,7 +10228,7 @@ var publishingInputs = (platforms, includePublishing) => {
 ${fields.join(`
 `)}`;
 };
-var jobCondition = (platform) => `github.event_name == 'workflow_dispatch' && (inputs.platform == 'all' || inputs.platform == '${platform}')`;
+var jobCondition = (platform2) => `github.event_name == 'workflow_dispatch' && (inputs.platform == 'all' || inputs.platform == '${platform2}')`;
 var androidJob = (options) => {
   const custom = customSecretEnvironment(options.customSecrets);
   const publishEnvironment = options.includePublishing ? `
@@ -9272,7 +10538,7 @@ var writeAbsoluteMobileGithubWorkflow = async (options) => {
     changed: previous !== generated.workflow,
     format: ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT,
     path,
-    platforms: options.config.engine === "expo" ? options.config.platforms.filter((platform) => platform === "android") : [...options.config.platforms].sort(),
+    platforms: options.config.engine === "expo" ? options.config.platforms.filter((platform2) => platform2 === "android") : [...options.config.platforms].sort(),
     publishing: options.includePublishing === true,
     requiredSecrets: generated.requiredSecrets
   };
@@ -9479,13 +10745,13 @@ var createAbsoluteMobilePreviewPlugin = (mobile) => {
   })).post("/__absolute/mobile-preview-telemetry", ({ body, status }) => {
     const value = isRecord10(body) ? body : undefined;
     const durationMs = value?.durationMs;
-    const platform2 = value?.platform;
-    if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0 || durationMs > 300000 || platform2 !== "android" && platform2 !== "ios") {
+    const platform3 = value?.platform;
+    if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0 || durationMs > 300000 || platform3 !== "android" && platform3 !== "ios") {
       return status(400, { error: "invalid-preview-telemetry" });
     }
     sendTelemetryEvent("mobile:preview-ready", {
       durationMs: Math.round(durationMs),
-      platform: platform2,
+      platform: platform3,
       provider: "capacitor",
       target: "mobile-preview"
     });
@@ -9649,12 +10915,12 @@ var configureIos = async (config) => {
   return changed.some(Boolean);
 };
 var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms) => {
-  const results = await Promise.all(platforms.map(async (platform2) => {
-    const didChange = platform2 === "android" ? await configureAndroid(config) : await configureIos(config);
-    return { didChange, platform: platform2 };
+  const results = await Promise.all(platforms.map(async (platform3) => {
+    const didChange = platform3 === "android" ? await configureAndroid(config) : await configureIos(config);
+    return { didChange, platform: platform3 };
   }));
   return {
-    changed: results.filter(({ didChange }) => didChange).map(({ platform: platform2 }) => platform2)
+    changed: results.filter(({ didChange }) => didChange).map(({ platform: platform3 }) => platform3)
   };
 };
 // src/mobile/nativeDeviceCapabilities.ts
@@ -9997,12 +11263,12 @@ ${content}
   return manifestChanged || firebaseChanged;
 };
 var applyAbsoluteNativeDeviceCapabilities = async (projectRoot, config, platforms = config.platforms, plan = resolveAbsoluteDeviceCapabilityPlan(projectRoot)) => {
-  const results = await Promise.all(platforms.map(async (platform2) => ({
-    didChange: platform2 === "ios" ? await configureIos2(config, plan) : await configureAndroid2(config, plan),
-    platform: platform2
+  const results = await Promise.all(platforms.map(async (platform3) => ({
+    didChange: platform3 === "ios" ? await configureIos2(config, plan) : await configureAndroid2(config, plan),
+    platform: platform3
   })));
   return {
-    changed: results.filter(({ didChange }) => didChange).map(({ platform: platform2 }) => platform2)
+    changed: results.filter(({ didChange }) => didChange).map(({ platform: platform3 }) => platform3)
   };
 };
 
@@ -10705,15 +11971,15 @@ var createWebHttpTransport = (options = {}) => {
     runtime: "web"
   });
 };
-var RUNTIME_REGISTRY = Symbol.for("@absolutejs/http/runtime");
-var registryHost = globalThis;
-var isRuntimeRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations"));
-var runtimeRegistry = (() => {
-  const existing = registryHost[RUNTIME_REGISTRY];
-  if (isRuntimeRegistry(existing))
+var RUNTIME_REGISTRY2 = Symbol.for("@absolutejs/http/runtime");
+var registryHost2 = globalThis;
+var isRuntimeRegistry2 = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations"));
+var runtimeRegistry2 = (() => {
+  const existing = registryHost2[RUNTIME_REGISTRY2];
+  if (isRuntimeRegistry2(existing))
     return existing;
   const created = { installations: [] };
-  Object.defineProperty(registryHost, RUNTIME_REGISTRY, {
+  Object.defineProperty(registryHost2, RUNTIME_REGISTRY2, {
     configurable: false,
     enumerable: false,
     value: created,
@@ -10726,14 +11992,14 @@ var fallbackTransport = () => {
     return createWebHttpTransport();
   throw new AbsoluteHttpError("not-configured", "Absolute HTTP requires a request-scoped SSR transport outside a browser.");
 };
-var getAbsoluteHttpTransport = () => runtimeRegistry.installations.at(-1)?.transport ?? (runtimeRegistry.fallback ??= fallbackTransport());
+var getAbsoluteHttpTransport = () => runtimeRegistry2.installations.at(-1)?.transport ?? (runtimeRegistry2.fallback ??= fallbackTransport());
 var installAbsoluteHttpTransport = (transport) => {
   const installation = { transport };
-  runtimeRegistry.installations.push(installation);
+  runtimeRegistry2.installations.push(installation);
   return () => {
-    const index = runtimeRegistry.installations.indexOf(installation);
+    const index = runtimeRegistry2.installations.indexOf(installation);
     if (index >= 0)
-      runtimeRegistry.installations.splice(index, 1);
+      runtimeRegistry2.installations.splice(index, 1);
   };
 };
 var forbiddenCredentialHeaders = new Set([
@@ -10864,6 +12130,7 @@ export {
   ABSOLUTE_MOBILE_PREVIEW_PATH,
   ABSOLUTE_MOBILE_RETAINED_GENERATIONS,
   ABSOLUTE_MOBILE_ROUTE_DETAIL,
+  ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABILITIES,
   ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL,
   ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV,
   ABSOLUTE_NATIVE_AUTH_SCOPES,
@@ -10935,6 +12202,7 @@ export {
   inspectAbsoluteRemoteMacLanHost,
   inspectAbsoluteRemoteMacWorkspace,
   installAbsoluteIosRelease,
+  installAbsoluteMobileAdaptiveShell,
   installAbsoluteMobileAuthEnvironment,
   installAbsoluteMobileShellHttp,
   installAbsoluteMobileSyncRemediation,
@@ -11011,5 +12279,5 @@ export {
   writeAbsoluteMobileGithubWorkflow
 };
 
-//# debugId=61B4FE527637B49864756E2164756E21
+//# debugId=15034BCB4D45F19A64756E2164756E21
 //# sourceMappingURL=index.js.map