@absolutejs/absolute 0.20.0-beta.3 → 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
     },
@@ -2533,14 +2556,582 @@ var createAbsoluteIosNativeWatcher = async (options) => {
   return { close };
 };
 var isAbsoluteIosNativeRootInput = (path) => ROOT_NATIVE_INPUTS.has(basename(path));
+// src/mobile/remoteMacProtocol.ts
+import { createHash as createHash7, randomUUID as randomUUID3 } from "crypto";
+import { chmod, mkdir as mkdir6, readFile as readFile8, rename as rename7, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import {
+  dirname as dirname5,
+  isAbsolute as isAbsolute5,
+  join as join7,
+  posix,
+  relative as relative6,
+  resolve as resolvePath2,
+  sep as sep5
+} from "path";
+
+// src/mobile/remoteMacWire.ts
+var ABSOLUTE_REMOTE_MAC_EVENT_PREFIX = "ABSOLUTE_REMOTE_MAC\t";
+var ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION = 1;
+
+// src/mobile/remoteMacProtocol.ts
+var PROFILE_FORMAT = 1;
+var PROFILE_NAME = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/u;
+var SSH_DESTINATION = /^(?:[A-Za-z0-9._-]+@)?[A-Za-z0-9._:-]+$/u;
+var defaultProfilePath = () => join7(homedir2(), ".absolutejs", "mobile", "remote-macs.json");
+var emptyStore = () => ({
+  format: PROFILE_FORMAT,
+  profiles: {}
+});
+var loadStore = async (path = defaultProfilePath()) => {
+  try {
+    const parsed = JSON.parse(await readFile8(path, "utf8"));
+    if (parsed.format !== PROFILE_FORMAT || typeof parsed.profiles !== "object" || parsed.profiles === null || Array.isArray(parsed.profiles))
+      throw new Error("Unsupported remote Mac profile format.");
+    for (const [key, profile] of Object.entries(parsed.profiles)) {
+      if (typeof profile !== "object" || profile === null || validateAbsoluteRemoteMacProfileName(key) !== key || profile.name !== key || validateAbsoluteSshDestination(profile.destination) !== profile.destination || validatePort(profile.port) !== profile.port || typeof profile.createdAt !== "string" || !profile.createdAt || typeof profile.bunPath !== "string" || !profile.bunPath.startsWith("/") || /[\r\n\0]/u.test(profile.bunPath) || typeof profile.workspaceRoot !== "string" || !profile.workspaceRoot.startsWith("/") || profile.workspaceRoot === "/" || /[\r\n\0]/u.test(profile.workspaceRoot) || typeof profile.xcodeVersion !== "string" || !profile.xcodeVersion.startsWith("Xcode "))
+        throw new Error(`Remote Mac profile ${JSON.stringify(key)} is invalid.`);
+    }
+    if (parsed.defaultProfile !== undefined && !parsed.profiles[parsed.defaultProfile])
+      throw new Error("The default remote Mac profile does not exist.");
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return emptyStore();
+    throw error;
+  }
+};
+var saveStore = async (store, path = defaultProfilePath()) => {
+  await mkdir6(dirname5(path), { recursive: true });
+  const temporary = `${path}.${randomUUID3()}.tmp`;
+  await writeFile7(temporary, `${JSON.stringify(store, null, 2)}
+`, {
+    mode: 384
+  });
+  await rename7(temporary, path);
+  await chmod(path, 384);
+};
+var validateAbsoluteRemoteMacProfileName = (name) => {
+  const normalized = name.trim().toLowerCase();
+  if (!PROFILE_NAME.test(normalized))
+    throw new TypeError("Remote Mac profile names must use 1-64 lowercase letters, digits, dots, dashes, or underscores.");
+  return normalized;
+};
+var validateAbsoluteSshDestination = (destination) => {
+  const normalized = destination.trim();
+  if (!SSH_DESTINATION.test(normalized) || normalized.startsWith("-"))
+    throw new TypeError("Remote Mac SSH destination must be a host, SSH alias, or user@host without command-line options.");
+  return normalized;
+};
+var validatePort = (port) => {
+  if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
+    throw new TypeError("Remote Mac SSH port must be between 1 and 65535.");
+  return port;
+};
+var shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+var absoluteRemoteMacSshBase = (profile, options = {}) => [
+  "ssh",
+  "-o",
+  "BatchMode=yes",
+  "-o",
+  "ConnectTimeout=10",
+  "-o",
+  "ServerAliveInterval=15",
+  "-o",
+  "ServerAliveCountMax=3",
+  "-o",
+  `StrictHostKeyChecking=${options.acceptNew ? "accept-new" : "yes"}`,
+  ...profile.port ? ["-p", String(profile.port)] : [],
+  profile.destination
+];
+var localCapture = async (command) => {
+  const process2 = Bun.spawn(command, {
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    process2.exited,
+    new Response(process2.stdout).text(),
+    new Response(process2.stderr).text()
+  ]);
+  return { exitCode, stderr, stdout };
+};
+var defaultTransport = {
+  capture: localCapture,
+  spawn: (command, options) => Bun.spawn(command, {
+    signal: options.signal,
+    stderr: "pipe",
+    stdin: "pipe",
+    stdout: "pipe"
+  })
+};
+var requireRemoteSuccess = (result, label) => {
+  if (result.exitCode !== 0)
+    throw new Error(`${label} failed: ${(result.stderr || result.stdout).trim() || `status ${result.exitCode}`}`);
+  return result.stdout.trim();
+};
+var getAbsoluteRemoteMacProfile = async (name, profilePath) => {
+  const store = await loadStore(profilePath);
+  const selected = name ?? process.env.ABSOLUTE_IOS_REMOTE ?? store.defaultProfile;
+  if (!selected)
+    return;
+  const profile = store.profiles[selected];
+  if (!profile)
+    throw new Error(`Remote Mac profile ${JSON.stringify(selected)} was not found.`);
+  return profile;
+};
+var inspectAbsoluteRemoteMac = async (destination, options = {}) => {
+  const profile = {
+    destination: validateAbsoluteSshDestination(destination),
+    port: validatePort(options.port)
+  };
+  const capture = options.transport?.capture ?? defaultTransport.capture;
+  const command = [
+    ...absoluteRemoteMacSshBase(profile, {
+      acceptNew: options.acceptNew === true
+    }),
+    "/bin/sh -lc",
+    shellQuote(`bun_path="$(command -v bun || true)"; if [ -z "$bun_path" ] && [ -x "$HOME/.bun/bin/bun" ]; then bun_path="$HOME/.bun/bin/bun"; fi; printf '%s\\n' "$(uname -s)" "$HOME" "$bun_path" "$(/usr/bin/xcodebuild -version 2>/dev/null | tr '\\n' ' ' || true)"`)
+  ];
+  const lines = requireRemoteSuccess(await capture(command), "Remote Mac handshake").split(/\r?\n/u);
+  const [operatingSystem, home, bunPath, xcodeVersion] = lines;
+  if (operatingSystem !== "Darwin")
+    throw new Error("The SSH target is not a Mac.");
+  if (!home?.startsWith("/") || !bunPath?.startsWith("/"))
+    throw new Error("The remote Mac must have Bun installed and available to SSH.");
+  if (!xcodeVersion?.startsWith("Xcode "))
+    throw new Error("The remote Mac must have full Xcode installed and selected.");
+  return { bunPath, home, os: operatingSystem, xcodeVersion };
+};
+var listAbsoluteRemoteMacProfiles = async (profilePath) => {
+  const store = await loadStore(profilePath);
+  return {
+    defaultProfile: store.defaultProfile,
+    profiles: Object.values(store.profiles).sort((left, right) => left.name.localeCompare(right.name))
+  };
+};
+var pairAbsoluteRemoteMac = async (options) => {
+  const name = validateAbsoluteRemoteMacProfileName(options.name);
+  const destination = validateAbsoluteSshDestination(options.destination);
+  const port = validatePort(options.port);
+  const inspection = await inspectAbsoluteRemoteMac(destination, {
+    acceptNew: true,
+    port,
+    transport: options.transport
+  });
+  const workspaceRoot = options.workspaceRoot ? options.workspaceRoot.trim() : posix.join(inspection.home, ".absolutejs", "remote-ios");
+  if (!workspaceRoot.startsWith("/") || workspaceRoot === "/" || /[\r\n\0]/u.test(workspaceRoot))
+    throw new TypeError("Remote Mac workspace must be an absolute macOS path.");
+  const profile = {
+    bunPath: inspection.bunPath,
+    createdAt: new Date().toISOString(),
+    destination,
+    name,
+    ...port ? { port } : {},
+    workspaceRoot,
+    xcodeVersion: inspection.xcodeVersion
+  };
+  const store = await loadStore(options.profilePath);
+  store.profiles[name] = profile;
+  store.defaultProfile = name;
+  await saveStore(store, options.profilePath);
+  return profile;
+};
+var removeAbsoluteRemoteMacProfile = async (name, profilePath) => {
+  const normalized = validateAbsoluteRemoteMacProfileName(name);
+  const store = await loadStore(profilePath);
+  if (!store.profiles[normalized])
+    return false;
+  delete store.profiles[normalized];
+  if (store.defaultProfile === normalized) {
+    const [nextDefault] = Object.keys(store.profiles).sort();
+    store.defaultProfile = nextDefault;
+  }
+  await saveStore(store, profilePath);
+  return true;
+};
+var projectIdentity = (projectRoot, appId) => createHash7("sha256").update(`${resolvePath2(projectRoot)}\x00${appId}`).digest("hex").slice(0, 20);
+var createAbsoluteRemoteIosDevProject = (config, projectRoot, profile) => ({
+  cap: join7(resolvePath2(projectRoot), "node_modules", ".bin", "cap"),
+  config,
+  nativeDirectory: join7(config.nativeProjectDirectory, "ios"),
+  profile,
+  projectRoot: resolvePath2(projectRoot),
+  remote: true,
+  remoteProjectRoot: posix.join(profile.workspaceRoot, "projects", projectIdentity(projectRoot, config.appId), "current"),
+  xcodebuild: "remote:xcodebuild",
+  xcrun: "remote:xcrun"
+});
+var installAbsoluteRemoteMacAgent = async (project) => {
+  const artifact = await materializeAbsoluteRemoteMacAgent(project.projectRoot);
+  const directory = posix.join(project.profile.workspaceRoot, "agents", `protocol-${ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION}`, artifact.sha256);
+  const remotePath = posix.join(directory, "agent.js");
+  const verifyScript = `test -f ${shellQuote(remotePath)} && ` + `test "$(shasum -a 256 ${shellQuote(remotePath)} | awk '{print $1}')" = ${shellQuote(artifact.sha256)}`;
+  const verified = await defaultTransport.capture([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(verifyScript)
+  ]);
+  if (verified.exitCode === 0)
+    return { ...artifact, remotePath, uploaded: false };
+  const temporary = posix.join(directory, `.agent-${randomUUID3()}.tmp`);
+  const installScript = [
+    "set -eu",
+    "umask 077",
+    `mkdir -p ${shellQuote(directory)}`,
+    `cat > ${shellQuote(temporary)}`,
+    `test "$(shasum -a 256 ${shellQuote(temporary)} | awk '{print $1}')" = ${shellQuote(artifact.sha256)}`,
+    `chmod 600 ${shellQuote(temporary)}`,
+    `mv ${shellQuote(temporary)} ${shellQuote(remotePath)}`
+  ].join("; ");
+  const upload = Bun.spawn([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(installScript)
+  ], {
+    stderr: "pipe",
+    stdin: Bun.file(artifact.path),
+    stdout: "pipe"
+  });
+  const [exitCode, stderr] = await Promise.all([
+    upload.exited,
+    new Response(upload.stderr).text()
+  ]);
+  if (exitCode !== 0)
+    throw new Error(`Remote Mac agent installation failed: ${stderr.trim() || `status ${exitCode}`}`);
+  return { ...artifact, remotePath, uploaded: true };
+};
+var materializeAbsoluteRemoteMacAgent = async (projectRoot) => {
+  const shippedCandidates = [
+    join7(import.meta.dir, "remoteMacAgentEntry.js"),
+    join7(import.meta.dir, "..", "mobile", "remoteMacAgentEntry.js")
+  ];
+  let path;
+  for (const candidate of shippedCandidates) {
+    if (await Bun.file(candidate).exists()) {
+      path = candidate;
+      break;
+    }
+  }
+  if (!path) {
+    const sourceCandidates = [
+      join7(import.meta.dir, "remoteMacAgentEntry.ts"),
+      join7(import.meta.dir, "..", "..", "src", "mobile", "remoteMacAgentEntry.ts")
+    ];
+    const source = await sourceCandidates.reduce(async (found, candidate) => await found ?? (await Bun.file(candidate).exists() ? candidate : undefined), Promise.resolve(undefined));
+    if (!source)
+      throw new Error("The AbsoluteJS installation does not contain its remote Mac agent artifact.");
+    const outdir = join7(resolvePath2(projectRoot), ".absolutejs", "mobile", "remote-agent");
+    await mkdir6(outdir, { recursive: true });
+    const result = await Bun.build({
+      entrypoints: [source],
+      minify: true,
+      outdir,
+      target: "bun"
+    });
+    if (!result.success)
+      throw new AggregateError(result.logs, "Failed to build the AbsoluteJS remote Mac agent.");
+    path = join7(outdir, "remoteMacAgentEntry.js");
+  }
+  const bytes = await Bun.file(path).arrayBuffer();
+  const sha256 = createHash7("sha256").update(new Uint8Array(bytes)).digest("hex");
+  return { bytes: bytes.byteLength, path, sha256 };
+};
+var portableRelativePath = (root, path) => relative6(root, path).split(sep5).join(posix.sep);
+var portableMobileConfig = (project) => ({
+  appId: project.config.appId,
+  appName: project.config.appName,
+  bundleDirectory: portableRelativePath(project.projectRoot, project.config.bundleDirectory),
+  ...project.config.deepLinkScheme || project.config.deepLinkHosts.length > 1 || project.config.appleAppIdPrefix ? {
+    deepLinks: {
+      ...project.config.deepLinkScheme ? { scheme: project.config.deepLinkScheme } : {},
+      hosts: project.config.deepLinkHosts,
+      ...project.config.appleAppIdPrefix ? {
+        apple: {
+          appIdPrefix: project.config.appleAppIdPrefix
+        }
+      } : {}
+    }
+  } : {},
+  entry: project.config.entry,
+  ...project.config.iosVersion ? { ios: { version: project.config.iosVersion } } : {},
+  nativeProject: {
+    directory: portableRelativePath(project.projectRoot, project.config.nativeProjectDirectory),
+    mode: "source"
+  },
+  platforms: ["ios"],
+  server: { productionOrigin: project.config.productionOrigin }
+});
+var absoluteRemoteProjectSyncCommands = (project) => {
+  const current = project.remoteProjectRoot;
+  const parent = posix.dirname(current);
+  const staging = posix.join(parent, `.incoming-${randomUUID3()}`);
+  const previous = posix.join(parent, ".previous");
+  const script = [
+    "set -eu",
+    `mkdir -p ${shellQuote(staging)}`,
+    `tar -xf - -C ${shellQuote(staging)}`,
+    `if [ -d ${shellQuote(posix.join(current, "node_modules"))} ]; then mv ${shellQuote(posix.join(current, "node_modules"))} ${shellQuote(posix.join(staging, "node_modules"))}; fi`,
+    `if [ -d ${shellQuote(posix.join(current, ".absolutejs"))} ]; then mv ${shellQuote(posix.join(current, ".absolutejs"))} ${shellQuote(posix.join(staging, ".absolutejs"))}; fi`,
+    `rm -rf ${shellQuote(previous)}`,
+    `if [ -d ${shellQuote(current)} ]; then mv ${shellQuote(current)} ${shellQuote(previous)}; fi`,
+    `mv ${shellQuote(staging)} ${shellQuote(current)}`,
+    `rm -rf ${shellQuote(previous)}`
+  ].join("; ");
+  return {
+    remote: [
+      ...absoluteRemoteMacSshBase(project.profile),
+      "/bin/sh -lc",
+      shellQuote(script)
+    ],
+    tar: [
+      "tar",
+      "--exclude=.git",
+      "--exclude=node_modules",
+      "--exclude=build",
+      "--exclude=.absolutejs",
+      "-cf",
+      "-",
+      "-C",
+      project.projectRoot,
+      "."
+    ]
+  };
+};
+var syncAbsoluteRemoteMacProject = async (project) => {
+  const commands = absoluteRemoteProjectSyncCommands(project);
+  const archive = Bun.spawn(commands.tar, {
+    stderr: "pipe",
+    stdout: "pipe"
+  });
+  const upload = Bun.spawn(commands.remote, {
+    stderr: "pipe",
+    stdin: archive.stdout,
+    stdout: "pipe"
+  });
+  const [archiveExit, uploadExit, archiveError, uploadError] = await Promise.all([
+    archive.exited,
+    upload.exited,
+    new Response(archive.stderr).text(),
+    new Response(upload.stderr).text()
+  ]);
+  if (archiveExit !== 0 || uploadExit !== 0)
+    throw new Error(`Remote Mac project synchronization failed: ${(archiveError || uploadError).trim()}`);
+  const install = await defaultTransport.capture([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(`cd ${shellQuote(project.remoteProjectRoot)} && ${shellQuote(project.profile.bunPath)} install --frozen-lockfile`)
+  ]);
+  requireRemoteSuccess(install, "Remote Mac dependency installation");
+};
+var consumeLines2 = async (stream, onLine) => {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffered += decoder.decode(value, { stream: true });
+      const lines = buffered.split(/\r?\n/u);
+      buffered = lines.pop() ?? "";
+      lines.forEach(onLine);
+    }
+    buffered += decoder.decode();
+    if (buffered)
+      onLine(buffered);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var startAbsoluteRemoteIosDevSession = async (options) => {
+  const startedAt = performance.now();
+  const transport = options.transport ?? defaultTransport;
+  const installAgent = options.installAgent ?? installAbsoluteRemoteMacAgent;
+  const syncProject = options.syncProject ?? syncAbsoluteRemoteMacProject;
+  const agentStartedAt = performance.now();
+  const agent = await installAgent(options.project);
+  const agentDuration = performance.now() - agentStartedAt;
+  const syncStartedAt = performance.now();
+  await syncProject(options.project);
+  const syncDuration = performance.now() - syncStartedAt;
+  const encodedConfig = Buffer.from(JSON.stringify(portableMobileConfig(options.project))).toString("base64url");
+  const remoteCommand = [
+    `cd ${shellQuote(options.project.remoteProjectRoot)}`,
+    "&&",
+    "exec",
+    shellQuote(options.project.profile.bunPath),
+    shellQuote(agent.remotePath),
+    "--port",
+    String(options.port),
+    "--mobile-config",
+    shellQuote(encodedConfig),
+    ...options.https ? ["--https"] : []
+  ].join(" ");
+  const command = [
+    ...absoluteRemoteMacSshBase(options.project.profile),
+    "-o",
+    "ExitOnForwardFailure=yes",
+    "-R",
+    `${options.port}:127.0.0.1:${options.port}`,
+    "/bin/sh -lc",
+    shellQuote(remoteCommand)
+  ];
+  const connectStartedAt = performance.now();
+  const process2 = transport.spawn(command, { signal: options.signal });
+  let state = "syncing";
+  let ready;
+  let fatal;
+  const pending = new Map;
+  let resolveReady;
+  let rejectReady;
+  const readyPromise = new Promise((resolve6, reject) => {
+    resolveReady = resolve6;
+    rejectReady = reject;
+  });
+  const handleEvent = (event) => {
+    if (event.v !== ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION) {
+      rejectReady(new Error("Remote Mac protocol version mismatch."));
+      return;
+    }
+    if (event.type === "log")
+      options.log?.(event.message);
+    if (event.type === "native-log")
+      options.nativeLog?.(event.entry);
+    if (event.type === "state") {
+      ({ state } = event);
+      options.onStateChange?.(state);
+    }
+    if (event.type === "timing")
+      options.onPhaseTiming?.(event);
+    if (event.type === "ready") {
+      ready = event;
+      resolveReady();
+    }
+    if (event.type === "fatal") {
+      fatal = new Error(event.error);
+      rejectReady(fatal);
+    }
+    if (event.type === "response") {
+      const request2 = pending.get(event.id);
+      if (!request2)
+        return;
+      pending.delete(event.id);
+      if (event.ok)
+        request2.resolve(event.result);
+      else
+        request2.reject(new Error(event.error ?? "Remote command failed."));
+    }
+  };
+  const stdoutDone = consumeLines2(process2.stdout, (line) => {
+    if (!line.startsWith(ABSOLUTE_REMOTE_MAC_EVENT_PREFIX))
+      return;
+    try {
+      handleEvent(JSON.parse(line.slice(ABSOLUTE_REMOTE_MAC_EVENT_PREFIX.length)));
+    } catch {
+      options.log?.(`Remote Mac emitted an invalid protocol event.`);
+    }
+  }).catch((error) => {
+    fatal = error instanceof Error ? error : new Error("Failed to read the remote Mac protocol stream.");
+    rejectReady(fatal);
+  });
+  const stderrDone = consumeLines2(process2.stderr, (line) => options.log?.(`[remote] ${line}`)).catch((error) => options.log?.(`[remote] ${error instanceof Error ? error.message : "Failed to read SSH stderr."}`));
+  process2.exited.then(async (exitCode) => {
+    await Promise.all([stdoutDone, stderrDone]);
+    const error = fatal ?? new Error(`Remote Mac connection closed with status ${exitCode}.`);
+    if (!ready)
+      rejectReady(error);
+    pending.forEach(({ reject }) => reject(error));
+    pending.clear();
+    return;
+  });
+  await readyPromise;
+  if (!ready)
+    throw fatal ?? new Error("Remote Mac did not become ready.");
+  const totalDuration = performance.now() - startedAt;
+  let currentReady = {
+    ...ready,
+    timings: {
+      ...ready.timings,
+      "remote-agent": agentDuration,
+      "remote-connect": performance.now() - connectStartedAt,
+      "remote-sync": syncDuration,
+      total: totalDuration
+    }
+  };
+  options.log?.(`Remote Mac connected (${options.project.profile.name}); agent ${agent.uploaded ? "uploaded" : "cache hit"}, project synced, and iOS ready in ${totalDuration.toFixed(2)}ms.`);
+  const request = (commandName) => {
+    const id = randomUUID3();
+    const response = new Promise((resolve6, reject) => pending.set(id, { reject, resolve: resolve6 }));
+    process2.stdin.write(`${JSON.stringify({ command: commandName, id, v: 1 })}
+`);
+    process2.stdin.flush();
+    return response;
+  };
+  let closed = false;
+  const close = async () => {
+    if (closed)
+      return;
+    closed = true;
+    await request("close").catch(() => {
+      return;
+    });
+    process2.stdin.end();
+    await process2.exited.catch(() => {
+      return;
+    });
+  };
+  const makeSession = () => ({
+    close,
+    nativeCacheHit: currentReady.nativeCacheHit,
+    startedSimulator: currentReady.startedSimulator,
+    timings: currentReady.timings,
+    udid: currentReady.udid,
+    rebuild: async () => {
+      const rebuildStartedAt = performance.now();
+      const rebuildSyncStartedAt = performance.now();
+      await syncProject(options.project);
+      const rebuildSyncDuration = performance.now() - rebuildSyncStartedAt;
+      const result = await request("rebuild");
+      currentReady = {
+        ...result,
+        timings: {
+          ...result.timings,
+          "remote-sync": rebuildSyncDuration,
+          total: performance.now() - rebuildStartedAt
+        }
+      };
+      return makeSession();
+    },
+    relaunch: async () => {
+      await request("relaunch");
+    },
+    screenshot: async (destination) => {
+      const result = await request("screenshot");
+      const target = resolvePath2(options.project.projectRoot, destination);
+      const targetRelative = relative6(options.project.projectRoot, target);
+      if (targetRelative.startsWith("..") || isAbsolute5(targetRelative))
+        throw new Error("iOS screenshot must remain inside the project.");
+      await mkdir6(dirname5(target), { recursive: true });
+      await writeFile7(target, Buffer.from(result.data, "base64"));
+      return target;
+    },
+    get state() {
+      return state;
+    }
+  });
+  return makeSession();
+};
 // src/mobile/associationFiles.ts
 import {
   access as access7,
-  mkdir as mkdir6,
-  readFile as readFile8,
-  rename as rename7,
+  mkdir as mkdir7,
+  readFile as readFile9,
+  rename as rename8,
   rm as rm6,
-  writeFile as writeFile7
+  writeFile as writeFile8
 } from "fs/promises";
 import { resolve as resolve7 } from "path";
 import { Elysia } from "elysia";
@@ -2575,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.");
@@ -2600,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));
   }
@@ -2640,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.");
   }
@@ -2742,7 +3333,7 @@ var createAbsoluteMobileAssociationPlugin = (mobile, projectRoot, options = {})
 var writeAtomic = async (path, source) => {
   let current;
   try {
-    current = await readFile8(path, "utf8");
+    current = await readFile9(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -2751,8 +3342,8 @@ var writeAtomic = async (path, source) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile7(temporary, source, { flag: "wx" });
-  await rename7(temporary, path);
+  await writeFile8(temporary, source, { flag: "wx" });
+  await rename8(temporary, path);
   return true;
 };
 var exists2 = async (path) => {
@@ -2767,7 +3358,7 @@ var assertOwnedOutput = async (root) => {
   const path = resolve7(root, OWNERSHIP_FILE);
   let ownership;
   try {
-    ownership = JSON.parse(await readFile8(path, "utf8"));
+    ownership = JSON.parse(await readFile9(path, "utf8"));
   } catch {
     throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
   }
@@ -2781,12 +3372,12 @@ var publishGeneratedDirectory = async (temporary, root) => {
     await assertOwnedOutput(root);
   const backup = `${root}.${crypto.randomUUID()}.previous`;
   if (hasCurrent)
-    await rename7(root, backup);
+    await rename8(root, backup);
   try {
-    await rename7(temporary, root);
+    await rename8(temporary, root);
   } catch (error) {
     if (hasCurrent)
-      await rename7(backup, root);
+      await rename8(backup, root);
     throw error;
   }
   if (hasCurrent)
@@ -2794,7 +3385,7 @@ var publishGeneratedDirectory = async (temporary, root) => {
 };
 var materializeHost = async (root, host, files) => {
   const directory = resolve7(root, host, ".well-known");
-  await mkdir6(directory, { recursive: true });
+  await mkdir7(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document]) => {
     const path = resolve7(directory, name);
     await writeAtomic(path, `${JSON.stringify(document, null, 2)}
@@ -2832,7 +3423,7 @@ var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory)
   if (documents.apple) {
     files.push(["apple-app-site-association", documents.apple]);
   }
-  await mkdir6(temporary, { recursive: true });
+  await mkdir7(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
     await writeAtomic(resolve7(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
@@ -2903,15 +3494,23 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
   };
 };
 // src/mobile/buildPipeline.ts
-import { readFile as readFile12 } from "fs/promises";
-import { join as join10, resolve as resolve10 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join12, resolve as resolve10 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
-import { createHash as createHash7 } from "crypto";
-import { readFile as readFile9 } from "fs/promises";
-import { join as join7, relative as relative6, resolve as resolve8 } from "path";
-var sha256 = (bytes) => createHash7("sha256").update(bytes).digest("hex");
+import { createHash as createHash8 } from "crypto";
+import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
+import { basename as basename2, dirname as dirname6, extname, join as join8, relative as relative7, resolve as resolve8 } from "path";
+var sha256 = (bytes) => createHash8("sha256").update(bytes).digest("hex");
+var STATIC_SCRIPT_PATTERN = /(<script\b[^>]*?\bsrc\s*=\s*["'])(\/[^"']+\.(?:js|ts))(["'][^>]*>)/giu;
+var rewriteStaticScriptPaths = (source, manifest) => source.replace(STATIC_SCRIPT_PATTERN, (match, prefix, path, suffix) => {
+  if (path.endsWith("/htmx.min.js"))
+    return match;
+  const key = toPascal(basename2(path, extname(path)));
+  const builtPath = manifest[key];
+  return builtPath ? `${prefix}${builtPath}${suffix}` : match;
+});
 var readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]);
 var resolveAssetPath = (buildDirectory, assetPath) => {
   const resolvedBuildDirectory = resolve8(buildDirectory);
@@ -2919,29 +3518,51 @@ var resolveAssetPath = (buildDirectory, assetPath) => {
   if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
     return resolvedAsset;
   }
-  return join7(buildDirectory, assetPath.replace(/^\/+/, ""));
+  return join8(buildDirectory, assetPath.replace(/^\/+/, ""));
 };
 var pageFor = async (metadata, manifest, buildDirectory) => {
   const assetPath = manifest[metadata.bundleKey];
   if (!assetPath) {
     throw new TypeError(`Mobile page ${metadata.pageId} references missing manifest asset ${metadata.bundleKey}.`);
   }
-  const resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
-  const bytes = await readFile9(resolvedAssetPath);
-  const bundlePath = `/${relative6(resolve8(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  let resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
+  if (metadata.framework === "html" || metadata.framework === "htmx") {
+    const source = await readFile10(resolvedAssetPath, "utf8");
+    const rewritten = rewriteStaticScriptPaths(source, manifest);
+    const documentHash = sha256(new TextEncoder().encode(rewritten));
+    resolvedAssetPath = join8(buildDirectory, ".absolutejs", "mobile-pages", `${documentHash}.html`);
+    await mkdir8(dirname6(resolvedAssetPath), { recursive: true });
+    await writeFile9(resolvedAssetPath, rewritten);
+  }
+  const pageAssetKey = metadata.bundleKey.replace(/Index$/u, "");
+  const styleAssetPath = [
+    `${pageAssetKey}BundledCSS`,
+    `${pageAssetKey}CompiledCSS`
+  ].map((key) => manifest[key]).find((path) => typeof path === "string");
+  const resolvedStylePath = styleAssetPath ? resolveAssetPath(buildDirectory, styleAssetPath) : undefined;
+  const [bytes, styleBytes] = await Promise.all([
+    readFile10(resolvedAssetPath),
+    resolvedStylePath ? readFile10(resolvedStylePath) : undefined
+  ]);
+  const bundlePath = `/${relative7(resolve8(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const styleBundlePath = resolvedStylePath ? `/${relative7(resolve8(buildDirectory), resolvedStylePath).replaceAll("\\", "/")}` : undefined;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
     contract: metadata.contract,
     framework: metadata.framework,
     pageId: metadata.pageId,
-    propsSchemaHash: metadata.propsSchemaHash
+    propsSchemaHash: metadata.propsSchemaHash,
+    ...styleBytes && styleBundlePath ? {
+      styleBundleHash: sha256(styleBytes),
+      styleBundlePath
+    } : {}
   };
 };
 var buildAbsoluteMobileCompatibilityRelease = async (options) => {
   const [captured, producerBytes] = await Promise.all([
     captureAbsoluteMobileRouteGraph(options.app),
-    readFile9(options.producerPath)
+    readFile10(options.producerPath)
   ]);
   if (captured.length === 0) {
     throw new TypeError("No instrumented AbsoluteJS mobile page routes were found in the finalized Elysia route graph.");
@@ -2957,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
@@ -3021,16 +3650,17 @@ var captureAbsoluteMobileRouteGraph = async (app) => {
 
 // src/mobile/capacitorBundle.ts
 import {
+  cp,
   copyFile as copyFile5,
-  mkdir as mkdir7,
+  mkdir as mkdir9,
   mkdtemp as mkdtemp4,
-  readFile as readFile10,
-  rename as rename8,
+  readFile as readFile11,
+  rename as rename9,
   rm as rm7,
-  writeFile as writeFile8
+  writeFile as writeFile10
 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { basename as basename2, dirname as dirname5, extname, join as join8, 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;
@@ -3303,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",
@@ -3358,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",
@@ -3456,19 +4098,51 @@ var resolveAbsoluteMobileDeepLink = (manifest, value) => {
   }
   return `${url.pathname || "/"}${url.search}${url.hash}`;
 };
+var resolveAbsoluteMobileNavigation = (manifest, value, localOrigin) => {
+  const url = new URL(value, `${localOrigin}/`);
+  const local = new URL(localOrigin);
+  const production = new URL(manifest.productionOrigin);
+  const matches = (candidate, allowed) => candidate.protocol === allowed.protocol && candidate.host === allowed.host;
+  if (!matches(url, local) && !matches(url, production)) {
+    return;
+  }
+  return `${url.pathname}${url.search}${url.hash}`;
+};
 
 // src/mobile/capacitorBundle.ts
 var MANIFEST_FILE = "absolute-mobile-manifest.json";
 var BOOTSTRAP_FILE = "absolute-mobile-bootstrap.js";
 var INDEX_FILE = "index.html";
-var CLIENT_IMPORT_PATTERN = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s*)["'](\/[^"']+)["']/gu;
+var CLIENT_CSS_DEPENDENCY_PATTERN = /(?:@import\s+(?:url\(\s*)?|url\(\s*)["']?((?:\/|\.\.\/|\.\/)[^"')\s]+)["']?\s*\)?/gu;
+var CLIENT_MARKUP_DEPENDENCY_PATTERN = /<(?:script\b[^>]*\bsrc|link\b[^>]*\bhref|img\b[^>]*\bsrc|source\b[^>]*\bsrcset)\s*=\s*["']((?:\/|\.\.\/|\.\/)[^"',\s]+)/giu;
+var CAPACITOR_CLIENT_FRAMEWORKS = new Set([
+  "angular",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var CLIENT_ASSET_DIRECTORIES = ["assets", "html", "htmx", "indexes"];
 var errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
 var shellBootstrapModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join8(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
 };
+var shellAuthModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellAuth.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile auth shell module is missing.");
+};
+var shellSyncModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellSync.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile Sync shell module is missing.");
+};
 var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 var indexHtml = (appName) => `<!doctype html>
 <html>
@@ -3492,11 +4166,16 @@ var sourceAssetPath = (buildDirectory, bundlePath) => {
   }
   return asset;
 };
-var buildShellBootstrap = async (staging) => {
+var buildShellBootstrap = async (staging, auth, sync) => {
   const modulePath = shellBootstrapModule();
-  const entryPath = join8(staging, ".absolute-mobile-entry.ts");
-  await writeFile8(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
-void startAbsoluteMobileShell();
+  const authImport = auth ? `import { createAbsoluteMobileShellAuth } from ${JSON.stringify(shellAuthModule())};
+` : "";
+  const options = auth ? `{ createAuth: createAbsoluteMobileShellAuth${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }` : "";
+  const syncImport = sync ? `import { installAbsoluteMobileShellSync } from ${JSON.stringify(shellSyncModule())};
+` : "";
+  const entryPath = join9(staging, ".absolute-mobile-entry.ts");
+  await writeFile10(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+${authImport}${syncImport}void startAbsoluteMobileShell(${options});
 `);
   const build = await Bun.build({
     entrypoints: [entryPath],
@@ -3507,7 +4186,7 @@ void startAbsoluteMobileShell();
   if (!build.success || build.outputs.length !== 1) {
     throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
   }
-  await rename8(build.outputs[0]?.path ?? "", join8(staging, BOOTSTRAP_FILE));
+  await rename9(build.outputs[0]?.path ?? "", join9(staging, BOOTSTRAP_FILE));
   await rm7(entryPath, { force: true });
 };
 var removePreviousBundle = async (backup, moved) => {
@@ -3518,20 +4197,20 @@ var removePreviousBundle = async (backup, moved) => {
 var restorePreviousBundle = async (backup, destination, moved) => {
   if (!moved)
     return;
-  await rename8(backup, destination);
+  await rename9(backup, destination);
 };
 var installBundle = async (staging, destination) => {
   const backup = `${destination}.previous-${crypto.randomUUID()}`;
   let movedPrevious = false;
   try {
-    await rename8(destination, backup);
+    await rename9(destination, backup);
     movedPrevious = true;
   } catch (error) {
     if (!errorHasCode2(error, "ENOENT"))
       throw error;
   }
   try {
-    await rename8(staging, destination);
+    await rename9(staging, destination);
     await removePreviousBundle(backup, movedPrevious);
   } catch (error) {
     await restorePreviousBundle(backup, destination, movedPrevious);
@@ -3539,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, join8(staging, localBundlePath));
+  await copyFile5(source, join9(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
-  return { ...page, localBundlePath };
+  let localStylePath;
+  if (page.styleBundlePath && page.styleBundleHash) {
+    const styleExtension = extname2(page.styleBundlePath) || ".css";
+    localStylePath = `./styles/${page.styleBundleHash}${styleExtension}`;
+    const styleSource = sourceAssetPath(buildDirectory, page.styleBundlePath);
+    await mkdir9(dirname7(join9(staging, localStylePath)), {
+      recursive: true
+    });
+    await copyFile5(styleSource, join9(staging, localStylePath));
+    await copyAbsoluteClientDependencies(styleSource, buildDirectory, staging, copiedDependencies);
+  }
+  return {
+    ...page,
+    localBundlePath,
+    ...localStylePath ? { localStylePath } : {}
+  };
 };
-var absoluteClientImports = async (sourcePath) => {
-  const source = await readFile10(sourcePath, "utf8");
-  return [...source.matchAll(CLIENT_IMPORT_PATTERN)].flatMap((match) => {
-    const [specifier] = match.slice(1);
-    return specifier ? [specifier.split(/[?#]/u, 1)[0] ?? specifier] : [];
+var absoluteClientImports = async (sourcePath, buildDirectory) => {
+  const source = await readFile11(sourcePath, "utf8");
+  const extension = extname2(sourcePath).toLowerCase();
+  let scriptLoader;
+  if (extension === ".tsx")
+    scriptLoader = "tsx";
+  else if (extension === ".ts")
+    scriptLoader = "ts";
+  else if (extension === ".jsx")
+    scriptLoader = "jsx";
+  else if ([".js", ".mjs", ".cjs"].includes(extension))
+    scriptLoader = "js";
+  const scriptImports = scriptLoader ? new Bun.Transpiler({ loader: scriptLoader }).scanImports(source).map(({ path }) => path) : [];
+  const cssImports = extension === ".css" ? [...source.matchAll(CLIENT_CSS_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  const markupImports = extension === ".html" ? [...source.matchAll(CLIENT_MARKUP_DEPENDENCY_PATTERN)].flatMap((match) => match[1] ?? []) : [];
+  return [...scriptImports, ...cssImports, ...markupImports].flatMap((specifier) => {
+    if (!specifier)
+      return [];
+    if (!specifier.startsWith("/") && !specifier.startsWith("./") && !specifier.startsWith("../")) {
+      return [];
+    }
+    const clean = specifier.split(/[?#]/u, 1)[0] ?? specifier;
+    if (clean.startsWith("/"))
+      return [clean];
+    const resolved = resolve9(dirname7(sourcePath), clean);
+    const root = resolve9(buildDirectory);
+    const relativePath = relative8(root, resolved).replaceAll("\\", "/");
+    if (relativePath === ".." || relativePath.startsWith("../")) {
+      throw new TypeError(`Mobile client dependency escaped the build directory: ${specifier}`);
+    }
+    return [`/${relativePath}`];
   });
 };
 var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, copied) => {
@@ -3561,13 +4281,13 @@ var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, co
     return;
   copied.add(specifier);
   const source = sourceAssetPath(buildDirectory, specifier);
-  const destination = join8(staging, specifier.replace(/^\/+/, ""));
-  await mkdir7(dirname5(destination), { recursive: true });
+  const destination = join9(staging, specifier.replace(/^\/+/, ""));
+  await mkdir9(dirname7(destination), { recursive: true });
   await copyFile5(source, destination);
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
 };
 var copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
-  const dependencies = await absoluteClientImports(sourcePath);
+  const dependencies = await absoluteClientImports(sourcePath, buildDirectory);
   await Promise.all(dependencies.map((specifier) => copyAbsoluteClientDependency(specifier, buildDirectory, staging, copied)));
 };
 var materializeAbsoluteCapacitorWebBundle = async (options) => {
@@ -3575,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 mkdir7(dirname5(destination), { recursive: true });
-  const staging = await mkdtemp4(join8(dirname5(destination), `.${basename2(destination)}.stage-`));
+  await mkdir9(dirname7(destination), { recursive: true });
+  const staging = await mkdtemp4(join9(dirname7(destination), `.${basename3(destination)}.stage-`));
   try {
-    const pageDirectory = join8(staging, "pages");
-    await mkdir7(pageDirectory, { recursive: true });
+    const pageDirectory = join9(staging, "pages");
+    await mkdir9(pageDirectory, { recursive: true });
+    await Promise.all(CLIENT_ASSET_DIRECTORIES.map((directory) => ({
+      destination: join9(staging, directory),
+      source: join9(options.buildDirectory, directory)
+    })).filter(({ source }) => existsSync2(source)).map(({ destination: assetDestination, source }) => cp(source, assetDestination, { recursive: true })));
     const copiedDependencies = new Set;
     const pages = await Promise.all(options.artifact.pages.map((page) => copyClientPage(page, options.buildDirectory, staging, copiedDependencies)));
     const manifest = {
       appBuild: options.artifact.appBuild,
+      ...options.auth ? { auth: options.auth } : {},
       appId: options.config.appId,
       appName: options.config.appName,
       deepLinkHosts: options.config.deepLinkHosts,
@@ -3593,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([
-      writeFile8(join8(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+      writeFile10(join9(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
-      writeFile8(join8(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;
@@ -3610,17 +4336,17 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
 };
 
 // src/mobile/materializedBundle.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import {
   access as access8,
-  mkdir as mkdir8,
+  mkdir as mkdir10,
   mkdtemp as mkdtemp5,
-  readFile as readFile11,
-  rename as rename9,
+  readFile as readFile12,
+  rename as rename10,
   rm as rm8,
-  writeFile as writeFile9
+  writeFile as writeFile11
 } from "fs/promises";
-import { dirname as dirname6, join as join9, resolve as resolvePath2 } from "path";
+import { dirname as dirname8, join as join10, resolve as resolvePath3 } from "path";
 import { pathToFileURL } from "url";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1;
 var CURRENT_BUNDLE_FILE = "current.json";
@@ -3634,7 +4360,7 @@ var bundleIdFor = (currentReleaseId, releases) => {
     currentReleaseId,
     releases: releases.map(({ releaseId }) => releaseId)
   });
-  return `amb_${createHash8("sha256").update(identity).digest("hex")}`;
+  return `amb_${createHash9("sha256").update(identity).digest("hex")}`;
 };
 var parseBundleIndex = (value) => {
   if (!isRecord7(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
@@ -3660,17 +4386,17 @@ var parseBundleIndex = (value) => {
   };
 };
 var writeRelease = async (root, release) => {
-  const directory = join9(root, release.artifact.releaseId);
-  const producerPath = join9(directory, release.artifact.producer.module);
-  await mkdir8(dirname6(producerPath), { recursive: true });
+  const directory = join10(root, release.artifact.releaseId);
+  const producerPath = join10(directory, release.artifact.producer.module);
+  await mkdir10(dirname8(producerPath), { recursive: true });
   await Promise.all([
-    writeFile9(join9(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile11(join10(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
-    writeFile9(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+    writeFile11(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 };
 var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join9(bundlesRoot, bundleId);
+  const destination = join10(bundlesRoot, bundleId);
   try {
     await access8(destination);
     return destination;
@@ -3678,10 +4404,10 @@ var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
     if (!errorHasCode3(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp5(join9(bundlesRoot, ".stage-"));
+  const staging = await mkdtemp5(join10(bundlesRoot, ".stage-"));
   try {
     await Promise.all(releases.map((release) => writeRelease(staging, release)));
-    await rename9(staging, destination);
+    await rename10(staging, destination);
   } catch (error) {
     await rm8(staging, { force: true, recursive: true });
     if (errorHasCode3(error, "EEXIST") || errorHasCode3(error, "ENOTEMPTY")) {
@@ -3711,16 +4437,16 @@ var resolveProducerHandler = (loaded, exportName) => {
   };
 };
 var loadAbsoluteMobileMaterializedBundle = async (root) => {
-  const resolvedRoot = resolvePath2(root);
-  const serialized = await readFile11(join9(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+  const resolvedRoot = resolvePath3(root);
+  const serialized = await readFile12(join10(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
   const parsed = JSON.parse(serialized);
   const index = parseBundleIndex(parsed);
-  const bundleRoot = join9(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+  const bundleRoot = join10(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
   return {
     artifacts: index.releases,
     currentReleaseId: index.currentReleaseId,
     loadProducer: async (artifact) => {
-      const modulePath = join9(bundleRoot, artifact.releaseId, artifact.producer.module);
+      const modulePath = join10(bundleRoot, artifact.releaseId, artifact.producer.module);
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer: Bun.file(modulePath)
@@ -3746,9 +4472,9 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     }
     return release;
   });
-  const root = resolvePath2(input.root);
-  const bundlesRoot = join9(root, BUNDLES_DIRECTORY);
-  await mkdir8(bundlesRoot, { recursive: true });
+  const root = resolvePath3(input.root);
+  const bundlesRoot = join10(root, BUNDLES_DIRECTORY);
+  await mkdir10(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
   const index = {
@@ -3757,22 +4483,22 @@ var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
     format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
     releases: artifacts
   };
-  const pointerPath = join9(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join9(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile9(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+  const pointerPath = join10(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join10(root, `.current-${crypto.randomUUID()}.json`);
+  await writeFile11(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
 `, { flag: "wx" });
-  await rename9(temporaryPointerPath, pointerPath);
+  await rename10(temporaryPointerPath, pointerPath);
   return index;
 };
 var readAbsoluteMobileMaterializedReleases = async (root) => {
-  const resolvedRoot = resolvePath2(root);
+  const resolvedRoot = resolvePath3(root);
   try {
-    const serialized = await readFile11(join9(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const serialized = await readFile12(join10(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
     const parsed = JSON.parse(serialized);
     const index = parseBundleIndex(parsed);
-    const bundleRoot = join9(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    const bundleRoot = join10(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
     return Promise.all(index.releases.map(async (artifact) => {
-      const producer = Bun.file(join9(bundleRoot, artifact.releaseId, artifact.producer.module));
+      const producer = Bun.file(join10(bundleRoot, artifact.releaseId, artifact.producer.module));
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer
@@ -3786,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");
@@ -3796,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);
@@ -3823,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 = join10(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join12(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile12(join10(buildDirectory, "manifest.json"), "utf8"),
+    readFile13(join12(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -3833,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,
@@ -3850,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
@@ -3862,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;
 };
@@ -3888,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));
@@ -3915,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;
@@ -3938,23 +4791,28 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
       console.error(`[Mobile] Failed to load retained producer ${resolved.artifact.releaseId}:`, error);
       return createAbsoluteMobilePageErrorResponse(parsed.client.pageId);
     }
+  }).afterHandle("global", ({ request, responseValue }) => {
+    const origin = mobileWebViewOrigin(request);
+    if (!origin || !(responseValue instanceof Response))
+      return;
+    applyMobileCorsHeaders(responseValue, origin);
   }).as("global");
 };
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile13, rename as rename10, writeFile as writeFile10 } from "fs/promises";
-import { join as join11 } 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";
 var NOT_FOUND = -1;
 var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var writeChangedFile = async (path, source) => {
-  const current = await readFile13(path, "utf8");
+  const current = await readFile14(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile10(temporary, source, { flag: "wx" });
-  await rename10(temporary, path);
+  await writeFile12(temporary, source, { flag: "wx" });
+  await rename11(temporary, path);
   return true;
 };
 var replaceManagedRegion = (source, region, insertAt) => {
@@ -3999,8 +4857,8 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join11(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile13(path, "utf8");
+  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) {
     throw new TypeError("Android MainActivity was not found.");
@@ -4025,8 +4883,8 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join11(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile13(path, "utf8");
+  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}
 `;
@@ -4049,10 +4907,10 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join11(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join13(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
-    current = await readFile13(path, "utf8");
+    current = await readFile14(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -4062,13 +4920,13 @@ var configureIosEntitlements = async (config) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile10(temporary, source, { flag: "wx" });
-  await rename10(temporary, path);
+  await writeFile12(temporary, source, { flag: "wx" });
+  await rename11(temporary, path);
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join11(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const source = await readFile13(path, "utf8");
+  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)
   ].map((match) => match[1]);
@@ -4107,7 +4965,7 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
 };
 // src/mobile/releasePublisher.ts
 import { access as access9 } from "fs/promises";
-import { isAbsolute as isAbsolute5, relative as relative7, resolve as resolve11, sep as sep5 } 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") {
@@ -4135,8 +4993,8 @@ var isPublisher = (value) => isRecord8(value) && typeof value.publish === "funct
 var publisherModulePath = (projectRoot, requested) => {
   const root = resolve11(projectRoot);
   const path = resolve11(root, requested);
-  const projectRelative = relative7(root, path);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep5}`) || isAbsolute5(projectRelative)) {
+  const projectRelative = relative9(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute6(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
   return path;
@@ -4204,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 dirname7, extname as extname2, relative as relative8, 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(dirname7(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) {
@@ -4223,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, dirname7(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);
@@ -4329,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(relative8(projectRoot, file));
+  const source = posixPath(relative10(projectRoot, file));
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
@@ -4361,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);
@@ -4386,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;
-  const props = objectPropertyExpression(input, "props");
-  const index = objectPropertyExpression(input, "index");
-  const bundleKey = assetKey(index, checker);
+  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, 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}`
@@ -4466,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;
@@ -4532,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"
         };
       });
     }
@@ -4543,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(relative8(projectRoot, file)),
+    file: posixPath(relative10(projectRoot, file)),
     metadata
   })));
 };
@@ -4552,17 +5597,27 @@ export {
   waitForAbsoluteIosHmrLog,
   verifyAbsoluteMobileCompatibilityProducer,
   verifyAbsoluteMobileAssociationFiles,
+  validateAbsoluteSshDestination,
+  validateAbsoluteRemoteMacProfileName,
+  syncAbsoluteRemoteMacProject,
+  startAbsoluteRemoteIosDevSession,
   startAbsoluteIosDevSession,
+  serializeAbsoluteMobileAuthEnvironment,
   runWithAbsoluteMobileProducer,
   retainAbsoluteMobileCompatibilityArtifacts,
   resolveAbsoluteMobileRoute,
+  resolveAbsoluteMobileNavigation,
   resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
+  resolveAbsoluteMobileAuthManifest,
   repairAbsoluteIosDevSession,
+  removeAbsoluteRemoteMacProfile,
   redactAbsoluteIosLog,
   readAbsoluteMobileMaterializedReleases,
   publishAbsoluteIosRelease,
   publishAbsoluteAndroidRelease,
+  projectUsesAbsoluteSync,
+  projectUsesAbsoluteAuth,
   prepareAbsoluteIosRelease,
   prepareAbsoluteIosDevProject,
   prepareAbsoluteAndroidRelease,
@@ -4575,23 +5630,32 @@ export {
   parseAbsoluteMobileBuildPageMetadata,
   parseAbsoluteIosLogLine,
   parseAbsoluteIosHmrLog,
+  pairAbsoluteRemoteMac,
   normalizeAbsoluteMobileConfig,
   navigateAbsoluteMobilePage,
+  materializeAbsoluteRemoteMacAgent,
   materializeAbsoluteMobileCompatibilityBundle,
   materializeAbsoluteMobileAssociationFiles,
   materializeAbsoluteCapacitorWebBundle,
   matchesAbsoluteMobileRoutePattern,
   loadAbsoluteNativeReleasePublisher,
   loadAbsoluteMobileMaterializedBundle,
+  listAbsoluteRemoteMacProfiles,
   isAbsoluteIosNativeRootInput,
+  installAbsoluteRemoteMacAgent,
+  installAbsoluteMobileAuthEnvironment,
+  inspectAbsoluteRemoteMac,
   inspectAbsoluteMobileRouteMetadata,
   hashAbsoluteMobilePropsSchema,
   getCurrentAbsoluteMobileProducerContext,
+  getAbsoluteRemoteMacProfile,
   fingerprintAbsoluteIosNativeProject,
   fingerprintAbsoluteIosDevProject,
   finalizeAbsoluteMobilePage,
   finalizeAbsoluteMobileCompatibilityBuild,
   fetchAbsoluteMobilePage,
+  disposeAbsoluteMobilePage,
+  createAbsoluteRemoteIosDevProject,
   createAbsoluteMobileUpgradeResponse,
   createAbsoluteMobileRouteMetadataPlugin,
   createAbsoluteMobilePageRequest,
@@ -4601,6 +5665,7 @@ export {
   createAbsoluteMobileCompatibilityDispatcher,
   createAbsoluteMobileCompatibilityArtifact,
   createAbsoluteMobileBlobArtifactStore,
+  createAbsoluteMobileAuthManifest,
   createAbsoluteMobileAssociationPlugin,
   createAbsoluteMobileAssociationDocuments,
   createAbsoluteIosNativeWatcher,
@@ -4612,10 +5677,17 @@ export {
   applyAbsoluteNativeDeepLinks,
   activateAbsoluteMobilePage,
   acceptsAbsoluteMobilePage,
+  absoluteRemoteProjectSyncCommands,
+  absoluteRemoteMacSshBase,
   MOBILE_PAGE_REQUEST_HEADERS,
   AbsoluteMobilePageProtocolError,
   APPLE_ASSOCIATION_PATH,
   ANDROID_ASSOCIATION_PATH,
+  ABSOLUTE_SYNC_PACKAGE,
+  ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION,
+  ABSOLUTE_REMOTE_MAC_EVENT_PREFIX,
+  ABSOLUTE_NATIVE_AUTH_SCOPES,
+  ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV,
   ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL,
   ABSOLUTE_MOBILE_ROUTE_DETAIL,
   ABSOLUTE_MOBILE_RETAINED_GENERATIONS,
@@ -4626,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=048422942BB9C32864756E2164756E21
+//# debugId=7AFC88B0A927AFE564756E2164756E21
 //# sourceMappingURL=index.js.map