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

package/dist/angular/components/core/streamingSlotRegistrar.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-BrXrzr/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-lF9auc/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");

package/dist/angular/components/core/streamingSlotRegistry.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-BrXrzr/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-lF9auc/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
@@ -48,7 +48,7 @@ var warnMissingStreamingSlotCollector = (primitiveName) => {
   getWarningController()?.maybeWarn(primitiveName);
 };
 
-// .angular-partial-tmp-BrXrzr/src/core/streamingSlotRegistry.ts
+// .angular-partial-tmp-lF9auc/src/core/streamingSlotRegistry.ts
 var STREAMING_SLOT_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotAsyncLocalStorage");
 var isObjectRecord2 = (value) => Boolean(value) && typeof value === "object";
 var isAsyncLocalStorage = (value) => isObjectRecord2(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";

package/dist/cli/index.js

@@ -16840,10 +16840,36 @@ var exports_mobile = {};
 __export(exports_mobile, {
   runMobile: () => runMobile
 });
-import { access as access11, mkdir as mkdir13, writeFile as writeFile13 } from "fs/promises";
+import { access as access11, mkdir as mkdir13, readFile as readFile16, writeFile as writeFile13 } from "fs/promises";
 import { join as join47, resolve as resolve39 } from "path";
 import { createInterface } from "readline/promises";
-var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), CAPACITOR_PACKAGES, CAPACITOR_PACKAGE_SPECS, valueAfter = (args, flag) => {
+var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), CAPACITOR_PACKAGES, CAPACITOR_PACKAGE_SPECS, CAPACITOR_SYNC_PACKAGE_SPECS, packageNameFromSpec = (spec) => spec.slice(0, spec.lastIndexOf("@")), directProjectPackages = async (projectRoot) => {
+  const manifest = JSON.parse(await readFile16(join47(projectRoot, "package.json"), "utf8"));
+  if (!isRecord15(manifest))
+    throw new TypeError("Application package.json must contain an object.");
+  const names = new Set;
+  for (const field of ["dependencies", "devDependencies"]) {
+    const dependencies = Reflect.get(manifest, field);
+    if (isRecord15(dependencies))
+      for (const name of Object.keys(dependencies))
+        names.add(name);
+  }
+  return names;
+}, ensureCapacitorPackages = async (projectRoot, args) => {
+  const specs = [
+    ...CAPACITOR_PACKAGE_SPECS,
+    ...projectUsesAbsoluteSync(projectRoot) ? CAPACITOR_SYNC_PACKAGE_SPECS : []
+  ];
+  const installed = await directProjectPackages(projectRoot);
+  const missing = specs.filter((spec) => !installed.has(packageNameFromSpec(spec)));
+  if (missing.length === 0)
+    return;
+  const approved = args.includes("--yes") || await confirmInstall("Capacitor and the AbsoluteJS native adapters are missing. Install the tested mobile toolchain now?");
+  if (!approved)
+    throw new TypeError(`Mobile initialization requires: bun add ${missing.join(" ")}`);
+  if (!installPackages(projectRoot, missing))
+    throw new TypeError("Failed to install the AbsoluteJS mobile toolchain.");
+}, valueAfter = (args, flag) => {
   const index = args.indexOf(flag);
   return index === NOT_FOUND2 ? undefined : args[index + 1];
 }, valuesAfter = (args, flag) => args.flatMap((value, index) => {
@@ -16916,15 +16942,7 @@ var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value
   console.log(removed ? `Removed remote Mac profile ${args[1]}.` : `Remote Mac profile ${args[1]} was not found.`);
 }, initialize = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
-  try {
-    await access11(join47(projectRoot, "node_modules", ".bin", "cap"));
-  } catch {
-    const approved = args.includes("--yes") || await confirmInstall("Capacitor and the AbsoluteJS native device adapter are missing. Install the tested mobile toolchain now?");
-    if (!approved)
-      throw new TypeError(`Mobile initialization requires: bun add ${CAPACITOR_PACKAGE_SPECS.join(" ")}`);
-    if (!installPackages(projectRoot, CAPACITOR_PACKAGE_SPECS))
-      throw new TypeError("Failed to install the AbsoluteJS mobile toolchain.");
-  }
+  await ensureCapacitorPackages(projectRoot, args);
   const generated = await writeAbsoluteCapacitorConfig(mobile, {
     force: args.includes("--force"),
     projectRoot
@@ -16936,6 +16954,7 @@ var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value
   await applyAbsoluteNativeDeepLinks(mobile);
 }, sync = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
+  await ensureCapacitorPackages(projectRoot, args);
   const platform6 = args.find((value) => value === "android" || value === "ios");
   const platforms = platform6 ? [platform6] : mobile.platforms;
   if (platforms.includes("android"))
@@ -17876,6 +17895,7 @@ var init_mobile = __esm(() => {
   init_utils();
   init_getDurationString();
   init_remoteMacProtocol();
+  init_nativeAuth();
   CAPACITOR_PACKAGES = [
     "@capacitor/core",
     "@capacitor/app",
@@ -17900,6 +17920,10 @@ var init_mobile = __esm(() => {
     "@absolutejs/devices@0.0.2",
     "@absolutejs/devices-capacitor@0.1.2"
   ];
+  CAPACITOR_SYNC_PACKAGE_SPECS = [
+    "@absolutejs/sync-capacitor@0.2.0",
+    "@capacitor-community/sqlite@8.1.1"
+  ];
 });
 
 // src/cli/scripts/typecheck.ts

package/dist/mobile/shellAuth.js

@@ -0,0 +1,41 @@
+// src/mobile/shellAuth.ts
+import { lifecycle, links, secureStorage } from "@absolutejs/devices";
+import { installCapacitorDeviceAdapter } from "@absolutejs/devices-capacitor";
+import {
+  createMobileAuthClient,
+  createMobileAuthTransport,
+  installAuthClientRuntimeTransport
+} from "@absolutejs/auth/client/mobile";
+var installed = false;
+var createAbsoluteMobileShellAuth = async (config) => {
+  if (!installed) {
+    installCapacitorDeviceAdapter({
+      storagePrefix: `absolutejs.${config.clientId}.`
+    });
+    installed = true;
+  }
+  const client = createMobileAuthClient({
+    allowedOrigins: [config.issuer],
+    clientId: config.clientId,
+    issuer: config.issuer,
+    lifecycle,
+    links,
+    redirectUri: config.redirectUri,
+    resource: config.issuer,
+    scopes: config.scopes,
+    storage: secureStorage
+  });
+  await client.start();
+  const principal = await client.principal();
+  installAuthClientRuntimeTransport(createMobileAuthTransport(client, { baseUrl: config.issuer }));
+  return {
+    fetch: client.fetchOptional,
+    onPrincipalChange: client.onPrincipalChange,
+    principal,
+    redirectUri: config.redirectUri,
+    socketTicket: client.socketTicket
+  };
+};
+export {
+  createAbsoluteMobileShellAuth
+};

package/dist/mobile/shellBootstrap.js

@@ -0,0 +1,581 @@
+// src/mobile/shellBootstrap.ts
+import { App } from "@capacitor/app";
+
+// 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 {
+  code;
+  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" });
+};
+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;
+};
+
+// src/mobile/shellBootstrap.ts
+var MANIFEST_PATH = "./absolute-mobile-manifest.json";
+var STATUS_ID = "absolute-mobile-status";
+var navigationGeneration = 0;
+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) => {
+  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}" role="status"></main>`;
+  const status = document.getElementById(STATUS_ID);
+  if (status)
+    status.textContent = message;
+};
+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>';
+};
+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 navigate = async (manifest, path, pushHistory, fetchImpl) => {
+  await disposeAbsoluteMobilePage();
+  renderStatus("Loading…");
+  const envelope = await fetchAbsoluteMobilePage(manifest, path, {
+    ...fetchImpl ? { fetch: fetchImpl } : {}
+  });
+  const 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));
+    }
+  });
+  if (activation.kind === "upgrade-required") {
+    renderStatus("This app version must be updated to continue.");
+    return;
+  }
+  if (pushHistory)
+    history.pushState({ absoluteMobile: true }, "", path);
+};
+var installAnchorNavigation = (manifest, onNavigate) => {
+  const handleClick = (event) => {
+    if (!(event.target instanceof Element))
+      return;
+    const anchor = event.target.closest("a[href]");
+    if (!(anchor instanceof HTMLAnchorElement) || anchor.target)
+      return;
+    try {
+      const path = resolveAbsoluteMobileNavigation(manifest, anchor.href, location.origin);
+      if (!path)
+        return;
+      event.preventDefault();
+      onNavigate(path);
+    } 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 navigateWithFailureState = async (manifest, path, pushHistory, reinstallBrowserNavigation, fetchImpl) => {
+  try {
+    await navigate(manifest, path, pushHistory, fetchImpl);
+  } catch (error) {
+    console.error("[Absolute Mobile] Navigation failed:", error);
+    renderStatus("Unable to load this page. Check your connection and retry.");
+  } finally {
+    reinstallBrowserNavigation();
+  }
+};
+var startAbsoluteMobileShell = async (options = {}) => {
+  const manifest = await readManifest();
+  const auth = manifest.auth && options.createAuth ? await options.createAuth(manifest.auth) : undefined;
+  if (auth && manifest.sync?.socketTickets)
+    options.installSync?.(auth);
+  let removeAnchorNavigation = () => {
+    return;
+  };
+  const handlePopState = () => {
+    navigateWithFailureState(manifest, `${location.pathname}${location.search}${location.hash}`, false, reinstallBrowserNavigation, auth?.fetch);
+  };
+  const reinstallBrowserNavigation = () => {
+    removeAnchorNavigation();
+    removeEventListener("popstate", handlePopState);
+    removeAnchorNavigation = installAnchorNavigation(manifest, onNavigate);
+    addEventListener("popstate", handlePopState);
+  };
+  const onNavigate = (path) => {
+    navigateWithFailureState(manifest, path, true, reinstallBrowserNavigation, auth?.fetch);
+  };
+  await navigateWithFailureState(manifest, manifest.entry, false, reinstallBrowserNavigation, auth?.fetch);
+  await installDeepLinks(manifest, onNavigate, auth?.redirectUri);
+};
+export {
+  startAbsoluteMobileShell
+};

package/dist/mobile/shellSync.js

@@ -0,0 +1,57 @@
+// src/mobile/shellSync.ts
+import { lifecycle, network } from "@absolutejs/devices";
+import {
+  createCapacitorSyncLocalStore,
+  installCapacitorSyncLifecycle
+} from "@absolutejs/sync-capacitor";
+import { installSyncClientRuntimeTransport } from "@absolutejs/sync/client/runtime";
+var reloadShell = () => globalThis.location.reload();
+var ABSOLUTE_MOBILE_SYNC_STATUS_EVENT = "absolute:sync-status";
+var reportShellStatus = (status) => globalThis.dispatchEvent(new CustomEvent(ABSOLUTE_MOBILE_SYNC_STATUS_EVENT, { detail: status }));
+var installAbsoluteMobileShellSync = (auth, options = {}) => {
+  const namespace = auth.principal?.namespace;
+  const store = namespace ? options.createStore?.() ?? createCapacitorSyncLocalStore() : undefined;
+  const installLifecycle = options.installLifecycle ?? installCapacitorSyncLifecycle;
+  const reportStatus = options.reportStatus ?? reportShellStatus;
+  const removeTransport = installSyncClientRuntimeTransport({
+    ...namespace && store ? { durable: { namespace, store } } : {},
+    socketTicket: auth.socketTicket,
+    registerClient: (client) => {
+      let active2 = true;
+      const removeStatus = client.subscribeStatus(reportStatus);
+      const reportLifecycleFailure = (error) => console.error("[Absolute Mobile] Sync lifecycle installation failed:", error);
+      const removal = installLifecycle({
+        client,
+        lifecycle,
+        network
+      }).catch((error) => {
+        reportLifecycleFailure(error);
+        return;
+      });
+      return () => {
+        if (!active2)
+          return;
+        active2 = false;
+        removeStatus();
+        removal.then((remove) => remove?.());
+      };
+    }
+  });
+  const reload = options.reload ?? reloadShell;
+  const removePrincipalListener = auth.onPrincipalChange((principal) => {
+    if (principal?.namespace !== namespace)
+      reload();
+  });
+  let active = true;
+  return () => {
+    if (!active)
+      return;
+    active = false;
+    removePrincipalListener();
+    removeTransport();
+  };
+};
+export {
+  installAbsoluteMobileShellSync,
+  ABSOLUTE_MOBILE_SYNC_STATUS_EVENT
+};

package/dist/src/mobile/shellAuth.d.ts

@@ -1,7 +1,10 @@
+import { type MobileAuthPrincipal } from '@absolutejs/auth/client/mobile';
 import type { AbsoluteMobileAuthManifest } from './nativeAuth';
 import type { AbsoluteMobileFetch } from './transport';
 export type AbsoluteMobileShellAuth = {
     fetch: AbsoluteMobileFetch;
+    onPrincipalChange: (listener: (principal: MobileAuthPrincipal | null) => void) => () => void;
+    principal: MobileAuthPrincipal | null;
     redirectUri: string;
     socketTicket: (audience?: string) => Promise<string>;
 };

package/dist/src/mobile/shellBootstrap.d.ts

@@ -1,11 +1,16 @@
 import { type AbsoluteMobileFetch, type AbsoluteMobileClientManifest } from './transport';
 export type AbsoluteMobileShellAuthRuntime = {
     fetch: AbsoluteMobileFetch;
+    onPrincipalChange: (listener: (principal: AbsoluteMobileShellPrincipal | null) => void) => () => void;
+    principal: AbsoluteMobileShellPrincipal | null;
     redirectUri: string;
     socketTicket: (audience?: string) => Promise<string>;
 };
+export type AbsoluteMobileShellPrincipal = {
+    namespace: string;
+};
 export type AbsoluteMobileShellOptions = {
     createAuth?: (config: NonNullable<AbsoluteMobileClientManifest['auth']>) => Promise<AbsoluteMobileShellAuthRuntime>;
-    installSync?: (auth: AbsoluteMobileShellAuthRuntime) => void;
+    installSync?: (auth: AbsoluteMobileShellAuthRuntime) => void | (() => void);
 };
 export declare const startAbsoluteMobileShell: (options?: AbsoluteMobileShellOptions) => Promise<void>;

package/dist/src/mobile/shellSync.d.ts

@@ -1,2 +1,16 @@
+import { type CapacitorSyncLifecycleOptions } from '@absolutejs/sync-capacitor';
+import type { SyncClientStatus, SyncLocalStore } from '@absolutejs/sync/client';
 import type { AbsoluteMobileShellAuthRuntime } from './shellBootstrap';
-export declare const installAbsoluteMobileShellSync: (auth: AbsoluteMobileShellAuthRuntime) => void;
+export type AbsoluteMobileShellSyncOptions = {
+    createStore?: () => SyncLocalStore;
+    installLifecycle?: (options: CapacitorSyncLifecycleOptions) => Promise<() => void>;
+    reload?: () => void;
+    reportStatus?: (status: SyncClientStatus) => void;
+};
+export declare const ABSOLUTE_MOBILE_SYNC_STATUS_EVENT = "absolute:sync-status";
+/**
+ * Provisions unchanged Sync clients with native durability, Auth isolation, and
+ * foreground/connectivity reconnects. An identity change reloads the shell so
+ * no page-held client can retain the previous account's in-memory rows.
+ */
+export declare const installAbsoluteMobileShellSync: (auth: AbsoluteMobileShellAuthRuntime, options?: AbsoluteMobileShellSyncOptions) => () => void;

package/package.json

@@ -7,7 +7,7 @@
 		"url": "https://github.com/absolutejs/absolutejs/issues"
 	},
 	"dependencies": {
-		"@absolutejs/auth": "0.69.6",
+		"@absolutejs/auth": "0.70.0",
 		"@absolutejs/devices": "0.0.2",
 		"@absolutejs/devices-capacitor": "0.1.2",
 		"@capacitor/browser": "8.0.4",
@@ -25,7 +25,8 @@
 	"devDependencies": {
 		"@absolutejs/manifest": "0.9.0",
 		"@absolutejs/scoped-state": "0.2.2",
-		"@absolutejs/sync": "2.15.1",
+		"@absolutejs/sync": "2.22.2",
+		"@absolutejs/sync-capacitor": "0.2.0",
 		"@angular/animations": "21.2.6",
 		"@angular/cdk": "21.2.6",
 		"@angular/common": "21.2.6",
@@ -39,6 +40,7 @@
 		"@angular/router": "21.2.6",
 		"@angular/ssr": "21.2.5",
 		"@babel/preset-typescript": "^7.28.5",
+		"@capacitor-community/sqlite": "8.1.1",
 		"@capacitor/android": "8.5.0",
 		"@capacitor/app": "8.1.1",
 		"@capacitor/cli": "8.5.0",
@@ -272,12 +274,12 @@
 	"main": "./dist/index.js",
 	"name": "@absolutejs/absolute",
 	"optionalDependencies": {
-		"@absolutejs/native-darwin-arm64": "0.20.0-beta.6",
-		"@absolutejs/native-darwin-x64": "0.20.0-beta.6",
-		"@absolutejs/native-linux-arm64": "0.20.0-beta.6",
-		"@absolutejs/native-linux-x64": "0.20.0-beta.6",
-		"@absolutejs/native-windows-arm64": "0.20.0-beta.6",
-		"@absolutejs/native-windows-x64": "0.20.0-beta.6"
+		"@absolutejs/native-darwin-arm64": "0.20.0-beta.8",
+		"@absolutejs/native-darwin-x64": "0.20.0-beta.8",
+		"@absolutejs/native-linux-arm64": "0.20.0-beta.8",
+		"@absolutejs/native-linux-x64": "0.20.0-beta.8",
+		"@absolutejs/native-windows-arm64": "0.20.0-beta.8",
+		"@absolutejs/native-windows-x64": "0.20.0-beta.8"
 	},
 	"overrides": {
 		"@sinclair/typebox": "0.34.52",
@@ -287,7 +289,7 @@
 		"typebox": "1.3.16"
 	},
 	"peerDependencies": {
-		"@absolutejs/sync": ">=2.15.1 <3",
+		"@absolutejs/sync": ">=2.22.2 <3",
 		"@angular/animations": "^21.0.0",
 		"@angular/common": "^21.0.0",
 		"@angular/compiler": "^21.0.0",
@@ -488,7 +490,7 @@
 			]
 		}
 	},
-	"version": "0.20.0-beta.6",
+	"version": "0.20.0-beta.8",
 	"workspaces": [
 		"tests/fixtures/*",
 		"tests/fixtures/_packages/*"