@absolutejs/absolute 0.20.0-beta.6 → 0.20.0-beta.60

package/dist/mobile/shellBootstrap.js

@@ -0,0 +1,1800 @@
+// src/mobile/uiPrimitives.ts
+var STYLE_ID = "absolute-mobile-ui-primitives";
+var NAVIGATION_EVENT = "absolute:navigation-change";
+var SHEET_EVENT = "absolute:sheet-change";
+var BACK_EVENT = "absolute:back-request";
+var ACTIVE_SHEET_SELECTOR = "dialog[data-absolute-sheet][open]";
+var TAB_LINK_SELECTOR = "[data-absolute-tab-bar] a[href]";
+var UI_STYLE = `
+[data-absolute-app-shell] {
+	display: grid;
+	grid-template-rows: auto minmax(0, 1fr) auto;
+	box-sizing: border-box;
+	min-height: var(--absolute-available-height, 100dvh);
+	padding-inline: var(--absolute-safe-area-inset-left, 0px) var(--absolute-safe-area-inset-right, 0px);
+}
+[data-absolute-app-header] {
+	padding-top: var(--absolute-safe-area-inset-top, 0px);
+}
+[data-absolute-app-main], [data-absolute-navigation-stack] {
+	min-width: 0;
+	min-height: 0;
+}
+[data-absolute-app-main] {
+	overflow: auto;
+	overscroll-behavior-y: contain;
+}
+[data-absolute-navigation-stack] {
+	view-transition-name: absolute-mobile-stack;
+}
+[data-absolute-tab-bar] {
+	display: flex;
+	align-items: stretch;
+	justify-content: space-around;
+	box-sizing: border-box;
+	padding-bottom: var(--absolute-safe-area-inset-bottom, 0px);
+	background: Canvas;
+	color: CanvasText;
+}
+[data-absolute-tab-bar] > a {
+	display: grid;
+	flex: 1 1 0;
+	min-width: 0;
+	min-height: 2.75rem;
+	place-items: center;
+	padding: 0.375rem 0.5rem;
+	color: inherit;
+	text-align: center;
+	text-decoration: none;
+	touch-action: manipulation;
+}
+[data-absolute-tab-bar] > a[aria-current="page"] {
+	font-weight: 700;
+}
+dialog[data-absolute-sheet] {
+	box-sizing: border-box;
+	width: min(100%, var(--absolute-sheet-max-width, 42rem));
+	max-height: min(90dvh, var(--absolute-available-height, 90dvh));
+	margin: auto auto 0;
+	padding: 1rem max(1rem, var(--absolute-safe-area-inset-right, 0px)) max(1rem, var(--absolute-safe-area-inset-bottom, 0px)) max(1rem, var(--absolute-safe-area-inset-left, 0px));
+	overflow: auto;
+	border: 1px solid color-mix(in srgb, CanvasText 18%, transparent);
+	border-radius: 1rem 1rem 0 0;
+	background: Canvas;
+	color: CanvasText;
+	box-shadow: 0 -0.5rem 2rem color-mix(in srgb, CanvasText 18%, transparent);
+}
+dialog[data-absolute-sheet]::backdrop {
+	background: color-mix(in srgb, CanvasText 38%, transparent);
+}
+@keyframes absolute-mobile-forward-old { to { opacity: 0; transform: translateX(-12%); } }
+@keyframes absolute-mobile-forward-new { from { opacity: 0; transform: translateX(12%); } }
+@keyframes absolute-mobile-back-old { to { opacity: 0; transform: translateX(12%); } }
+@keyframes absolute-mobile-back-new { from { opacity: 0; transform: translateX(-12%); } }
+html[data-absolute-navigation-direction="forward"]::view-transition-old(absolute-mobile-stack) { animation: 180ms ease both absolute-mobile-forward-old; }
+html[data-absolute-navigation-direction="forward"]::view-transition-new(absolute-mobile-stack) { animation: 180ms ease both absolute-mobile-forward-new; }
+html[data-absolute-navigation-direction="back"]::view-transition-old(absolute-mobile-stack) { animation: 180ms ease both absolute-mobile-back-old; }
+html[data-absolute-navigation-direction="back"]::view-transition-new(absolute-mobile-stack) { animation: 180ms ease both absolute-mobile-back-new; }
+html[data-absolute-reduced-motion="reduce"]::view-transition-old(absolute-mobile-stack),
+html[data-absolute-reduced-motion="reduce"]::view-transition-new(absolute-mobile-stack) { animation: none; }
+`;
+var currentPath = () => `${location.pathname}${location.search}${location.hash}`;
+var ensureStyle = () => {
+  let style = document.getElementById(STYLE_ID);
+  if (!(style instanceof HTMLStyleElement)) {
+    style = document.createElement("style");
+    style.id = STYLE_ID;
+    style.textContent = UI_STYLE;
+    document.head.append(style);
+  }
+};
+var sheetById = (id) => {
+  const target = document.getElementById(id);
+  return target instanceof HTMLDialogElement && target.dataset.absoluteSheet !== undefined ? target : undefined;
+};
+var dispatchSheet = (sheet, open) => dispatchEvent(new CustomEvent(SHEET_EVENT, {
+  detail: { id: sheet.id, open }
+}));
+var focusSheet = (sheet) => {
+  const target = sheet.querySelector('[autofocus], button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
+  (target ?? sheet).focus();
+};
+var sheetOpeners = new WeakMap;
+var closeAbsoluteMobileSheet = (target) => {
+  const sheet = typeof target === "string" ? sheetById(target) : target;
+  if (!sheet || !sheet.open)
+    return false;
+  if (typeof sheet.close === "function")
+    sheet.close();
+  else
+    sheet.removeAttribute("open");
+  sheet.removeAttribute("aria-modal");
+  sheetOpeners.get(sheet)?.focus();
+  sheetOpeners.delete(sheet);
+  dispatchSheet(sheet, false);
+  return true;
+};
+var openAbsoluteMobileSheet = (target, opener) => {
+  const sheet = typeof target === "string" ? sheetById(target) : target;
+  if (!sheet || sheet.dataset.absoluteSheet === undefined)
+    return false;
+  const active = document.querySelector(ACTIVE_SHEET_SELECTOR);
+  if (active && active !== sheet)
+    closeAbsoluteMobileSheet(active);
+  if (opener)
+    sheetOpeners.set(sheet, opener);
+  if (!sheet.open) {
+    if (typeof sheet.showModal === "function")
+      sheet.showModal();
+    else
+      sheet.setAttribute("open", "");
+  }
+  sheet.setAttribute("aria-modal", "true");
+  focusSheet(sheet);
+  dispatchSheet(sheet, true);
+  return true;
+};
+var readAbsoluteMobileLinkIntent = (anchor) => {
+  const mode = anchor.dataset.absoluteLink;
+  if (mode === "back")
+    return { kind: "back" };
+  if (mode === "external")
+    return { kind: "external" };
+  return { kind: "navigate", replace: mode === "replace" };
+};
+var requestAbsoluteMobileBack = () => {
+  const event = new CustomEvent(BACK_EVENT, { cancelable: true });
+  return !dispatchEvent(event);
+};
+var normalizePathname = (value) => {
+  try {
+    return new URL(value, location.href).pathname.replace(/\/$/u, "") || "/";
+  } catch {
+    return;
+  }
+};
+var syncTabLinks = (path) => {
+  const activePath = normalizePathname(path);
+  if (!activePath)
+    return;
+  document.querySelectorAll(TAB_LINK_SELECTOR).forEach((anchor) => {
+    const candidate = normalizePathname(anchor.href);
+    const prefix = anchor.dataset.absoluteTabMatch === "prefix";
+    const active = candidate !== undefined && (prefix ? activePath === candidate || candidate !== "/" && activePath.startsWith(`${candidate}/`) : activePath === candidate);
+    if (active)
+      anchor.setAttribute("aria-current", "page");
+    else
+      anchor.removeAttribute("aria-current");
+  });
+};
+var installAbsoluteMobileUiPrimitives = () => {
+  let disposed = false;
+  let scheduled = false;
+  let path = currentPath();
+  const refreshDocument = (nextPath = path) => {
+    if (disposed || !document.head || !document.body)
+      return;
+    path = nextPath;
+    ensureStyle();
+    syncTabLinks(path);
+  };
+  const scheduleRefresh = () => {
+    if (scheduled || disposed)
+      return;
+    scheduled = true;
+    queueMicrotask(() => {
+      scheduled = false;
+      refreshDocument();
+    });
+  };
+  const handleClick = (event) => {
+    if (!(event.target instanceof Element))
+      return;
+    const opener = event.target.closest("[data-absolute-sheet-open]");
+    if (opener?.dataset.absoluteSheetOpen) {
+      if (openAbsoluteMobileSheet(opener.dataset.absoluteSheetOpen, opener))
+        event.preventDefault();
+      return;
+    }
+    const closer = event.target.closest("[data-absolute-sheet-close]");
+    const sheet = closer?.closest("dialog[data-absolute-sheet]");
+    if (sheet && closeAbsoluteMobileSheet(sheet)) {
+      event.preventDefault();
+      return;
+    }
+    if (event.target instanceof HTMLDialogElement && event.target.dataset.absoluteSheet !== undefined) {
+      const rect = event.target.getBoundingClientRect();
+      const outside = event.clientX < rect.left || event.clientX > rect.right || event.clientY < rect.top || event.clientY > rect.bottom;
+      if (outside && closeAbsoluteMobileSheet(event.target))
+        event.preventDefault();
+    }
+  };
+  const handleCancel = (event) => {
+    if (!(event.target instanceof HTMLDialogElement))
+      return;
+    if (event.target.dataset.absoluteSheet === undefined)
+      return;
+    event.preventDefault();
+    closeAbsoluteMobileSheet(event.target);
+  };
+  const handleBack = (event) => {
+    const active = document.querySelector(ACTIVE_SHEET_SELECTOR);
+    if (!active)
+      return;
+    event.preventDefault();
+    closeAbsoluteMobileSheet(active);
+  };
+  const observer = new MutationObserver(scheduleRefresh);
+  observer.observe(document.documentElement, {
+    childList: true,
+    subtree: true
+  });
+  addEventListener("click", handleClick);
+  addEventListener("cancel", handleCancel, true);
+  addEventListener(BACK_EVENT, handleBack);
+  refreshDocument();
+  return {
+    refreshDocument,
+    requestBack: requestAbsoluteMobileBack,
+    dispose: () => {
+      if (disposed)
+        return;
+      disposed = true;
+      observer.disconnect();
+      removeEventListener("click", handleClick);
+      removeEventListener("cancel", handleCancel, true);
+      removeEventListener(BACK_EVENT, handleBack);
+    },
+    navigate: (detail) => {
+      path = detail.to;
+      document.documentElement.dataset.absoluteNavigationDirection = detail.direction;
+      refreshDocument(path);
+      dispatchEvent(new CustomEvent(NAVIGATION_EVENT, {
+        detail
+      }));
+    }
+  };
+};
+
+// src/mobile/shellBootstrap.ts
+import { App } from "@capacitor/app";
+import { Browser } from "@capacitor/browser";
+
+// src/mobile/producerContextState.ts
+var ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY = Symbol.for("absolutejs.mobileProducerAsyncLocalStorage");
+var frameworks = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+
+// src/mobile/pageProtocol.ts
+var ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
+var ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION = 1;
+var MOBILE_PAGE_REQUEST_HEADERS = {
+  appBuild: "x-absolute-mobile-app-build",
+  pageBundle: "x-absolute-mobile-page-bundle",
+  pageContracts: "x-absolute-mobile-page-contracts",
+  pageId: "x-absolute-mobile-page-id",
+  protocol: "x-absolute-mobile-protocol",
+  runtime: "x-absolute-mobile-runtime"
+};
+var headerVaryValues = [
+  "Accept",
+  MOBILE_PAGE_REQUEST_HEADERS.protocol,
+  MOBILE_PAGE_REQUEST_HEADERS.runtime,
+  MOBILE_PAGE_REQUEST_HEADERS.appBuild,
+  MOBILE_PAGE_REQUEST_HEADERS.pageBundle,
+  MOBILE_PAGE_REQUEST_HEADERS.pageContracts,
+  MOBILE_PAGE_REQUEST_HEADERS.pageId
+];
+
+// src/mobile/client.ts
+class AbsoluteMobilePageProtocolError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "AbsoluteMobilePageProtocolError";
+    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 frameworks2 = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var upgradeReasons = new Set([
+  "app-release",
+  "page-contract",
+  "protocol",
+  "runtime"
+]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isFramework = (value) => typeof value === "string" && frameworks2.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 (!isRecord(value.props)) {
+    throw new AbsoluteMobilePageProtocolError("invalid-props", "The mobile page response must contain an object props value.");
+  }
+  return {
+    contract: value.contract,
+    framework: value.framework,
+    kind: "page",
+    pageId: value.pageId,
+    props: value.props,
+    status: value.status
+  };
+};
+var parseUpgradeResult = (value) => {
+  if (typeof value.pageId !== "string" || !isUpgradeReason(value.reason)) {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The update response is missing its page or reason.");
+  }
+  return {
+    kind: "upgrade-required",
+    pageId: value.pageId,
+    reason: value.reason,
+    supportedContracts: Array.isArray(value.supportedContracts) ? value.supportedContracts.filter((contract) => typeof contract === "string") : undefined,
+    supportedRuntimes: Array.isArray(value.supportedRuntimes) ? value.supportedRuntimes.filter((runtime) => typeof runtime === "string") : undefined
+  };
+};
+var activateAbsoluteMobilePage = async (value, options) => {
+  const envelope = parseAbsoluteMobilePageEnvelope(value);
+  if (envelope.response.kind === "upgrade-required") {
+    return envelope.response;
+  }
+  if (envelope.response.kind !== "page") {
+    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",
+    pageId: envelope.response.pageId
+  };
+};
+var parseAbsoluteMobilePageEnvelope = (value) => {
+  if (!isRecord(value) || !isRecord(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) {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", `Unsupported mobile page protocol ${String(value.protocol)}.`);
+  }
+  const { kind } = value.response;
+  if (kind === "page") {
+    return {
+      protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+      response: parsePageResult(value.response)
+    };
+  }
+  if (kind === "upgrade-required") {
+    return {
+      protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+      response: parseUpgradeResult(value.response)
+    };
+  }
+  if (kind === "invalid-request") {
+    throw new AbsoluteMobilePageProtocolError("server-rejected-request", typeof value.response.message === "string" ? value.response.message : "The server rejected the mobile page request.");
+  }
+  if (kind === "error") {
+    throw new AbsoluteMobilePageProtocolError("server-error", "The server could not create a compatible mobile page representation.");
+  }
+  throw new AbsoluteMobilePageProtocolError("invalid-envelope", `Unknown mobile page response kind ${String(kind)}.`);
+};
+
+// src/mobile/routeMatcher.ts
+var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
+var routeSegmentPattern = (segment) => {
+  if (segment === "*")
+    return ".*";
+  if (segment.startsWith(":") && segment.endsWith("?"))
+    return "[^/]*";
+  if (segment.startsWith(":"))
+    return "[^/]+";
+  return segment.replace(REGEXP_SPECIAL_CHARACTERS, "\\$&");
+};
+var matchesAbsoluteMobileRoutePattern = (pattern, pathname) => {
+  const expression = pattern.split("/").map(routeSegmentPattern).join("/");
+  return new RegExp(`^${expression}/?$`).test(pathname);
+};
+var resolveAbsoluteMobileRoute = (routes, pathname, method = "GET") => routes.find((route) => route.method === method && matchesAbsoluteMobileRoutePattern(route.pattern, pathname));
+
+// src/mobile/transport.ts
+var pageForPathname = (manifest, pathname) => {
+  const route = resolveAbsoluteMobileRoute(manifest.routes, pathname);
+  if (!route) {
+    throw new TypeError(`No embedded mobile page owns ${pathname}.`);
+  }
+  const page = manifest.pages.find((candidate) => candidate.pageId === route.pageId);
+  if (!page) {
+    throw new TypeError(`Mobile route ${route.pattern} references missing page ${route.pageId}.`);
+  }
+  return page;
+};
+var canonicalBackendUrl = (manifest, path) => {
+  const origin = new URL(manifest.productionOrigin);
+  const url = new URL(path, `${origin.origin}/`);
+  if (url.origin !== origin.origin) {
+    throw new TypeError("Mobile transport cannot leave productionOrigin.");
+  }
+  url.hash = "";
+  return url;
+};
+var createAbsoluteMobilePageRequest = (manifest, path, options = {}) => {
+  const url = canonicalBackendUrl(manifest, path);
+  const page = pageForPathname(manifest, url.pathname);
+  const headers = new Headers(options.headers);
+  headers.set("accept", ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.appBuild, manifest.appBuild);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageBundle, page.bundleHash);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageContracts, page.contract);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageId, page.pageId);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.protocol, String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION));
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.runtime, manifest.runtime);
+  return new Request(url, {
+    headers,
+    method: "GET",
+    ...options.signal ? { signal: options.signal } : {}
+  });
+};
+var fetchAbsoluteMobilePage = async (manifest, path, options = {}) => {
+  const request = createAbsoluteMobilePageRequest(manifest, path, options);
+  const response = await (options.fetch ?? globalThis.fetch)(request);
+  const value = await response.json();
+  return value;
+};
+var resolveAbsoluteMobileDeepLink = (manifest, value) => {
+  const url = new URL(value);
+  if (url.username || url.password) {
+    throw new TypeError("Mobile deep links cannot contain credentials.");
+  }
+  const isHttpsHost = url.protocol === "https:" && manifest.deepLinkHosts.includes(url.hostname.toLowerCase());
+  const isCustomScheme = manifest.deepLinkScheme !== undefined && url.protocol === `${manifest.deepLinkScheme}:`;
+  if (!isHttpsHost && !isCustomScheme) {
+    throw new TypeError("Mobile deep link is outside the configured app URLs.");
+  }
+  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/staticDocument.ts
+var HTMX_REQUEST_ATTRIBUTE_PATTERN = /(\s(?:action|formaction|hx-(?:delete|get|patch|post|put))\s*=\s*["'])(\/[^"']*)(["'])/giu;
+var BLOCKED_FRAGMENT_ELEMENTS = 'script,base,iframe,object,embed,link[rel="modulepreload"],meta[http-equiv="refresh"]';
+var HTMX_REQUEST_ATTRIBUTES = new Set([
+  "hx-delete",
+  "hx-get",
+  "hx-patch",
+  "hx-post",
+  "hx-put"
+]);
+var URL_ATTRIBUTES = new Set(["action", "formaction", "href", "src"]);
+var HEX_RADIX = 16;
+var SCRIPT_PLACEHOLDER_ATTRIBUTE = "data-absolute-mobile-script";
+var bytesToHex = (bytes) => [...bytes].map((byte) => byte.toString(HEX_RADIX).padStart(2, "0")).join("");
+var hashAbsoluteMobileStaticDocument = async (source) => bytesToHex(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(source))));
+var rewriteAbsoluteMobileHtmxRequests = (source, productionOrigin) => source.replace(HTMX_REQUEST_ATTRIBUTE_PATTERN, (_match, prefix, path, quote) => `${prefix}${new URL(path, productionOrigin).href}${quote}`);
+var backendUrl = (value, productionOrigin) => {
+  try {
+    const expected = new URL(productionOrigin);
+    const candidate = new URL(value, expected);
+    return candidate.origin === expected.origin ? candidate.href : undefined;
+  } catch {
+    return;
+  }
+};
+var sanitizeFragmentAttribute = (element, attribute, productionOrigin) => {
+  const name = attribute.name.toLowerCase();
+  const isExecutable = name === "srcdoc" || name.startsWith("on") || name.startsWith("hx-on");
+  const isUnsafeUrl = (HTMX_REQUEST_ATTRIBUTES.has(name) || URL_ATTRIBUTES.has(name)) && !backendUrl(attribute.value, productionOrigin);
+  if (isExecutable || isUnsafeUrl)
+    element.removeAttribute(attribute.name);
+  else if (HTMX_REQUEST_ATTRIBUTES.has(name) || URL_ATTRIBUTES.has(name)) {
+    element.setAttribute(attribute.name, backendUrl(attribute.value, productionOrigin) ?? attribute.value);
+  }
+};
+var sanitizeAbsoluteMobileHtmxFragment = (source, productionOrigin, parse = (value) => new DOMParser().parseFromString(value, "text/html")) => {
+  const parsed = parse(source);
+  parsed.querySelectorAll(BLOCKED_FRAGMENT_ELEMENTS).forEach((element) => {
+    element.remove();
+  });
+  parsed.querySelectorAll("*").forEach((element) => {
+    for (const attribute of [...element.attributes]) {
+      sanitizeFragmentAttribute(element, attribute, productionOrigin);
+    }
+  });
+  return parsed.body.innerHTML;
+};
+var installHtmxFragmentBoundary = (productionOrigin) => {
+  const validateUrl = (event) => {
+    const detail = Reflect.get(event, "detail");
+    if (typeof detail !== "object" || detail === null) {
+      event.preventDefault();
+      return;
+    }
+    const url = Reflect.get(detail, "url");
+    if (!(url instanceof URL) || !backendUrl(url.href, productionOrigin)) {
+      event.preventDefault();
+    }
+  };
+  const configureRequest = (event) => {
+    const detail = Reflect.get(event, "detail");
+    if (typeof detail !== "object" || detail === null)
+      return;
+    const path = Reflect.get(detail, "path");
+    if (typeof path !== "string")
+      return;
+    const resolved = backendUrl(path, productionOrigin);
+    if (resolved)
+      Reflect.set(detail, "path", resolved);
+  };
+  const sanitize = (event) => {
+    const detail = Reflect.get(event, "detail");
+    if (typeof detail !== "object" || detail === null)
+      return;
+    const serverResponse = Reflect.get(detail, "serverResponse");
+    if (typeof serverResponse !== "string")
+      return;
+    Reflect.set(detail, "serverResponse", sanitizeAbsoluteMobileHtmxFragment(serverResponse, productionOrigin));
+  };
+  addEventListener("htmx:validateUrl", validateUrl);
+  addEventListener("htmx:configRequest", configureRequest);
+  addEventListener("htmx:beforeSwap", sanitize);
+  return () => {
+    removeEventListener("htmx:validateUrl", validateUrl);
+    removeEventListener("htmx:configRequest", configureRequest);
+    removeEventListener("htmx:beforeSwap", sanitize);
+  };
+};
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var replaceAttributes = (target, source) => {
+  for (const attribute of [...target.attributes]) {
+    target.removeAttribute(attribute.name);
+  }
+  for (const attribute of [...source.attributes]) {
+    target.setAttribute(attribute.name, attribute.value);
+  }
+};
+var applyScriptAttribute = (element, name, value, localUrl) => {
+  if (name === SCRIPT_PLACEHOLDER_ATTRIBUTE)
+    return;
+  if (name === "src") {
+    const source = new URL(value, localUrl);
+    const navigation = new URL(localUrl).searchParams.get("absoluteNavigation");
+    if (navigation)
+      source.searchParams.set("absoluteNavigation", navigation);
+    element.src = source.href;
+    return;
+  }
+  element.setAttribute(name, value);
+};
+var executableScript = (script, localUrl) => {
+  const element = document.createElement("script");
+  for (const [name, value] of script.attributes) {
+    applyScriptAttribute(element, name, value, localUrl);
+  }
+  element.textContent = script.content;
+  return element;
+};
+var executeTrustedDocumentScript = async (placeholder, script, localUrl) => {
+  const executable = executableScript(script, localUrl);
+  if (executable.type === "module" && executable.src !== "") {
+    placeholder.remove();
+    await import(executable.src);
+    return;
+  }
+  const waitsForLoad = executable.src !== "" || executable.type === "module";
+  const loaded = waitsForLoad ? new Promise((resolve, reject) => {
+    executable.addEventListener("load", () => resolve(), {
+      once: true
+    });
+    executable.addEventListener("error", () => reject(new TypeError(`Embedded document script failed: ${executable.src || "inline module"}.`)), { once: true });
+  }) : Promise.resolve();
+  placeholder.replaceWith(executable);
+  await loaded;
+};
+var configureHtmxDocument = (parsed) => {
+  let meta = parsed.head.querySelector('meta[name="htmx-config"]');
+  if (!meta) {
+    meta = parsed.createElement("meta");
+    meta.name = "htmx-config";
+    parsed.head.appendChild(meta);
+  }
+  let authorConfig = {};
+  try {
+    const parsedConfig = JSON.parse(meta.content || "{}");
+    if (isRecord2(parsedConfig))
+      authorConfig = parsedConfig;
+  } catch {}
+  meta.content = JSON.stringify({
+    ...authorConfig,
+    selfRequestsOnly: false
+  });
+};
+var executeTrustedDocumentScripts = async (scripts, localUrl, index = 0) => {
+  const script = scripts[index];
+  if (!script)
+    return;
+  const placeholder = document.querySelector(`script[${SCRIPT_PLACEHOLDER_ATTRIBUTE}="${index}"]`);
+  if (placeholder) {
+    await executeTrustedDocumentScript(placeholder, script, localUrl);
+  }
+  await executeTrustedDocumentScripts(scripts, localUrl, index + 1);
+};
+var installTrustedDocument = async (source, localUrl, options) => {
+  const parsed = new DOMParser().parseFromString(source, "text/html");
+  if (options.htmx)
+    configureHtmxDocument(parsed);
+  const scripts = [...parsed.querySelectorAll("script")].map((script, index) => {
+    const definition = {
+      attributes: [...script.attributes].map((attribute) => [
+        attribute.name,
+        attribute.value
+      ]),
+      content: script.textContent ?? ""
+    };
+    script.removeAttribute("src");
+    script.type = "application/x-absolute-mobile-script";
+    script.setAttribute(SCRIPT_PLACEHOLDER_ATTRIBUTE, String(index));
+    return definition;
+  });
+  replaceAttributes(document.documentElement, parsed.documentElement);
+  document.head.replaceChildren(...[...parsed.head.childNodes].map((node) => document.importNode(node, true)));
+  document.body.replaceWith(document.importNode(parsed.body, true));
+  await executeTrustedDocumentScripts(scripts, localUrl);
+};
+var installAbsoluteMobileStaticDocument = async (manifest, page, localUrl) => {
+  const response = await fetch(localUrl, { cache: "no-store" });
+  if (!response.ok) {
+    throw new TypeError(`Embedded ${page.framework} document failed with HTTP ${response.status}.`);
+  }
+  const source = await response.text();
+  const actualHash = await hashAbsoluteMobileStaticDocument(source);
+  if (actualHash !== page.bundleHash) {
+    throw new TypeError(`Embedded ${page.framework} document failed integrity.`);
+  }
+  const disposeHtmxBoundary = page.framework === "htmx" ? installHtmxFragmentBoundary(manifest.productionOrigin) : undefined;
+  const ready = installTrustedDocument(page.framework === "htmx" ? rewriteAbsoluteMobileHtmxRequests(source, manifest.productionOrigin) : source, localUrl, { htmx: page.framework === "htmx" });
+  Reflect.set(window, "__ABSOLUTE_PAGE_READY__", ready);
+  Reflect.set(window, "__ABSOLUTE_PAGE_DISPOSE__", () => disposeHtmxBoundary?.());
+  await ready;
+};
+
+// node_modules/@absolutejs/http/dist/index.js
+class AbsoluteHttpError extends Error {
+  code;
+  cause;
+  status;
+  url;
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "AbsoluteHttpError";
+    this.code = code;
+    this.cause = options.cause;
+    this.status = options.status;
+    this.url = options.url;
+  }
+}
+var loopbackHosts = new Set(["127.0.0.1", "[::1]", "localhost"]);
+var normalizeAbsoluteHttpOrigin = (value) => {
+  let url;
+  try {
+    url = new URL(value);
+  } catch (cause) {
+    throw new AbsoluteHttpError("origin", "HTTP origin is invalid.", {
+      cause
+    });
+  }
+  const loopback = url.protocol === "http:" && loopbackHosts.has(url.hostname);
+  if (url.protocol !== "https:" && !loopback)
+    throw new AbsoluteHttpError("origin", "HTTP origin must use HTTPS outside loopback development.");
+  if (url.username || url.password || url.pathname !== "/" || url.search || url.hash)
+    throw new AbsoluteHttpError("origin", "HTTP origin cannot contain credentials, a path, query, or fragment.");
+  return url.origin;
+};
+var resolveAbsoluteHttpUrl = (target, origin) => {
+  let url;
+  try {
+    url = new URL(String(target), `${origin}/`);
+  } catch (cause) {
+    throw new AbsoluteHttpError("origin", "HTTP request URL is invalid.", {
+      cause
+    });
+  }
+  if (url.username || url.password)
+    throw new AbsoluteHttpError("origin", "HTTP request URLs cannot contain credentials.");
+  if (url.origin !== origin)
+    throw new AbsoluteHttpError("origin", "Absolute HTTP refused a request outside the configured application origin.", { url: url.href });
+  url.hash = "";
+  return url;
+};
+var createAbsoluteHttpTransport = ({
+  fetch: fetchImpl = globalThis.fetch,
+  origin,
+  runtime
+}) => ({
+  fetch: fetchImpl,
+  origin: normalizeAbsoluteHttpOrigin(origin),
+  runtime
+});
+var createWebHttpTransport = (options = {}) => {
+  const origin = options.origin ?? globalThis.location?.origin;
+  if (!origin)
+    throw new TypeError("The web HTTP transport requires a browser origin or explicit origin.");
+  return createAbsoluteHttpTransport({
+    ...options.fetch ? { fetch: options.fetch } : {},
+    origin,
+    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))
+    return existing;
+  const created = { installations: [] };
+  Object.defineProperty(registryHost, RUNTIME_REGISTRY, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+})();
+var fallbackTransport = () => {
+  if (typeof location !== "undefined" && location.origin)
+    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 installAbsoluteHttpTransport = (transport) => {
+  const installation = { transport };
+  runtimeRegistry.installations.push(installation);
+  return () => {
+    const index = runtimeRegistry.installations.indexOf(installation);
+    if (index >= 0)
+      runtimeRegistry.installations.splice(index, 1);
+  };
+};
+var forbiddenCredentialHeaders = new Set([
+  "authorization",
+  "cookie",
+  "proxy-authorization"
+]);
+var transportFor = (configured) => configured ?? getAbsoluteHttpTransport();
+var safeHeaders = (input) => {
+  const headers = new Headers(input);
+  for (const name of forbiddenCredentialHeaders) {
+    if (headers.has(name))
+      throw new AbsoluteHttpError("origin", `Absolute HTTP owns the ${name} credential header for trusted transports.`);
+  }
+  return headers;
+};
+var requestFor = (target, options, transport) => {
+  const source = target instanceof Request ? target : undefined;
+  const requestedUrl = source ? source.url : target;
+  const url = resolveAbsoluteHttpUrl(requestedUrl, transport.origin);
+  const headers = safeHeaders(options?.headers ?? source?.headers);
+  return new Request(source ?? url, {
+    ...options,
+    credentials: transport.runtime === "web" ? "same-origin" : "omit",
+    headers,
+    redirect: "error"
+  });
+};
+var normalizeFetchError = (caught, url) => {
+  if (caught instanceof AbsoluteHttpError)
+    return caught;
+  if (caught instanceof DOMException && (caught.name === "AbortError" || caught.name === "TimeoutError"))
+    return new AbsoluteHttpError("aborted", "HTTP request was aborted.", {
+      cause: caught,
+      url
+    });
+  return new AbsoluteHttpError("network", "HTTP request failed.", {
+    cause: caught,
+    url
+  });
+};
+var requireOk = (response) => {
+  if (!response.ok)
+    throw new AbsoluteHttpError("http", `HTTP request failed with status ${response.status}.`, { status: response.status, url: response.url });
+  return response;
+};
+var parseJson = async (response) => {
+  const text = await response.text();
+  if (text === "")
+    return;
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new AbsoluteHttpError("response", "HTTP response is not valid JSON.", {
+      cause,
+      status: response.status,
+      url: response.url
+    });
+  }
+};
+var jsonOptions = (method, body, options) => {
+  const headers = new Headers(options?.headers);
+  if (body !== undefined && !headers.has("content-type"))
+    headers.set("content-type", "application/json");
+  let encoded;
+  try {
+    encoded = body === undefined ? undefined : JSON.stringify(body);
+  } catch (cause) {
+    throw new AbsoluteHttpError("body", "HTTP body is not JSON serializable.", {
+      cause
+    });
+  }
+  return encoded === undefined ? { ...options, headers, method } : { ...options, body: encoded, headers, method };
+};
+var createAbsoluteHttpClient = (options = {}) => {
+  const fetchTrusted = async (input, init) => {
+    const transport = transportFor(options.transport);
+    const request2 = requestFor(input, init, transport);
+    try {
+      return await transport.fetch(request2);
+    } catch (caught) {
+      throw normalizeFetchError(caught, request2.url);
+    }
+  };
+  const request = (target, requestOptions) => fetchTrusted(target, requestOptions);
+  const json = async (target, requestOptions) => parseJson(requireOk(await request(target, requestOptions)));
+  const jsonMethod = (method, target, body, requestOptions) => json(target, jsonOptions(method, body, requestOptions));
+  return {
+    delete: (target, requestOptions) => {
+      const { body, ...optionsWithoutBody } = requestOptions ?? {};
+      return jsonMethod("DELETE", target, body, optionsWithoutBody);
+    },
+    fetch: fetchTrusted,
+    get: (target, requestOptions) => json(target, { ...requestOptions, method: "GET" }),
+    json,
+    origin: () => transportFor(options.transport).origin,
+    patch: (target, body, requestOptions) => jsonMethod("PATCH", target, body, requestOptions),
+    post: (target, body, requestOptions) => jsonMethod("POST", target, body, requestOptions),
+    put: (target, body, requestOptions) => jsonMethod("PUT", target, body, requestOptions),
+    request,
+    text: async (target, requestOptions) => requireOk(await request(target, requestOptions)).text()
+  };
+};
+var http = createAbsoluteHttpClient();
+
+// src/mobile/shellHttp.ts
+var installAbsoluteMobileShellHttp = (origin, fetch2 = globalThis.fetch) => installAbsoluteHttpTransport(createAbsoluteHttpTransport({ fetch: fetch2, origin, runtime: "native" }));
+
+// src/mobile/adaptiveShell.ts
+import {
+  keyboard,
+  network,
+  platform,
+  systemBars
+} from "@absolutejs/devices";
+var STYLE_ID2 = "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 ensureStyle2 = () => {
+  let style = document.getElementById(STYLE_ID2);
+  if (!(style instanceof HTMLStyleElement)) {
+    style = document.createElement("style");
+    style.id = STYLE_ID2;
+    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();
+    ensureStyle2();
+    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/navigationLifecycle.ts
+var isAbortError = (error) => error instanceof DOMException ? error.name === "AbortError" : error instanceof Error && error.name === "AbortError";
+var cancelledResult = { kind: "cancelled" };
+var committedResult = { kind: "committed" };
+var failedResult = (error, phase) => ({ error, kind: "failed", phase });
+var createAbsoluteMobileNavigationCoordinator = (options) => {
+  let activeLoad;
+  let commitQueue = Promise.resolve();
+  let disposed = false;
+  let generation = 0;
+  let lifecyclePhase = "idle";
+  const navigate = async (request) => {
+    if (disposed)
+      return cancelledResult;
+    const ownGeneration = generation += 1;
+    activeLoad?.abort();
+    const controller = new AbortController;
+    activeLoad = controller;
+    lifecyclePhase = "loading";
+    options.onStart?.(request);
+    let payload;
+    try {
+      payload = await options.load(request, controller.signal);
+    } catch (error) {
+      if (controller.signal.aborted || isAbortError(error) || ownGeneration !== generation || disposed) {
+        if (ownGeneration === generation)
+          lifecyclePhase = "idle";
+        return cancelledResult;
+      }
+      lifecyclePhase = "idle";
+      options.onFailure?.(error, "load", request);
+      return failedResult(error, "load");
+    }
+    if (ownGeneration !== generation || disposed)
+      return cancelledResult;
+    if (activeLoad === controller)
+      activeLoad = undefined;
+    lifecyclePhase = "queued";
+    const execute = async () => {
+      if (ownGeneration !== generation || disposed) {
+        if (ownGeneration === generation)
+          lifecyclePhase = "idle";
+        return cancelledResult;
+      }
+      lifecyclePhase = "committing";
+      try {
+        await options.commit(payload, request);
+        options.onCommit?.(request);
+      } catch (error) {
+        if (ownGeneration === generation) {
+          lifecyclePhase = "idle";
+          options.onFailure?.(error, "commit", request);
+        }
+        return failedResult(error, "commit");
+      }
+      if (ownGeneration !== generation || disposed) {
+        return cancelledResult;
+      }
+      lifecyclePhase = "idle";
+      options.onSuccess?.(request);
+      return committedResult;
+    };
+    const result = commitQueue.then(execute, execute);
+    commitQueue = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  };
+  return {
+    cancelPending: () => {
+      if (disposed || lifecyclePhase !== "loading" && lifecyclePhase !== "queued")
+        return false;
+      generation += 1;
+      activeLoad?.abort();
+      activeLoad = undefined;
+      lifecyclePhase = "idle";
+      return true;
+    },
+    dispose: () => {
+      if (disposed)
+        return;
+      disposed = true;
+      generation += 1;
+      activeLoad?.abort();
+      activeLoad = undefined;
+      lifecyclePhase = "idle";
+    },
+    navigate: (request) => navigate(request),
+    phase: () => lifecyclePhase
+  };
+};
+
+// src/mobile/navigationState.ts
+var CONTROL_SELECTOR = 'input, textarea, select, details, [contenteditable="true"]';
+var FOCUS_SELECTOR = '[data-absolute-navigation-focus], button, a[href], input, textarea, select, [tabindex]:not([tabindex="-1"])';
+var SCROLL_SELECTOR = "[data-absolute-app-main], [data-absolute-scroll-restoration]";
+var SENSITIVE_AUTOCOMPLETE = new Set([
+  "cc-csc",
+  "cc-number",
+  "current-password",
+  "new-password",
+  "one-time-code"
+]);
+var locatorFor = (element, elements) => {
+  if (element.id)
+    return { kind: "id", value: element.id };
+  const name = element.getAttribute("name");
+  if (name) {
+    const matching = elements.filter((candidate) => candidate.getAttribute("name") === name);
+    return { index: matching.indexOf(element), kind: "name", value: name };
+  }
+  return { index: elements.indexOf(element), kind: "index" };
+};
+var resolveLocator = (locator, selector) => {
+  if (locator.kind === "id") {
+    return document.getElementById(locator.value) ?? undefined;
+  }
+  if (locator.kind === "name") {
+    return [...document.querySelectorAll(selector)].filter((element) => element.getAttribute("name") === locator.value)[locator.index];
+  }
+  return document.querySelectorAll(selector)[locator.index];
+};
+var shouldCaptureControl = (element) => {
+  if (element.closest('[data-absolute-navigation-preserve="off"]'))
+    return false;
+  if (!(element instanceof HTMLInputElement))
+    return true;
+  if (element.type === "file" || element.type === "hidden" || element.type === "password")
+    return false;
+  return !SENSITIVE_AUTOCOMPLETE.has(element.autocomplete.toLowerCase());
+};
+var captureControl = (element, locator) => {
+  const snapshot = {
+    locator,
+    tag: element.tagName.toLowerCase()
+  };
+  if (element instanceof HTMLInputElement) {
+    if (element.type === "checkbox" || element.type === "radio") {
+      snapshot.checked = element.checked;
+    } else {
+      snapshot.value = element.value;
+      if (element.selectionStart !== null)
+        snapshot.selectionStart = element.selectionStart;
+      if (element.selectionEnd !== null)
+        snapshot.selectionEnd = element.selectionEnd;
+    }
+  } else if (element instanceof HTMLTextAreaElement) {
+    snapshot.value = element.value;
+    snapshot.selectionStart = element.selectionStart;
+    snapshot.selectionEnd = element.selectionEnd;
+  } else if (element instanceof HTMLSelectElement) {
+    snapshot.values = [...element.selectedOptions].map(({ value }) => value);
+  } else if (element instanceof HTMLDetailsElement) {
+    snapshot.open = element.open;
+  } else if (element.getAttribute("contenteditable") === "true") {
+    snapshot.value = element.textContent ?? "";
+  }
+  return snapshot;
+};
+var restoreControl = (snapshot) => {
+  const element = resolveLocator(snapshot.locator, CONTROL_SELECTOR);
+  if (!element || element.tagName.toLowerCase() !== snapshot.tag)
+    return;
+  if (element instanceof HTMLInputElement) {
+    if (snapshot.checked !== undefined)
+      element.checked = snapshot.checked;
+    else if (snapshot.value !== undefined)
+      element.value = snapshot.value;
+    if (snapshot.selectionStart !== undefined && snapshot.selectionEnd !== undefined) {
+      try {
+        element.setSelectionRange(snapshot.selectionStart, snapshot.selectionEnd);
+      } catch {}
+    }
+  } else if (element instanceof HTMLTextAreaElement) {
+    if (snapshot.value !== undefined)
+      element.value = snapshot.value;
+    if (snapshot.selectionStart !== undefined && snapshot.selectionEnd !== undefined)
+      element.setSelectionRange(snapshot.selectionStart, snapshot.selectionEnd);
+  } else if (element instanceof HTMLSelectElement && snapshot.values) {
+    for (const option of element.options) {
+      option.selected = snapshot.values.includes(option.value);
+    }
+  } else if (element instanceof HTMLDetailsElement && snapshot.open !== undefined) {
+    element.open = snapshot.open;
+  } else if (element.getAttribute("contenteditable") === "true" && snapshot.value !== undefined) {
+    element.textContent = snapshot.value;
+  }
+};
+var focusElement = (element) => {
+  if (!(element instanceof HTMLElement))
+    return false;
+  if (!element.matches(FOCUS_SELECTOR))
+    element.tabIndex = -1;
+  element.focus({ preventScroll: true });
+  return document.activeElement === element;
+};
+var createAbsoluteMobileHistoryEntry = (path, index, entryId = crypto.randomUUID()) => ({
+  absoluteMobile: true,
+  entryId,
+  index,
+  path
+});
+var readAbsoluteMobileHistoryEntry = (value) => {
+  if (typeof value !== "object" || value === null)
+    return;
+  if (Reflect.get(value, "absoluteMobile") !== true || typeof Reflect.get(value, "entryId") !== "string" || !Number.isSafeInteger(Reflect.get(value, "index")) || typeof Reflect.get(value, "path") !== "string")
+    return;
+  return {
+    absoluteMobile: true,
+    entryId: Reflect.get(value, "entryId"),
+    index: Reflect.get(value, "index"),
+    path: Reflect.get(value, "path")
+  };
+};
+var captureAbsoluteMobileDocumentState = () => {
+  const controls = [
+    ...document.querySelectorAll(CONTROL_SELECTOR)
+  ].filter(shouldCaptureControl);
+  const focusable = [...document.querySelectorAll(FOCUS_SELECTOR)];
+  const scrollable = [...document.querySelectorAll(SCROLL_SELECTOR)];
+  const active = document.activeElement;
+  return {
+    controls: controls.map((element) => captureControl(element, locatorFor(element, controls))),
+    ...active instanceof Element && focusable.includes(active) ? { focus: locatorFor(active, focusable) } : {},
+    scroll: scrollable.map((element) => ({
+      left: element.scrollLeft,
+      locator: locatorFor(element, scrollable),
+      top: element.scrollTop
+    })),
+    window: { x: window.scrollX, y: window.scrollY }
+  };
+};
+var restoreAbsoluteMobileDocumentState = (snapshot) => {
+  for (const control of snapshot.controls)
+    restoreControl(control);
+  const focus = snapshot.focus ? resolveLocator(snapshot.focus, FOCUS_SELECTOR) : undefined;
+  focusElement(focus);
+  for (const scroll of snapshot.scroll) {
+    const element = resolveLocator(scroll.locator, SCROLL_SELECTOR);
+    if (element)
+      element.scrollTo(scroll.left, scroll.top);
+  }
+  window.scrollTo(snapshot.window.x, snapshot.window.y);
+};
+var resetAbsoluteMobileDocumentState = () => {
+  for (const element of document.querySelectorAll(SCROLL_SELECTOR)) {
+    element.scrollTo(0, 0);
+  }
+  window.scrollTo(0, 0);
+  const autofocus = document.querySelector("[autofocus]");
+  if (autofocus && focusElement(autofocus))
+    return;
+  const target = ["[data-absolute-navigation-focus]", "main h1", "h1", "main"].map((selector) => document.querySelector(selector)).find((element) => element !== null);
+  focusElement(target ?? undefined);
+};
+
+// src/mobile/shellBootstrap.ts
+var MANIFEST_PATH = "./absolute-mobile-manifest.json";
+var STATUS_ID = "absolute-mobile-status";
+var NAVIGATION_ERROR_ID = "absolute-mobile-navigation-error";
+var initialNavigationPath = (entry) => {
+  const expoPath = new URLSearchParams(location.search).get("absolutePath");
+  if (expoPath?.startsWith("/") && !expoPath.startsWith("//"))
+    return expoPath;
+  const current = `${location.pathname}${location.search}${location.hash}`;
+  return current === "/" || current === "/index.html" ? entry : current;
+};
+var currentNavigationPath = () => {
+  const expoPath = new URLSearchParams(location.search).get("absolutePath");
+  return expoPath?.startsWith("/") && !expoPath.startsWith("//") ? expoPath : `${location.pathname}${location.search}${location.hash}`;
+};
+var historyUrl = (path) => {
+  if (!Reflect.get(globalThis, "__absoluteExpoBridge")) {
+    return path;
+  }
+  const url = new URL(location.href);
+  url.search = "";
+  url.hash = "";
+  url.searchParams.set("absolutePath", path);
+  return url.href;
+};
+var writeNavigationHistory = (entry, mode) => {
+  history[mode === "push" ? "pushState" : "replaceState"](entry, "", historyUrl(entry.path));
+  notifyExpoNavigationPath(entry.path);
+};
+var notifyExpoNavigationPath = (path) => {
+  const bridge = Reflect.get(globalThis, "__absoluteExpoBridge");
+  if (typeof bridge === "object" && bridge !== null && typeof Reflect.get(bridge, "setPath") === "function") {
+    Reflect.get(bridge, "setPath").call(bridge, path);
+  }
+};
+var navigationGeneration = 0;
+var adaptiveShell;
+var uiPrimitives;
+var notifyCapacitorSystemBarsDomReady = () => {
+  const provider = Reflect.get(globalThis, "CapacitorSystemBarsAndroidInterface");
+  if (typeof provider !== "object" || provider === null)
+    return;
+  const onDOMReady = Reflect.get(provider, "onDOMReady");
+  if (typeof onDOMReady !== "function")
+    return;
+  try {
+    onDOMReady.call(provider);
+  } catch {}
+};
+var readManifest = async () => {
+  const response = await fetch(MANIFEST_PATH, { cache: "no-store" });
+  if (!response.ok) {
+    throw new TypeError(`Mobile manifest failed with HTTP ${response.status}.`);
+  }
+  const manifest = await response.json();
+  return manifest;
+};
+var renderStatus = (message, kind = "loading") => {
+  document.title = "AbsoluteJS";
+  document.head.innerHTML = '<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">';
+  document.body.innerHTML = `<main id="${STATUS_ID}" data-absolute-mobile-status="${kind}" role="status" aria-atomic="true" aria-live="polite"></main>`;
+  const status = document.getElementById(STATUS_ID);
+  if (status)
+    status.textContent = message;
+  adaptiveShell?.refreshDocument();
+};
+var clearNavigationFailure = () => {
+  document.getElementById(NAVIGATION_ERROR_ID)?.remove();
+};
+var renderNavigationFailure = (message, retry) => {
+  clearNavigationFailure();
+  const error = document.createElement("aside");
+  error.id = NAVIGATION_ERROR_ID;
+  error.dataset.absoluteMobileNavigationError = "";
+  error.setAttribute("role", "alert");
+  error.style.cssText = "position:fixed;z-index:2147483646;inset:auto max(1rem,var(--absolute-safe-area-inset-right,0px)) max(1rem,var(--absolute-safe-area-inset-bottom,0px)) max(1rem,var(--absolute-safe-area-inset-left,0px));display:flex;align-items:center;justify-content:space-between;gap:1rem;box-sizing:border-box;padding:.75rem 1rem;border:1px solid color-mix(in srgb,CanvasText 24%,transparent);border-radius:.75rem;background:Canvas;color:CanvasText;box-shadow:0 .5rem 2rem color-mix(in srgb,CanvasText 20%,transparent)";
+  const text = document.createElement("span");
+  text.textContent = message;
+  const button = document.createElement("button");
+  button.type = "button";
+  button.textContent = "Retry";
+  button.addEventListener("click", retry, { once: true });
+  error.append(text, button);
+  document.body.append(error);
+};
+var markNavigationPending = (pending) => {
+  if (pending) {
+    document.body.dataset.absoluteMobileNavigationPending = "";
+    document.body.setAttribute("aria-busy", "true");
+  } else {
+    delete document.body.dataset.absoluteMobileNavigationPending;
+    document.body.removeAttribute("aria-busy");
+  }
+};
+var renderPageTarget = () => {
+  document.title = "AbsoluteJS";
+  document.head.innerHTML = '<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">';
+  document.body.innerHTML = '<div id="root"></div>';
+  adaptiveShell?.refreshDocument();
+};
+var localBundleUrl = (manifest, pageId, contract) => {
+  const page = manifest.pages.find((candidate) => candidate.pageId === pageId && candidate.contract === contract);
+  if (!page) {
+    throw new TypeError(`The embedded app does not contain ${pageId} contract ${contract}.`);
+  }
+  const url = new URL(page.localBundlePath, document.baseURI);
+  url.searchParams.set("absoluteNavigation", String(navigationGeneration += 1));
+  return url.href;
+};
+var installLocalPageStyle = (manifest, pageId, contract) => {
+  const page = manifest.pages.find((candidate) => candidate.pageId === pageId && candidate.contract === contract);
+  if (!page?.localStylePath)
+    return;
+  const link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.href = new URL(page.localStylePath, document.baseURI).href;
+  link.dataset.absoluteMobilePageStyle = page.bundleHash;
+  document.head.appendChild(link);
+};
+var waitForDocumentPaint = () => new Promise((resolve) => {
+  if (typeof requestAnimationFrame !== "function") {
+    setTimeout(resolve, 0);
+    return;
+  }
+  requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+});
+var commitNavigation = async (manifest, envelope, hadActivePage) => {
+  if (!hadActivePage)
+    renderStatus("Loading…");
+  let activation;
+  const commit = async () => {
+    await disposeAbsoluteMobilePage();
+    activation = await activateAbsoluteMobilePage(envelope, {
+      loadPage: ({ contract, pageId }) => {
+        const page = manifest.pages.find((candidate) => candidate.pageId === pageId && candidate.contract === contract);
+        if (!page) {
+          throw new TypeError(`The embedded app does not contain ${pageId} contract ${contract}.`);
+        }
+        if (page.framework === "html" || page.framework === "htmx") {
+          return installAbsoluteMobileStaticDocument(manifest, page, localBundleUrl(manifest, pageId, contract));
+        }
+        renderPageTarget();
+        installLocalPageStyle(manifest, pageId, contract);
+        return import(localBundleUrl(manifest, pageId, contract));
+      }
+    });
+  };
+  const transitionDocument = document;
+  if (hadActivePage && document.documentElement.dataset.absoluteReducedMotion !== "reduce" && transitionDocument.startViewTransition) {
+    const transition = transitionDocument.startViewTransition(commit);
+    await transition.updateCallbackDone;
+    await transition.finished.catch(() => {
+      return;
+    });
+  } else
+    await commit();
+  if (!activation)
+    throw new TypeError("The mobile page did not produce an activation.");
+  if (activation.kind === "upgrade-required") {
+    renderStatus("This app version must be updated to continue.", "update");
+    return false;
+  }
+  await waitForDocumentPaint();
+  document.body.dataset.absoluteMobilePageActive = "";
+  adaptiveShell?.refreshDocument();
+  return true;
+};
+var openExternalLink = (anchor, event) => {
+  if (Reflect.get(globalThis, "__absoluteExpoBridge"))
+    return;
+  try {
+    const url = new URL(anchor.href);
+    if (url.username || url.password || url.protocol !== "http:" && url.protocol !== "https:")
+      return;
+    event.preventDefault();
+    Browser.open({ url: url.href }).catch(() => location.assign(url.href));
+  } catch {}
+};
+var installAnchorNavigation = (manifest, onNavigate, onBack) => {
+  const handleClick = (event) => {
+    if (!(event.target instanceof Element))
+      return;
+    const anchor = event.target.closest("a[href]");
+    if (!(anchor instanceof HTMLAnchorElement) || anchor.target)
+      return;
+    const intent = readAbsoluteMobileLinkIntent(anchor);
+    if (intent.kind === "back") {
+      event.preventDefault();
+      if (!uiPrimitives?.requestBack() && !onBack())
+        history.back();
+      return;
+    }
+    if (intent.kind === "external") {
+      openExternalLink(anchor, event);
+      return;
+    }
+    try {
+      const path = resolveAbsoluteMobileNavigation(manifest, anchor.href, location.origin);
+      if (!path)
+        return;
+      event.preventDefault();
+      onNavigate(path, intent.kind === "navigate" && intent.replace ? "replace" : "forward", intent.kind === "navigate" && intent.replace);
+    } catch {}
+  };
+  addEventListener("click", handleClick);
+  return () => removeEventListener("click", handleClick);
+};
+var navigateDeepLink = (manifest, onNavigate, url, authRedirectUri) => {
+  if (!url)
+    return;
+  if (authRedirectUri) {
+    const actual = new URL(url);
+    const redirect = new URL(authRedirectUri);
+    if (actual.protocol === redirect.protocol && actual.host === redirect.host && actual.pathname === redirect.pathname)
+      return;
+  }
+  onNavigate(resolveAbsoluteMobileDeepLink(manifest, url));
+};
+var deepLinkListener = (manifest, onNavigate, authRedirectUri) => ({ url }) => navigateDeepLink(manifest, onNavigate, url, authRedirectUri);
+var installDeepLinks = async (manifest, onNavigate, authRedirectUri) => {
+  let listener;
+  try {
+    listener = await App.addListener("appUrlOpen", deepLinkListener(manifest, onNavigate, authRedirectUri));
+    const launch = await App.getLaunchUrl();
+    navigateDeepLink(manifest, onNavigate, launch?.url, authRedirectUri);
+  } catch {}
+  return listener;
+};
+var startAbsoluteMobileShell = async (options = {}) => {
+  notifyCapacitorSystemBarsDomReady();
+  await adaptiveShell?.dispose();
+  uiPrimitives?.dispose();
+  adaptiveShell = await installAbsoluteMobileAdaptiveShell();
+  uiPrimitives = installAbsoluteMobileUiPrimitives();
+  const manifest = await readManifest();
+  let activePath = initialNavigationPath(manifest.entry);
+  let activeEntry = readAbsoluteMobileHistoryEntry(history.state) ?? createAbsoluteMobileHistoryEntry(activePath, 0);
+  if (activeEntry.path !== activePath) {
+    activeEntry = createAbsoluteMobileHistoryEntry(activePath, 0);
+  }
+  writeNavigationHistory(activeEntry, "replace");
+  const auth = manifest.auth && options.createAuth ? await options.createAuth(manifest.auth, {
+    beforeSignOut: options.beforeSignOut
+  }) : undefined;
+  const applicationFetch = auth?.fetch ?? options.createFetch?.(manifest) ?? globalThis.fetch;
+  installAbsoluteMobileShellHttp(manifest.productionOrigin, applicationFetch);
+  if (auth)
+    options.connectPush?.(auth);
+  if (auth && manifest.sync?.socketTickets)
+    options.installSync?.(auth, manifest.sync);
+  const snapshots = new Map;
+  const targetEntries = new WeakMap;
+  let suppressNextPop = false;
+  let hasActivePage = false;
+  let removeAnchorNavigation = () => {
+    return;
+  };
+  const coordinator = createAbsoluteMobileNavigationCoordinator({
+    commit: async (envelope, request) => {
+      if (hasActivePage) {
+        snapshots.set(activeEntry.entryId, captureAbsoluteMobileDocumentState());
+      }
+      document.documentElement.dataset.absoluteNavigationDirection = request.direction;
+      try {
+        const previouslyActive = hasActivePage;
+        hasActivePage = false;
+        hasActivePage = await commitNavigation(manifest, envelope, previouslyActive);
+      } finally {
+        reinstallBrowserNavigation();
+      }
+    },
+    load: (request, signal) => fetchAbsoluteMobilePage(manifest, request.path, {
+      fetch: applicationFetch,
+      signal
+    }),
+    onFailure: (error, phase, request) => {
+      console.error("[Absolute Mobile] Navigation failed:", error);
+      markNavigationPending(false);
+      const targetEntry = targetEntries.get(request);
+      if (targetEntry && targetEntry.index !== activeEntry.index) {
+        suppressNextPop = true;
+        history.go(activeEntry.index - targetEntry.index);
+      }
+      const message = document.documentElement.dataset.absoluteNetwork === "offline" ? "You are offline. Reconnect to load this page." : "Unable to load this page. Check your connection and retry.";
+      if (phase === "load" && hasActivePage) {
+        renderNavigationFailure(message, () => {
+          if (targetEntry) {
+            history.go(targetEntry.index - activeEntry.index);
+          } else
+            coordinator.navigate(request);
+        });
+      } else
+        renderStatus(message, "error");
+    },
+    onStart: () => {
+      clearNavigationFailure();
+      markNavigationPending(true);
+    },
+    onSuccess: (request) => {
+      let nextEntry = targetEntries.get(request);
+      if (request.historyMode === "push") {
+        nextEntry = createAbsoluteMobileHistoryEntry(request.path, activeEntry.index + 1);
+        writeNavigationHistory(nextEntry, "push");
+      } else if (request.historyMode === "replace") {
+        nextEntry = createAbsoluteMobileHistoryEntry(request.path, activeEntry.index);
+        writeNavigationHistory(nextEntry, "replace");
+      }
+      nextEntry ??= activeEntry;
+      activeEntry = nextEntry;
+      activePath = request.path;
+      markNavigationPending(false);
+      clearNavigationFailure();
+      const snapshot = snapshots.get(activeEntry.entryId);
+      if (snapshot)
+        restoreAbsoluteMobileDocumentState(snapshot);
+      else if (request.historyMode !== "none")
+        resetAbsoluteMobileDocumentState();
+      uiPrimitives?.navigate({
+        direction: request.direction,
+        from: request.from,
+        to: request.path
+      });
+    }
+  });
+  const cancelPendingNavigation = () => {
+    if (!coordinator.cancelPending())
+      return false;
+    markNavigationPending(false);
+    clearNavigationFailure();
+    return true;
+  };
+  const handlePopState = (event) => {
+    const path = currentNavigationPath();
+    if (suppressNextPop) {
+      suppressNextPop = false;
+      notifyExpoNavigationPath(activePath);
+      return;
+    }
+    const targetEntry = readAbsoluteMobileHistoryEntry(event.state) ?? createAbsoluteMobileHistoryEntry(path, activeEntry.index - 1);
+    notifyExpoNavigationPath(path);
+    const request = {
+      direction: targetEntry.index > activeEntry.index ? "forward" : "back",
+      from: activePath,
+      historyMode: "none",
+      path
+    };
+    targetEntries.set(request, targetEntry);
+    coordinator.navigate(request);
+  };
+  const reinstallBrowserNavigation = () => {
+    removeAnchorNavigation();
+    removeEventListener("popstate", handlePopState);
+    uiPrimitives?.dispose();
+    uiPrimitives = installAbsoluteMobileUiPrimitives();
+    uiPrimitives.refreshDocument(activePath);
+    removeAnchorNavigation = installAnchorNavigation(manifest, onNavigate, cancelPendingNavigation);
+    addEventListener("popstate", handlePopState);
+  };
+  const onNavigate = (path, direction = "forward", replace = false) => {
+    if (path === activePath && !replace && hasActivePage)
+      return;
+    coordinator.navigate({
+      direction,
+      from: activePath,
+      historyMode: replace ? "replace" : "push",
+      path
+    });
+  };
+  reinstallBrowserNavigation();
+  await coordinator.navigate({
+    direction: "replace",
+    from: activePath,
+    historyMode: "none",
+    path: activePath
+  });
+  await options.installUpdates?.(manifest);
+  await installDeepLinks(manifest, onNavigate, auth?.redirectUri);
+  try {
+    await App.addListener("backButton", ({ canGoBack }) => {
+      if (uiPrimitives?.requestBack())
+        return;
+      if (cancelPendingNavigation())
+        return;
+      if (canGoBack)
+        history.back();
+      else
+        App.exitApp();
+    });
+  } catch {}
+};
+export {
+  startAbsoluteMobileShell
+};