@absolutejs/absolute 0.20.0-beta.4 → 0.20.0-beta.5

package/dist/mobile/index.js

@@ -159,6 +159,14 @@ var init_startupBanner = __esm(() => {
   ];
 });
 
+// src/utils/stringModifiers.ts
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+};
+
 // src/mobile/artifactStore.ts
 import { createHash as createHash2 } from "crypto";
 import {
@@ -249,13 +257,19 @@ var parseCompatibilityPage = (value) => {
   if (!isCanonicalRecord(value) || !isPageFramework(value.framework)) {
     throw new TypeError("Compatibility artifact contains an invalid page.");
   }
+  const styleBundleHash = typeof value.styleBundleHash === "string" ? value.styleBundleHash : undefined;
+  const styleBundlePath = typeof value.styleBundlePath === "string" ? value.styleBundlePath : undefined;
+  if (Boolean(styleBundleHash) !== Boolean(styleBundlePath)) {
+    throw new TypeError("Compatibility page style hash and path must be provided together.");
+  }
   return {
     bundleHash: readString(value.bundleHash, "page.bundleHash"),
     bundlePath: readString(value.bundlePath, "page.bundlePath"),
     contract: readString(value.contract, "page.contract"),
     framework: value.framework,
     pageId: readString(value.pageId, "page.pageId"),
-    propsSchemaHash: readString(value.propsSchemaHash, "page.propsSchemaHash")
+    propsSchemaHash: readString(value.propsSchemaHash, "page.propsSchemaHash"),
+    ...styleBundleHash && styleBundlePath ? { styleBundleHash, styleBundlePath } : {}
   };
 };
 var parseCompatibilityRoute = (value) => {
@@ -287,14 +301,23 @@ var validateProducerModule = (module) => {
   }
   return module;
 };
-var normalizePage = (page) => ({
-  bundleHash: requireNonEmpty(page.bundleHash, "page.bundleHash"),
-  bundlePath: requireNonEmpty(page.bundlePath, "page.bundlePath"),
-  contract: requireNonEmpty(page.contract, "page.contract"),
-  framework: page.framework,
-  pageId: requireNonEmpty(page.pageId, "page.pageId"),
-  propsSchemaHash: requireNonEmpty(page.propsSchemaHash, "page.propsSchemaHash")
-});
+var normalizePage = (page) => {
+  if (Boolean(page.styleBundleHash) !== Boolean(page.styleBundlePath)) {
+    throw new TypeError("Compatibility page style hash and path must be provided together.");
+  }
+  return {
+    bundleHash: requireNonEmpty(page.bundleHash, "page.bundleHash"),
+    bundlePath: requireNonEmpty(page.bundlePath, "page.bundlePath"),
+    contract: requireNonEmpty(page.contract, "page.contract"),
+    framework: page.framework,
+    pageId: requireNonEmpty(page.pageId, "page.pageId"),
+    propsSchemaHash: requireNonEmpty(page.propsSchemaHash, "page.propsSchemaHash"),
+    ...page.styleBundleHash && page.styleBundlePath ? {
+      styleBundleHash: requireNonEmpty(page.styleBundleHash, "page.styleBundleHash"),
+      styleBundlePath: requireNonEmpty(page.styleBundlePath, "page.styleBundlePath")
+    } : {}
+  };
+};
 var normalizeRoute = (route) => {
   if (!route.pattern.startsWith("/")) {
     throw new TypeError("route.pattern must start with /.");
@@ -1059,11 +1082,11 @@ var hashNativeTree = async (root, label, ignorePublicBundle) => {
   const records = await collectNativeDirectory(resolvedRoot, label, resolvedRoot, ignorePublicBundle);
   return createHash3("sha256").update(records.join("")).digest("hex");
 };
-var fingerprintAbsoluteAndroidNativeProject = async (project) => {
+var fingerprintAbsoluteAndroidNativeProject = async (project, options = {}) => {
   const { dependencies } = await nativeDependencySources(project.nativeDirectory);
   const roots = [
     {
-      ignorePublicBundle: true,
+      ignorePublicBundle: options.includePublicBundle !== true,
       label: "android",
       source: project.nativeDirectory
     },
@@ -3143,8 +3166,9 @@ var normalizeEntry = (entry) => {
 };
 var normalizeProductionOrigin = (value) => {
   const parsed = new URL(requireText(value, "mobile.server.productionOrigin"));
-  if (parsed.protocol !== "https:") {
-    throw new TypeError("mobile.server.productionOrigin must use HTTPS in production.");
+  const isLoopbackHttp = parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]");
+  if (parsed.protocol !== "https:" && !isLoopbackHttp) {
+    throw new TypeError("mobile.server.productionOrigin must use HTTPS, except for a loopback development origin.");
   }
   if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
     throw new TypeError("mobile.server.productionOrigin must be an origin without credentials, path, query, or hash.");
@@ -3168,9 +3192,8 @@ var normalizeHosts = (hosts, productionOrigin) => {
     }
     return value;
   };
-  const normalized = new Set([
-    normalizeHostname(new URL(productionOrigin).hostname)
-  ]);
+  const productionHostname = new URL(productionOrigin).hostname;
+  const normalized = new Set(productionHostname === "[::1]" ? [] : [normalizeHostname(productionHostname)]);
   for (const host of hosts ?? []) {
     normalized.add(normalizeHostname(host));
   }
@@ -3208,7 +3231,7 @@ var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
     throw new TypeError("mobile.appId must use reverse-domain notation, for example com.example.app.");
   }
   const productionOrigin = normalizeProductionOrigin(config.server.productionOrigin);
-  const deepLinkScheme = config.deepLinks?.scheme?.trim().toLowerCase();
+  const deepLinkScheme = (config.deepLinks?.scheme ?? appId).trim().toLowerCase();
   if (deepLinkScheme && !SCHEME_PATTERN.test(deepLinkScheme)) {
     throw new TypeError("mobile.deepLinks.scheme is not a valid URL scheme.");
   }
@@ -3472,14 +3495,22 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
 };
 // src/mobile/buildPipeline.ts
 import { readFile as readFile13 } from "fs/promises";
-import { join as join11, resolve as resolve10 } from "path";
+import { join as join12, resolve as resolve10 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
 import { createHash as createHash8 } from "crypto";
-import { readFile as readFile10 } from "fs/promises";
-import { join as join8, relative as relative7, resolve as resolve8 } from "path";
+import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
+import { basename as basename2, dirname as dirname6, extname, join as join8, relative as relative7, resolve as resolve8 } from "path";
 var sha256 = (bytes) => createHash8("sha256").update(bytes).digest("hex");
+var STATIC_SCRIPT_PATTERN = /(<script\b[^>]*?\bsrc\s*=\s*["'])(\/[^"']+\.(?:js|ts))(["'][^>]*>)/giu;
+var rewriteStaticScriptPaths = (source, manifest) => source.replace(STATIC_SCRIPT_PATTERN, (match, prefix, path, suffix) => {
+  if (path.endsWith("/htmx.min.js"))
+    return match;
+  const key = toPascal(basename2(path, extname(path)));
+  const builtPath = manifest[key];
+  return builtPath ? `${prefix}${builtPath}${suffix}` : match;
+});
 var readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]);
 var resolveAssetPath = (buildDirectory, assetPath) => {
   const resolvedBuildDirectory = resolve8(buildDirectory);
@@ -3494,16 +3525,38 @@ var pageFor = async (metadata, manifest, buildDirectory) => {
   if (!assetPath) {
     throw new TypeError(`Mobile page ${metadata.pageId} references missing manifest asset ${metadata.bundleKey}.`);
   }
-  const resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
-  const bytes = await readFile10(resolvedAssetPath);
+  let resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
+  if (metadata.framework === "html" || metadata.framework === "htmx") {
+    const source = await readFile10(resolvedAssetPath, "utf8");
+    const rewritten = rewriteStaticScriptPaths(source, manifest);
+    const documentHash = sha256(new TextEncoder().encode(rewritten));
+    resolvedAssetPath = join8(buildDirectory, ".absolutejs", "mobile-pages", `${documentHash}.html`);
+    await mkdir8(dirname6(resolvedAssetPath), { recursive: true });
+    await writeFile9(resolvedAssetPath, rewritten);
+  }
+  const pageAssetKey = metadata.bundleKey.replace(/Index$/u, "");
+  const styleAssetPath = [
+    `${pageAssetKey}BundledCSS`,
+    `${pageAssetKey}CompiledCSS`
+  ].map((key) => manifest[key]).find((path) => typeof path === "string");
+  const resolvedStylePath = styleAssetPath ? resolveAssetPath(buildDirectory, styleAssetPath) : undefined;
+  const [bytes, styleBytes] = await Promise.all([
+    readFile10(resolvedAssetPath),
+    resolvedStylePath ? readFile10(resolvedStylePath) : undefined
+  ]);
   const bundlePath = `/${relative7(resolve8(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const styleBundlePath = resolvedStylePath ? `/${relative7(resolve8(buildDirectory), resolvedStylePath).replaceAll("\\", "/")}` : undefined;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
     contract: metadata.contract,
     framework: metadata.framework,
     pageId: metadata.pageId,
-    propsSchemaHash: metadata.propsSchemaHash
+    propsSchemaHash: metadata.propsSchemaHash,
+    ...styleBytes && styleBundlePath ? {
+      styleBundleHash: sha256(styleBytes),
+      styleBundlePath
+    } : {}
   };
 };
 var buildAbsoluteMobileCompatibilityRelease = async (options) => {
@@ -3525,11 +3578,19 @@ var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   const pages = await Promise.all([...metadataByPage.values()].map((metadata) => pageFor(metadata, options.manifest, options.buildDirectory)));
   const producerHash = sha256(producerBytes);
   const appBuild = `ambuild_${sha256(new TextEncoder().encode(JSON.stringify({
-    pages: pages.map(({ bundleHash, bundlePath, contract, pageId }) => ({
+    pages: pages.map(({
+      bundleHash,
+      bundlePath,
+      contract,
+      pageId,
+      styleBundleHash,
+      styleBundlePath
+    }) => ({
       bundleHash,
       bundlePath,
       contract,
-      pageId
+      pageId,
+      ...styleBundleHash && styleBundlePath ? { styleBundleHash, styleBundlePath } : {}
     })),
     producerHash,
     runtime: options.runtime
@@ -3589,16 +3650,17 @@ var captureAbsoluteMobileRouteGraph = async (app) => {
 
 // src/mobile/capacitorBundle.ts
 import {
+  cp,
   copyFile as copyFile5,
-  mkdir as mkdir8,
+  mkdir as mkdir9,
   mkdtemp as mkdtemp4,
   readFile as readFile11,
   rename as rename9,
   rm as rm7,
-  writeFile as writeFile9
+  writeFile as writeFile10
 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { basename as basename2, dirname as dirname6, extname, join as join9, resolve as resolve9 } from "path";
+import { basename as basename3, dirname as dirname7, extname as extname2, join as join9, relative as relative8, resolve as resolve9 } from "path";
 
 // src/mobile/routeMatcher.ts
 var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
@@ -3871,6 +3933,13 @@ class AbsoluteMobilePageProtocolError extends Error {
     this.code = code;
   }
 }
+var disposeAbsoluteMobilePage = async (target = window) => {
+  const dispose = target.__ABSOLUTE_PAGE_DISPOSE__;
+  target.__ABSOLUTE_PAGE_DISPOSE__ = undefined;
+  target.__ABSOLUTE_PAGE_READY__ = undefined;
+  if (dispose)
+    await dispose();
+};
 var frameworks4 = new Set([
   "angular",
   "ember",
@@ -3926,12 +3995,17 @@ var activateAbsoluteMobilePage = async (value, options) => {
     throw new AbsoluteMobilePageProtocolError("invalid-envelope", "Expected a renderable mobile page response.");
   }
   const target = options.target ?? window;
+  await disposeAbsoluteMobilePage(target);
   target.__INITIAL_PROPS__ = envelope.response.props;
+  target.__ABS_ANGULAR_REQUEST_CONTEXT__ = envelope.response.props;
   target.__ABSOLUTE_PAGE_RENDER_MODE__ = "client";
   await options.loadPage({
     contract: envelope.response.contract,
     pageId: envelope.response.pageId
   });
+  if (target.__ABSOLUTE_PAGE_READY__) {
+    await target.__ABSOLUTE_PAGE_READY__;
+  }
   return {
     contract: envelope.response.contract,
     kind: "rendered",
@@ -4024,12 +4098,32 @@ var resolveAbsoluteMobileDeepLink = (manifest, value) => {
   }
   return `${url.pathname || "/"}${url.search}${url.hash}`;
 };
+var resolveAbsoluteMobileNavigation = (manifest, value, localOrigin) => {
+  const url = new URL(value, `${localOrigin}/`);
+  const local = new URL(localOrigin);
+  const production = new URL(manifest.productionOrigin);
+  const matches = (candidate, allowed) => candidate.protocol === allowed.protocol && candidate.host === allowed.host;
+  if (!matches(url, local) && !matches(url, production)) {
+    return;
+  }
+  return `${url.pathname}${url.search}${url.hash}`;
+};
 
 // src/mobile/capacitorBundle.ts
 var MANIFEST_FILE = "absolute-mobile-manifest.json";
 var BOOTSTRAP_FILE = "absolute-mobile-bootstrap.js";
 var INDEX_FILE = "index.html";
-var CLIENT_IMPORT_PATTERN = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s*)["'](\/[^"']+)["']/gu;
+var CLIENT_CSS_DEPENDENCY_PATTERN = /(?:@import\s+(?:url\(\s*)?|url\(\s*)["']?((?:\/|\.\.\/|\.\/)[^"')\s]+)["']?\s*\)?/gu;
+var CLIENT_MARKUP_DEPENDENCY_PATTERN = /<(?:script\b[^>]*\bsrc|link\b[^>]*\bhref|img\b[^>]*\bsrc|source\b[^>]*\bsrcset)\s*=\s*["']((?:\/|\.\.\/|\.\/)[^"',\s]+)/giu;
+var CAPACITOR_CLIENT_FRAMEWORKS = new Set([
+  "angular",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var CLIENT_ASSET_DIRECTORIES = ["assets", "html", "htmx", "indexes"];
 var errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var shellBootstrapModule = () => {
   const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
@@ -4037,6 +4131,18 @@ var shellBootstrapModule = () => {
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
 };
+var shellAuthModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellAuth.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile auth shell module is missing.");
+};
+var shellSyncModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellSync.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile Sync shell module is missing.");
+};
 var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 var indexHtml = (appName) => `<!doctype html>
 <html>
@@ -4060,11 +4166,16 @@ var sourceAssetPath = (buildDirectory, bundlePath) => {
   }
   return asset;
 };
-var buildShellBootstrap = async (staging) => {
+var buildShellBootstrap = async (staging, auth, sync) => {
   const modulePath = shellBootstrapModule();
+  const authImport = auth ? `import { createAbsoluteMobileShellAuth } from ${JSON.stringify(shellAuthModule())};
+` : "";
+  const options = auth ? `{ createAuth: createAbsoluteMobileShellAuth${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }` : "";
+  const syncImport = sync ? `import { installAbsoluteMobileShellSync } from ${JSON.stringify(shellSyncModule())};
+` : "";
   const entryPath = join9(staging, ".absolute-mobile-entry.ts");
-  await writeFile9(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
-void startAbsoluteMobileShell();
+  await writeFile10(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+${authImport}${syncImport}void startAbsoluteMobileShell(${options});
 `);
   const build = await Bun.build({
     entrypoints: [entryPath],
@@ -4107,21 +4218,62 @@ var installBundle = async (staging, destination) => {
   }
 };
 var copyClientPage = async (page, buildDirectory, staging, copiedDependencies) => {
-  if (page.framework !== "react") {
-    throw new TypeError(`Capacitor spike currently supports React pages; ${page.pageId} is ${page.framework}.`);
+  if (!CAPACITOR_CLIENT_FRAMEWORKS.has(page.framework)) {
+    throw new TypeError(`Capacitor client rendering does not yet support ${page.framework} page ${page.pageId}.`);
   }
-  const extension = extname(page.bundlePath) || ".js";
+  const extension = extname2(page.bundlePath) || ".js";
   const localBundlePath = `./pages/${page.bundleHash}${extension}`;
   const source = sourceAssetPath(buildDirectory, page.bundlePath);
   await copyFile5(source, join9(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
-  return { ...page, localBundlePath };
+  let localStylePath;
+  if (page.styleBundlePath && page.styleBundleHash) {
+    const styleExtension = extname2(page.styleBundlePath) || ".css";
+    localStylePath = `./styles/${page.styleBundleHash}${styleExtension}`;
+    const styleSource = sourceAssetPath(buildDirectory, page.styleBundlePath);
+    await mkdir9(dirname7(join9(staging, localStylePath)), {
+      recursive: true
+    });
+    await copyFile5(styleSource, join9(staging, localStylePath));
+    await copyAbsoluteClientDependencies(styleSource, buildDirectory, staging, copiedDependencies);
+  }
+  return {
+    ...page,
+    localBundlePath,
+    ...localStylePath ? { localStylePath } : {}
+  };
 };
-var absoluteClientImports = async (sourcePath) => {
+var absoluteClientImports = async (sourcePath, buildDirectory) => {
   const source = await readFile11(sourcePath, "utf8");
-  return [...source.matchAll(CLIENT_IMPORT_PATTERN)].flatMap((match) => {
-    const [specifier] = match.slice(1);
-    return specifier ? [specifier.split(/[?#]/u, 1)[0] ?? specifier] : [];
+  const extension = extname2(sourcePath).toLowerCase();
+  let scriptLoader;
+  if (extension === ".tsx")
+    scriptLoader = "tsx";
+  else if (extension === ".ts")
+    scriptLoader = "ts";
+  else if (extension === ".jsx")
+    scriptLoader = "jsx";
+  else if ([".js", ".mjs", ".cjs"].includes(extension))
+    scriptLoader = "js";
+  const scriptImports = scriptLoader ? new Bun.Transpiler({ loader: scriptLoader }).scanImports(source).map(({ path }) => path) : [];
+  const cssImports = extension === ".css" ? [...source.matchAll(CLIENT_CSS_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  const markupImports = extension === ".html" ? [...source.matchAll(CLIENT_MARKUP_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  return [...scriptImports, ...cssImports, ...markupImports].flatMap((specifier) => {
+    if (!specifier)
+      return [];
+    if (!specifier.startsWith("/") && !specifier.startsWith("./") && !specifier.startsWith("../")) {
+      return [];
+    }
+    const clean = specifier.split(/[?#]/u, 1)[0] ?? specifier;
+    if (clean.startsWith("/"))
+      return [clean];
+    const resolved = resolve9(dirname7(sourcePath), clean);
+    const root = resolve9(buildDirectory);
+    const relativePath = relative8(root, resolved).replaceAll("\\", "/");
+    if (relativePath === ".." || relativePath.startsWith("../")) {
+      throw new TypeError(`Mobile client dependency escaped the build directory: ${specifier}`);
+    }
+    return [`/${relativePath}`];
   });
 };
 var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, copied) => {
@@ -4130,12 +4282,12 @@ var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, co
   copied.add(specifier);
   const source = sourceAssetPath(buildDirectory, specifier);
   const destination = join9(staging, specifier.replace(/^\/+/, ""));
-  await mkdir8(dirname6(destination), { recursive: true });
+  await mkdir9(dirname7(destination), { recursive: true });
   await copyFile5(source, destination);
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
 };
 var copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
-  const dependencies = await absoluteClientImports(sourcePath);
+  const dependencies = await absoluteClientImports(sourcePath, buildDirectory);
   await Promise.all(dependencies.map((specifier) => copyAbsoluteClientDependency(specifier, buildDirectory, staging, copied)));
 };
 var materializeAbsoluteCapacitorWebBundle = async (options) => {
@@ -4143,15 +4295,20 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
     throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
   }
   const destination = options.config.bundleDirectory;
-  await mkdir8(dirname6(destination), { recursive: true });
-  const staging = await mkdtemp4(join9(dirname6(destination), `.${basename2(destination)}.stage-`));
+  await mkdir9(dirname7(destination), { recursive: true });
+  const staging = await mkdtemp4(join9(dirname7(destination), `.${basename3(destination)}.stage-`));
   try {
     const pageDirectory = join9(staging, "pages");
-    await mkdir8(pageDirectory, { recursive: true });
+    await mkdir9(pageDirectory, { recursive: true });
+    await Promise.all(CLIENT_ASSET_DIRECTORIES.map((directory) => ({
+      destination: join9(staging, directory),
+      source: join9(options.buildDirectory, directory)
+    })).filter(({ source }) => existsSync2(source)).map(({ destination: assetDestination, source }) => cp(source, assetDestination, { recursive: true })));
     const copiedDependencies = new Set;
     const pages = await Promise.all(options.artifact.pages.map((page) => copyClientPage(page, options.buildDirectory, staging, copiedDependencies)));
     const manifest = {
       appBuild: options.artifact.appBuild,
+      ...options.auth ? { auth: options.auth } : {},
       appId: options.config.appId,
       appName: options.config.appName,
       deepLinkHosts: options.config.deepLinkHosts,
@@ -4161,13 +4318,14 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       pages,
       productionOrigin: options.config.productionOrigin,
       routes: options.artifact.routes,
-      runtime: options.artifact.runtime
+      runtime: options.artifact.runtime,
+      ...options.sync ? { sync: { socketTickets: true } } : {}
     };
     await Promise.all([
-      writeFile9(join9(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+      writeFile10(join9(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
-      writeFile9(join9(staging, INDEX_FILE), indexHtml(options.config.appName)),
-      buildShellBootstrap(staging)
+      writeFile10(join9(staging, INDEX_FILE), indexHtml(options.config.appName)),
+      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true)
     ]);
     await installBundle(staging, destination);
     return manifest;
@@ -4181,14 +4339,14 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
 import { createHash as createHash9 } from "crypto";
 import {
   access as access8,
-  mkdir as mkdir9,
+  mkdir as mkdir10,
   mkdtemp as mkdtemp5,
   readFile as readFile12,
   rename as rename10,
   rm as rm8,
-  writeFile as writeFile10
+  writeFile as writeFile11
 } from "fs/promises";
-import { dirname as dirname7, join as join10, resolve as resolvePath3 } from "path";
+import { dirname as dirname8, join as join10, resolve as resolvePath3 } from "path";
 import { pathToFileURL } from "url";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1;
 var CURRENT_BUNDLE_FILE = "current.json";
@@ -4230,11 +4388,11 @@ var parseBundleIndex = (value) => {
 var writeRelease = async (root, release) => {
   const directory = join10(root, release.artifact.releaseId);
   const producerPath = join10(directory, release.artifact.producer.module);
-  await mkdir9(dirname7(producerPath), { recursive: true });
+  await mkdir10(dirname8(producerPath), { recursive: true });
   await Promise.all([
-    writeFile10(join10(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile11(join10(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
-    writeFile10(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+    writeFile11(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 };
 var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
@@ -4316,7 +4474,7 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
   });
   const root = resolvePath3(input.root);
   const bundlesRoot = join10(root, BUNDLES_DIRECTORY);
-  await mkdir9(bundlesRoot, { recursive: true });
+  await mkdir10(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
   const index = {
@@ -4327,7 +4485,7 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
   };
   const pointerPath = join10(root, CURRENT_BUNDLE_FILE);
   const temporaryPointerPath = join10(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile10(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+  await writeFile11(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
 `, { flag: "wx" });
   await rename10(temporaryPointerPath, pointerPath);
   return index;
@@ -4354,6 +4512,58 @@ var readAbsoluteMobileMaterializedReleases = async (root) => {
   }
 };
 
+// src/mobile/nativeAuth.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join11 } from "path";
+var ABSOLUTE_AUTH_PACKAGE = "@absolutejs/auth";
+var ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV = "ABSOLUTE_AUTH_NATIVE_CLIENTS";
+var ABSOLUTE_NATIVE_AUTH_SCOPES = ["openid", "profile"];
+var ABSOLUTE_SYNC_PACKAGE = "@absolutejs/sync";
+var readPackageManifest = (projectRoot) => {
+  try {
+    return JSON.parse(readFileSync2(join11(projectRoot, "package.json"), "utf8"));
+  } catch {
+    return;
+  }
+};
+var packageManifestHas = (manifest, packageName) => {
+  if (typeof manifest !== "object" || manifest === null)
+    return false;
+  return [
+    Reflect.get(manifest, "dependencies"),
+    Reflect.get(manifest, "devDependencies"),
+    Reflect.get(manifest, "optionalDependencies"),
+    Reflect.get(manifest, "peerDependencies")
+  ].some((dependencies) => typeof dependencies === "object" && dependencies !== null && Object.hasOwn(dependencies, packageName));
+};
+var createAbsoluteMobileAuthManifest = (config) => {
+  const scheme = config.deepLinkScheme ?? config.appId.toLowerCase();
+  return {
+    clientId: `absolutejs-native:${config.appId}`,
+    issuer: config.productionOrigin,
+    redirectUri: `${scheme}://auth/callback`,
+    scopes: [...ABSOLUTE_NATIVE_AUTH_SCOPES]
+  };
+};
+var installAbsoluteMobileAuthEnvironment = (projectRoot, config) => {
+  const auth = resolveAbsoluteMobileAuthManifest(projectRoot, config);
+  const serialized = serializeAbsoluteMobileAuthEnvironment(config, auth);
+  if (serialized === undefined)
+    delete process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV];
+  else
+    process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV] = serialized;
+  return auth;
+};
+var projectUsesAbsoluteAuth = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_AUTH_PACKAGE);
+var projectUsesAbsoluteSync = (projectRoot) => packageManifestHas(readPackageManifest(projectRoot), ABSOLUTE_SYNC_PACKAGE);
+var resolveAbsoluteMobileAuthManifest = (projectRoot, config) => projectUsesAbsoluteAuth(projectRoot) ? createAbsoluteMobileAuthManifest(config) : undefined;
+var serializeAbsoluteMobileAuthEnvironment = (config, auth) => auth === undefined ? undefined : JSON.stringify([
+  {
+    ...auth,
+    name: `${config.appName} native app`
+  }
+]);
+
 // src/mobile/buildPipeline.ts
 var isElysiaApp = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "compile") === "function" && Array.isArray(Reflect.get(value, "routes"));
 var isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
@@ -4364,12 +4574,11 @@ var serverExportName = (loaded, app) => {
     return "app";
   return "default";
 };
-var restoreBuildDirectory = (previous) => {
-  if (previous !== undefined) {
-    process.env.ABSOLUTE_BUILD_DIR = previous;
-    return;
-  }
-  delete process.env.ABSOLUTE_BUILD_DIR;
+var restoreEnvironmentVariable = (name, previous) => {
+  if (previous !== undefined)
+    process.env[name] = previous;
+  else
+    delete process.env[name];
 };
 var requireRelease = (releases, releaseId) => {
   const release = releases.get(releaseId);
@@ -4391,9 +4600,9 @@ var loadServerApp = async (producerPath) => {
 var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   const buildDirectory = resolve10(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join11(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join12(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile13(join11(buildDirectory, "manifest.json"), "utf8"),
+    readFile13(join12(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -4401,12 +4610,20 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     throw new TypeError("Invalid AbsoluteJS build manifest for mobile capture.");
   }
   const previousBuildDirectory = process.env.ABSOLUTE_BUILD_DIR;
+  const previousCompiledRuntime = process.env.ABSOLUTE_COMPILED_RUNTIME;
+  const previousConfigPath = process.env.ABSOLUTE_CONFIG;
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
+  process.env.ABSOLUTE_COMPILED_RUNTIME = "1";
+  if (options.configPath) {
+    process.env.ABSOLUTE_CONFIG = resolve10(options.projectRoot, options.configPath);
+  }
   let loaded;
   try {
     loaded = await loadServerApp(resolve10(options.producerPath));
   } finally {
-    restoreBuildDirectory(previousBuildDirectory);
+    restoreEnvironmentVariable("ABSOLUTE_BUILD_DIR", previousBuildDirectory);
+    restoreEnvironmentVariable("ABSOLUTE_COMPILED_RUNTIME", previousCompiledRuntime);
+    restoreEnvironmentVariable("ABSOLUTE_CONFIG", previousConfigPath);
   }
   const current = await buildAbsoluteMobileCompatibilityRelease({
     app: loaded.app,
@@ -4418,6 +4635,11 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     producerPath: resolve10(options.producerPath),
     runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
   });
+  const auth = resolveAbsoluteMobileAuthManifest(options.projectRoot, mobile);
+  const sync = auth !== undefined && projectUsesAbsoluteSync(options.projectRoot);
+  if (auth && !loaded.app.routes.some((route) => route.path === "/.well-known/openid-configuration")) {
+    throw new TypeError("@absolutejs/auth is installed, but its OIDC provider is not mounted. Native authentication requires the auth oidc configuration so AbsoluteJS can provision a public PKCE client.");
+  }
   const releasesById = new Map([current, ...previous].map((release) => [
     release.artifact.releaseId,
     release
@@ -4430,8 +4652,10 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   });
   await materializeAbsoluteCapacitorWebBundle({
     artifact: current.artifact,
+    ...auth ? { auth } : {},
     buildDirectory,
-    config: mobile
+    config: mobile,
+    ...sync ? { sync: true } : {}
   });
   return current.artifact;
 };
@@ -4456,6 +4680,64 @@ var ensureProducerStorage = () => {
 var runWithAbsoluteMobileProducer = (context, callback) => ensureProducerStorage().run(context, callback);
 
 // src/mobile/compatibilityDispatcher.ts
+var MOBILE_WEBVIEW_ORIGINS = new Set([
+  "capacitor://localhost",
+  "http://localhost",
+  "https://localhost"
+]);
+var MOBILE_REQUEST_HEADER_NAMES = Object.values(MOBILE_PAGE_REQUEST_HEADERS);
+var MOBILE_CORS_ALLOW_HEADERS = [
+  "accept",
+  "content-type",
+  "authorization",
+  "hx-current-url",
+  "hx-request",
+  "hx-target",
+  "hx-trigger",
+  "hx-trigger-name",
+  ...MOBILE_REQUEST_HEADER_NAMES
+].join(", ");
+var MOBILE_CORS_METHODS = new Set([
+  "DELETE",
+  "GET",
+  "HEAD",
+  "OPTIONS",
+  "PATCH",
+  "POST",
+  "PUT"
+]);
+var mobileWebViewOrigin = (request) => {
+  const origin = request.headers.get("origin");
+  return origin && MOBILE_WEBVIEW_ORIGINS.has(origin) ? origin : undefined;
+};
+var applyMobileCorsHeaders = (response, origin) => {
+  response.headers.set("access-control-allow-credentials", "true");
+  response.headers.set("access-control-allow-origin", origin);
+  response.headers.append("vary", "Origin");
+  return response;
+};
+var mobilePreflightResponse = (request) => {
+  if (request.method !== "OPTIONS")
+    return;
+  const origin = mobileWebViewOrigin(request);
+  if (!origin)
+    return;
+  const requestedHeaders = request.headers.get("access-control-request-headers");
+  const requestedMethod = request.headers.get("access-control-request-method")?.toUpperCase() ?? "";
+  if (!MOBILE_CORS_METHODS.has(requestedMethod))
+    return;
+  return new Response(null, {
+    headers: {
+      "access-control-allow-credentials": "true",
+      "access-control-allow-headers": requestedHeaders || MOBILE_CORS_ALLOW_HEADERS,
+      "access-control-allow-methods": [...MOBILE_CORS_METHODS].join(", "),
+      "access-control-allow-origin": origin,
+      "access-control-max-age": "600",
+      vary: "Origin, Access-Control-Request-Headers"
+    },
+    status: 204
+  });
+};
 var artifactOwnsRequest = (artifact, pageId, request) => {
   const { pathname } = new URL(request.url);
   return artifact.routes.some((route) => route.pageId === pageId && route.method === request.method && matchesAbsoluteMobileRoutePattern(route.pattern, pathname));
@@ -4483,6 +4765,9 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
   return new Elysia2({ name: "absolutejs-mobile-compatibility-dispatcher" }).request(async ({ request }) => {
     if (getCurrentAbsoluteMobileProducerContext())
       return;
+    const preflight = mobilePreflightResponse(request);
+    if (preflight)
+      return preflight;
     const parsed = parseAbsoluteMobilePageRequest(request);
     if (parsed.kind !== "mobile")
       return;
@@ -4506,11 +4791,16 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
       console.error(`[Mobile] Failed to load retained producer ${resolved.artifact.releaseId}:`, error);
       return createAbsoluteMobilePageErrorResponse(parsed.client.pageId);
     }
+  }).afterHandle("global", ({ request, responseValue }) => {
+    const origin = mobileWebViewOrigin(request);
+    if (!origin || !(responseValue instanceof Response))
+      return;
+    applyMobileCorsHeaders(responseValue, origin);
   }).as("global");
 };
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile14, rename as rename11, writeFile as writeFile11 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile14, rename as rename11, writeFile as writeFile12 } from "fs/promises";
+import { join as join13 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->";
 var END_MARKER = "<!-- absolutejs:deep-links:end -->";
 var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
@@ -4521,7 +4811,7 @@ var writeChangedFile = async (path, source) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile11(temporary, source, { flag: "wx" });
+  await writeFile12(temporary, source, { flag: "wx" });
   await rename11(temporary, path);
   return true;
 };
@@ -4567,7 +4857,7 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join12(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const path = join13(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
   const source = await readFile14(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
@@ -4593,7 +4883,7 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join12(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const path = join13(config.nativeProjectDirectory, "ios/App/App/Info.plist");
   const source = await readFile14(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
@@ -4617,7 +4907,7 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join12(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join13(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
     current = await readFile14(path, "utf8");
@@ -4630,12 +4920,12 @@ var configureIosEntitlements = async (config) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile11(temporary, source, { flag: "wx" });
+  await writeFile12(temporary, source, { flag: "wx" });
   await rename11(temporary, path);
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join12(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const path = join13(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
   const source = await readFile14(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
@@ -4675,7 +4965,7 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
 };
 // src/mobile/releasePublisher.ts
 import { access as access9 } from "fs/promises";
-import { isAbsolute as isAbsolute6, relative as relative8, resolve as resolve11, sep as sep6 } from "path";
+import { isAbsolute as isAbsolute6, relative as relative9, resolve as resolve11, sep as sep6 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -4703,7 +4993,7 @@ var isPublisher = (value) => isRecord8(value) && typeof value.publish === "funct
 var publisherModulePath = (projectRoot, requested) => {
   const root = resolve11(projectRoot);
   const path = resolve11(root, requested);
-  const projectRelative = relative8(root, path);
+  const projectRelative = relative9(root, path);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute6(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
@@ -4772,14 +5062,59 @@ var publishAbsoluteIosRelease = async (options) => {
   return publication;
 };
 // src/mobile/routeMetadataTransform.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname8, extname as extname2, relative as relative9, resolve as resolve12 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname9, extname as extname3, relative as relative10, resolve as resolve12 } from "path";
 import ts from "typescript";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
-var PAGE_HANDLER = "handleReactPageRequest";
+var PAGE_HANDLERS = new Map([
+  [
+    "handleHTMLPageRequest",
+    { framework: "html", inputKind: "static", propsProperty: "props" }
+  ],
+  [
+    "handleHTMXPageRequest",
+    { framework: "htmx", inputKind: "static", propsProperty: "props" }
+  ],
+  [
+    "handleAngularPageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "angular",
+      propsProperty: "requestContext",
+      sourceProperty: "pagePath"
+    }
+  ],
+  [
+    "handleReactPageRequest",
+    {
+      bundleProperty: "index",
+      framework: "react",
+      pageProperty: "Page",
+      propsProperty: "props"
+    }
+  ],
+  [
+    "handleSveltePageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "svelte",
+      propsProperty: "props",
+      sourceProperty: "pagePath"
+    }
+  ],
+  [
+    "handleVuePageRequest",
+    {
+      bundleProperty: "indexPath",
+      framework: "vue",
+      propsProperty: "props",
+      sourceProperty: "pagePath"
+    }
+  ]
+]);
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname8(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname9(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
@@ -4791,7 +5126,7 @@ var createProgram = (entry, projectRoot) => {
       target: ts.ScriptTarget.ESNext
     });
   }
-  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync2(path, "utf8")).config, ts.sys, dirname8(configPath));
+  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync3(path, "utf8")).config, ts.sys, dirname9(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts.createProgram(parsed.fileNames, parsed.options);
@@ -4897,7 +5232,7 @@ var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   const declaration = symbol?.declarations?.[0];
   const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
   const exportedName = symbol?.name ?? expression.getText(sourceFile);
-  const source = posixPath(relative9(projectRoot, file));
+  const source = posixPath(relative10(projectRoot, file));
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
@@ -4929,13 +5264,108 @@ var assetKey = (expression, checker, seen = new Set) => {
   const [, key] = expression.arguments;
   return key && ts.isStringLiteralLike(key) ? key.text : undefined;
 };
+var staticString = (expression, bindings) => {
+  if (ts.isStringLiteralLike(expression))
+    return expression.text;
+  if (ts.isIdentifier(expression))
+    return bindings.get(expression.text);
+  if (ts.isNoSubstitutionTemplateLiteral(expression))
+    return expression.text;
+  if (!ts.isTemplateExpression(expression))
+    return;
+  let value = expression.head.text;
+  for (const span of expression.templateSpans) {
+    const substitution = staticString(span.expression, bindings);
+    if (substitution === undefined)
+      return;
+    value += substitution + span.literal.text;
+  }
+  return value;
+};
+var assetKeyWithBindings = (expression, checker, bindings = new Map) => {
+  if (!expression)
+    return;
+  if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "asset") {
+    const [, key] = expression.arguments;
+    return key ? staticString(key, bindings) : undefined;
+  }
+  return assetKey(expression, checker);
+};
+var callableObject = (call, checker) => {
+  const symbol = checker.getSymbolAtLocation(call.expression);
+  const resolved = symbol ? resolveAlias(symbol, checker) : undefined;
+  const declaration = resolved?.valueDeclaration ?? resolved?.declarations?.[0];
+  let callable;
+  if (declaration && ts.isFunctionDeclaration(declaration)) {
+    callable = declaration;
+  } else if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) {
+    callable = declaration.initializer;
+  }
+  if (!callable)
+    return;
+  const bindings = new Map;
+  callable.parameters.forEach((parameter, index) => {
+    if (!ts.isIdentifier(parameter.name))
+      return;
+    const argument = call.arguments[index];
+    if (!argument)
+      return;
+    const value = staticString(argument, new Map);
+    if (value !== undefined)
+      bindings.set(parameter.name.text, value);
+  });
+  const { body } = callable;
+  if (!body)
+    return;
+  const expressionBody = ts.isParenthesizedExpression(body) ? body.expression : body;
+  if (ts.isObjectLiteralExpression(expressionBody)) {
+    return { bindings, object: expressionBody };
+  }
+  if (ts.isBlock(body)) {
+    const returned = body.statements.find(ts.isReturnStatement)?.expression;
+    if (returned && ts.isObjectLiteralExpression(returned)) {
+      return { bindings, object: returned };
+    }
+  }
+  return;
+};
+var spreadObject = (expression, checker, bindings) => {
+  if (ts.isObjectLiteralExpression(expression)) {
+    return { bindings, object: expression };
+  }
+  if (!ts.isCallExpression(expression))
+    return;
+  return callableObject(expression, checker);
+};
+var objectAssetKey = (object, name, checker, bindings = new Map) => {
+  for (const property of [...object.properties].reverse()) {
+    if (propertyName(property) === name && ts.isShorthandPropertyAssignment(property)) {
+      return assetKeyWithBindings(property.name, checker, bindings);
+    }
+    if (propertyName(property) === name && ts.isPropertyAssignment(property)) {
+      return assetKeyWithBindings(property.initializer, checker, bindings);
+    }
+    if (!ts.isSpreadAssignment(property))
+      continue;
+    const nestedObject = spreadObject(property.expression, checker, bindings);
+    if (!nestedObject)
+      continue;
+    const nested = objectAssetKey(nestedObject.object, name, checker, nestedObject.bindings);
+    if (nested)
+      return nested;
+  }
+  return;
+};
 var findPageCall = (nodes) => {
   let found;
   const visit = (candidate) => {
     if (found)
       return;
-    if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && candidate.expression.text === PAGE_HANDLER) {
-      found = candidate;
+    if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && PAGE_HANDLERS.has(candidate.expression.text)) {
+      const definition = PAGE_HANDLERS.get(candidate.expression.text);
+      if (!definition)
+        return;
+      found = { definition, node: candidate };
       return;
     }
     ts.forEachChild(candidate, visit);
@@ -4954,30 +5384,67 @@ var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
   const [routePath] = node.arguments;
   if (!routePath || !ts.isStringLiteralLike(routePath))
     return;
-  const pageCall = findPageCall(node.arguments.slice(1));
+  const foundPageCall = findPageCall(node.arguments.slice(1));
+  const pageCall = foundPageCall?.node;
+  const definition = foundPageCall?.definition;
   const [input] = pageCall?.arguments ?? [];
-  if (!pageCall || !input || !ts.isObjectLiteralExpression(input)) {
+  if (!pageCall || !input) {
     return;
   }
-  const page = objectPropertyExpression(input, "Page");
-  if (!page)
+  if (!definition)
+    return;
+  if (definition.inputKind === "static") {
+    const bundleKey2 = assetKey(input, checker);
+    if (!bundleKey2)
+      return;
+    const pageId2 = `${definition.framework}:${bundleKey2}`;
+    const propsSchemaHash2 = hashAbsoluteMobilePropsSchema({
+      properties: {},
+      type: "object"
+    });
+    return {
+      inputKind: "static",
+      metadata: {
+        bundleKey: bundleKey2,
+        contract: `${definition.framework}:${pageId2}:${propsSchemaHash2}`,
+        framework: definition.framework,
+        pageId: pageId2,
+        propsSchemaHash: propsSchemaHash2
+      },
+      pageCallStart: pageCall.getStart(sourceFile),
+      routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
+    };
+  }
+  if (!ts.isObjectLiteralExpression(input) || !definition.bundleProperty) {
+    return;
+  }
+  const page = definition.pageProperty ? objectPropertyExpression(input, definition.pageProperty) : undefined;
+  const source = definition.sourceProperty ? objectAssetKey(input, definition.sourceProperty, checker) : undefined;
+  if (definition.pageProperty && !page)
+    return;
+  if (definition.sourceProperty && !source)
     return;
-  const props = objectPropertyExpression(input, "props");
-  const index = objectPropertyExpression(input, "index");
-  const bundleKey = assetKey(index, checker);
+  const props = objectPropertyExpression(input, definition.propsProperty);
+  const bundleKey = objectAssetKey(input, definition.bundleProperty, checker);
   if (!bundleKey)
     return;
-  const pageId = resolvePageIdentity(page, sourceFile, checker, projectRoot);
-  const schema = serializeType(pagePropsType(page, props, checker), checker);
+  const pageId = page ? resolvePageIdentity(page, sourceFile, checker, projectRoot) : `${definition.framework}:${source}`;
+  let propsType;
+  if (page)
+    propsType = pagePropsType(page, props, checker);
+  else if (props)
+    propsType = checker.getTypeAtLocation(props);
+  const schema = propsType ? serializeType(propsType, checker) : { properties: {}, type: "object" };
   const propsSchemaHash = hashAbsoluteMobilePropsSchema(schema);
   const metadata = {
     bundleKey,
-    contract: `react:${pageId}:${propsSchemaHash}`,
-    framework: "react",
+    contract: `${definition.framework}:${pageId}:${propsSchemaHash}`,
+    framework: definition.framework,
     pageId,
     propsSchemaHash
   };
   const result = {
+    inputKind: "object",
     metadata,
     pageCallStart: pageCall.getStart(sourceFile),
     routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
@@ -5034,6 +5501,16 @@ var routeOptions = (existing, metadata) => {
 var transformPageCall = (node, page) => {
   if (!page)
     return;
+  if (page.inputKind === "static") {
+    const [pagePath, existingOptions, ...rest] = node.arguments;
+    if (!pagePath)
+      return;
+    const options = ts.factory.createObjectLiteralExpression([
+      ...existingOptions ? [ts.factory.createSpreadAssignment(existingOptions)] : [],
+      ts.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+    ]);
+    return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [pagePath, options, ...rest]);
+  }
   const [input] = node.arguments;
   if (!input || !ts.isObjectLiteralExpression(input))
     return;
@@ -5100,7 +5577,7 @@ var createAbsoluteMobileRouteMetadataPlugin = (options) => {
         const source = await Bun.file(path).text();
         return {
           contents: transformFile(source, path, analysis),
-          loader: extname2(path).endsWith("x") ? "tsx" : "ts"
+          loader: extname3(path).endsWith("x") ? "tsx" : "ts"
         };
       });
     }
@@ -5111,7 +5588,7 @@ var inspectAbsoluteMobileRouteMetadata = (options) => {
   const entry = resolve12(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return [...analyzed.entries()].flatMap(([file, analysis]) => [...analysis.byRouteCall.values()].map(({ metadata }) => ({
-    file: posixPath(relative9(projectRoot, file)),
+    file: posixPath(relative10(projectRoot, file)),
     metadata
   })));
 };
@@ -5125,17 +5602,22 @@ export {
   syncAbsoluteRemoteMacProject,
   startAbsoluteRemoteIosDevSession,
   startAbsoluteIosDevSession,
+  serializeAbsoluteMobileAuthEnvironment,
   runWithAbsoluteMobileProducer,
   retainAbsoluteMobileCompatibilityArtifacts,
   resolveAbsoluteMobileRoute,
+  resolveAbsoluteMobileNavigation,
   resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
+  resolveAbsoluteMobileAuthManifest,
   repairAbsoluteIosDevSession,
   removeAbsoluteRemoteMacProfile,
   redactAbsoluteIosLog,
   readAbsoluteMobileMaterializedReleases,
   publishAbsoluteIosRelease,
   publishAbsoluteAndroidRelease,
+  projectUsesAbsoluteSync,
+  projectUsesAbsoluteAuth,
   prepareAbsoluteIosRelease,
   prepareAbsoluteIosDevProject,
   prepareAbsoluteAndroidRelease,
@@ -5161,6 +5643,7 @@ export {
   listAbsoluteRemoteMacProfiles,
   isAbsoluteIosNativeRootInput,
   installAbsoluteRemoteMacAgent,
+  installAbsoluteMobileAuthEnvironment,
   inspectAbsoluteRemoteMac,
   inspectAbsoluteMobileRouteMetadata,
   hashAbsoluteMobilePropsSchema,
@@ -5171,6 +5654,7 @@ export {
   finalizeAbsoluteMobilePage,
   finalizeAbsoluteMobileCompatibilityBuild,
   fetchAbsoluteMobilePage,
+  disposeAbsoluteMobilePage,
   createAbsoluteRemoteIosDevProject,
   createAbsoluteMobileUpgradeResponse,
   createAbsoluteMobileRouteMetadataPlugin,
@@ -5181,6 +5665,7 @@ export {
   createAbsoluteMobileCompatibilityDispatcher,
   createAbsoluteMobileCompatibilityArtifact,
   createAbsoluteMobileBlobArtifactStore,
+  createAbsoluteMobileAuthManifest,
   createAbsoluteMobileAssociationPlugin,
   createAbsoluteMobileAssociationDocuments,
   createAbsoluteIosNativeWatcher,
@@ -5198,8 +5683,11 @@ export {
   AbsoluteMobilePageProtocolError,
   APPLE_ASSOCIATION_PATH,
   ANDROID_ASSOCIATION_PATH,
+  ABSOLUTE_SYNC_PACKAGE,
   ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION,
   ABSOLUTE_REMOTE_MAC_EVENT_PREFIX,
+  ABSOLUTE_NATIVE_AUTH_SCOPES,
+  ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV,
   ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL,
   ABSOLUTE_MOBILE_ROUTE_DETAIL,
   ABSOLUTE_MOBILE_RETAINED_GENERATIONS,
@@ -5210,8 +5698,9 @@ export {
   ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
   ABSOLUTE_IOS_SIMULATOR_NAME,
   ABSOLUTE_IOS_RELEASE_FORMAT,
+  ABSOLUTE_AUTH_PACKAGE,
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=5FE7B7589D1661C064756E2164756E21
+//# debugId=7AFC88B0A927AFE564756E2164756E21
 //# sourceMappingURL=index.js.map