@absolutejs/absolute 0.20.0-beta.39 → 0.20.0-beta.40

package/dist/cli/index.js

@@ -791,7 +791,26 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     }
     return value.match(/.{2}/g)?.join(":") ?? value;
   }))
-].sort(), normalizeAbsoluteMobileConfig = (config, projectRoot) => {
+].sort(), normalizeExpoNativeRoutes = (config, projectRoot) => {
+  if (config.engine !== "expo")
+    return {};
+  const routes = config.routes?.native ?? {};
+  const normalized = {};
+  for (const [route, module] of Object.entries(routes)) {
+    const path = normalizeEntry(route);
+    if (path.includes("?") || path.includes("#") || path !== "/" && path.endsWith("/")) {
+      throw new TypeError(`mobile.routes.native route ${path} must be a canonical path without a query, fragment, or trailing slash.`);
+    }
+    if (path === "/__absolute/native") {
+      throw new TypeError("mobile.routes.native reserves /__absolute/native for the Expo diagnostic screen.");
+    }
+    if (path.includes("*") || path.includes(":")) {
+      throw new TypeError(`mobile.routes.native route ${path} must be static during the Expo experiment; parameters and wildcards are not supported yet.`);
+    }
+    normalized[path] = resolveProjectPath(projectRoot, requireText(module, `mobile.routes.native[${path}]`), `mobile.routes.native[${path}]`);
+  }
+  return Object.fromEntries(Object.entries(normalized).sort(([left], [right]) => left.localeCompare(right)));
+}, normalizeAbsoluteMobileConfig = (config, projectRoot) => {
   const appId = requireText(config.appId, "mobile.appId");
   if (!APP_ID_PATTERN.test(appId)) {
     throw new TypeError("mobile.appId must use reverse-domain notation, for example com.example.app.");
@@ -809,10 +828,12 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     bundleDirectory: resolveProjectPath(projectRoot, config.bundleDirectory ?? ".absolutejs/mobile/web", "mobile.bundleDirectory"),
     deepLinkHosts: normalizeHosts(config.deepLinks?.hosts, productionOrigin),
     deepLinkScheme,
-    engine: "capacitor",
+    engine: config.engine ?? "capacitor",
     entry: normalizeEntry(config.entry),
+    expoNativeRoutes: normalizeExpoNativeRoutes(config, projectRoot),
+    ...config.engine === "expo" ? { expoSdkVersion: config.expo?.sdkVersion ?? 57 } : {},
     iosVersion: normalizeIosVersion(config.ios?.version),
-    nativeProjectDirectory: resolveProjectPath(projectRoot, config.nativeProject?.directory ?? "mobile", "mobile.nativeProject.directory"),
+    nativeProjectDirectory: resolveProjectPath(projectRoot, config.nativeProject?.directory ?? (config.engine === "expo" ? ".absolutejs/mobile/expo" : "mobile"), "mobile.nativeProject.directory"),
     platforms: normalizePlatforms(config.platforms),
     productionOrigin,
     pushAndroidGoogleServicesFile: resolveProjectPath(projectRoot, config.pushNotifications?.android?.googleServicesFile ?? "google-services.json", "mobile.pushNotifications.android.googleServicesFile")
@@ -6420,6 +6441,11 @@ var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile push shell module is missing.");
+}, shellExpoDevicesModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join17(import.meta.dir, `shellExpoDevices.${extension}`)).find(existsSync9);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS Expo device bridge module is missing.");
 }, escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;"), contentSecurityPolicy = (productionOrigin) => {
   const backend = new URL(productionOrigin);
   const socketOrigin = `${backend.protocol === "https:" ? "wss:" : "ws:"}//${backend.host}`;
@@ -6474,18 +6500,20 @@ var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-
   if (!resolved.startsWith(`${resolve14(packageDirectory)}/`))
     throw new TypeError(`${specifier} has an unsafe import entry.`);
   return resolved;
-}, buildShellBootstrap = async (staging, auth, sync, storagePrefix, deviceCapabilities, projectRoot) => {
+}, buildShellBootstrap = async (staging, auth, sync, storagePrefix, engine, deviceCapabilities, projectRoot) => {
+  const capacitor = engine !== "expo";
+  const shellCapabilities = capacitor ? deviceCapabilities.capabilities : [];
   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 pushIndex = deviceCapabilities.capabilities.indexOf("pushNotifications");
+  const pushIndex = shellCapabilities.indexOf("pushNotifications");
   const push = pushIndex !== -1;
   const pushImport = push ? `import { createAbsoluteMobileShellPush } from ${JSON.stringify(shellPushModule())};
 ` : "";
-  const capabilityImports = (await Promise.all(deviceCapabilities.capabilities.map(async (name, index) => {
+  const capabilityImports = (await Promise.all(shellCapabilities.map(async (name, index) => {
     const provider = deviceCapabilities.providers[name];
     if (!provider)
       throw new TypeError(`Missing device capability provider ${name}.`);
@@ -6495,14 +6523,22 @@ var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-
   const pushSetup = push ? `const absoluteMobilePush = createAbsoluteMobileShellPush();
 const absoluteMobilePushCapability = absoluteDeviceCapability${pushIndex}(absoluteMobilePush.capabilityOptions);
 ` : "";
-  const capabilityOptions = deviceCapabilities.capabilities.map((name, index) => `${JSON.stringify(name)}: ${name === "pushNotifications" ? "absoluteMobilePushCapability" : `absoluteDeviceCapability${index}()`}`).join(", ");
+  const capabilityOptions = shellCapabilities.map((name, index) => `${JSON.stringify(name)}: ${name === "pushNotifications" ? "absoluteMobilePushCapability" : `absoluteDeviceCapability${index}()`}`).join(", ");
   const entryPath = join17(staging, ".absolute-mobile-entry.ts");
-  const baseAdapterModule = await resolveProjectImport(projectRoot, "@absolutejs/devices-capacitor");
+  const baseAdapterModule = capacitor ? await resolveProjectImport(projectRoot, "@absolutejs/devices-capacitor") : shellExpoDevicesModule();
+  const adapterImport = capacitor ? `import { installCapacitorDeviceAdapterIfNative } from ${JSON.stringify(baseAdapterModule)};` : `import { createAbsoluteExpoBridgeFetch, installAbsoluteExpoWebDeviceAdapter } from ${JSON.stringify(baseAdapterModule)};`;
+  const adapterInstall = capacitor ? `installCapacitorDeviceAdapterIfNative({ storagePrefix: ${JSON.stringify(storagePrefix)}${capabilityOptions ? `, ${capabilityOptions}` : ""} });` : "installAbsoluteExpoWebDeviceAdapter();";
+  let shellOptions = "{ createFetch: createAbsoluteExpoBridgeFetch }";
+  if (capacitor)
+    shellOptions = options;
+  if (push) {
+    shellOptions = `{ createAuth: (config, options) => createAbsoluteMobileShellAuth(config, options), beforeSignOut: absoluteMobilePush.beforeSignOut, connectPush: (auth) => absoluteMobilePush.connect(auth, absoluteMobilePushCapability)${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }`;
+  }
   await writeFile7(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
-import { installCapacitorDeviceAdapterIfNative } from ${JSON.stringify(baseAdapterModule)};
+${adapterImport}
 ${authImport}${syncImport}${pushImport}${capabilityImports}
-${pushSetup}installCapacitorDeviceAdapterIfNative({ storagePrefix: ${JSON.stringify(storagePrefix)}${capabilityOptions ? `, ${capabilityOptions}` : ""} });
-void startAbsoluteMobileShell(${push ? `{ createAuth: (config, options) => createAbsoluteMobileShellAuth(config, options), beforeSignOut: absoluteMobilePush.beforeSignOut, connectPush: (auth) => absoluteMobilePush.connect(auth, absoluteMobilePushCapability)${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }` : options});
+${pushSetup}${adapterInstall}
+void startAbsoluteMobileShell(${shellOptions});
 `);
   const build = await Bun.build({
     entrypoints: [entryPath],
@@ -6658,7 +6694,7 @@ void startAbsoluteMobileShell(${push ? `{ createAuth: (config, options) => creat
       writeFile7(join17(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
       writeFile7(join17(staging, INDEX_FILE), indexHtml(options.config.appName, options.config.productionOrigin)),
-      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true, `absolutejs.${options.auth?.clientId ?? options.config.appId}.`, options.deviceCapabilities, options.projectRoot)
+      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true, `absolutejs.${options.auth?.clientId ?? options.config.appId}.`, options.config.engine, options.deviceCapabilities, options.projectRoot)
     ]);
     await installBundle(staging, destination);
     return manifest;
@@ -7509,9 +7545,523 @@ var init_deviceCapabilities = __esm(() => {
   ];
 });
 
+// src/mobile/expoProject.ts
+import {
+  access as access7,
+  cp as cp3,
+  mkdir as mkdir10,
+  mkdtemp as mkdtemp5,
+  readdir as readdir3,
+  readFile as readFile11,
+  rename as rename8,
+  rm as rm7,
+  writeFile as writeFile9
+} from "fs/promises";
+import { createHash as createHash11 } from "crypto";
+import { basename as basename8, dirname as dirname13, join as join21, relative as relative12, resolve as resolve17 } from "path";
+var EXPO_GENERATED_HEADER = `// Generated by AbsoluteJS. Edit absolute.config.ts, then run absolute mobile sync.
+`, EXPO_ASSET_EXTENSION = ".absasset", EXPO_PROJECT_MARKER = ".absolutejs-expo-project", exists2 = async (path) => {
+  try {
+    await access7(path);
+    return true;
+  } catch {
+    return false;
+  }
+}, portableRelative2 = (from, destination) => {
+  const value = relative12(from, destination).replaceAll("\\", "/");
+  return value.startsWith(".") ? value : `./${value}`;
+}, routeSegments = (route) => route.split("/").filter(Boolean).map((segment) => {
+  if (segment.startsWith(":"))
+    return `[${segment.slice(1)}]`;
+  if (segment === "." || segment === ".." || !/^[A-Za-z0-9._~-]+$/u.test(segment)) {
+    throw new TypeError(`Expo native route ${route} contains an unsupported segment ${segment}.`);
+  }
+  return segment;
+}), routeFile = (project, route) => join21(project, "app", ...routeSegments(route), "index.tsx"), expoPackage = () => ({
+  dependencies: {
+    expo: "~57.0.9",
+    "expo-asset": "~57.0.15",
+    "expo-constants": "~57.0.16",
+    "expo-file-system": "~57.0.6",
+    "expo-haptics": "~57.0.2",
+    "expo-linking": "~57.0.8",
+    "expo-router": "~57.0.17",
+    react: "19.2.3",
+    "react-native": "0.86.3",
+    "react-native-safe-area-context": "~5.7.0",
+    "react-native-screens": "4.26.0",
+    "react-native-webview": "13.16.1"
+  },
+  devDependencies: {
+    "@types/react": "~19.2.2",
+    typescript: "~6.0.3"
+  },
+  main: "expo-router/entry",
+  name: "absolutejs-expo-shell",
+  private: true,
+  scripts: {
+    android: "expo run:android",
+    ios: "expo run:ios",
+    start: "expo start --dev-client"
+  },
+  version: "0.0.0"
+}), expoAppConfig = (config) => ({
+  expo: {
+    android: {
+      intentFilters: config.deepLinkHosts.map((host2) => ({
+        action: "VIEW",
+        autoVerify: true,
+        category: ["BROWSABLE", "DEFAULT"],
+        data: [{ host: host2, pathPrefix: "/", scheme: "https" }]
+      })),
+      package: config.appId
+    },
+    experiments: { typedRoutes: true },
+    ios: {
+      associatedDomains: config.deepLinkHosts.map((host2) => `applinks:${host2}`),
+      bundleIdentifier: config.appId,
+      ...config.iosVersion ? { buildNumber: config.iosVersion } : {}
+    },
+    name: config.appName,
+    plugins: ["expo-router"],
+    runtimeVersion: { policy: "appVersion" },
+    scheme: config.deepLinkScheme,
+    slug: config.appId.toLowerCase().replaceAll(".", "-"),
+    version: config.iosVersion ?? "0.1.0"
+  }
+}), metroConfig = (projectRoot) => `${EXPO_GENERATED_HEADER}const { getDefaultConfig } = require('expo/metro-config');
+const path = require('node:path');
+
+const projectRoot = __dirname;
+const appRoot = ${JSON.stringify(projectRoot)};
+const config = getDefaultConfig(projectRoot);
+config.resolver.assetExts.push('absasset');
+config.resolver.nodeModulesPaths = [
+	path.join(projectRoot, 'node_modules'),
+	path.join(appRoot, 'node_modules')
+];
+config.watchFolders = [appRoot];
+
+module.exports = config;
+`, layoutSource, nativeDiagnosticSource, webHostSource = (config) => {
+  const nativeRoutes = [
+    "/__absolute/native",
+    ...Object.keys(config.expoNativeRoutes)
+  ];
+  return `${EXPO_GENERATED_HEADER}import * as Haptics from 'expo-haptics';
+import * as Linking from 'expo-linking';
+import { router, usePathname } from 'expo-router';
+import { useEffect, useRef, useState } from 'react';
+import { ActivityIndicator, BackHandler, StyleSheet, View } from 'react-native';
+import { WebView, type WebViewMessageEvent } from 'react-native-webview';
+import { materializeAbsoluteWebBundle } from './webAssets';
+
+const BRIDGE_FORMAT = 1;
+const MAX_MESSAGE_BYTES = 64 * 1024;
+const MAX_HTTP_BODY_BYTES = 48 * 1024;
+const NATIVE_ROUTES = new Set(${JSON.stringify(nativeRoutes)});
+const PRODUCTION_ORIGIN = ${JSON.stringify(config.productionOrigin)};
+
+const bridgeBootstrap = (path: string) => \`(() => {
+	const pending = new Map();
+	let sequence = 0;
+	let currentPath = \${JSON.stringify(path)};
+	const send = value => {
+		const source = JSON.stringify(value);
+		if (new TextEncoder().encode(source).byteLength > 65536) throw new Error('Expo bridge message exceeds 64 KiB.');
+		window.ReactNativeWebView.postMessage(source);
+	};
+	globalThis.__absoluteExpoReceive = source => {
+		const message = JSON.parse(source);
+		const operation = pending.get(message.id);
+		if (!operation) return;
+		pending.delete(message.id);
+		clearTimeout(operation.timer);
+		message.error ? operation.reject(new Error(message.error.message)) : operation.resolve(message.result);
+	};
+	globalThis.__absoluteExpoBridge = {
+		request(method, params) {
+			const id = 'web_' + Date.now().toString(36) + '_' + (++sequence).toString(36);
+			send({ format: 1, id, kind: 'request', method, params, path: currentPath });
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					pending.delete(id);
+					reject(new Error('Expo bridge request timed out.'));
+				}, 10000);
+				pending.set(id, { reject, resolve, timer });
+			});
+		},
+		setPath(path) {
+			currentPath = path;
+			send({ format: 1, kind: 'event', event: 'navigation', path });
+		}
+	};
+	document.addEventListener('click', event => {
+		const anchor = event.target instanceof Element ? event.target.closest('a[href]') : null;
+		if (!anchor) return;
+		const url = new URL(anchor.href, location.href);
+		if (!${JSON.stringify(nativeRoutes)}.includes(url.pathname)) return;
+		event.preventDefault();
+		send({ format: 1, kind: 'event', event: 'navigation', path: url.pathname + url.search + url.hash });
+	}, true);
+	send({ format: 1, kind: 'event', event: 'ready', path: \${JSON.stringify(path)} });
+})(); true;\`;
+
+const impact = async (params: Record<string, unknown>) => {
+	const style = params.style;
+	if (style === 'selection') return Haptics.selectionAsync();
+	if (style === 'success' || style === 'warning' || style === 'error') {
+		const value = style === 'success' ? Haptics.NotificationFeedbackType.Success : style === 'warning' ? Haptics.NotificationFeedbackType.Warning : Haptics.NotificationFeedbackType.Error;
+		return Haptics.notificationAsync(value);
+	}
+	const value = style === 'light' ? Haptics.ImpactFeedbackStyle.Light : style === 'heavy' ? Haptics.ImpactFeedbackStyle.Heavy : Haptics.ImpactFeedbackStyle.Medium;
+	return Haptics.impactAsync(value);
+};
+
+const bridgeFetch = async (params: Record<string, unknown>) => {
+	if (params.method !== 'GET' || typeof params.url !== 'string' || typeof params.headers !== 'object' || params.headers === null || Array.isArray(params.headers)) throw new Error('Expo bridge HTTP request is invalid.');
+	const url = new URL(params.url);
+	if (url.origin !== PRODUCTION_ORIGIN || url.username || url.password) throw new Error('Expo bridge HTTP request left productionOrigin.');
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(params.headers as Record<string, unknown>)) {
+		const normalized = name.toLowerCase();
+		if (typeof value !== 'string' || (normalized !== 'accept' && !normalized.startsWith('x-absolute-mobile-'))) throw new Error('Expo bridge HTTP header is not allowed.');
+		headers.set(normalized, value);
+	}
+	const response = await fetch(url, { headers, method: 'GET', redirect: 'manual' });
+	if (new URL(response.url || url.href).origin !== PRODUCTION_ORIGIN || response.status >= 300 && response.status < 400) throw new Error('Expo bridge HTTP redirects are not allowed.');
+	const body = await response.text();
+	if (new TextEncoder().encode(body).byteLength > MAX_HTTP_BODY_BYTES) throw new Error('Expo bridge HTTP response exceeds 48 KiB.');
+	const responseHeaders: Record<string, string> = {};
+	for (const name of ['cache-control', 'content-type']) {
+		const value = response.headers.get(name);
+		if (value) responseHeaders[name] = value;
+	}
+	return { body, headers: responseHeaders, status: response.status };
+};
+
+export function AbsoluteWebHost() {
+	const pathname = usePathname() || '/';
+	const webView = useRef<WebView>(null);
+	const [indexUri, setIndexUri] = useState<string>();
+	const [canGoBack, setCanGoBack] = useState(false);
+	const activeWebPath = useRef(pathname);
+
+	useEffect(() => { void materializeAbsoluteWebBundle().then(setIndexUri); }, []);
+	useEffect(() => {
+		const subscription = BackHandler.addEventListener('hardwareBackPress', () => {
+			if (!canGoBack) return false;
+			webView.current?.goBack();
+			return true;
+		});
+		return () => subscription.remove();
+	}, [canGoBack]);
+
+	const respond = (message: Record<string, unknown>) => {
+		const source = JSON.stringify(message).replaceAll('\\u2028', '\\\\u2028').replaceAll('\\u2029', '\\\\u2029');
+		if (new TextEncoder().encode(source).byteLength > MAX_MESSAGE_BYTES) throw new Error('Expo bridge response exceeds 64 KiB.');
+		webView.current?.injectJavaScript(\`globalThis.__absoluteExpoReceive(\${JSON.stringify(source)}); true;\`);
+	};
+	const onMessage = async (event: WebViewMessageEvent) => {
+		const source = event.nativeEvent.data;
+		if (new TextEncoder().encode(source).byteLength > MAX_MESSAGE_BYTES) return;
+		let message: Record<string, unknown>;
+		try { message = JSON.parse(source); } catch { return; }
+		if (message.format !== BRIDGE_FORMAT || typeof message.path !== 'string' || !message.path.startsWith('/') || message.path.startsWith('//')) return;
+		if (message.kind === 'event' && (message.event === 'navigation' || message.event === 'ready')) {
+			const target = new URL(message.path, PRODUCTION_ORIGIN);
+			if (target.origin !== PRODUCTION_ORIGIN) return;
+			if (NATIVE_ROUTES.has(target.pathname)) router.push(message.path as never);
+			else activeWebPath.current = message.path;
+			return;
+		}
+		if (message.kind !== 'request' || typeof message.id !== 'string' || message.path !== activeWebPath.current) return;
+		try {
+			if (typeof message.params !== 'object' || message.params === null || Array.isArray(message.params)) throw new Error('Expo bridge method params are invalid.');
+			if (message.method === 'devices.haptics.impact') {
+				const style = (message.params as Record<string, unknown>).style;
+				if (typeof style !== 'string' || !['error', 'heavy', 'light', 'medium', 'selection', 'success', 'vibrate', 'warning'].includes(style)) throw new Error('Expo bridge haptics style is invalid.');
+				await impact(message.params as Record<string, unknown>);
+				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: null });
+			} else if (message.method === 'http.fetch') {
+				respond({ format: BRIDGE_FORMAT, id: message.id, kind: 'response', result: await bridgeFetch(message.params as Record<string, unknown>) });
+			} else {
+				throw new Error('Expo bridge method is not allowed.');
+			}
+		} catch (error) {
+			respond({ error: { code: 'failed', message: error instanceof Error ? error.message : 'Native operation failed.' }, format: BRIDGE_FORMAT, id: message.id, kind: 'response' });
+		}
+	};
+
+	if (!indexUri) return <View style={styles.loading}><ActivityIndicator /></View>;
+	return <WebView
+		allowFileAccess
+		allowFileAccessFromFileURLs
+		allowUniversalAccessFromFileURLs={false}
+		allowingReadAccessToURL={indexUri.slice(0, indexUri.lastIndexOf('/') + 1)}
+		injectedJavaScriptBeforeContentLoaded={bridgeBootstrap(pathname)}
+		onMessage={onMessage}
+		onNavigationStateChange={state => setCanGoBack(state.canGoBack)}
+		onShouldStartLoadWithRequest={request => {
+			if (request.url.startsWith('file:') || request.url.startsWith(PRODUCTION_ORIGIN)) return true;
+			void Linking.openURL(request.url);
+			return false;
+		}}
+		ref={webView}
+		source={{ uri: indexUri + '?absolutePath=' + encodeURIComponent(pathname) }}
+		style={styles.web}
+	/>;
+}
+
+const styles = StyleSheet.create({ loading: { alignItems: 'center', flex: 1, justifyContent: 'center' }, web: { flex: 1 } });
+`;
+}, webRouteSource, catchAllRouteSource, nativeWrapperSource = (wrapper, module) => `${EXPO_GENERATED_HEADER}export { default } from ${JSON.stringify(portableRelative2(dirname13(wrapper), module).replace(/\.(?:[cm]?[jt]sx?)$/u, ""))};
+`, expoTsConfig = (projectRoot, project) => ({
+  compilerOptions: {
+    paths: {
+      "*": [
+        "./node_modules/*",
+        `${portableRelative2(project, projectRoot)}/node_modules/*`
+      ],
+      react: ["./node_modules/@types/react/index.d.ts"],
+      "react/*": ["./node_modules/@types/react/*"]
+    },
+    strict: true
+  },
+  extends: "expo/tsconfig.base"
+}), writeManagedFile = async (path, source, force) => {
+  await mkdir10(dirname13(path), { recursive: true });
+  if (await exists2(path)) {
+    const current = await readFile11(path, "utf8");
+    if (current === source)
+      return false;
+    if (!force && !current.startsWith(EXPO_GENERATED_HEADER)) {
+      throw new TypeError(`Expo project file ${path} is not AbsoluteJS-managed; rerun with --force only after reviewing it.`);
+    }
+  }
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile9(temporary, source, { flag: "wx" });
+  await rename8(temporary, path);
+  return true;
+}, jsonSource = (value) => `${JSON.stringify(value, null, "\t")}
+`, writeAbsoluteExpoProject = async (config, options) => {
+  if (config.engine !== "expo")
+    throw new TypeError("Expo project generation requires mobile.engine: expo.");
+  const projectRoot = resolve17(options.projectRoot);
+  const project = config.nativeProjectDirectory;
+  const routeModules = Object.entries(config.expoNativeRoutes);
+  const moduleChecks = await Promise.all(routeModules.map(async ([route, module]) => ({
+    exists: await exists2(module),
+    module,
+    route
+  })));
+  const missing = moduleChecks.find((entry) => !entry.exists);
+  if (missing) {
+    throw new TypeError(`Expo native route ${missing.route} references missing module ${missing.module}.`);
+  }
+  const marker = join21(project, EXPO_PROJECT_MARKER);
+  if (await exists2(project) && !await exists2(marker)) {
+    const entries = await readdir3(project);
+    if (entries.length > 0 && !options.force) {
+      throw new TypeError(`Expo project directory ${project} is not AbsoluteJS-managed; rerun with --force only after reviewing it.`);
+    }
+  }
+  await mkdir10(project, { recursive: true });
+  await writeFile9(marker, `format=1
+`);
+  const files = new Map([
+    [
+      join21(project, ".gitignore"),
+      `.expo/
+android/
+ios/
+node_modules/
+`
+    ],
+    [join21(project, "app.json"), jsonSource(expoAppConfig(config))],
+    [join21(project, "package.json"), jsonSource(expoPackage())],
+    [join21(project, "metro.config.js"), metroConfig(projectRoot)],
+    [
+      join21(project, "tsconfig.json"),
+      jsonSource(expoTsConfig(projectRoot, project))
+    ],
+    [join21(project, "app", "_layout.tsx"), layoutSource],
+    [
+      join21(project, "app", "__absolute", "native", "index.tsx"),
+      nativeDiagnosticSource
+    ],
+    [
+      join21(project, "src", "generated", "AbsoluteWebHost.tsx"),
+      webHostSource(config)
+    ]
+  ]);
+  if (!config.expoNativeRoutes["/"]) {
+    files.set(join21(project, "app", "index.tsx"), webRouteSource);
+  }
+  files.set(join21(project, "app", "[...absolute].tsx"), catchAllRouteSource);
+  for (const [route, module] of routeModules) {
+    const wrapper = route === "/" ? join21(project, "app", "index.tsx") : routeFile(project, route);
+    files.set(wrapper, nativeWrapperSource(wrapper, module));
+  }
+  const changes = await Promise.all([...files].map(([path, source]) => writeManagedFile(path, source, true)));
+  const changed = changes.filter(Boolean).length;
+  return { changed, path: project, written: [...files.keys()] };
+}, walkFiles = async (root, directory = root) => {
+  const entries = await readdir3(directory, { withFileTypes: true });
+  const nested = await Promise.all(entries.map((entry) => {
+    const path = join21(directory, entry.name);
+    if (entry.isDirectory())
+      return walkFiles(root, path);
+    if (entry.isFile())
+      return [path];
+    throw new TypeError(`Expo embedded bundle cannot contain a symbolic link or special file: ${path}.`);
+  }));
+  return nested.flat().sort();
+}, renameIfPresent = async (source, destination) => {
+  try {
+    await rename8(source, destination);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}, installStagedDirectory = async (staging, destination) => {
+  const backup = `${destination}.previous-${crypto.randomUUID()}`;
+  const moved = await renameIfPresent(destination, backup);
+  try {
+    await rename8(staging, destination);
+    if (moved)
+      await rm7(backup, { force: true, recursive: true });
+  } catch (error) {
+    if (moved)
+      await rename8(backup, destination);
+    throw error;
+  }
+}, assetModuleSource = (assets, bundleId) => `${EXPO_GENERATED_HEADER}import { Asset } from 'expo-asset';
+import { Directory, File, Paths } from 'expo-file-system';
+
+declare const require: (path: string) => number;
+const BUNDLE_ID = ${JSON.stringify(bundleId)};
+const ASSETS = [
+${assets.map(({ asset, path }) => `	{ module: require(${JSON.stringify(asset)}), path: ${JSON.stringify(path)} }`).join(`,
+`)}
+] as const;
+
+export const materializeAbsoluteWebBundle = async () => {
+	const root = new Directory(Paths.document, 'absolutejs-web', BUNDLE_ID);
+	root.create({ idempotent: true, intermediates: true });
+	for (const entry of ASSETS) {
+		const parts = entry.path.split('/');
+		const name = parts.pop();
+		if (!name) throw new Error('AbsoluteJS embedded asset path is invalid.');
+		const directory = new Directory(root, ...parts);
+		directory.create({ idempotent: true, intermediates: true });
+		const destination = new File(directory, name);
+		if (destination.exists) continue;
+		const asset = await Asset.fromModule(entry.module).downloadAsync();
+		if (!asset.localUri) throw new Error('Expo did not materialize an embedded AbsoluteJS asset.');
+		new File(asset.localUri).copy(destination);
+	}
+
+	return new File(root, 'index.html').uri;
+};
+`, syncAbsoluteExpoWebAssets = async (config) => {
+  if (config.engine !== "expo")
+    throw new TypeError("Expo asset sync requires mobile.engine: expo.");
+  const marker = join21(config.nativeProjectDirectory, EXPO_PROJECT_MARKER);
+  if (!await exists2(marker)) {
+    throw new TypeError("Expo asset sync requires an AbsoluteJS-managed Expo project. Run mobile init first.");
+  }
+  const manifestPath = join21(config.bundleDirectory, "absolute-mobile-manifest.json");
+  const manifest = JSON.parse(await readFile11(manifestPath, "utf8"));
+  const appBuild = typeof manifest === "object" && manifest !== null && typeof Reflect.get(manifest, "appBuild") === "string" ? String(Reflect.get(manifest, "appBuild")) : undefined;
+  if (!appBuild)
+    throw new TypeError("AbsoluteJS mobile manifest has no appBuild.");
+  const files = await walkFiles(config.bundleDirectory);
+  const bundleHash = createHash11("sha256");
+  const filesWithContents = await Promise.all(files.map(async (file) => ({ contents: await readFile11(file), file })));
+  filesWithContents.forEach(({ contents, file }) => {
+    bundleHash.update(relative12(config.bundleDirectory, file).replaceAll("\\", "/"));
+    bundleHash.update("\x00");
+    bundleHash.update(contents);
+    bundleHash.update("\x00");
+  });
+  const bundleId = `amexpo_${bundleHash.digest("hex")}`;
+  const destination = join21(config.nativeProjectDirectory, "assets", "absolute");
+  await mkdir10(dirname13(destination), { recursive: true });
+  const staging = await mkdtemp5(join21(dirname13(destination), `.${basename8(destination)}.stage-`));
+  let assets;
+  try {
+    assets = await Promise.all(files.map(async (source, index) => {
+      const name = `${String(index).padStart(6, "0")}${EXPO_ASSET_EXTENSION}`;
+      await cp3(source, join21(staging, name));
+      return {
+        asset: portableRelative2(join21(config.nativeProjectDirectory, "src", "generated"), join21(destination, name)),
+        path: relative12(config.bundleDirectory, source).replaceAll("\\", "/")
+      };
+    }));
+    await installStagedDirectory(staging, destination);
+  } catch (error) {
+    await rm7(staging, { force: true, recursive: true });
+    throw error;
+  }
+  const generated = join21(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
+  await writeManagedFile(generated, assetModuleSource(assets, bundleId), true);
+  return { appBuild, assets: assets.length, bundleId, path: destination };
+};
+var init_expoProject = __esm(() => {
+  layoutSource = `${EXPO_GENERATED_HEADER}import { Stack } from 'expo-router';
+
+export default function AbsoluteLayout() {
+	return <Stack screenOptions={{ headerShown: false }} />;
+}
+`;
+  nativeDiagnosticSource = `${EXPO_GENERATED_HEADER}import * as Haptics from 'expo-haptics';
+import { Link } from 'expo-router';
+import { Pressable, SafeAreaView, StyleSheet, Text, View } from 'react-native';
+
+export default function AbsoluteNativeDiagnostic() {
+	return (
+		<SafeAreaView style={styles.page}>
+			<View style={styles.card}>
+				<Text style={styles.eyebrow}>ABSOLUTEJS \xB7 EXPO EXPERIMENT</Text>
+				<Text style={styles.title}>This screen is native React UI.</Text>
+				<Text style={styles.body}>Ordinary AbsoluteJS routes remain embedded web routes. Only explicitly owned routes use React Native.</Text>
+				<Pressable style={styles.button} onPress={() => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium)}>
+					<Text style={styles.buttonText}>Test native haptics</Text>
+				</Pressable>
+				<Link href="/" style={styles.link}>Open the AbsoluteJS app</Link>
+			</View>
+		</SafeAreaView>
+	);
+}
+
+const styles = StyleSheet.create({
+	body: { color: '#cbd5e1', fontSize: 16, lineHeight: 24 },
+	button: { backgroundColor: '#f8fafc', borderRadius: 12, padding: 14 },
+	buttonText: { color: '#020617', fontSize: 16, fontWeight: '700', textAlign: 'center' },
+	card: { backgroundColor: '#0f172a', borderRadius: 24, gap: 20, maxWidth: 560, padding: 28, width: '100%' },
+	eyebrow: { color: '#38bdf8', fontSize: 12, fontWeight: '800', letterSpacing: 1.5 },
+	link: { color: '#7dd3fc', fontSize: 16, textAlign: 'center' },
+	page: { alignItems: 'center', backgroundColor: '#020617', flex: 1, justifyContent: 'center', padding: 20 },
+	title: { color: '#f8fafc', fontSize: 32, fontWeight: '800' }
+});
+`;
+  webRouteSource = `${EXPO_GENERATED_HEADER}import { AbsoluteWebHost } from '../src/generated/AbsoluteWebHost';
+
+export default AbsoluteWebHost;
+`;
+  catchAllRouteSource = `${EXPO_GENERATED_HEADER}import { AbsoluteWebHost } from '../src/generated/AbsoluteWebHost';
+
+export default AbsoluteWebHost;
+`;
+});
+
 // src/mobile/buildPipeline.ts
-import { readFile as readFile11 } from "fs/promises";
-import { join as join21, resolve as resolve17 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join22, resolve as resolve18 } from "path";
 import { pathToFileURL } from "url";
 var isElysiaApp = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "compile") === "function" && Array.isArray(Reflect.get(value, "routes")), isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string"), serverExportName = (loaded, app) => {
   if (loaded.server === app)
@@ -7540,11 +8090,11 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
   const exportName = serverExportName(loaded, app);
   return { app, exportName };
 }, finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve17(options.buildDirectory);
+  const buildDirectory = resolve18(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join21(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join22(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile11(join21(buildDirectory, "manifest.json"), "utf8"),
+    readFile12(join22(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -7557,11 +8107,11 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
   process.env.ABSOLUTE_COMPILED_RUNTIME = "1";
   if (options.configPath) {
-    process.env.ABSOLUTE_CONFIG = resolve17(options.projectRoot, options.configPath);
+    process.env.ABSOLUTE_CONFIG = resolve18(options.projectRoot, options.configPath);
   }
   let loaded;
   try {
-    loaded = await loadServerApp(resolve17(options.producerPath));
+    loaded = await loadServerApp(resolve18(options.producerPath));
   } finally {
     restoreEnvironmentVariable("ABSOLUTE_BUILD_DIR", previousBuildDirectory);
     restoreEnvironmentVariable("ABSOLUTE_COMPILED_RUNTIME", previousCompiledRuntime);
@@ -7574,19 +8124,27 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve17(options.producerPath),
+    producerPath: resolve18(options.producerPath),
     runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
   });
   const auth = resolveAbsoluteMobileAuthManifest(options.projectRoot, mobile);
+  if (mobile.engine === "expo" && auth) {
+    throw new TypeError("Expo mobile Auth is not released yet. The experimental Expo shell cannot safely substitute Capacitor credentials; remove engine: 'expo' or wait for @absolutejs/auth-expo.");
+  }
   const sync = auth !== undefined && projectUsesAbsoluteSync(options.projectRoot);
   const syncSchema = sync ? discoverAbsoluteSyncSchema(options.projectRoot) : undefined;
   const deviceCapabilities = resolveAbsoluteDeviceCapabilityPlan(options.projectRoot);
   const usesPush = deviceCapabilities.capabilities.includes("pushNotifications");
+  if (mobile.engine === "expo" && deviceCapabilities.capabilities.some((capability) => capability !== "haptics")) {
+    throw new TypeError("Experimental Expo builds currently bridge only @absolutejs/devices haptics. Other detected device capabilities require their Expo adapters.");
+  }
   if (usesPush && !auth)
     throw new TypeError("Portable push notifications require @absolutejs/auth so provider tokens can be registered without exposing identity controls to page code.");
   if (usesPush && !loaded.app.routes.some((route) => route.path === "/auth/push" || route.path === "/auth/mobile/push"))
     throw new TypeError("@absolutejs/devices pushNotifications is used, but Auth push is not configured. Pass a trusted server-side registrar to auth({ push: ... }).");
-  assertAbsoluteDeviceCapabilityPackages(options.projectRoot, deviceCapabilities);
+  if (mobile.engine === "capacitor") {
+    assertAbsoluteDeviceCapabilityPackages(options.projectRoot, deviceCapabilities);
+  }
   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.");
   }
@@ -7610,6 +8168,12 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
     ...sync ? { sync: true } : {},
     ...syncSchema ? { syncSchema: { components: syncSchema.components } } : {}
   });
+  if (mobile.engine === "expo") {
+    await writeAbsoluteExpoProject(mobile, {
+      projectRoot: options.projectRoot
+    });
+    await syncAbsoluteExpoWebAssets(mobile);
+  }
   return current.artifact;
 };
 var init_buildPipeline = __esm(() => {
@@ -7622,13 +8186,14 @@ var init_buildPipeline = __esm(() => {
   init_nativeAuth();
   init_syncSchema();
   init_deviceCapabilities();
+  init_expoProject();
 });
 
 // src/mobile/routeMetadataTransform.ts
 import { existsSync as existsSync10, readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname13, extname as extname6, relative as relative12, resolve as resolve18 } from "path";
+import { dirname as dirname14, extname as extname6, relative as relative13, resolve as resolve19 } from "path";
 import ts5 from "typescript";
-var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.replace(/\\/g, "/"), findTsconfig = (entry, projectRoot) => ts5.findConfigFile(dirname13(entry), existsSync10, "tsconfig.json") ?? ts5.findConfigFile(projectRoot, existsSync10, "tsconfig.json"), createProgram = (entry, projectRoot) => {
+var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.replace(/\\/g, "/"), findTsconfig = (entry, projectRoot) => ts5.findConfigFile(dirname14(entry), existsSync10, "tsconfig.json") ?? ts5.findConfigFile(projectRoot, existsSync10, "tsconfig.json"), createProgram = (entry, projectRoot) => {
   const configPath2 = findTsconfig(entry, projectRoot);
   if (!configPath2) {
     return ts5.createProgram([entry], {
@@ -7639,7 +8204,7 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
       target: ts5.ScriptTarget.ESNext
     });
   }
-  const parsed = ts5.parseJsonConfigFileContent(ts5.readConfigFile(configPath2, (path) => readFileSync13(path, "utf8")).config, ts5.sys, dirname13(configPath2));
+  const parsed = ts5.parseJsonConfigFileContent(ts5.readConfigFile(configPath2, (path) => readFileSync13(path, "utf8")).config, ts5.sys, dirname14(configPath2));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts5.createProgram(parsed.fileNames, parsed.options);
@@ -7740,7 +8305,7 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
   const declaration = symbol?.declarations?.[0];
   const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
   const exportedName = symbol?.name ?? expression.getText(sourceFile);
-  const source = posixPath(relative12(projectRoot, file));
+  const source = posixPath(relative13(projectRoot, file));
   return `${source}#${exportedName}`;
 }, resolveAlias = (symbol, checker) => {
   if (!(symbol.flags & ts5.SymbolFlags.Alias))
@@ -7967,7 +8532,7 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
   const checker = program.getTypeChecker();
   const analyzed = new Map;
   for (const sourceFile of program.getSourceFiles()) {
-    const resolvedFile = resolve18(sourceFile.fileName);
+    const resolvedFile = resolve19(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -8053,14 +8618,14 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
     result.dispose();
   }
 }, createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve18(options.projectRoot ?? process.cwd());
-  const entry = resolve18(options.entry);
+  const projectRoot = resolve19(options.projectRoot ?? process.cwd());
+  const entry = resolve19(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return {
     name: "absolute-mobile-route-metadata",
     setup(build) {
       build.onLoad({ filter: SOURCE_FILTER }, async ({ path }) => {
-        const analysis = analyzed.get(resolve18(path));
+        const analysis = analyzed.get(resolve19(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
@@ -8127,7 +8692,7 @@ var init_routeMetadataTransform = __esm(() => {
 });
 
 // src/cli/elysiaOpenApiTypeboxPlugin.ts
-import { dirname as dirname14, resolve as resolve19 } from "path";
+import { dirname as dirname15, resolve as resolve20 } from "path";
 var OPENAPI_TYPEBOX_PREFIX = "../node_modules/typebox/", OPENAPI_DISTRIBUTION_SEGMENT = "/@elysia/openapi/dist/", createElysiaOpenApiTypeboxPlugin = () => ({
   name: "absolute-elysia-openapi-typebox",
   setup(build) {
@@ -8137,9 +8702,9 @@ var OPENAPI_TYPEBOX_PREFIX = "../node_modules/typebox/", OPENAPI_DISTRIBUTION_SE
         return;
       }
       const relativePath = args.path.slice(OPENAPI_TYPEBOX_PREFIX.length);
-      const typeboxEntry = Bun.resolveSync("typebox", dirname14(args.importer));
+      const typeboxEntry = Bun.resolveSync("typebox", dirname15(args.importer));
       return {
-        path: resolve19(dirname14(typeboxEntry), "..", relativePath)
+        path: resolve20(dirname15(typeboxEntry), "..", relativePath)
       };
     });
   }
@@ -8200,7 +8765,7 @@ __export(exports_prerender, {
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync14 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, DEFAULT_FETCH_TIMEOUT_MS = 1e4, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
@@ -8270,7 +8835,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     if (!isCompleteHtml(html))
       return false;
     const fileName = routeToFilename(route);
-    const filePath = join22(prerenderDir, fileName);
+    const filePath = join23(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -8300,13 +8865,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     return;
   }
   const fileName = routeToFilename(route);
-  const filePath = join22(prerenderDir, fileName);
+  const filePath = join23(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log) => {
-  const prerenderDir = join22(outDir, "_prerendered");
+  const prerenderDir = join23(outDir, "_prerendered");
   mkdirSync6(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -8682,7 +9247,7 @@ var init_maskLiterals = __esm(() => {
 // src/build/nativeRewrite.ts
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import { platform as platform4, arch as arch3 } from "os";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 var ffiDefinition, nativeLib = null, loadNative = () => {
   if (nativeLib !== null)
     return nativeLib;
@@ -8700,7 +9265,7 @@ var ffiDefinition, nativeLib = null, loadNative = () => {
   if (!libPath)
     return null;
   try {
-    const fullPath = resolve20(import.meta.dir, "../../native/packages", libPath);
+    const fullPath = resolve21(import.meta.dir, "../../native/packages", libPath);
     const lib = dlopen(fullPath, ffiDefinition);
     nativeLib = lib.symbols;
     return nativeLib;
@@ -8741,8 +9306,8 @@ var init_nativeRewrite = __esm(() => {
 });
 
 // src/build/rewriteImportsPlugin.ts
-import { readdir as readdir3 } from "fs/promises";
-import { join as join23 } from "path";
+import { readdir as readdir4 } from "fs/promises";
+import { join as join24 } from "path";
 var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -8818,10 +9383,10 @@ ${content}`;
   const allFiles = [];
   for (const dir of vendorDirs) {
     try {
-      const entries = await readdir3(dir);
+      const entries = await readdir4(dir);
       for (const entry of entries) {
         if (entry.endsWith(".js"))
-          allFiles.push(join23(dir, entry));
+          allFiles.push(join24(dir, entry));
       }
     } catch {}
   }
@@ -8897,7 +9462,7 @@ var init_rewriteImports = __esm(() => {
 // src/cli/scripts/start.ts
 var {env: env2 } = globalThis.Bun;
 import { existsSync as existsSync11, readFileSync as readFileSync15, rmSync as rmSync4 } from "fs";
-import { basename as basename8, join as join24, resolve as resolve21 } from "path";
+import { basename as basename9, join as join25, resolve as resolve22 } from "path";
 var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, resolvePackageVersion = (candidates) => {
   for (const candidate of candidates) {
     const version2 = readPackageVersion2(candidate);
@@ -8946,18 +9511,18 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   process.exit(1);
 }, resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve21(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve21(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve21(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
-    resolve21(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve21(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve21(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve22(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve22(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve22(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
+    resolve22(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve22(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve22(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync11(candidate))
       return candidate;
   }
-  return resolve21(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
+  return resolve22(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
 }, jsxDevRuntimeCompatPath, prerenderStaticPages = async (outputPath, prerenderPort, resolvedOutdir, staticConfig, absoluteVersion, configPath2) => {
   const prerenderStart = performance.now();
   process.stdout.write(cliTag2("\x1B[36m", "Pre-rendering static pages"));
@@ -8991,7 +9556,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   serverEntry,
   totalDuration
 }) => {
-  const usesDocker = existsSync11(resolve21(COMPOSE_PATH));
+  const usesDocker = existsSync11(resolve22(COMPOSE_PATH));
   const scripts = usesDocker ? await readDbScripts() : null;
   if (scripts)
     await startDatabase(scripts);
@@ -9081,11 +9646,11 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   const port = Number(env2.PORT) || DEFAULT_PORT;
   killStaleProcesses(port);
-  const entryName = basename8(serverEntry).replace(/\.[^.]+$/, "");
-  const resolvedOutdir = resolve21(outdir ?? "dist");
+  const entryName = basename9(serverEntry).replace(/\.[^.]+$/, "");
+  const resolvedOutdir = resolve22(outdir ?? "dist");
   const absoluteVersion = resolvePackageVersion([
-    resolve21(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve21(import.meta.dir, "..", "..", "package.json")
+    resolve22(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve22(import.meta.dir, "..", "..", "package.json")
   ]);
   const buildConfig = await loadConfig(configPath2);
   buildConfig.buildDirectory = resolvedOutdir;
@@ -9100,7 +9665,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     buildConfig.vueDirectory && "vue",
     buildConfig.angularDirectory && "angular"
   ].filter((val) => Boolean(val));
-  const outputPath = resolve21(resolvedOutdir, `${entryName}.js`);
+  const outputPath = resolve22(resolvedOutdir, `${entryName}.js`);
   if (options.prebuilt) {
     if (!existsSync11(outputPath)) {
       throw new Error(`Prepared production server not found: ${outputPath}`);
@@ -9123,13 +9688,13 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   process.stdout.write(cliTag2("\x1B[36m", `Building assets`));
   try {
     const build = await resolveBuildModule([
-      resolve21(import.meta.dir, "..", "..", "core", "build"),
-      resolve21(import.meta.dir, "..", "build")
+      resolve22(import.meta.dir, "..", "..", "core", "build"),
+      resolve22(import.meta.dir, "..", "build")
     ]);
     if (!build)
       throw new Error("Could not locate build module");
     await build(buildConfig);
-    rmSync4(join24(resolvedOutdir, "_prerendered"), {
+    rmSync4(join25(resolvedOutdir, "_prerendered"), {
       force: true,
       recursive: true
     });
@@ -9206,17 +9771,17 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     }
   };
   const islandRegistrySpec = buildConfig.islands?.registry;
-  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve21(islandRegistrySpec))) : undefined;
+  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve22(islandRegistrySpec))) : undefined;
   const serverBundle = await Bun.build({
     define: { "process.env.NODE_ENV": '"production"' },
-    entrypoints: [resolve21(serverEntry)],
+    entrypoints: [resolve22(serverEntry)],
     external: resolveServerBundleExternals(buildConfig),
     outdir: resolvedOutdir,
     plugins: [
       ...islandRegistryPlugin ? [islandRegistryPlugin] : [],
       ...buildConfig.mobile ? [
         createAbsoluteMobileRouteMetadataPlugin({
-          entry: resolve21(serverEntry)
+          entry: resolve22(serverEntry)
         })
       ] : [],
       createElysiaOpenApiTypeboxPlugin(),
@@ -9233,9 +9798,9 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     console.error(cliTag2("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync11(resolve21(resolvedOutdir, "angular", "vendor", "server"))) {
+  if (existsSync11(resolve22(resolvedOutdir, "angular", "vendor", "server"))) {
     const { readdirSync: readdirSync2 } = await import("fs");
-    const vendorDir = resolve21(resolvedOutdir, "angular", "vendor", "server");
+    const vendorDir = resolve22(resolvedOutdir, "angular", "vendor", "server");
     const vendorEntries = readdirSync2(vendorDir).filter((fileName) => fileName.endsWith(".js"));
     const angularServerVendorPaths = {};
     const { relative: pathRelative, dirname: pathDirname } = await import("path");
@@ -9245,7 +9810,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = pathRelative(pathDirname(outputPath), resolve21(vendorDir, file));
+      const relPath = pathRelative(pathDirname(outputPath), resolve22(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
@@ -9433,16 +9998,16 @@ __export(exports_build, {
   build: () => build
 });
 import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync17 } from "fs";
-import { join as join25, resolve as resolve23 } from "path";
+import { join as join26, resolve as resolve24 } from "path";
 var PROFILE_TOP = 15, PROFILE_COL = 8, FRAMEWORK_KEYS, cliTag3 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, printProfile = (buildDir) => {
-  const traceDir = join25(buildDir, ".absolute-trace");
+  const traceDir = join26(buildDir, ".absolute-trace");
   if (!existsSync13(traceDir))
     return;
   const files = readdirSync3(traceDir).filter((file) => file.endsWith(".json")).sort();
   const latest = files[files.length - 1];
   if (latest === undefined)
     return;
-  const trace = JSON.parse(readFileSync17(join25(traceDir, latest), "utf-8"));
+  const trace = JSON.parse(readFileSync17(join26(traceDir, latest), "utf-8"));
   const events = Array.isArray(trace.events) ? trace.events : [];
   if (events.length === 0)
     return;
@@ -9479,7 +10044,7 @@ var PROFILE_TOP = 15, PROFILE_COL = 8, FRAMEWORK_KEYS, cliTag3 = (color, message
   }
   return resolveBuildModule2(remaining);
 }, build = async (outdir, configPath2, profile = false) => {
-  const resolvedOutdir = resolve23(outdir ?? "build");
+  const resolvedOutdir = resolve24(outdir ?? "build");
   const buildStart = performance.now();
   if (profile)
     process.env.ABSOLUTE_BUILD_TRACE = "1";
@@ -9489,8 +10054,8 @@ var PROFILE_TOP = 15, PROFILE_COL = 8, FRAMEWORK_KEYS, cliTag3 = (color, message
   buildConfig.mode = "production";
   try {
     const buildApp = await resolveBuildModule2([
-      resolve23(import.meta.dir, "..", "..", "core", "build"),
-      resolve23(import.meta.dir, "..", "build")
+      resolve24(import.meta.dir, "..", "..", "core", "build"),
+      resolve24(import.meta.dir, "..", "build")
     ]);
     if (!buildApp)
       throw new Error("Could not locate build module");
@@ -9528,7 +10093,7 @@ __export(exports_lintProof, {
   createLintProof: () => createLintProof
 });
 import {
-  createHash as createHash11,
+  createHash as createHash12,
   createPrivateKey,
   createPublicKey,
   sign,
@@ -9546,7 +10111,7 @@ import {
   writeFileSync as writeFileSync7
 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { delimiter, dirname as dirname15, relative as relative13, resolve as resolve24 } from "path";
+import { delimiter, dirname as dirname16, relative as relative14, resolve as resolve25 } from "path";
 var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSION = 2, FLAG_NOT_FOUND = -1, CHUNKED_FLAG = "--chunked", TSCONFIG_PATTERN, ABSOLUTE_BINARY, runGit = (args, options) => {
   const proc = Bun.spawnSync(["git", ...args], {
     cwd: options.cwd,
@@ -9559,8 +10124,8 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
     throw new Error(detail || `git ${args.join(" ")} failed`);
   }
   return proc.stdout.toString().trim();
-}, gitRoot = (cwd) => resolve24(runGit(["rev-parse", "--show-toplevel"], { cwd })), isInside3 = (parent, candidate) => {
-  const path = relative13(parent, candidate);
+}, gitRoot = (cwd) => resolve25(runGit(["rev-parse", "--show-toplevel"], { cwd })), isInside3 = (parent, candidate) => {
+  const path = relative14(parent, candidate);
   return path === "" || !path.startsWith("../") && path !== "..";
 }, attestationPayload = (proof) => Buffer.from([
   "absolute-lint-proof-attestation:1",
@@ -9571,8 +10136,8 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
     lintFingerprint: proof.lintFingerprint,
     sourceTree: proof.sourceTree
   })
-].join("\x00")), publicKeyId = (key) => createHash11("sha256").update(key.export({ format: "der", type: "spki" })).digest("hex"), readEd25519PrivateKey = (cwd, location) => {
-  const path = resolve24(cwd, location);
+].join("\x00")), publicKeyId = (key) => createHash12("sha256").update(key.export({ format: "der", type: "spki" })).digest("hex"), readEd25519PrivateKey = (cwd, location) => {
+  const path = resolve25(cwd, location);
   if (isInside3(realpathSync(gitRoot(cwd)), realpathSync(path))) {
     throw new Error("lint proof signing key must live outside the Git working tree");
   }
@@ -9582,7 +10147,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
   }
   return key;
 }, readEd25519PublicKey = (cwd, location) => {
-  const key = createPublicKey(readFileSync18(resolve24(cwd, location)));
+  const key = createPublicKey(readFileSync18(resolve25(cwd, location)));
   if (key.asymmetricKeyType !== "ed25519") {
     throw new Error("trusted lint proof key must be an Ed25519 public key");
   }
@@ -9610,7 +10175,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
     return null;
   const auxiliary = gitVisibleFiles(root).filter((file) => TSCONFIG_PATTERN.test(file));
   const configPath2 = findEslintConfigPath(root);
-  const configRelative = configPath2 === null ? null : relative13(root, configPath2).replaceAll("\\", "/");
+  const configRelative = configPath2 === null ? null : relative14(root, configPath2).replaceAll("\\", "/");
   return [
     ...new Set([
       ...resolveLintTargets(args, root),
@@ -9620,17 +10185,17 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
   ].sort();
 }, createLintSourceTree = (cwd = process.cwd(), proofLocation = DEFAULT_PROOF_LOCATION, command = []) => {
   const root = gitRoot(cwd);
-  const proofPath = resolve24(cwd, proofLocation);
-  const proofRelative = relative13(root, proofPath).replaceAll("\\", "/");
+  const proofPath = resolve25(cwd, proofLocation);
+  const proofRelative = relative14(root, proofPath).replaceAll("\\", "/");
   if (proofRelative === ".." || proofRelative.startsWith("../") || proofRelative === "") {
     throw new Error("lint proof must live inside the Git working tree");
   }
-  const temporaryDirectory = mkdtempSync(resolve24(tmpdir3(), "absolute-lint-proof-"));
-  const temporaryIndex = resolve24(temporaryDirectory, "index");
-  const temporaryObjects = resolve24(temporaryDirectory, "objects");
+  const temporaryDirectory = mkdtempSync(resolve25(tmpdir3(), "absolute-lint-proof-"));
+  const temporaryIndex = resolve25(temporaryDirectory, "index");
+  const temporaryObjects = resolve25(temporaryDirectory, "objects");
   mkdirSync8(temporaryObjects, { recursive: true });
   const repositoryObjectsPath = runGit(["rev-parse", "--git-path", "objects"], { cwd: root });
-  const repositoryObjects = resolve24(root, repositoryObjectsPath);
+  const repositoryObjects = resolve25(root, repositoryObjectsPath);
   const existingAlternates = process.env.GIT_ALTERNATE_OBJECT_DIRECTORIES?.trim();
   const env3 = {
     GIT_ALTERNATE_OBJECT_DIRECTORIES: [
@@ -9654,7 +10219,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
       if (!path || path === proofRelative)
         return false;
       try {
-        lstatSync(resolve24(root, path));
+        lstatSync(resolve25(root, path));
         return true;
       } catch {
         return false;
@@ -9665,7 +10230,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
   } finally {
     rmSync5(temporaryDirectory, { force: true, recursive: true });
   }
-}, proofFingerprint = (cwd) => createHash11("sha256").update(`absolute-lint-proof:${PROOF_CONTRACT_VERSION}\x00`).update(createEslintCacheFingerprint(cwd)).update("\x00").update(createEslintConfigDigest(cwd)).digest("hex"), createLintProof = (command, options = {}) => {
+}, proofFingerprint = (cwd) => createHash12("sha256").update(`absolute-lint-proof:${PROOF_CONTRACT_VERSION}\x00`).update(createEslintCacheFingerprint(cwd)).update("\x00").update(createEslintConfigDigest(cwd)).digest("hex"), createLintProof = (command, options = {}) => {
   const cwd = options.cwd ?? process.cwd();
   const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
   return {
@@ -9678,7 +10243,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
 }, writeLintProof = (command, options = {}) => {
   const cwd = options.cwd ?? process.cwd();
   const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
-  const path = resolve24(cwd, proofLocation);
+  const path = resolve25(cwd, proofLocation);
   const temporary = `${path}.${process.pid}.tmp`;
   const proof = createLintProof(command, { cwd, proofLocation });
   if (options.signingKeyLocation) {
@@ -9690,7 +10255,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
       signature: sign(null, attestationPayload(proof), privateKey).toString("base64")
     };
   }
-  mkdirSync8(dirname15(path), { recursive: true });
+  mkdirSync8(dirname16(path), { recursive: true });
   writeFileSync7(temporary, `${JSON.stringify(proof, null, 2)}
 `);
   renameSync2(temporary, path);
@@ -9734,7 +10299,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
 }, verifyLintProof = (command, options = {}) => {
   const cwd = options.cwd ?? process.cwd();
   const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
-  const path = resolve24(cwd, proofLocation);
+  const path = resolve25(cwd, proofLocation);
   if (!existsSync14(path))
     return { reason: `missing lint proof: ${proofLocation}`, valid: false };
   let proof;
@@ -9850,11 +10415,11 @@ var init_lintProof = __esm(() => {
 });
 
 // src/build/scanConventions.ts
-import { basename as basename9 } from "path";
+import { basename as basename10 } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
 import { existsSync as existsSync15 } from "fs";
 var CONVENTION_RE, classifyFile = (file, pageFiles, defaults, pages) => {
-  const fileName = basename9(file);
+  const fileName = basename10(file);
   const match = CONVENTION_RE.exec(fileName);
   if (!match) {
     pageFiles.push(file);
@@ -9905,7 +10470,7 @@ __export(exports_ls, {
   runLs: () => runLs
 });
 import { existsSync as existsSync16, readFileSync as readFileSync19, statSync } from "fs";
-import { basename as basename10, extname as extname7, join as join26, relative as relative14 } from "path";
+import { basename as basename11, extname as extname7, join as join27, relative as relative15 } from "path";
 var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELDS, readStringField = (source, key) => {
   const value = Reflect.get(source, key);
   return typeof value === "string" ? value : undefined;
@@ -9920,24 +10485,24 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
   } catch {
     return null;
   }
-}, relativeOrSelf = (target) => relative14(process.cwd(), target) || target, configCandidates = (raw) => isWorkspaceConfig(raw) ? Object.values(raw).map((service) => ({
+}, relativeOrSelf = (target) => relative15(process.cwd(), target) || target, configCandidates = (raw) => isWorkspaceConfig(raw) ? Object.values(raw).map((service) => ({
   baseDir: readStringField(service, "cwd") ?? ".",
   source: service
 })) : [{ baseDir: ".", source: raw }], specsFor = (source, baseDir) => FRAMEWORK_FIELDS.flatMap((framework) => {
   const dir = readStringField(source, framework.field);
   return dir === undefined ? [] : [
     {
-      dir: join26(baseDir, dir),
+      dir: join27(baseDir, dir),
       label: framework.label,
       pattern: framework.pattern
     }
   ];
 }), scanFramework = async (spec) => {
-  const { pageFiles } = await scanConventions(join26(spec.dir, "pages"), spec.pattern);
+  const { pageFiles } = await scanConventions(join27(spec.dir, "pages"), spec.pattern);
   if (pageFiles.length === 0)
     return null;
   const pages = pageFiles.map((file) => ({
-    name: basename10(file, extname7(file)),
+    name: basename11(file, extname7(file)),
     sizeBytes: null,
     sourcePath: relativeOrSelf(file)
   }));
@@ -9957,10 +10522,10 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
 }, resolveDiskPath = (buildDir, value) => {
   if (existsSync16(value))
     return value;
-  const underBuild = join26(buildDir, value);
+  const underBuild = join27(buildDir, value);
   if (existsSync16(underBuild))
     return underBuild;
-  return join26(process.cwd(), value);
+  return join27(process.cwd(), value);
 }, fileSize = (diskPath) => {
   try {
     return statSync(diskPath).size;
@@ -9968,7 +10533,7 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
     return 0;
   }
 }, readManifestSizes = (manifestDir) => {
-  const manifest = JSON.parse(readFileSync19(join26(manifestDir, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync19(join27(manifestDir, "manifest.json"), "utf-8"));
   const sizes = new Map;
   Object.entries(manifest).forEach(([key, value]) => {
     sizes.set(key, fileSize(resolveDiskPath(manifestDir, value)));
@@ -9987,7 +10552,7 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
   }))
 })), manifestAge = (manifestPath) => getDurationString(Date.now() - statSync(manifestPath).mtimeMs), firstBuildDir = (candidates) => candidates.map((candidate) => {
   const dir = readStringField(candidate.source, "buildDirectory");
-  return dir === undefined ? undefined : join26(candidate.baseDir, dir);
+  return dir === undefined ? undefined : join27(candidate.baseDir, dir);
 }).find((dir) => dir !== undefined), resolveSizesDir = (args, candidates) => parseFlagValue(args, "--outdir") ?? firstBuildDir(candidates) ?? DEFAULT_BUILD_DIR, formatSize = (bytes) => {
   if (bytes === null || bytes === 0)
     return "-";
@@ -10085,7 +10650,7 @@ ${colors.dim}${frameworkCount} ${frameworkCount === 1 ? "framework" : "framework
     return;
   }
   const sizesDir = resolveSizesDir(args, candidates);
-  const manifestPath = join26(sizesDir, "manifest.json");
+  const manifestPath = join27(sizesDir, "manifest.json");
   if (!existsSync16(manifestPath)) {
     printDim(`No build at ${relativeOrSelf(manifestPath)}. Run \`absolute build\` first, or pass \`--outdir <dir>\`.`);
     return;
@@ -10210,21 +10775,21 @@ var init_discoverInstances = __esm(() => {
 import { createConnection as createConnection2 } from "net";
 var {$: $4 } = globalThis.Bun;
 var displayHost = (host2) => host2 === "0.0.0.0" || host2 === "::" ? "localhost" : host2, probePort = (host2, port) => {
-  const { promise, resolve: resolve25 } = Promise.withResolvers();
+  const { promise, resolve: resolve26 } = Promise.withResolvers();
   const socket = createConnection2({ host: displayHost(host2), port });
   const timeout = setTimeout(() => {
     socket.destroy();
-    resolve25(false);
+    resolve26(false);
   }, INSTANCE_PROBE_TIMEOUT_MS);
   socket.once("connect", () => {
     clearTimeout(timeout);
     socket.end();
-    resolve25(true);
+    resolve26(true);
   });
   socket.once("error", () => {
     clearTimeout(timeout);
     socket.destroy();
-    resolve25(false);
+    resolve26(false);
   });
   return promise;
 }, probeStatus = async (record) => {
@@ -11094,10 +11659,10 @@ import {
   statSync as statSync2,
   writeFileSync as writeFileSync8
 } from "fs";
-import { resolve as resolve25 } from "path";
+import { resolve as resolve26 } from "path";
 var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFrameworkRepo = (cwd) => {
   try {
-    const pkg = JSON.parse(readFileSync21(resolve25(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync21(resolve26(cwd, "package.json"), "utf-8"));
     return pkg?.name === "@absolutejs/absolute";
   } catch {
     return false;
@@ -11118,10 +11683,10 @@ var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFramework
   };
 }, SCHEMA_VERSION = 1, packageVersion = (cwd, specifier) => {
   const candidates = specifier === "@absolutejs/absolute" ? [
-    resolve25(cwd, "node_modules", "@absolutejs", "absolute", "package.json"),
-    resolve25(cwd, "package.json")
+    resolve26(cwd, "node_modules", "@absolutejs", "absolute", "package.json"),
+    resolve26(cwd, "package.json")
   ] : [
-    resolve25(cwd, "node_modules", ...specifier.split("/"), "package.json")
+    resolve26(cwd, "node_modules", ...specifier.split("/"), "package.json")
   ];
   for (const candidate of candidates) {
     try {
@@ -11136,13 +11701,13 @@ var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFramework
   if (local) {
     const file = typeName === "PackageJson" ? "packageJson.ts" : "build.ts";
     try {
-      signature += `:${statSync2(resolve25(cwd, "types", file)).mtimeMs}`;
+      signature += `:${statSync2(resolve26(cwd, "types", file)).mtimeMs}`;
     } catch {}
   }
   return signature;
 }, cacheSlug = (specifier) => specifier.replace("@", "").split("/").join("-"), cacheFile = (cwd, typeName, specifier) => {
   const name = specifier === "@absolutejs/absolute" ? typeName : `${typeName}.${cacheSlug(specifier)}`;
-  return resolve25(cwd, ".absolutejs", "config-schema", `${name}.json`);
+  return resolve26(cwd, ".absolutejs", "config-schema", `${name}.json`);
 }, readDiskCache = (cwd, typeName, signature, specifier) => {
   try {
     const cached = JSON.parse(readFileSync21(cacheFile(cwd, typeName, specifier), "utf-8"));
@@ -11153,7 +11718,7 @@ var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFramework
   return null;
 }, writeDiskCache = (cwd, typeName, signature, fields, specifier) => {
   try {
-    mkdirSync9(resolve25(cwd, ".absolutejs", "config-schema"), {
+    mkdirSync9(resolve26(cwd, ".absolutejs", "config-schema"), {
       recursive: true
     });
     writeFileSync8(cacheFile(cwd, typeName, specifier), JSON.stringify({ fields, signature }));
@@ -11240,7 +11805,7 @@ var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFramework
   }
   return opaque();
 }, introspectFrom = (cwd, specifier, typeName, options, exclude) => {
-  const virtualPath = resolve25(cwd, VIRTUAL_NAME);
+  const virtualPath = resolve26(cwd, VIRTUAL_NAME);
   const source = `import type { ${typeName} } from '${specifier}';
 declare const value: ${typeName};
 export { value };
@@ -11250,8 +11815,8 @@ export { value };
   host2.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => fileName === virtualPath ? ts6.createSourceFile(fileName, source, languageVersion, true) : getSourceFile(fileName, languageVersion, onError, shouldCreate);
   const fileExists = host2.fileExists.bind(host2);
   host2.fileExists = (fileName) => fileName === virtualPath ? true : fileExists(fileName);
-  const readFile12 = host2.readFile.bind(host2);
-  host2.readFile = (fileName) => fileName === virtualPath ? source : readFile12(fileName);
+  const readFile13 = host2.readFile.bind(host2);
+  host2.readFile = (fileName) => fileName === virtualPath ? source : readFile13(fileName);
   const program = ts6.createProgram([virtualPath], options, host2);
   const checker = program.getTypeChecker();
   const sourceFile = program.getSourceFile(virtualPath);
@@ -11283,7 +11848,7 @@ export { value };
   const cached = cache.get(cacheKey);
   if (cached)
     return cached;
-  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync18(resolve25(cwd, "types/index.ts"));
+  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync18(resolve26(cwd, "types/index.ts"));
   const signature = cacheSignature(cwd, typeName, local, specifier);
   const fromDisk = readDiskCache(cwd, typeName, signature, specifier);
   if (fromDisk) {
@@ -11312,14 +11877,14 @@ var init_fromType = __esm(() => {
 // src/cli/config/absolute/resolveAbsoluteConfig.ts
 import ts7 from "typescript";
 import { existsSync as existsSync19, readFileSync as readFileSync22 } from "fs";
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 var CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath = (cwd, override) => {
   if (override) {
-    const resolved = resolve26(cwd, override);
+    const resolved = resolve27(cwd, override);
     return existsSync19(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES2) {
-    const candidate = resolve26(cwd, name);
+    const candidate = resolve27(cwd, name);
     if (existsSync19(candidate))
       return candidate;
   }
@@ -11552,8 +12117,8 @@ var init_frameworks = __esm(() => {
 });
 
 // src/cli/generate/context.ts
-import { dirname as dirname16, isAbsolute as isAbsolute5, join as join27, relative as relative15, resolve as resolve27 } from "path";
-var asString = (value) => typeof value === "string" ? value : undefined, isRecord10 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute5(value) ? value : resolve27(cwd, value), resolveStylesDir = (cwd, config) => {
+import { dirname as dirname17, isAbsolute as isAbsolute5, join as join28, relative as relative16, resolve as resolve28 } from "path";
+var asString = (value) => typeof value === "string" ? value : undefined, isRecord10 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute5(value) ? value : resolve28(cwd, value), resolveStylesDir = (cwd, config) => {
   const styles = config.stylesConfig;
   if (typeof styles === "string")
     return resolveDir(cwd, styles);
@@ -11562,10 +12127,10 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
     if (indexes)
       return resolveDir(cwd, indexes);
   }
-  return resolve27(cwd, "src/frontend/styles/indexes");
+  return resolve28(cwd, "src/frontend/styles/indexes");
 }, configuredFrameworks = (project) => FRAMEWORK_KEYS2.filter((key) => project.frameworkDirs[key] !== undefined), frontendRootFor = (project, framework) => {
   const dir = project.frameworkDirs[framework];
-  return dir ? dirname16(dir) : resolve27(project.cwd, "src/frontend");
+  return dir ? dirname17(dir) : resolve28(project.cwd, "src/frontend");
 }, resolveProject = async (cwd, configOverride) => {
   const loaded = await loadConfig(configOverride);
   const config = isRecord10(loaded) ? loaded : {};
@@ -11615,8 +12180,8 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
     message: `Multiple frameworks configured (${configured.join(", ")}). Pass --framework <name>.`,
     ok: false
   };
-}, sharedDirFor = (project, framework) => join27(frontendRootFor(project, framework), "shared"), toModuleSpecifier = (fromDir, toFileNoExt) => {
-  const rel = relative15(fromDir, toFileNoExt).split("\\").join("/");
+}, sharedDirFor = (project, framework) => join28(frontendRootFor(project, framework), "shared"), toModuleSpecifier = (fromDir, toFileNoExt) => {
+  const rel = relative16(fromDir, toFileNoExt).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 };
 var init_context = __esm(() => {
@@ -11645,7 +12210,7 @@ var emptyOutcome = () => ({
 // src/cli/generate/routeWiring.ts
 import ts8 from "typescript";
 import { existsSync as existsSync20, readFileSync as readFileSync23, readdirSync as readdirSync4, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname17, join as join28 } from "path";
+import { dirname as dirname18, join as join29 } from "path";
 var DEFAULT_SEPARATOR = `
 		`, BOUNDARY_USE, applyEdits = (text2, edits) => {
   const ordered = [...edits].sort((first, second) => second.start - first.start);
@@ -11804,14 +12369,14 @@ ${newLines.join(`
   for (const name of readdirSync4(pluginsDir)) {
     if (!name.endsWith(".ts"))
       continue;
-    const candidate = join28(pluginsDir, name);
+    const candidate = join29(pluginsDir, name);
     if (hasChain(candidate))
       return candidate;
   }
   return null;
 }, findRoutingFile = (serverEntry) => {
-  const pluginsDir = join28(dirname17(serverEntry), "plugins");
-  const preferred = join28(pluginsDir, "pagesPlugin.ts");
+  const pluginsDir = join29(dirname18(serverEntry), "plugins");
+  const preferred = join29(pluginsDir, "pagesPlugin.ts");
   if (hasChain(preferred))
     return preferred;
   const scanned = firstChainFile(pluginsDir);
@@ -11821,7 +12386,7 @@ ${newLines.join(`
     return serverEntry;
   return null;
 }, buildRouteContext = (input, routingFile) => {
-  const specifier = `${toModuleSpecifier(dirname17(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
+  const specifier = `${toModuleSpecifier(dirname18(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
   return {
     cssAssetKey: input.cssAssetKey,
     indexKey: input.indexKey,
@@ -11903,7 +12468,7 @@ var init_routeWiring = __esm(() => {
 
 // src/cli/generate/generateApi.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname18, join as join29 } from "path";
+import { dirname as dirname19, join as join30 } from "path";
 var apiPluginTemplate = (pluginName, base) => `import { Elysia } from 'elysia';
 
 export const ${pluginName} = new Elysia()
@@ -11915,8 +12480,8 @@ export const ${pluginName} = new Elysia()
   const pluginName = `${camel}Plugin`;
   const base = `/api/${kebab}`;
   const outcome = { ...emptyOutcome(), route: base };
-  const pluginsDir = join29(dirname18(project.serverEntry), "plugins");
-  const fileAbs = join29(pluginsDir, `${pluginName}.ts`);
+  const pluginsDir = join30(dirname19(project.serverEntry), "plugins");
+  const fileAbs = join30(pluginsDir, `${pluginName}.ts`);
   if (existsSync21(fileAbs)) {
     outcome.notes.push(`${pluginName} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
@@ -11924,7 +12489,7 @@ export const ${pluginName} = new Elysia()
   mkdirSync10(pluginsDir, { recursive: true });
   writeFileSync10(fileAbs, apiPluginTemplate(pluginName, base), "utf-8");
   outcome.created.push(fileAbs);
-  const specifier = toModuleSpecifier(dirname18(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
+  const specifier = toModuleSpecifier(dirname19(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
   const wired = wirePluginUse(project.serverEntry, pluginName, specifier);
   if (wired.kind === "edited")
     outcome.updated.push(wired.routingFile);
@@ -11991,7 +12556,7 @@ var init_componentTemplates = __esm(() => {
 
 // src/cli/generate/generateComponent.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname19, join as join30 } from "path";
+import { dirname as dirname20, join as join31 } from "path";
 var generateComponent = (project, framework, rawName) => {
   const def = frameworks6[framework];
   const pascal = toPascalCase(rawName);
@@ -12002,12 +12567,12 @@ var generateComponent = (project, framework, rawName) => {
     outcome.manual = { reason: "framework directory missing", snippet: "" };
     return outcome;
   }
-  const fileAbs = join30(frameworkDir, "components", def.componentFile({ kebab, pascal }));
+  const fileAbs = join31(frameworkDir, "components", def.componentFile({ kebab, pascal }));
   if (existsSync22(fileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
-  mkdirSync11(dirname19(fileAbs), { recursive: true });
+  mkdirSync11(dirname20(fileAbs), { recursive: true });
   writeFileSync11(fileAbs, componentTemplates[framework]({
     kebab,
     pascal,
@@ -12024,7 +12589,7 @@ var init_generateComponent = __esm(() => {
 // src/cli/generate/cssStrategy.ts
 import ts9 from "typescript";
 import { existsSync as existsSync23 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
 	margin: 0 auto;
 	max-width: 64rem;
@@ -12063,7 +12628,7 @@ var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
   return null;
 }, fileForKey = (stylesDir, assetKey2) => {
   const base = assetKey2.endsWith(CSS_SUFFIX) ? assetKey2.slice(0, -CSS_SUFFIX.length) : assetKey2;
-  return join31(stylesDir, `${toKebabCase(base)}.css`);
+  return join32(stylesDir, `${toKebabCase(base)}.css`);
 }, planCss = (routingText, stylesDir, pascal, kebab) => {
   const sharedKey = detectSharedKey(routingText);
   if (sharedKey) {
@@ -12076,7 +12641,7 @@ var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
       shared: true
     };
   }
-  const cssFileAbs = join31(stylesDir, `${kebab}.css`);
+  const cssFileAbs = join32(stylesDir, `${kebab}.css`);
   return {
     assetKey: `${pascal}${CSS_SUFFIX}`,
     contents: DEFAULT_CSS,
@@ -12090,7 +12655,7 @@ var init_cssStrategy = () => {};
 // src/cli/generate/navData.ts
 import ts10 from "typescript";
 import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync24, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname20 } from "path";
+import { dirname as dirname21 } from "path";
 var NAV_DATA_TEMPLATE = `type NavItem = {
 	href: string;
 	label: string;
@@ -12167,7 +12732,7 @@ ${indent}${entry}`;
 }, upsertNavItem = (navDataPath, item) => {
   const created = !existsSync24(navDataPath);
   if (created) {
-    mkdirSync12(dirname20(navDataPath), { recursive: true });
+    mkdirSync12(dirname21(navDataPath), { recursive: true });
     writeFileSync12(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
   }
   const existing = readNavItems(navDataPath);
@@ -12337,14 +12902,14 @@ import {
   readdirSync as readdirSync5,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname21, join as join32, relative as relative16 } from "path";
+import { dirname as dirname22, join as join33, relative as relative17 } from "path";
 var writeNew = (path, contents) => {
-  mkdirSync13(dirname21(path), { recursive: true });
+  mkdirSync13(dirname22(path), { recursive: true });
   writeFileSync13(path, contents, "utf-8");
 }, toHref = (fromDir, toFile) => {
-  const rel = relative16(fromDir, toFile).split("\\").join("/");
+  const rel = relative17(fromDir, toFile).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
-}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join32(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync25(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join32(pagesDir, name))), resyncPage = (file, items) => {
+}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join33(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync25(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join33(pagesDir, name))), resyncPage = (file, items) => {
   const html = readFileSync25(file, "utf-8");
   const synced = syncStaticNav(html, items);
   if (synced === null || synced === html)
@@ -12372,7 +12937,7 @@ var writeNew = (path, contents) => {
     outcome.manual = { reason: "framework directory missing", snippet: "" };
     return outcome;
   }
-  const pageFileAbs = join32(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
+  const pageFileAbs = join33(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
   if (existsSync25(pageFileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${pageFileAbs} \u2014 skipped.`);
     return outcome;
@@ -12380,11 +12945,11 @@ var writeNew = (path, contents) => {
   const routingFile = findRoutingFile(project.serverEntry);
   const routingText = routingFile ? readFileSync25(routingFile, "utf-8") : "";
   const css = planCss(routingText, project.stylesDir, pascal, kebab);
-  const navDataPath = join32(sharedDirFor(project, framework), "navData.ts");
+  const navDataPath = join33(sharedDirFor(project, framework), "navData.ts");
   const nav = upsertNavItem(navDataPath, { href: route, label: title });
-  const navImportPath = toModuleSpecifier(dirname21(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
+  const navImportPath = toModuleSpecifier(dirname22(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
   writeNew(pageFileAbs, pageTemplates[framework]({
-    cssHref: toHref(dirname21(pageFileAbs), css.cssFileAbs),
+    cssHref: toHref(dirname22(pageFileAbs), css.cssFileAbs),
     kebab,
     navImportPath,
     navItems: nav.items,
@@ -12434,7 +12999,7 @@ var exports_generate = {};
 __export(exports_generate, {
   runGenerate: () => runGenerate
 });
-import { relative as relative17 } from "path";
+import { relative as relative18 } from "path";
 var SUBCOMMANDS, write = (text2) => process.stdout.write(`${text2}
 `), fail = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -12466,7 +13031,7 @@ var SUBCOMMANDS, write = (text2) => process.stdout.write(`${text2}
     return;
   write(`  ${colors.dim}${label}${colors.reset}`);
   for (const path of paths)
-    write(`    ${relative17(cwd, path)}`);
+    write(`    ${relative18(cwd, path)}`);
 }, printSummary = (title, outcome, cwd) => {
   for (const note of outcome.notes) {
     write(`${colors.yellow}!${colors.reset} ${note}`);
@@ -12760,9 +13325,9 @@ var init_catalog = __esm(() => {
 
 // src/cli/integrations/addPlugin.ts
 import { existsSync as existsSync26, readFileSync as readFileSync27 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var isRecord11 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readPackageJson = (cwd) => {
-  const path = join33(cwd, "package.json");
+  const path = join34(cwd, "package.json");
   if (!existsSync26(path))
     return null;
   try {
@@ -13259,14 +13824,14 @@ var init_authCatalog = __esm(() => {
 // src/cli/config/auth/resolveAuthSettings.ts
 import ts12 from "typescript";
 import { existsSync as existsSync27, readFileSync as readFileSync28 } from "fs";
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 var AUTH_PACKAGE = "@absolutejs/auth", CONFIG_CANDIDATES3, findAuthSettingsPath = (cwd, override) => {
   if (override) {
-    const resolved = resolve28(cwd, override);
+    const resolved = resolve29(cwd, override);
     return existsSync27(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES3) {
-    const candidate = resolve28(cwd, name);
+    const candidate = resolve29(cwd, name);
     if (existsSync27(candidate))
       return candidate;
   }
@@ -13364,7 +13929,7 @@ var init_resolveAuthSettings = __esm(() => {
 // src/cli/config/auth/resolveAuthState.ts
 import ts13 from "typescript";
 import { existsSync as existsSync28, readdirSync as readdirSync6, readFileSync as readFileSync29 } from "fs";
-import { join as join34, relative as relative18, resolve as resolve29 } from "path";
+import { join as join35, relative as relative19, resolve as resolve30 } from "path";
 var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutejs/absolute-auth", NPM_URL = "https://www.npmjs.com/package/@absolutejs/auth", SKIP_DIRS, MAX_FILES = 4000, SETUP_EXPORTS, isRecord12 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson2 = (path) => {
   if (!existsSync28(path))
     return null;
@@ -13378,7 +13943,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
   const value = record?.[key];
   return typeof value === "string" ? value : null;
 }, declaredVersionFor = (cwd) => {
-  const pkg = readJson2(join34(cwd, "package.json"));
+  const pkg = readJson2(join35(cwd, "package.json"));
   if (!pkg)
     return null;
   for (const field of ["dependencies", "devDependencies"]) {
@@ -13390,14 +13955,14 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
       return version2;
   }
   return null;
-}, installedVersionFor = (cwd) => stringField(readJson2(join34(cwd, "node_modules", AUTH_PACKAGE2, "package.json")), "version"), SOURCE_FILE, safeReaddir = (dir) => {
+}, installedVersionFor = (cwd) => stringField(readJson2(join35(cwd, "node_modules", AUTH_PACKAGE2, "package.json")), "version"), SOURCE_FILE, safeReaddir = (dir) => {
   try {
     return readdirSync6(dir, { withFileTypes: true });
   } catch {
     return [];
   }
 }, sortEntry = (dir, entry, found, dirs) => {
-  const full = join34(dir, entry.name);
+  const full = join35(dir, entry.name);
   if (entry.isDirectory()) {
     if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
       return;
@@ -13495,7 +14060,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
   scaffoldable: isScaffoldableFeature(feature.id)
 })), resolveAuthState = (cwd) => {
   const installedVersion = installedVersionFor(cwd);
-  const root = existsSync28(join34(cwd, "src")) ? join34(cwd, "src") : cwd;
+  const root = existsSync28(join35(cwd, "src")) ? join35(cwd, "src") : cwd;
   let match = null;
   let setupPath = null;
   for (const file of candidateFiles(root)) {
@@ -13503,7 +14068,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
     if (found === null)
       continue;
     match = found;
-    setupPath = relative18(cwd, resolve29(file));
+    setupPath = relative19(cwd, resolve30(file));
     break;
   }
   const keys = match?.keys ?? new Set;
@@ -13541,7 +14106,7 @@ var init_resolveAuthState = __esm(() => {
 
 // src/cli/config/auth/scaffoldAuthFeature.ts
 import { existsSync as existsSync29, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname22, join as join35, relative as relative19, resolve as resolve30 } from "path";
+import { dirname as dirname23, join as join36, relative as relative20, resolve as resolve31 } from "path";
 var renderScaffold = (scaffold) => {
   const importNames = [...scaffold.imports, `type ${scaffold.typeName}`];
   const importLine = `import { ${importNames.join(", ")} } from '@absolutejs/auth';`;
@@ -13566,8 +14131,8 @@ ${body}
 }, targetDir = (cwd) => {
   const { setupPath } = resolveAuthState(cwd);
   if (setupPath)
-    return dirname22(resolve30(cwd, setupPath));
-  const src = join35(cwd, "src");
+    return dirname23(resolve31(cwd, setupPath));
+  const src = join36(cwd, "src");
   return existsSync29(src) ? src : cwd;
 }, spreadFor = (scaffold) => `import { ${scaffold.exportName} } from './${scaffold.exportName}';
 // add to your auth() call:
@@ -13581,8 +14146,8 @@ ${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
   const scaffold = AUTH_SCAFFOLDS[id];
   if (!scaffold)
     return failure2(`Unknown auth feature "${id}".`);
-  const filePath = join35(targetDir(cwd), `${scaffold.exportName}.ts`);
-  const relPath = relative19(cwd, filePath);
+  const filePath = join36(targetDir(cwd), `${scaffold.exportName}.ts`);
+  const relPath = relative20(cwd, filePath);
   if (existsSync29(filePath)) {
     return {
       created: null,
@@ -13611,11 +14176,11 @@ var init_scaffoldAuthFeature = __esm(() => {
 
 // src/cli/htmx/install.ts
 import { existsSync as existsSync30, mkdirSync as mkdirSync14, readFileSync as readFileSync30, writeFileSync as writeFileSync16 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
-  join36(import.meta.dir, "htmx.min.js"),
-  join36(import.meta.dir, "htmx", "htmx.min.js"),
-  join36(import.meta.dir, "..", "htmx", "htmx.min.js")
+  join37(import.meta.dir, "htmx.min.js"),
+  join37(import.meta.dir, "htmx", "htmx.min.js"),
+  join37(import.meta.dir, "..", "htmx", "htmx.min.js")
 ].find((path) => existsSync30(path)) ?? null, detectHtmxVersion = (content) => {
   const match = content.match(/version:"([0-9.]+)"/);
   return match ? match[1] : null;
@@ -13627,7 +14192,7 @@ var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   }
   return response.text();
 }, installedHtmxVersion = (htmxDir) => {
-  const file = join36(htmxDir, "htmx.min.js");
+  const file = join37(htmxDir, "htmx.min.js");
   if (!existsSync30(file))
     return null;
   return detectHtmxVersion(readFileSync30(file, "utf-8"));
@@ -13636,7 +14201,7 @@ var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   return file ? readFileSync30(file, "utf-8") : null;
 }, writeHtmx = (htmxDir, content) => {
   mkdirSync14(htmxDir, { recursive: true });
-  const file = join36(htmxDir, "htmx.min.js");
+  const file = join37(htmxDir, "htmx.min.js");
   writeFileSync16(file, content, "utf-8");
   return file;
 };
@@ -13647,7 +14212,7 @@ var exports_add = {};
 __export(exports_add, {
   runAdd: () => runAdd
 });
-import { dirname as dirname23, join as join37, relative as relative20 } from "path";
+import { dirname as dirname24, join as join38, relative as relative21 } from "path";
 var write2 = (text2) => process.stdout.write(`${text2}
 `), fail2 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -13658,11 +14223,11 @@ var write2 = (text2) => process.stdout.write(`${text2}
     return;
   write2(`  ${colors.dim}${label}${colors.reset}`);
   for (const path of paths)
-    write2(`    ${relative20(cwd, path)}`);
+    write2(`    ${relative21(cwd, path)}`);
 }, frontendRoot = (project, cwd) => {
   const [firstKey] = configuredFrameworks(project);
   const firstDir = firstKey ? project.frameworkDirs[firstKey] : undefined;
-  return firstDir ? dirname23(firstDir) : join37(cwd, "src", "frontend");
+  return firstDir ? dirname24(firstDir) : join38(cwd, "src", "frontend");
 }, addIntegrationCli = (id, install) => {
   const result = addIntegration(process.cwd(), id, { install });
   if (!result.ok) {
@@ -13726,8 +14291,8 @@ var write2 = (text2) => process.stdout.write(`${text2}
     write2(`${colors.yellow}!${colors.reset} ${frameworks6[framework].label} is already configured \u2014 nothing to do.`);
     return;
   }
-  const dirAbs = join37(frontendRoot(project, cwd), framework);
-  const dirRel = `./${relative20(cwd, dirAbs).split("\\").join("/")}`;
+  const dirAbs = join38(frontendRoot(project, cwd), framework);
+  const dirRel = `./${relative21(cwd, dirAbs).split("\\").join("/")}`;
   let depNote = "Skipped dependency install (--no-install).";
   if (!noInstall) {
     write2(`${colors.dim}Installing ${frameworks6[framework].label} dependencies\u2026${colors.reset}`);
@@ -13797,7 +14362,7 @@ __export(exports_analyze, {
   runAnalyze: () => runAnalyze
 });
 import { existsSync as existsSync31, readFileSync as readFileSync31, statSync as statSync3, writeFileSync as writeFileSync17 } from "fs";
-import { join as join38, resolve as resolve31 } from "path";
+import { join as join39, resolve as resolve32 } from "path";
 var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_WIDTH = 16, SIZE_WIDTH = 12, CHANGE_WIDTH = 10, CATEGORY_ORDER, categoryOf = (key) => {
   if (key.startsWith("Island"))
     return "Islands";
@@ -13817,17 +14382,17 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
     return 0;
   }
 }, readSizes = (manifestDir) => {
-  const manifestPath = join38(manifestDir, "manifest.json");
+  const manifestPath = join39(manifestDir, "manifest.json");
   if (!existsSync31(manifestPath))
     return null;
   const manifest = JSON.parse(readFileSync31(manifestPath, "utf-8"));
   const sizes = {};
   for (const [key, value] of Object.entries(manifest)) {
-    sizes[key] = fileSize2(join38(manifestDir, value.replace(/^\//, "")));
+    sizes[key] = fileSize2(join39(manifestDir, value.replace(/^\//, "")));
   }
   return sizes;
 }, readBaseline = (cwd) => {
-  const path = join38(cwd, BASELINE_FILE);
+  const path = join39(cwd, BASELINE_FILE);
   if (!existsSync31(path))
     return null;
   try {
@@ -13909,14 +14474,14 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   const config = await loadConfig(configIndex >= 0 ? args[configIndex + 1] : undefined);
   const outdirIndex = args.indexOf("--outdir");
   const outdir = outdirIndex >= 0 ? args[outdirIndex + 1] : config.buildDirectory;
-  const sizes = readSizes(resolve31(cwd, outdir ?? "build"));
+  const sizes = readSizes(resolve32(cwd, outdir ?? "build"));
   if (sizes === null) {
     process.stdout.write(`${colors.dim}No build found. Run \`absolute build\` first.${colors.reset}
 `);
     return;
   }
   if (args.includes("--save")) {
-    writeFileSync17(join38(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
+    writeFileSync17(join39(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
 `);
     process.stdout.write(`${colors.green}\u2713${colors.reset} Saved size baseline (${Object.keys(sizes).length} entries) to ${BASELINE_FILE}
 `);
@@ -14163,7 +14728,7 @@ __export(exports_remove, {
   runRemove: () => runRemove
 });
 import { existsSync as existsSync32, readFileSync as readFileSync32 } from "fs";
-import { relative as relative21 } from "path";
+import { relative as relative22 } from "path";
 var write3 = (text2) => process.stdout.write(`${text2}
 `), fail3 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -14212,10 +14777,10 @@ var write3 = (text2) => process.stdout.write(`${text2}
   }
   write3(`${colors.green}\u2713${colors.reset} Removed ${framework}Directory from absolute.config.ts
 `);
-  write3(`  ${colors.dim}Kept${colors.reset}  ${relative21(cwd, frameworkDir)} \u2014 delete its source manually if no longer needed.`);
+  write3(`  ${colors.dim}Kept${colors.reset}  ${relative22(cwd, frameworkDir)} \u2014 delete its source manually if no longer needed.`);
   const refs = referencingFiles(project.serverEntry, HANDLER_NAME[framework]);
   for (const file of refs) {
-    write3(`  ${colors.yellow}Still references${colors.reset}  ${relative21(cwd, file)} (calls ${HANDLER_NAME[framework]})`);
+    write3(`  ${colors.yellow}Still references${colors.reset}  ${relative22(cwd, file)} (calls ${HANDLER_NAME[framework]})`);
   }
   const deps = frameworkDependencyNames(framework);
   if (prune && deps.length > 0) {
@@ -14304,9 +14869,9 @@ __export(exports_env, {
   collectEnvVars: () => collectEnvVars
 });
 import { existsSync as existsSync33, readFileSync as readFileSync33 } from "fs";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 var {env: env3, Glob: Glob3 } = globalThis.Bun;
-var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text2) => [...text2.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync33(join39(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
+var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text2) => [...text2.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync33(join40(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
   const scans = scanPatterns().map((pattern) => Array.fromAsync(new Glob3(pattern).scan({ cwd: process.cwd() })));
   const files = (await Promise.all(scans)).flat();
   const usage = new Map;
@@ -14373,7 +14938,7 @@ __export(exports_db, {
   chunkRows: () => chunkRows
 });
 import { existsSync as existsSync34, mkdirSync as mkdirSync15, readFileSync as readFileSync34, writeFileSync as writeFileSync18 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 var {env: env4, spawn: spawn2, SQL } = globalThis.Bun;
 var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA_TYPES, SEED_CANDIDATES, VALUE_FLAGS, paint = (text2, color) => `${color}${text2}${colors.reset}`, chunkRows = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, idx) => items.slice(idx * size, idx * size + size)), quoteIdent = (name) => `"${name.replace(/"/g, '""')}"`, resolveUrl = (explicit) => {
   const found = explicit ?? URL_ENV_KEYS.map((key) => env4[key]).find((value) => typeof value === "string" && value !== "");
@@ -14483,12 +15048,12 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
     tables,
     v: BACKUP_FORMAT_VERSION
   };
-  const dir = options.out ?? join40(process.cwd(), "backups");
+  const dir = options.out ?? join41(process.cwd(), "backups");
   mkdirSync15(dir, { recursive: true });
   const json = JSON.stringify(payload, (_, value) => typeof value === "bigint" ? value.toString() : value);
-  const file = join40(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
+  const file = join41(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
   writeFileSync18(file, json);
-  writeFileSync18(join40(dir, "latest.json"), json);
+  writeFileSync18(join41(dir, "latest.json"), json);
   const total = chosen.reduce((sum, name) => sum + (tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 backup \u2192 ${file}`, colors.green));
   console.log(paint(`  ${chosen.length} tables, ${total} rows`, colors.dim));
@@ -14517,7 +15082,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
   const total = order.reduce((sum, name) => sum + (payload.tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 restored ${order.length} tables, ${total} rows (idempotent upsert by primary key)`, colors.green));
 }, runSeed = async (entry) => {
-  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync34(join40(process.cwd(), candidate)));
+  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync34(join41(process.cwd(), candidate)));
   if (target === undefined)
     throw new Error(`No seed script found (looked for ${SEED_CANDIDATES.join(", ")}). Pass a path: absolute db seed <file>.`);
   console.log(paint(`seeding via ${target}\u2026`, colors.cyan));
@@ -14552,7 +15117,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
     return;
   }
   if (sub === "restore") {
-    const file = positionalArgs(rest)[0] ?? join40(process.cwd(), "backups", "latest.json");
+    const file = positionalArgs(rest)[0] ?? join41(process.cwd(), "backups", "latest.json");
     await runRestore(file, parseOptions(rest));
     return;
   }
@@ -14672,7 +15237,7 @@ import {
   writeFileSync as writeFileSync19
 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname24, join as join41, resolve as resolve32, sep as sep5 } from "path";
+import { dirname as dirname25, join as join42, resolve as resolve33, sep as sep5 } from "path";
 var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   try {
     const parsed = JSON.parse(readFileSync35(path, "utf-8"));
@@ -14692,13 +15257,13 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   const version2 = Reflect.get(manifest, "version");
   return typeof version2 === "string" ? version2 : "unknown";
 }, packageJsonFromEntry = (entry, expectedName) => {
-  let directory = dirname24(entry);
+  let directory = dirname25(entry);
   for (;; ) {
-    const candidate = join41(directory, "package.json");
+    const candidate = join42(directory, "package.json");
     const manifest = readManifest(candidate);
     if (manifest && manifestName(manifest, "") === expectedName)
       return candidate;
-    const parent = dirname24(directory);
+    const parent = dirname25(directory);
     if (parent === directory)
       return null;
     directory = parent;
@@ -14714,27 +15279,27 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
     }
   }
 }, findInstallRoot = (cwd) => {
-  let directory = resolve32(cwd);
+  let directory = resolve33(cwd);
   for (;; ) {
-    if (existsSync36(join41(directory, "bun.lock")) || existsSync36(join41(directory, "bun.lockb"))) {
+    if (existsSync36(join42(directory, "bun.lock")) || existsSync36(join42(directory, "bun.lockb"))) {
       return directory;
     }
-    const parent = dirname24(directory);
+    const parent = dirname25(directory);
     if (parent === directory)
-      return resolve32(cwd);
+      return resolve33(cwd);
     directory = parent;
   }
 }, findProjectManifest = (cwd, installRoot) => {
-  let directory = resolve32(cwd);
+  let directory = resolve33(cwd);
   for (;; ) {
-    const candidate = join41(directory, "package.json");
+    const candidate = join42(directory, "package.json");
     if (existsSync36(candidate))
       return candidate;
     if (directory === installRoot)
-      return join41(installRoot, "package.json");
-    const parent = dirname24(directory);
+      return join42(installRoot, "package.json");
+    const parent = dirname25(directory);
     if (parent === directory)
-      return join41(installRoot, "package.json");
+      return join42(installRoot, "package.json");
     directory = parent;
   }
 }, appendConsumer = (consumers, consumerPaths, path, manifest) => {
@@ -14772,7 +15337,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   appendConsumer(consumers, consumerPaths, inspection.consumer.path, inspection.consumer.manifest);
 }, inspectTypeGraph = (cwd) => {
   const installRoot = findInstallRoot(cwd);
-  const rootManifestPath = join41(installRoot, "package.json");
+  const rootManifestPath = join42(installRoot, "package.json");
   const rootManifest = readManifest(rootManifestPath) ?? {};
   const consumers = [
     { manifest: rootManifest, path: rootManifestPath }
@@ -14808,7 +15373,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   const duplicates = duplicateTypeGraphPackages(report);
   if (duplicates.length === 0)
     return [];
-  const manifestPath = join41(report.installRoot, "package.json");
+  const manifestPath = join42(report.installRoot, "package.json");
   const manifest = readManifest(manifestPath);
   if (!manifest)
     return [];
@@ -14830,7 +15395,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   }
   return changes;
 }, removeDuplicateTypeGraphPackages = (report) => {
-  const manifest = readManifest(join41(report.installRoot, "package.json")) ?? {};
+  const manifest = readManifest(join42(report.installRoot, "package.json")) ?? {};
   const rootName = manifestName(manifest, "<workspace>");
   const installPrefix = `${realpathSync2(report.installRoot)}${sep5}`;
   const nodeModulesSegment = `${sep5}node_modules${sep5}`;
@@ -14842,7 +15407,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   for (const stalePath of stalePaths) {
     if (!stalePath.startsWith(installPrefix) || !stalePath.includes(nodeModulesSegment))
       continue;
-    rmSync6(dirname24(stalePath), { force: true, recursive: true });
+    rmSync6(dirname25(stalePath), { force: true, recursive: true });
     removed.push(stalePath);
   }
   return removed;
@@ -14872,7 +15437,7 @@ __export(exports_doctor, {
 import { existsSync as existsSync37, mkdirSync as mkdirSync16, readFileSync as readFileSync36, writeFileSync as writeFileSync20 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { arch as arch4, platform as platform5 } from "os";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
   detail,
   label,
@@ -14907,7 +15472,7 @@ var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
     return [];
   const label = `${field.replace("Directory", "")} pages`;
   return [
-    existsSync37(join42(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
+    existsSync37(join43(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
   ];
 }), envCheck = async () => {
   const vars = await collectEnvVars();
@@ -14969,9 +15534,9 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const fixes = [];
   for (const field of FRAMEWORK_FIELDS2) {
     const dir = readString2(config, field);
-    if (dir === undefined || existsSync37(join42(cwd, dir)))
+    if (dir === undefined || existsSync37(join43(cwd, dir)))
       continue;
-    mkdirSync16(join42(cwd, dir, "pages"), { recursive: true });
+    mkdirSync16(join43(cwd, dir, "pages"), { recursive: true });
     fixes.push(`created ${dir}/pages`);
   }
   return fixes;
@@ -14979,7 +15544,7 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const missing = (await collectEnvVars()).filter((entry) => !entry.set);
   if (missing.length === 0)
     return null;
-  const envExample = join42(cwd, ".env.example");
+  const envExample = join43(cwd, ".env.example");
   const existing = existsSync37(envExample) ? readFileSync36(envExample, "utf-8") : "";
   const existingKeys = new Set(existing.split(`
 `).map((line) => line.split("=")[0]?.trim()));
@@ -15050,7 +15615,7 @@ var init_doctor = __esm(() => {
     "htmlDirectory",
     "htmxDirectory"
   ];
-  projectRequire = createRequire2(join42(process.cwd(), "package.json"));
+  projectRequire = createRequire2(join43(process.cwd(), "package.json"));
   STATUS_MARK = {
     fail: `${colors.red}\u2717${colors.reset}`,
     ok: `${colors.green}\u2713${colors.reset}`,
@@ -15440,7 +16005,7 @@ var init_sourceMetadata = __esm(() => {
 
 // src/islands/pageMetadata.ts
 import { readFileSync as readFileSync37 } from "fs";
-import { dirname as dirname25, resolve as resolve33 } from "path";
+import { dirname as dirname26, resolve as resolve34 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -15460,8 +16025,8 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve33(dirname25(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve33(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve34(dirname26(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve34(resolvedSource));
   }
   return lookup;
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage2) => {
@@ -15474,13 +16039,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve33(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve34(entry.dir), pattern);
   for (const filePath of files) {
     const source = readFileSync37(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve33(filePath), {
+    pageMetadata.set(resolve34(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve33(filePath)
+      pagePath: resolve34(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -15510,13 +16075,13 @@ __export(exports_islands, {
   runIslands: () => runIslands
 });
 import { existsSync as existsSync39, readFileSync as readFileSync38, statSync as statSync5 } from "fs";
-import { join as join43, relative as relative22, resolve as resolve34 } from "path";
+import { join as join44, relative as relative23, resolve as resolve35 } from "path";
 var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.write(`${colors.dim}${message}${colors.reset}
 `), hostFrameworkOf = (pagePath, cwd, config) => {
-  const resolved = resolve34(cwd, pagePath);
+  const resolved = resolve35(cwd, pagePath);
   for (const [framework, key] of Object.entries(FRAMEWORK_DIR_KEY)) {
     const dir = config[key];
-    if (typeof dir === "string" && resolved.startsWith(resolve34(cwd, dir))) {
+    if (typeof dir === "string" && resolved.startsWith(resolve35(cwd, dir))) {
       return framework;
     }
   }
@@ -15528,20 +16093,20 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
     return 0;
   }
 }, readManifestSizes2 = (manifestDir) => {
-  const manifestPath = join43(manifestDir, "manifest.json");
+  const manifestPath = join44(manifestDir, "manifest.json");
   if (!existsSync39(manifestPath))
     return null;
   const manifest = JSON.parse(readFileSync38(manifestPath, "utf-8"));
   const sizes = new Map;
   for (const [key, value] of Object.entries(manifest)) {
-    sizes.set(key, fileSize3(join43(manifestDir, value.replace(/^\//, ""))));
+    sizes.set(key, fileSize3(join44(manifestDir, value.replace(/^\//, ""))));
   }
   return sizes;
 }, collectIslands = async (cwd, config, sizes) => {
   const registryPath = config.islands?.registry;
   if (typeof registryPath !== "string")
     return null;
-  const buildInfo = await loadIslandRegistryBuildInfo(resolve34(cwd, registryPath));
+  const buildInfo = await loadIslandRegistryBuildInfo(resolve35(cwd, registryPath));
   const pageMetadata = await loadPageIslandMetadata(config);
   const usages = [...pageMetadata.values()].flatMap((meta) => meta.islands.map((island) => ({ ...island, page: meta.pagePath })));
   return buildInfo.definitions.map((definition) => {
@@ -15551,7 +16116,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
         crossFramework: hostFramework !== null && hostFramework !== definition.framework,
         hostFramework,
         hydrate: usage2.hydrate ?? "load",
-        page: relative22(cwd, resolve34(cwd, usage2.page))
+        page: relative23(cwd, resolve35(cwd, usage2.page))
       };
     });
     const key = getIslandManifestKey(definition.framework, definition.component);
@@ -15590,7 +16155,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
     `  ${color}\u2B21${colors.reset} ${colors.bold}${island.component}${colors.reset}  ${meta}${sizeText}`
   ];
   if (island.source) {
-    lines.push(`    ${colors.dim}${relative22(cwd, island.source)}${colors.reset}`);
+    lines.push(`    ${colors.dim}${relative23(cwd, island.source)}${colors.reset}`);
   }
   if (pages.length === 0) {
     lines.push(`    ${colors.dim}(registered but not mounted on any page)${colors.reset}`);
@@ -15620,7 +16185,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
   }
   const outdirIndex = args.indexOf("--outdir");
   const outdir = outdirIndex >= 0 ? args[outdirIndex + 1] : config.buildDirectory;
-  const sizes = args.includes("--sizes") ? readManifestSizes2(resolve34(cwd, outdir ?? "build")) : null;
+  const sizes = args.includes("--sizes") ? readManifestSizes2(resolve35(cwd, outdir ?? "build")) : null;
   const islands = await collectIslands(cwd, config, sizes);
   if (islands === null) {
     printDim6('No island registry configured. Set `islands: { registry: "..." }` in absolute.config.ts.');
@@ -15670,12 +16235,12 @@ var init_islands2 = __esm(() => {
 
 // src/build/externalAssetPlugin.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync40, mkdirSync as mkdirSync17, statSync as statSync6 } from "fs";
-import { basename as basename11, dirname as dirname26, join as join44, resolve as resolve35 } from "path";
+import { basename as basename12, dirname as dirname27, join as join45, resolve as resolve36 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
   setup(bld) {
     const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
-    const skipRoots = userSourceRoots.map((root) => resolve35(root));
+    const skipRoots = userSourceRoots.map((root) => resolve36(root));
     const isUserSource = (path) => skipRoots.some((root) => path.startsWith(`${root}/`));
     bld.onLoad({ filter: /\.[mc]?[jt]sx?$/ }, async (args) => {
       if (isUserSource(args.path))
@@ -15685,20 +16250,20 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         return;
       urlPattern.lastIndex = 0;
       let match;
-      const sourceDir = dirname26(args.path);
+      const sourceDir = dirname27(args.path);
       while ((match = urlPattern.exec(source)) !== null) {
         const relPath = match[1];
         if (!relPath)
           continue;
-        const assetPath = resolve35(sourceDir, relPath);
+        const assetPath = resolve36(sourceDir, relPath);
         if (!existsSync40(assetPath))
           continue;
         if (!statSync6(assetPath).isFile())
           continue;
-        const targetPath = join44(outDir, basename11(assetPath));
+        const targetPath = join45(outDir, basename12(assetPath));
         if (existsSync40(targetPath))
           continue;
-        mkdirSync17(dirname26(targetPath), { recursive: true });
+        mkdirSync17(dirname27(targetPath), { recursive: true });
         copyFileSync2(assetPath, targetPath);
       }
       return;
@@ -15727,12 +16292,12 @@ import {
 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import {
-  basename as basename12,
-  dirname as dirname27,
+  basename as basename13,
+  dirname as dirname28,
   isAbsolute as isAbsolute6,
-  join as join45,
-  relative as relative23,
-  resolve as resolve36
+  join as join46,
+  relative as relative24,
+  resolve as resolve37
 } from "path";
 var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, compileBanner = (version2) => {
   const resolvedVersion = version2 || "unknown";
@@ -15746,7 +16311,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join45(entry.parentPath, entry.name);
+    const fullPath = join46(entry.parentPath, entry.name);
     if (entry.isDirectory())
       pending = pending.concat(readdirSync7(fullPath, { withFileTypes: true }));
     else
@@ -15765,7 +16330,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!Array.isArray(map.sources))
     return;
   const sourceRoot = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
-  const bundleDirectory = dirname27(filePath);
+  const bundleDirectory = dirname28(filePath);
   map.sources = map.sources.map((entry) => {
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(entry))
       return entry;
@@ -15774,7 +16339,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(sourceRoot)) {
       return new URL(entry, sourceRoot).href;
     }
-    return resolve36(bundleDirectory, sourceRoot, entry);
+    return resolve37(bundleDirectory, sourceRoot, entry);
   });
   delete map.sourceRoot;
   const rebased = Buffer.from(JSON.stringify(map)).toString("base64");
@@ -15792,7 +16357,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join45(entry.parentPath, entry.name);
+    const fullPath = join46(entry.parentPath, entry.name);
     if (entry.isDirectory()) {
       if (SERVER_RUNTIME_SCAN_SKIP_DIRS.has(entry.name))
         continue;
@@ -15804,18 +16369,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return result;
 }, copyServerRuntimeAssetReferences = (outdir) => {
   const copied = new Set;
-  const normalizedOutdir = resolve36(outdir);
+  const normalizedOutdir = resolve37(outdir);
   const copyReference = (filePath, relPath) => {
-    const assetSource = resolve36(dirname27(filePath), relPath);
+    const assetSource = resolve37(dirname28(filePath), relPath);
     if (!existsSync41(assetSource) || !statSync7(assetSource).isFile())
       return;
-    const assetTarget = resolve36(normalizedOutdir, relPath.replace(/^\.\//, ""));
+    const assetTarget = resolve37(normalizedOutdir, relPath.replace(/^\.\//, ""));
     if (assetTarget !== normalizedOutdir && !assetTarget.startsWith(`${normalizedOutdir}/`))
       return;
     if (copied.has(assetTarget))
       return;
     copied.add(assetTarget);
-    mkdirSync18(dirname27(assetTarget), { recursive: true });
+    mkdirSync18(dirname28(assetTarget), { recursive: true });
     cpSync(assetSource, assetTarget, { force: true });
   };
   for (const filePath of collectProjectSourceFiles(process.cwd())) {
@@ -15883,18 +16448,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return resolveBuildModule3(remaining);
 }, resolveJsxDevRuntimeCompatPath2 = () => {
   const candidates = [
-    resolve36(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve36(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve36(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
-    resolve36(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve36(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve36(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve37(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve37(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve37(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
+    resolve37(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve37(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve37(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync41(candidate))
       return candidate;
   }
-  return resolve36(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
+  return resolve37(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
 }, jsxDevRuntimeCompatPath2, shouldEmbedCompiledAsset = (relativePath, skip = new Set) => {
   if (skip.has(relativePath))
     return false;
@@ -15919,7 +16484,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return true;
 }), requireForCompile, resolveNativeAssetForRuntime = (specifier) => {
   if (specifier.startsWith("."))
-    return resolve36(process.cwd(), specifier);
+    return resolve37(process.cwd(), specifier);
   if (specifier.startsWith("/"))
     return specifier;
   return requireForCompile.resolve(specifier, { paths: [process.cwd()] });
@@ -15931,11 +16496,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return nativeAssetEnv;
 }, tryReadNodePackageJson = (packageDir) => {
   try {
-    return JSON.parse(readFileSync39(join45(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(readFileSync39(join46(packageDir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
-}, resolveProjectPackageDir = (specifier) => resolve36(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
+}, resolveProjectPackageDir = (specifier) => resolve37(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
   if (seen.has(specifier))
     return;
   const srcDir = resolveProjectPackageDir(specifier);
@@ -15943,13 +16508,13 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!pkg)
     return;
   seen.add(specifier);
-  const destDir = join45(outdir, "node_modules", ...specifier.split("/"));
+  const destDir = join46(outdir, "node_modules", ...specifier.split("/"));
   rmSync7(destDir, { force: true, recursive: true });
   cpSync(srcDir, destDir, {
     force: true,
     recursive: true,
     filter(source) {
-      const rel = relative23(srcDir, source);
+      const rel = relative24(srcDir, source);
       const [firstSegment] = rel.split(/[\\/]/);
       return firstSegment !== "node_modules" && firstSegment !== ".git";
     }
@@ -15965,7 +16530,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
 }, copyAngularRuntimePackages = (buildConfig, outdir) => {
   if (!buildConfig.angularDirectory)
     return;
-  const angularScopeDir = resolve36(process.cwd(), "node_modules", "@angular");
+  const angularScopeDir = resolve37(process.cwd(), "node_modules", "@angular");
   const angularPackages = existsSync41(angularScopeDir) ? readdirSync7(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
   const roots = new Set([...angularPackages, "rxjs", "tslib", "typescript"]);
   const seen = new Set;
@@ -15984,7 +16549,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   copyAngularRuntimePackages(buildConfig, outdir);
   copyChunkReferencedPackages(outdir, seen);
 }, collectRuntimePackageSpecifiers = (distDir) => {
-  const nodeModulesDir = join45(distDir, "node_modules");
+  const nodeModulesDir = join46(distDir, "node_modules");
   if (!existsSync41(nodeModulesDir))
     return [];
   const specifiers = [];
@@ -15992,7 +16557,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!entry.isDirectory())
       continue;
     if (entry.name.startsWith("@")) {
-      const scopeDir = join45(nodeModulesDir, entry.name);
+      const scopeDir = join46(nodeModulesDir, entry.name);
       for (const scopedEntry of readdirSync7(scopeDir, {
         withFileTypes: true
       })) {
@@ -16006,7 +16571,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   return specifiers.sort((firstSpecifier, secondSpecifier) => secondSpecifier.length - firstSpecifier.length);
 }, ensureRelativeModuleSpecifier = (fromFile, toFile) => {
-  const rel = relative23(dirname27(fromFile), toFile).replace(/\\/g, "/");
+  const rel = relative24(dirname28(fromFile), toFile).replace(/\\/g, "/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }, pickExportEntry = (value) => {
   if (typeof value === "string")
@@ -16023,18 +16588,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const packageSpecifier = packageSpecifiers.find((root) => specifier === root || specifier.startsWith(`${root}/`));
   if (!packageSpecifier)
     return null;
-  const packageDir = join45(distDir, "node_modules", ...packageSpecifier.split("/"));
+  const packageDir = join46(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
-  const subPackageDir = subpath ? join45(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync41(join45(subPackageDir, "package.json")) ? subPackageDir : packageDir;
-  const packageJsonPath = join45(resolvedPackageDir, "package.json");
+  const subPackageDir = subpath ? join46(packageDir, ...subpath.slice(1).split("/")) : null;
+  const resolvedPackageDir = subPackageDir && existsSync41(join46(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const packageJsonPath = join46(resolvedPackageDir, "package.json");
   if (!existsSync41(packageJsonPath))
     return null;
   const pkg = JSON.parse(readFileSync39(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir !== subPackageDir && subpath ? `.${subpath}` : ".";
   const rootExport = pkg.exports?.[exportKey];
   const entry = pickExportEntry(rootExport) ?? (resolvedPackageDir === subPackageDir || !subpath ? pkg.module ?? pkg.main ?? "index.js" : `.${subpath}`);
-  return join45(resolvedPackageDir, entry);
+  return join46(resolvedPackageDir, entry);
 }, RUNTIME_JS_EXTENSIONS, MODULE_SPECIFIER_RE, isRuntimeJsFile = (filePath) => RUNTIME_JS_EXTENSIONS.some((extension) => filePath.endsWith(extension)), isNodeModulesPath = (filePath) => filePath.split(/[\\/]/).includes("node_modules"), isFile = (filePath) => {
   try {
     return statSync7(filePath).isFile();
@@ -16047,16 +16612,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const candidates = [
     candidate,
     ...RUNTIME_JS_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-    ...RUNTIME_JS_EXTENSIONS.map((extension) => join45(candidate, `index${extension}`))
+    ...RUNTIME_JS_EXTENSIONS.map((extension) => join46(candidate, `index${extension}`))
   ];
   return candidates.find((filePath) => isRuntimeJsFile(filePath) && isFile(filePath)) ?? null;
 }, findContainingRuntimePackageDir = (filePath) => {
-  let dir = dirname27(filePath);
-  while (dir !== dirname27(dir)) {
-    if (isNodeModulesPath(dir) && existsSync41(join45(dir, "package.json"))) {
+  let dir = dirname28(filePath);
+  while (dir !== dirname28(dir)) {
+    if (isNodeModulesPath(dir) && existsSync41(join46(dir, "package.json"))) {
       return dir;
     }
-    dir = dirname27(dir);
+    dir = dirname28(dir);
   }
   return null;
 }, resolvePackageImportEntryFile = (fromFile, specifier) => {
@@ -16069,11 +16634,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const entry = pickExportEntry(pkg?.imports?.[specifier]);
   if (!entry)
     return null;
-  return join45(packageDir, entry);
+  return join46(packageDir, entry);
 }, collectRuntimeRewriteRoots = (distDir) => collectFiles2(distDir).filter((filePath) => isRuntimeJsFile(filePath) && !isNodeModulesPath(filePath)), toTopLevelPackage = (specifier) => specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/"), FRAMEWORK_PACKAGE_NAME = "@absolutejs/absolute", copyChunkReferencedPackages = (distDir, seen) => {
-  const distRoot = resolve36(distDir);
+  const distRoot = resolve37(distDir);
   for (const filePath of collectRuntimeRewriteRoots(distDir)) {
-    if (resolve36(dirname27(filePath)) === distRoot)
+    if (resolve37(dirname28(filePath)) === distRoot)
       continue;
     const source = readFileSync39(filePath, "utf-8");
     for (const match of source.matchAll(MODULE_SPECIFIER_RE)) {
@@ -16109,7 +16674,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const { masked, restore } = maskLiterals(source);
     const rewrittenMasked = masked.replace(MODULE_SPECIFIER_RE, (match, prefix, quote, specifier) => {
       if (typeof specifier === "string" && specifier.startsWith(".")) {
-        enqueue(resolveRuntimeJsFile(resolve36(dirname27(filePath), specifier)));
+        enqueue(resolveRuntimeJsFile(resolve37(dirname28(filePath), specifier)));
         return match;
       }
       const packageImportTarget = resolveRuntimeJsFile(resolvePackageImportEntryFile(filePath, specifier) ?? "");
@@ -16130,7 +16695,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
 }, generateEntrypoint = (distDir, serverEntry, prerenderMap, version2, buildConfig) => {
   const allFiles = collectFiles2(distDir);
-  const serverBundleName = `${basename12(serverEntry).replace(/\.[^.]+$/, "")}.js`;
+  const serverBundleName = `${basename13(serverEntry).replace(/\.[^.]+$/, "")}.js`;
   const embeddedSkip = new Set(["_compile_entrypoint.ts"]);
   const assetSkip = new Set([
     serverBundleName,
@@ -16138,12 +16703,12 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     "_compile_entrypoint.ts"
   ]);
   const embeddedFiles = allFiles.filter((file) => {
-    const rel = relative23(distDir, file);
+    const rel = relative24(distDir, file);
     if (embeddedSkip.has(rel))
       return false;
     return true;
   });
-  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative23(distDir, file), assetSkip));
+  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative24(distDir, file), assetSkip));
   const imports = [];
   const nativeImports = [];
   const nativeMappings = [];
@@ -16153,19 +16718,19 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const nativeAssets = resolveCompileNativeAssets(buildConfig);
   nativeAssets.forEach((asset, idx) => {
     const varName = `__native${idx}`;
-    const importSpecifier = asset.import.startsWith(".") ? resolve36(process.cwd(), asset.import) : asset.import;
+    const importSpecifier = asset.import.startsWith(".") ? resolve37(process.cwd(), asset.import) : asset.import;
     nativeImports.push(`import ${varName} from ${JSON.stringify(importSpecifier)} with { type: "file" };`);
     nativeMappings.push(`	[${JSON.stringify(asset.env)}, resolveNativeAssetPath(${varName})],`);
   });
   embeddedFiles.forEach((filePath, idx) => {
-    const rel = relative23(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative24(distDir, filePath).replace(/\\/g, "/");
     const varName = `__a${idx}`;
     embeddedVarMap.set(rel, varName);
     imports.push(`import ${varName} from "./${rel}" with { type: "file" };`);
     embeddedMappings.push(`	["${rel}", ${varName}],`);
   });
   clientFiles.forEach((filePath) => {
-    const rel = relative23(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative24(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (!varName)
       return;
@@ -16179,7 +16744,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const pageVarMap = new Map;
   const prerenderEntries = Array.from(prerenderMap.entries());
   prerenderEntries.forEach(([route, filePath]) => {
-    const rel = relative23(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative24(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (varName)
       pageVarMap.set(route, varName);
@@ -16212,7 +16777,7 @@ import { buildGlobalWSHandler } from "elysia/ws";
 const SERVER_MODULE = (runtimeDir: string) => import(pathToFileURL(join(runtimeDir, ${JSON.stringify(serverBundleName)})).href);
 const RUNTIME_BUILD_ID = ${JSON.stringify(runtimeBuildId)};
 const RUNTIME_CONFIG_SOURCE = ${JSON.stringify(runtimeConfigSource)};
-const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve36(distDir))};
+const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve37(distDir))};
 const ORIGINAL_BUILD_DIR_NORMALIZED = ORIGINAL_BUILD_DIR.replace(/\\\\/g, "/");
 const EMBEDDED_NATIVE_AUTH_CLIENTS = ${JSON.stringify(process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV])};
 
@@ -16633,17 +17198,17 @@ console.log(\`
     });
   }
 }), compile = async (serverEntry, outdir, outfile, configPath2) => {
-  const resolvedOutdir = resolve36(outdir ?? "dist");
+  const resolvedOutdir = resolve37(outdir ?? "dist");
   await withBuildDirectoryLock(resolvedOutdir, () => compileUnlocked(serverEntry, resolvedOutdir, outfile, configPath2));
 }, compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath2) => {
   const configuredPrerenderPort = env5.COMPILE_PORT === undefined ? Number(env5.PORT) : Number(env5.COMPILE_PORT);
   const prerenderPort = configuredPrerenderPort > 0 ? configuredPrerenderPort : await findFreePort();
   killStaleProcesses(prerenderPort);
-  const entryName = basename12(serverEntry).replace(/\.[^.]+$/, "");
-  const resolvedOutfile = resolve36(outfile ?? "compiled-server");
+  const entryName = basename13(serverEntry).replace(/\.[^.]+$/, "");
+  const resolvedOutfile = resolve37(outfile ?? "compiled-server");
   const absoluteVersion = resolvePackageVersion3([
-    resolve36(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve36(import.meta.dir, "..", "..", "package.json")
+    resolve37(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve37(import.meta.dir, "..", "..", "package.json")
   ]);
   compileBanner(absoluteVersion);
   const totalStart = performance.now();
@@ -16656,8 +17221,8 @@ console.log(\`
     installAbsoluteMobileAuthEnvironment(process.cwd(), normalizeAbsoluteMobileConfig(buildConfig.mobile, process.cwd()));
   try {
     const build2 = await resolveBuildModule3([
-      resolve36(import.meta.dir, "..", "..", "core", "build"),
-      resolve36(import.meta.dir, "..", "build")
+      resolve37(import.meta.dir, "..", "..", "core", "build"),
+      resolve37(import.meta.dir, "..", "build")
     ]);
     if (!build2)
       throw new Error("Could not locate build module");
@@ -16679,11 +17244,11 @@ console.log(\`
     buildConfig.htmxDirectory
   ].filter((dir) => Boolean(dir));
   const islandRegistrySpec = buildConfig.islands?.registry;
-  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve36(islandRegistrySpec))) : undefined;
-  const serverBundleEntryDirectory = join45(resolvedOutdir, ".absolutejs-server-entry");
+  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve37(islandRegistrySpec))) : undefined;
+  const serverBundleEntryDirectory = join46(resolvedOutdir, ".absolutejs-server-entry");
   mkdirSync18(serverBundleEntryDirectory, { recursive: true });
-  const typeboxSetupEntry = join45(serverBundleEntryDirectory, "_typebox_setup.ts");
-  const serverBundleEntry = join45(serverBundleEntryDirectory, basename12(serverEntry));
+  const typeboxSetupEntry = join46(serverBundleEntryDirectory, "_typebox_setup.ts");
+  const serverBundleEntry = join46(serverBundleEntryDirectory, basename13(serverEntry));
   writeFileSync21(typeboxSetupEntry, `import { setupTypebox } from 'elysia';
 import * as compile from 'typebox/compile';
 import * as schema from 'typebox/schema';
@@ -16694,7 +17259,7 @@ import * as value from 'typebox/value';
 setupTypebox({ typebox: { compile, schema, system, type, value } });
 `);
   writeFileSync21(serverBundleEntry, `import './_typebox_setup';
-import * as serverModule from ${JSON.stringify(resolve36(serverEntry))};
+import * as serverModule from ${JSON.stringify(resolve37(serverEntry))};
 
 export const server = serverModule.server ?? serverModule.app ?? serverModule.default;
 export default server;
@@ -16708,7 +17273,7 @@ export default server;
       ...islandRegistryPlugin ? [islandRegistryPlugin] : [],
       ...buildConfig.mobile ? [
         createAbsoluteMobileRouteMetadataPlugin({
-          entry: resolve36(serverEntry)
+          entry: resolve37(serverEntry)
         })
       ] : [],
       createElysiaOpenApiTypeboxPlugin(),
@@ -16732,13 +17297,13 @@ export default server;
     console.error(cliTag4("\x1B[31m", "Server bundle failed."));
     process.exit(1);
   }
-  const outputPath = resolve36(resolvedOutdir, `${entryName}.js`);
+  const outputPath = resolve37(resolvedOutdir, `${entryName}.js`);
   if (!existsSync41(outputPath)) {
     console.error(cliTag4("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync41(resolve36(resolvedOutdir, "angular", "vendor", "server"))) {
-    const vendorDir = resolve36(resolvedOutdir, "angular", "vendor", "server");
+  if (existsSync41(resolve37(resolvedOutdir, "angular", "vendor", "server"))) {
+    const vendorDir = resolve37(resolvedOutdir, "angular", "vendor", "server");
     const vendorEntries = readdirSync7(vendorDir).filter((fileName) => fileName.endsWith(".js"));
     const angularServerVendorPaths = {};
     for (const file of vendorEntries) {
@@ -16747,7 +17312,7 @@ export default server;
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = relative23(dirname27(outputPath), resolve36(vendorDir, file));
+      const relPath = relative24(dirname28(outputPath), resolve37(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
@@ -16759,7 +17324,7 @@ export default server;
   copyServerRuntimeAssetReferences(resolvedOutdir);
   const prerenderStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Pre-rendering pages"));
-  rmSync7(join45(resolvedOutdir, "_prerendered"), {
+  rmSync7(join46(resolvedOutdir, "_prerendered"), {
     force: true,
     recursive: true
   });
@@ -16789,9 +17354,9 @@ export default server;
   const compileStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Compiling standalone executable"));
   const entrypointCode = generateEntrypoint(resolvedOutdir, serverEntry, prerenderMap, absoluteVersion, buildConfig);
-  const entrypointPath = join45(resolvedOutdir, "_compile_entrypoint.ts");
+  const entrypointPath = join46(resolvedOutdir, "_compile_entrypoint.ts");
   await Bun.write(entrypointPath, entrypointCode);
-  mkdirSync18(dirname27(resolvedOutfile), { recursive: true });
+  mkdirSync18(dirname28(resolvedOutfile), { recursive: true });
   const result = await Bun.build({
     compile: { outfile: resolvedOutfile },
     define: { "process.env.NODE_ENV": '"production"' },
@@ -16820,7 +17385,7 @@ export default server;
   const size = (Bun.file(resolvedOutfile).size / BYTES_PER_MB).toFixed(0);
   const totalDuration = getDurationString(performance.now() - totalStart);
   console.log(cliTag4("\x1B[32m", `Compiled to ${resolvedOutfile} (${size}MB) in ${totalDuration}`));
-  console.log(cliTag4("\x1B[2m", `Run with: ./${basename12(resolvedOutfile)}`));
+  console.log(cliTag4("\x1B[2m", `Run with: ./${basename13(resolvedOutfile)}`));
   sendTelemetryEvent("compile:complete", {
     durationMs: Math.round(performance.now() - totalStart),
     entry: serverEntry,
@@ -16874,15 +17439,15 @@ var init_compile = __esm(() => {
 });
 
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile12, rename as rename8, writeFile as writeFile9 } from "fs/promises";
-import { join as join46 } from "path";
+import { readFile as readFile13, rename as rename9, writeFile as writeFile10 } from "fs/promises";
+import { join as join47 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->", END_MARKER = "<!-- absolutejs:deep-links:end -->", IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements", NOT_FOUND = -1, escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"), writeChangedFile = async (path, source) => {
-  const current = await readFile12(path, "utf8");
+  const current = await readFile13(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile9(temporary, source, { flag: "wx" });
-  await rename8(temporary, path);
+  await writeFile10(temporary, source, { flag: "wx" });
+  await rename9(temporary, path);
   return true;
 }, replaceManagedRegion = (source, region, insertAt) => {
   const start2 = source.indexOf(START_MARKER);
@@ -16924,8 +17489,8 @@ ${hosts}
             ${END_MARKER}
 `;
 }, configureAndroid = async (config) => {
-  const path = join46(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile12(path, "utf8");
+  const path = join47(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile13(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
     throw new TypeError("Android MainActivity was not found.");
@@ -16948,8 +17513,8 @@ ${hosts}
 	</array>
 	${END_MARKER}
 `, configureIosInfo = async (config) => {
-  const path = join46(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile12(path, "utf8");
+  const path = join47(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile13(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
 `;
@@ -16970,10 +17535,10 @@ ${domains}
 </plist>
 `;
 }, configureIosEntitlements = async (config) => {
-  const path = join46(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join47(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
-    current = await readFile12(path, "utf8");
+    current = await readFile13(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -16983,12 +17548,12 @@ ${domains}
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile9(temporary, source, { flag: "wx" });
-  await rename8(temporary, path);
+  await writeFile10(temporary, source, { flag: "wx" });
+  await rename9(temporary, path);
   return true;
 }, configureIosProject = async (config) => {
-  const path = join46(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const source = await readFile12(path, "utf8");
+  const path = join47(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const source = await readFile13(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
   ].map((match) => match[1]);
@@ -17026,28 +17591,28 @@ ${domains}
 var init_nativeDeepLinks = () => {};
 
 // src/mobile/nativeDeviceCapabilities.ts
-import { readFile as readFile13, rename as rename9, writeFile as writeFile10 } from "fs/promises";
-import { join as join47 } from "path";
+import { readFile as readFile14, rename as rename10, writeFile as writeFile11 } from "fs/promises";
+import { join as join48 } from "path";
 var START_MARKER2 = "<!-- absolutejs:device-capabilities:start -->", END_MARKER2 = "<!-- absolutejs:device-capabilities:end -->", NOT_FOUND2 = -1, IOS_PRIVACY_FILE_REFERENCE = "A85D0C000000000000000001", IOS_PRIVACY_BUILD_FILE = "A85D0C000000000000000002", PUSH_START_MARKER = "absolutejs:push-notifications:start", PUSH_END_MARKER = "absolutejs:push-notifications:end", escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"), writeChangedFile2 = 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 rename9(temporary, path);
+  await writeFile11(temporary, source, { flag: "wx" });
+  await rename10(temporary, path);
   return true;
 }, writeOptionalChangedFile = async (path, source) => {
   const current = await optionalSource(path);
   if (current === source)
     return false;
   if (current === null) {
-    await writeFile10(path, source, { flag: "wx" });
+    await writeFile11(path, source, { flag: "wx" });
     return true;
   }
   return writeChangedFile2(path, source);
 }, optionalSource = async (path) => {
   try {
-    return await readFile13(path, "utf8");
+    return await readFile14(path, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "ENOENT")
       return null;
@@ -17149,13 +17714,13 @@ ${entries}
     return false;
   if (current !== null)
     return writeChangedFile2(path, source);
-  await writeFile10(path, source, { flag: "wx" });
+  await writeFile11(path, source, { flag: "wx" });
   return true;
 }, configureIosPrivacyProject = async (config, requirements) => {
   if (requirements.iosPrivacyAccessedApis.length === 0)
     return false;
-  const projectPath = join47(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const project = await readFile13(projectPath, "utf8");
+  const projectPath = join48(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const project = await readFile14(projectPath, "utf8");
   return writeChangedFile2(projectPath, addIosPrivacyProjectReference(project));
 }, addIosPrivacyProjectReference = (source) => {
   const fileMatch = source.match(/([A-F0-9]{24}) \/\* PrivacyInfo\.xcprivacy \*\/ = \{isa = PBXFileReference;/u);
@@ -17205,8 +17770,8 @@ ${next.slice(index)}`;
   }
   return next;
 }, configureIos2 = async (config, plan) => {
-  const path = join47(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile13(path, "utf8");
+  const path = join48(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile14(path, "utf8");
   const requirements = absoluteDeviceNativeRequirements(plan);
   const existingSystemBars = source.match(/<key>UIViewControllerBasedStatusBarAppearance<\/key>\s*<(true|false)\s*\/>/u);
   const ownedStart = source.indexOf(START_MARKER2);
@@ -17226,7 +17791,7 @@ ${content}
 	${END_MARKER2}
 ` : "";
   const infoChanged = await writeChangedFile2(path, managed(source, region, source.lastIndexOf("</dict>")));
-  const privacyPath = join47(config.nativeProjectDirectory, "ios/App/App/PrivacyInfo.xcprivacy");
+  const privacyPath = join48(config.nativeProjectDirectory, "ios/App/App/PrivacyInfo.xcprivacy");
   const privacyCurrent = await optionalSource(privacyPath);
   const privacySource = privacyManifestSource(privacyCurrent, requirements);
   const [privacyChanged, projectChanged, pushChanged] = await Promise.all([
@@ -17236,7 +17801,7 @@ ${content}
   ]);
   return infoChanged || privacyChanged || projectChanged || pushChanged;
 }, configureIosPushNotifications = async (config, enabled) => {
-  const entitlementsPath = join47(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const entitlementsPath = join48(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   const entitlements = await optionalSource(entitlementsPath);
   if (entitlements === null && !enabled)
     return false;
@@ -17248,7 +17813,7 @@ ${content}
 	<!-- ${PUSH_END_MARKER} -->
 ` : "";
   const nextEntitlements = replacePushRegion(entitlements, entitlementRegion, entitlements.lastIndexOf("</dict>"));
-  const delegatePath = join47(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
+  const delegatePath = join48(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
   const delegate = await optionalSource(delegatePath);
   if (delegate === null && !enabled)
     return false;
@@ -17295,8 +17860,8 @@ ${content}
     throw new TypeError("Could not find a safe native project location for push notifications.");
   return `${source.slice(0, insertion)}${region}${source.slice(insertion)}`;
 }, configureAndroid2 = async (config, plan) => {
-  const path = join47(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile13(path, "utf8");
+  const path = join48(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile14(path, "utf8");
   const permissions = absoluteDeviceNativeRequirements(plan).androidPermissions;
   const content = permissions.map((permission) => `    <uses-permission android:name="${escapeXml2(permission)}" />`).join(`
 `);
@@ -17331,7 +17896,7 @@ ${content}
     throw new TypeError(`Android google-services.json does not contain package ${config.appId}.`);
   const [manifestChanged, firebaseChanged] = await Promise.all([
     writeChangedFile2(path, nextManifest),
-    writeOptionalChangedFile(join47(config.nativeProjectDirectory, "android/app/google-services.json"), firebaseSource)
+    writeOptionalChangedFile(join48(config.nativeProjectDirectory, "android/app/google-services.json"), firebaseSource)
   ]);
   return manifestChanged || firebaseChanged;
 }, applyAbsoluteNativeDeviceCapabilities = async (projectRoot, config, platforms = config.platforms, plan = resolveAbsoluteDeviceCapabilityPlan(projectRoot)) => {
@@ -17355,15 +17920,15 @@ var init_nativeDeviceCapabilities = __esm(() => {
 });
 
 // src/mobile/nativeBackgroundSync.ts
-import { readFile as readFile14, rename as rename10, writeFile as writeFile11 } from "fs/promises";
-import { join as join48 } from "path";
+import { readFile as readFile15, rename as rename11, writeFile as writeFile12 } from "fs/promises";
+import { join as join49 } from "path";
 var writeChanged = async (path, source) => {
-  const current = await readFile14(path, "utf8");
+  const current = await readFile15(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile11(temporary, source, { flag: "wx" });
-  await rename10(temporary, path);
+  await writeFile12(temporary, source, { flag: "wx" });
+  await rename11(temporary, path);
   return true;
 }, replaceRegion = (source, start2, end, region, insert) => {
   const existingStart = source.indexOf(start2);
@@ -17439,11 +18004,11 @@ ${makeRegion(values)}	</array>
   if (!platforms.includes("ios") || !projectUsesAbsoluteAuth(projectRoot) || !projectUsesAbsoluteSync(projectRoot))
     return { changed: false };
   const identifier = `${config.appId}.absolutejs.background-sync`;
-  const infoPath = join48(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const info2 = await readFile14(infoPath, "utf8");
+  const infoPath = join49(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const info2 = await readFile15(infoPath, "utf8");
   const nextInfo = ensurePlistArrayValues(ensurePlistArrayValues(info2, "BGTaskSchedulerPermittedIdentifiers", [identifier], "background-sync-identifiers"), "UIBackgroundModes", ["fetch", "processing"], "background-sync-modes");
-  const delegatePath = join48(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
-  let delegate = await readFile14(delegatePath, "utf8");
+  const delegatePath = join49(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
+  let delegate = await readFile15(delegatePath, "utf8");
   if (!delegate.includes("import AbsoluteSyncCapacitor")) {
     const importIndex = delegate.lastIndexOf("import Capacitor");
     if (importIndex < 0)
@@ -17475,14 +18040,14 @@ var init_nativeBackgroundSync = __esm(() => {
 
 // src/mobile/associationFiles.ts
 import {
-  access as access7,
-  mkdir as mkdir10,
-  readFile as readFile15,
-  rename as rename11,
-  rm as rm7,
-  writeFile as writeFile12
+  access as access8,
+  mkdir as mkdir11,
+  readFile as readFile16,
+  rename as rename12,
+  rm as rm8,
+  writeFile as writeFile13
 } from "fs/promises";
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 import { Elysia } from "elysia";
 var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERIFY_TIMEOUT_MS = 1e4, ANDROID_ASSOCIATION_PATH = "/.well-known/assetlinks.json", APPLE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association", missingIdentity = (field, platform6) => new TypeError(`${field} is required to publish ${platform6} deep-link association files.`), createAppleDocument = (config, requireAll) => {
   if (!config.platforms.includes("ios"))
@@ -17535,7 +18100,7 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
 }, writeAtomic = async (path, source) => {
   let current;
   try {
-    current = await readFile15(path, "utf8");
+    current = await readFile16(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -17544,21 +18109,21 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile12(temporary, source, { flag: "wx" });
-  await rename11(temporary, path);
+  await writeFile13(temporary, source, { flag: "wx" });
+  await rename12(temporary, path);
   return true;
-}, exists2 = async (path) => {
+}, exists3 = async (path) => {
   try {
-    await access7(path);
+    await access8(path);
     return true;
   } catch {
     return false;
   }
 }, assertOwnedOutput = async (root) => {
-  const path = resolve37(root, OWNERSHIP_FILE);
+  const path = resolve38(root, OWNERSHIP_FILE);
   let ownership;
   try {
-    ownership = JSON.parse(await readFile15(path, "utf8"));
+    ownership = JSON.parse(await readFile16(path, "utf8"));
   } catch {
     throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
   }
@@ -17566,26 +18131,26 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
     throw new TypeError(`Association output ${root} has an unsupported ownership manifest.`);
   }
 }, publishGeneratedDirectory = async (temporary, root) => {
-  const hasCurrent = await exists2(root);
+  const hasCurrent = await exists3(root);
   if (hasCurrent)
     await assertOwnedOutput(root);
   const backup = `${root}.${crypto.randomUUID()}.previous`;
   if (hasCurrent)
-    await rename11(root, backup);
+    await rename12(root, backup);
   try {
-    await rename11(temporary, root);
+    await rename12(temporary, root);
   } catch (error) {
     if (hasCurrent)
-      await rename11(backup, root);
+      await rename12(backup, root);
     throw error;
   }
   if (hasCurrent)
-    await rm7(backup, { force: true, recursive: true });
+    await rm8(backup, { force: true, recursive: true });
 }, materializeHost = async (root, host2, files) => {
-  const directory = resolve37(root, host2, ".well-known");
-  await mkdir10(directory, { recursive: true });
+  const directory = resolve38(root, host2, ".well-known");
+  await mkdir11(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document]) => {
-    const path = resolve37(directory, name);
+    const path = resolve38(directory, name);
     await writeAtomic(path, `${JSON.stringify(document, null, 2)}
 `);
     return path;
@@ -17608,7 +18173,7 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
     });
   return endpoints;
 }), materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
-  const root = resolve37(outputDirectory);
+  const root = resolve38(outputDirectory);
   const temporary = `${root}.${crypto.randomUUID()}.tmp`;
   const documents = createAbsoluteMobileAssociationDocuments(config, {
     requireAll: true
@@ -17619,16 +18184,16 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
   if (documents.apple) {
     files.push(["apple-app-site-association", documents.apple]);
   }
-  await mkdir10(temporary, { recursive: true });
+  await mkdir11(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host2) => materializeHost(temporary, host2, files)))).flat();
-    await writeAtomic(resolve37(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+    await writeAtomic(resolve38(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
 `);
     await publishGeneratedDirectory(temporary, root);
-    const written = temporaryPaths.map((path) => resolve37(root, path.slice(temporary.length + 1)));
+    const written = temporaryPaths.map((path) => resolve38(root, path.slice(temporary.length + 1)));
     return { root, written };
   } catch (error) {
-    await rm7(temporary, { force: true, recursive: true });
+    await rm8(temporary, { force: true, recursive: true });
     throw error;
   }
 }, verifyAbsoluteMobileAssociationFiles = async (config, request = globalThis.fetch) => {
@@ -17666,8 +18231,8 @@ var init_associationFiles = __esm(() => {
 });
 
 // src/mobile/androidWebView.ts
-import { mkdir as mkdir11, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname28, resolve as resolve38 } from "path";
+import { mkdir as mkdir12, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname29, resolve as resolve39 } from "path";
 
 class CdpConnection {
   diagnostics = [];
@@ -17938,9 +18503,9 @@ var CDP_COMMAND_TIMEOUT_MS = 1e4, WEBVIEW_ATTACH_TIMEOUT_MS = 30000, WEBVIEW_POL
       if (typeof data !== "string") {
         throw new Error("Android WebView screenshot returned no image data.");
       }
-      const absolutePath = resolve38(path);
-      await mkdir11(dirname28(absolutePath), { recursive: true });
-      await writeFile13(absolutePath, Buffer.from(data, "base64"));
+      const absolutePath = resolve39(path);
+      await mkdir12(dirname29(absolutePath), { recursive: true });
+      await writeFile14(absolutePath, Buffer.from(data, "base64"));
       return absolutePath;
     },
     tap: async (coordinateX, coordinateY) => {
@@ -18071,21 +18636,21 @@ var DEFAULT_ROUTE_TIMEOUT_MS = 30000, DEFAULT_HMR_TIMEOUT_MS = 30000, routeExpre
 };
 
 // src/mobile/mobileBundleInspection.ts
-import { createHash as createHash12 } from "crypto";
-import { access as access8, readFile as readFile16, stat as stat2 } from "fs/promises";
-import { join as join49, relative as relative24, resolve as resolve39 } from "path";
+import { createHash as createHash13 } from "crypto";
+import { access as access9, readFile as readFile17, stat as stat2 } from "fs/promises";
+import { join as join50, relative as relative25, resolve as resolve40 } from "path";
 var MOBILE_FRAMEWORKS, SHA256_PATTERN, isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), portablePath = (projectRoot, path) => {
-  const value = relative24(resolve39(projectRoot), resolve39(path)).replaceAll("\\", "/");
+  const value = relative25(resolve40(projectRoot), resolve40(path)).replaceAll("\\", "/");
   return value || ".";
 }, pathExists5 = async (path) => {
   try {
-    await access8(path);
+    await access9(path);
     return true;
   } catch {
     return false;
   }
 }, readObject = async (path) => {
-  const value = JSON.parse(await readFile16(path, "utf8"));
+  const value = JSON.parse(await readFile17(path, "utf8"));
   if (!isObject2(value))
     throw new TypeError("JSON root must be an object.");
   return value;
@@ -18099,8 +18664,8 @@ var MOBILE_FRAMEWORKS, SHA256_PATTERN, isObject2 = (value) => typeof value === "
   return value;
 }, requireBundleFile = async (root, value, field, expectedHash) => {
   const portable = requireString(value, field);
-  const path = resolve39(root, portable);
-  const normalizedRoot = resolve39(root);
+  const path = resolve40(root, portable);
+  const normalizedRoot = resolve40(root);
   if (path === normalizedRoot || !path.startsWith(`${normalizedRoot}/`))
     throw new TypeError(`${field} must remain inside the mobile bundle.`);
   if (!(await stat2(path).catch(() => {
@@ -18110,13 +18675,13 @@ var MOBILE_FRAMEWORKS, SHA256_PATTERN, isObject2 = (value) => typeof value === "
   if (expectedHash !== undefined) {
     if (!SHA256_PATTERN.test(expectedHash))
       throw new TypeError(`${field} has an invalid SHA-256 digest.`);
-    const actual = createHash12("sha256").update(await readFile16(path)).digest("hex");
+    const actual = createHash13("sha256").update(await readFile17(path)).digest("hex");
     if (actual !== expectedHash)
       throw new TypeError(`${field} failed its SHA-256 integrity check.`);
   }
   return portable;
 }, inspectAbsoluteMobileBundle = async (config, projectRoot) => {
-  const manifestPath = join49(config.bundleDirectory, "absolute-mobile-manifest.json");
+  const manifestPath = join50(config.bundleDirectory, "absolute-mobile-manifest.json");
   const manifest = portablePath(projectRoot, manifestPath);
   if (!await pathExists5(manifestPath))
     return { manifest, status: "missing" };
@@ -18216,11 +18781,11 @@ var init_mobileBundleInspection = __esm(() => {
 });
 
 // src/mobile/releaseDoctor.ts
-import { access as access9, readFile as readFile17, readdir as readdir4 } from "fs/promises";
-import { dirname as dirname29, extname as extname8, join as join50, relative as relative25 } from "path";
+import { access as access10, readFile as readFile18, readdir as readdir5 } from "fs/promises";
+import { dirname as dirname30, extname as extname8, join as join51, relative as relative26 } from "path";
 var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, EXACT_VERSION_PATTERN, NOT_FOUND3 = -1, LOCK_FILES, MANUAL_REVIEW, pathExists6 = async (path) => {
   try {
-    await access9(path);
+    await access10(path);
     return true;
   } catch {
     return false;
@@ -18230,13 +18795,13 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
     return findHmrAsset(path);
   if (!isFile2 || !RELEASE_ASSET_EXTENSIONS.has(extname8(path)))
     return;
-  const source = await readFile17(path, "utf8");
+  const source = await readFile18(path, "utf8");
   return HMR_ASSET_PATTERN.test(source) ? path : undefined;
 }, findHmrAsset = async (root) => {
   if (!await pathExists6(root))
     return;
-  const entries = await readdir4(root, { withFileTypes: true });
-  const matches = await Promise.all(entries.map((entry) => inspectReleaseAsset(join50(root, entry.name), entry.isDirectory(), entry.isFile())));
+  const entries = await readdir5(root, { withFileTypes: true });
+  const matches = await Promise.all(entries.map((entry) => inspectReleaseAsset(join51(root, entry.name), entry.isDirectory(), entry.isFile())));
   return matches.find((match) => match !== undefined);
 }, pass = (id, detail, path) => ({ detail, id, path, status: "pass" }), fail5 = (id, detail, path, remediation) => ({
   detail,
@@ -18251,7 +18816,7 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   remediation,
   status: "warn"
 }), readJsonObject = async (path) => {
-  const value = JSON.parse(await readFile17(path, "utf8"));
+  const value = JSON.parse(await readFile18(path, "utf8"));
   if (typeof value !== "object" || value === null || Array.isArray(value))
     throw new TypeError("JSON root must be an object.");
   return Object.fromEntries(Object.entries(value));
@@ -18267,7 +18832,7 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   }
   return declarations;
 }, versionCore = (version2) => version2.split("-")[0]?.split(".").slice(0, 2).join("."), capacitorVersionCheck = async (config, projectRoot) => {
-  const manifestPath = join50(projectRoot, "package.json");
+  const manifestPath = join51(projectRoot, "package.json");
   try {
     const manifest = await readJsonObject(manifestPath);
     const declarations = packageDeclarations(manifest);
@@ -18280,7 +18845,7 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
       const declared = declarations.get(name);
       if (!declared || !EXACT_VERSION_PATTERN.test(declared))
         throw new TypeError(`${name} must be a direct exact dependency.`);
-      const installed = await readJsonObject(join50(projectRoot, "node_modules", name, "package.json"));
+      const installed = await readJsonObject(join51(projectRoot, "node_modules", name, "package.json"));
       if (installed.version !== declared)
         throw new TypeError(`${name} does not match its installed version.`);
       return declared;
@@ -18294,10 +18859,10 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   }
 }, dependencyLockCheck = async (projectRoot) => {
   const present = (await Promise.all(LOCK_FILES.map(async (name) => ({
-    exists: await pathExists6(join50(projectRoot, name)),
+    exists: await pathExists6(join51(projectRoot, name)),
     name
-  })))).find(({ exists: exists3 }) => exists3);
-  return present ? pass("mobile.dependency-lock", `Dependency graph is locked by ${present.name}.`, join50(projectRoot, present.name)) : fail5("mobile.dependency-lock", "No supported dependency lockfile is present.", projectRoot, "Install dependencies with the project package manager and commit its lockfile before release.");
+  })))).find(({ exists: exists4 }) => exists4);
+  return present ? pass("mobile.dependency-lock", `Dependency graph is locked by ${present.name}.`, join51(projectRoot, present.name)) : fail5("mobile.dependency-lock", "No supported dependency lockfile is present.", projectRoot, "Install dependencies with the project package manager and commit its lockfile before release.");
 }, productionOriginCheck = (config, projectRoot) => {
   const origin = new URL(config.productionOrigin);
   return origin.protocol === "https:" ? pass("mobile.production-origin", "Production transport uses an HTTPS origin.") : fail5("mobile.production-origin", "A loopback development origin cannot be used for a signed release.", projectRoot, "Configure mobile.server.productionOrigin with the deployed HTTPS origin.");
@@ -18332,7 +18897,7 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   if (!await pathExists6(nativeConfigPath)) {
     return fail5("android.capacitor-config", "The generated Android Capacitor config is missing.", nativeConfigPath, "Run `absolute mobile sync android` before release validation.");
   }
-  const unsafe = isUnsafeCapacitorConfig(await readFile17(nativeConfigPath, "utf8"));
+  const unsafe = isUnsafeCapacitorConfig(await readFile18(nativeConfigPath, "utf8"));
   return unsafe ? fail5("android.capacitor-config", "Android Capacitor config contains a development server URL, cleartext transport, navigation allowlist, or invalid JSON.", nativeConfigPath, "Run `absolute mobile sync android`; do not ship development transport overrides.") : pass("android.capacitor-config", "Android Capacitor config contains no development transport overrides.", nativeConfigPath);
 }, capacitorIdentityCheck = async (config, platform6, nativeConfigPath) => {
   try {
@@ -18347,12 +18912,12 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   if (!await pathExists6(manifestPath)) {
     return fail5("android.cleartext", "The Android manifest is missing.", manifestPath, "Run `absolute mobile sync android` before release validation.");
   }
-  const source = await readFile17(manifestPath, "utf8");
+  const source = await readFile18(manifestPath, "utf8");
   const cleartext = /android:usesCleartextTraffic=["']true["']/u.test(source);
   const networkConfigName = source.match(/android:networkSecurityConfig=["']@xml\/([a-z0-9_]+)["']/u)?.[1];
-  const networkConfigPath = networkConfigName ? join50(dirname29(manifestPath), "res", "xml", `${networkConfigName}.xml`) : undefined;
+  const networkConfigPath = networkConfigName ? join51(dirname30(manifestPath), "res", "xml", `${networkConfigName}.xml`) : undefined;
   const developmentTrustReference = /android:networkSecurityConfig=["']@xml\/absolutejs_dev_network_security["']/u.test(source);
-  const developmentTrustContents = networkConfigPath ? await readFile17(networkConfigPath, "utf8").then((value) => value.includes("@raw/absolutejs_dev_ca")).catch(() => false) : false;
+  const developmentTrustContents = networkConfigPath ? await readFile18(networkConfigPath, "utf8").then((value) => value.includes("@raw/absolutejs_dev_ca")).catch(() => false) : false;
   const developmentTrust = developmentTrustReference || developmentTrustContents;
   return cleartext || developmentTrust ? fail5("android.cleartext", developmentTrust ? "Android still references the AbsoluteJS development certificate authority." : "Android explicitly permits cleartext traffic.", manifestPath, "Run `absolute mobile sync android`; do not ship development transport or trust overrides.") : pass("android.cleartext", "Android does not explicitly permit cleartext traffic.", manifestPath);
 }, hmrAssetsReleaseCheck = async (publicRoot) => {
@@ -18361,12 +18926,12 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
 }, embeddedBundleReleaseCheck = async (config, projectRoot, platform6, publicRoot) => {
   const inspection = await inspectAbsoluteMobileBundle({ ...config, bundleDirectory: publicRoot }, projectRoot);
   if (inspection.status === "valid")
-    return pass(`${platform6}.bundle-integrity`, `Packaged mobile manifest, runtime, routes, and ${inspection.pageCount ?? 0} page asset(s) passed structural and SHA-256 validation.`, join50(publicRoot, "absolute-mobile-manifest.json"));
-  return fail5(`${platform6}.bundle-integrity`, inspection.status === "missing" ? "The packaged mobile manifest is missing." : `The packaged mobile bundle is invalid: ${inspection.issue ?? "unknown validation error"}`, join50(publicRoot, "absolute-mobile-manifest.json"), "Rebuild the production mobile bundle and run Capacitor sync for this platform.");
+    return pass(`${platform6}.bundle-integrity`, `Packaged mobile manifest, runtime, routes, and ${inspection.pageCount ?? 0} page asset(s) passed structural and SHA-256 validation.`, join51(publicRoot, "absolute-mobile-manifest.json"));
+  return fail5(`${platform6}.bundle-integrity`, inspection.status === "missing" ? "The packaged mobile manifest is missing." : `The packaged mobile bundle is invalid: ${inspection.issue ?? "unknown validation error"}`, join51(publicRoot, "absolute-mobile-manifest.json"), "Rebuild the production mobile bundle and run Capacitor sync for this platform.");
 }, contentSecurityPolicyCheck = async (config, platform6, publicRoot) => {
-  const path = join50(publicRoot, "index.html");
+  const path = join51(publicRoot, "index.html");
   try {
-    const source = await readFile17(path, "utf8");
+    const source = await readFile18(path, "utf8");
     const requirements = [
       "Content-Security-Policy",
       "default-src 'self'",
@@ -18387,18 +18952,18 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   if (!await pathExists6(root))
     return [];
   const files = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: root, onlyFiles: true }));
-  return files.filter((file) => extensions.has(extname8(file))).map((file) => join50(root, file));
+  return files.filter((file) => extensions.has(extname8(file))).map((file) => join51(root, file));
 }, containsPattern = async (paths, pattern) => {
-  const sources = await Promise.all(paths.map((path) => readFile17(path, "utf8")));
+  const sources = await Promise.all(paths.map((path) => readFile18(path, "utf8")));
   const index = sources.findIndex((source) => pattern.test(source));
   return index === NOT_FOUND3 ? undefined : paths[index];
 }, androidNativeSecurityCheck = async (androidRoot) => {
-  const manifestPath = join50(androidRoot, "app/src/main/AndroidManifest.xml");
+  const manifestPath = join51(androidRoot, "app/src/main/AndroidManifest.xml");
   try {
-    const manifest = await readFile17(manifestPath, "utf8");
+    const manifest = await readFile18(manifestPath, "utf8");
     if (/android:debuggable=["']true["']/u.test(manifest))
       throw new TypeError("Android release manifest explicitly enables application debugging.");
-    const sources = await sourceFiles(join50(androidRoot, "app/src/main"), new Set([".java", ".kt"]));
+    const sources = await sourceFiles(join51(androidRoot, "app/src/main"), new Set([".java", ".kt"]));
     const debugSource = await containsPattern(sources, /setWebContentsDebuggingEnabled\s*\(\s*true\s*\)/u);
     if (debugSource)
       return fail5("android.native-debugging", "Android application source unconditionally enables WebView debugging.", debugSource, "Remove the unconditional WebView debugging call; use the platform debug-build behavior during development.");
@@ -18407,14 +18972,14 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
     return fail5("android.native-debugging", error instanceof Error ? error.message : "Android native debugging configuration could not be validated.", manifestPath, "Remove explicit release debugging settings and rerun mobile sync.");
   }
 }, androidExportedComponentsCheck = async (manifestPath) => {
-  const source = await readFile17(manifestPath, "utf8").catch(() => "");
+  const source = await readFile18(manifestPath, "utf8").catch(() => "");
   const exported = [
     ...source.matchAll(/<(?:activity|activity-alias|provider|receiver|service)\b[^>]*>/giu)
   ].map(([tag]) => tag).filter((tag) => /android:exported=["']true["']/iu.test(tag)).map((tag) => tag.match(/android:name=["']([^"']+)["']/iu)?.[1]).filter((name) => Boolean(name) && name !== ".MainActivity");
   return exported.length === 0 ? pass("android.exported-components", "No non-launcher Android component is explicitly exported.", manifestPath) : warn("android.exported-components", `${exported.length} non-launcher Android component(s) are exported and require manual authorization review.`, manifestPath, "Confirm each exported component is intentional, permission-protected where appropriate, and documented in the mobile threat model review.");
 }, androidDeepLinkProjectionCheck = async (config, manifestPath) => {
   try {
-    const source = await readFile17(manifestPath, "utf8");
+    const source = await readFile18(manifestPath, "utf8");
     const required = [
       'android:autoVerify="true"',
       "android.intent.category.BROWSABLE",
@@ -18428,24 +18993,24 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
     return fail5("android.deep-links", error instanceof Error ? error.message : "Android deep-link projection could not be validated.", manifestPath, "Run `absolute mobile sync android` and review the AbsoluteJS-owned deep-link region.");
   }
 }, iosNativeSecurityCheck = async (iosRoot) => {
-  const entitlementsPath = join50(iosRoot, "App/AbsoluteJS.entitlements");
-  const entitlements = await readFile17(entitlementsPath, "utf8").catch(() => "");
+  const entitlementsPath = join51(iosRoot, "App/AbsoluteJS.entitlements");
+  const entitlements = await readFile18(entitlementsPath, "utf8").catch(() => "");
   if (/<key>get-task-allow<\/key>\s*<true\s*\/>/u.test(entitlements) || /<key>com\.apple\.security\.get-task-allow<\/key>\s*<true\s*\/>/u.test(entitlements))
     return fail5("ios.native-debugging", "iOS source entitlements explicitly permit debugger attachment.", entitlementsPath, "Remove get-task-allow from source entitlements; Xcode supplies development entitlements only to debug builds.");
-  const sources = await sourceFiles(join50(iosRoot, "App"), new Set([".m", ".mm", ".swift"]));
+  const sources = await sourceFiles(join51(iosRoot, "App"), new Set([".m", ".mm", ".swift"]));
   const debugSource = await containsPattern(sources, /\.isInspectable\s*=\s*true|setInspectable\s*\(\s*true\s*\)/u);
   if (debugSource)
     return fail5("ios.native-debugging", "iOS application source unconditionally enables WebView inspection.", debugSource, "Remove unconditional WebView inspection from release source.");
   return pass("ios.native-debugging", "iOS source does not enable release debugger attachment or WebView inspection.", entitlementsPath);
 }, iosDeepLinkProjectionCheck = async (config, iosRoot) => {
-  const infoPath = join50(iosRoot, "App/App/Info.plist");
-  const entitlementsPath = join50(iosRoot, "App/AbsoluteJS.entitlements");
-  const projectPath = join50(iosRoot, "App/App.xcodeproj/project.pbxproj");
+  const infoPath = join51(iosRoot, "App/App/Info.plist");
+  const entitlementsPath = join51(iosRoot, "App/AbsoluteJS.entitlements");
+  const projectPath = join51(iosRoot, "App/App.xcodeproj/project.pbxproj");
   try {
     const [info2, entitlements, project] = await Promise.all([
-      readFile17(infoPath, "utf8"),
-      readFile17(entitlementsPath, "utf8"),
-      readFile17(projectPath, "utf8")
+      readFile18(infoPath, "utf8"),
+      readFile18(entitlementsPath, "utf8"),
+      readFile18(projectPath, "utf8")
     ]);
     if (config.deepLinkScheme && (!info2.includes("<key>CFBundleURLTypes</key>") || !info2.includes(`<string>${config.deepLinkScheme}</string>`)))
       throw new TypeError("iOS custom URL scheme does not match mobile config.");
@@ -18460,7 +19025,7 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
 }, syncSchemaReleaseCheck = (projectRoot) => {
   if (!projectUsesAbsoluteSync(projectRoot))
     return;
-  const manifestPath = join50(projectRoot, "package.json");
+  const manifestPath = join51(projectRoot, "package.json");
   try {
     const schema = discoverAbsoluteSyncSchema(projectRoot);
     const versions = schema.components.map((component2) => `${component2.id}@${component2.version}`).join(", ");
@@ -18482,8 +19047,8 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
 }, IOS_USAGE_KEYS, androidDevicePermissionCheck = async (config, permissions) => {
   if (!config.platforms.includes("android") || permissions.length === 0)
     return;
-  const path = join50(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile17(path, "utf8");
+  const path = join51(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile18(path, "utf8");
   const missing = permissions.filter((permission) => !source.includes(`android:name="${permission}"`) && !source.includes(`android:name='${permission}'`));
   if (missing.length === 0)
     return;
@@ -18491,8 +19056,8 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
 }, iosDevicePermissionCheck = async (config, purposes) => {
   if (!config.platforms.includes("ios") || purposes.length === 0)
     return;
-  const path = join50(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile17(path, "utf8");
+  const path = join51(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile18(path, "utf8");
   const missing = purposes.filter((purpose) => !source.includes(`<key>${IOS_USAGE_KEYS[purpose]}</key>`));
   if (missing.length === 0)
     return;
@@ -18500,35 +19065,35 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
 }, iosCapabilityProjectionCheck = async (config, requirements) => {
   if (!config.platforms.includes("ios"))
     return;
-  const appRoot = join50(config.nativeProjectDirectory, "ios/App/App");
-  const infoPath = join50(appRoot, "Info.plist");
-  const info2 = await readFile17(infoPath, "utf8").catch(() => "");
+  const appRoot = join51(config.nativeProjectDirectory, "ios/App/App");
+  const infoPath = join51(appRoot, "Info.plist");
+  const info2 = await readFile18(infoPath, "utf8").catch(() => "");
   if (requirements.iosSystemBars && !/<key>UIViewControllerBasedStatusBarAppearance<\/key>\s*<true\s*\/>/u.test(info2))
     return fail5("mobile.device-capabilities", "iOS system-bar capability is missing its required view-controller setting.", infoPath, "Run `absolute mobile sync ios` to regenerate native capability settings.");
   if (requirements.iosPrivacyAccessedApis.length > 0) {
-    const privacyPath = join50(appRoot, "PrivacyInfo.xcprivacy");
-    const projectPath = join50(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+    const privacyPath = join51(appRoot, "PrivacyInfo.xcprivacy");
+    const projectPath = join51(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
     const [privacy, project] = await Promise.all([
-      readFile17(privacyPath, "utf8").catch(() => ""),
-      readFile17(projectPath, "utf8").catch(() => "")
+      readFile18(privacyPath, "utf8").catch(() => ""),
+      readFile18(projectPath, "utf8").catch(() => "")
     ]);
     const missing = requirements.iosPrivacyAccessedApis.some(({ api, reasons }) => !privacy.includes(`<string>${api}</string>`) || reasons.some((reason) => !privacy.includes(`<string>${reason}</string>`)));
     if (missing || !project.includes("PrivacyInfo.xcprivacy in Resources"))
       return fail5("mobile.device-capabilities", "iOS privacy manifest or target membership does not match detected native capabilities.", privacyPath, "Run `absolute mobile sync ios` to regenerate and target PrivacyInfo.xcprivacy.");
   }
   if (requirements.iosPushNotifications) {
-    const entitlementsPath = join50(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
-    const delegatePath = join50(appRoot, "AppDelegate.swift");
+    const entitlementsPath = join51(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+    const delegatePath = join51(appRoot, "AppDelegate.swift");
     const [entitlements, delegate] = await Promise.all([
-      readFile17(entitlementsPath, "utf8").catch(() => ""),
-      readFile17(delegatePath, "utf8").catch(() => "")
+      readFile18(entitlementsPath, "utf8").catch(() => ""),
+      readFile18(delegatePath, "utf8").catch(() => "")
     ]);
     if (!entitlements.includes("<key>aps-environment</key>") || !delegate.includes("capacitorDidRegisterForRemoteNotifications") || !delegate.includes("capacitorDidFailToRegisterForRemoteNotifications"))
       return fail5("mobile.device-capabilities", "iOS push entitlement or AppDelegate forwarding does not match detected capabilities.", entitlementsPath, "Run `absolute mobile sync ios` to regenerate native push integration.");
   }
   return;
 }, deviceCapabilityReleaseCheck = async (config, projectRoot) => {
-  const manifestPath = join50(projectRoot, "package.json");
+  const manifestPath = join51(projectRoot, "package.json");
   try {
     const plan = resolveAbsoluteDeviceCapabilityPlan(projectRoot);
     assertAbsoluteDeviceCapabilityPackages(projectRoot, plan);
@@ -18547,11 +19112,11 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
     return fail5("mobile.device-capabilities", error instanceof Error ? error.message : "Native device capability provisioning is invalid.", manifestPath, "Run `absolute mobile sync` and approve the exact capability plugins before releasing.");
   }
 }, inspectAndroidRelease = async (config, projectRoot) => {
-  const androidRoot = join50(config.nativeProjectDirectory, "android");
-  const nativeConfigPath = join50(androidRoot, "app", "src", "main", "assets", "capacitor.config.json");
-  const manifestPath = join50(androidRoot, "app", "src", "main", "AndroidManifest.xml");
-  const publicRoot = join50(androidRoot, "app", "src", "main", "assets", "public");
-  const journalPath = join50(projectRoot, ".absolutejs", "mobile", "dev-session", "journal.json");
+  const androidRoot = join51(config.nativeProjectDirectory, "android");
+  const nativeConfigPath = join51(androidRoot, "app", "src", "main", "assets", "capacitor.config.json");
+  const manifestPath = join51(androidRoot, "app", "src", "main", "AndroidManifest.xml");
+  const publicRoot = join51(androidRoot, "app", "src", "main", "assets", "public");
+  const journalPath = join51(projectRoot, ".absolutejs", "mobile", "dev-session", "journal.json");
   const checks = await Promise.all([
     journalReleaseCheck(journalPath, "android"),
     capacitorConfigReleaseCheck(nativeConfigPath),
@@ -18566,14 +19131,14 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   ]);
   return checks.map((check2) => ({
     ...check2,
-    path: check2.path ? relative25(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
+    path: check2.path ? relative26(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
   }));
 }, inspectIosRelease = async (config, projectRoot) => {
-  const iosAppRoot = join50(config.nativeProjectDirectory, "ios", "App", "App");
-  const nativeConfigPath = join50(iosAppRoot, "capacitor.config.json");
-  const infoPath = join50(iosAppRoot, "Info.plist");
-  const publicRoot = join50(iosAppRoot, "public");
-  const journalPath = join50(projectRoot, ".absolutejs", "mobile", "ios-dev-session", "journal.json");
+  const iosAppRoot = join51(config.nativeProjectDirectory, "ios", "App", "App");
+  const nativeConfigPath = join51(iosAppRoot, "capacitor.config.json");
+  const infoPath = join51(iosAppRoot, "Info.plist");
+  const publicRoot = join51(iosAppRoot, "public");
+  const journalPath = join51(projectRoot, ".absolutejs", "mobile", "ios-dev-session", "journal.json");
   const checks = [
     await journalReleaseCheck(journalPath, "ios")
   ];
@@ -18584,7 +19149,7 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   }
   if (!await pathExists6(nativeConfigPath)) {
     checks.push(fail5("ios.capacitor-config", "The generated iOS Capacitor config is missing.", nativeConfigPath, "Run `absolute mobile sync ios` before release validation."));
-  } else if (isUnsafeCapacitorConfig(await readFile17(nativeConfigPath, "utf8"))) {
+  } else if (isUnsafeCapacitorConfig(await readFile18(nativeConfigPath, "utf8"))) {
     checks.push(fail5("ios.capacitor-config", "iOS Capacitor config contains a development server URL, cleartext transport, navigation allowlist, or invalid JSON.", nativeConfigPath, "Run `absolute mobile sync ios`; do not ship development transport overrides."));
   } else {
     checks.push(pass("ios.capacitor-config", "iOS Capacitor config contains no development transport overrides.", nativeConfigPath));
@@ -18593,15 +19158,15 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   if (!await pathExists6(infoPath)) {
     checks.push(fail5("ios.transport-security", "The iOS Info.plist is missing.", infoPath, "Run `absolute mobile sync ios` before release validation."));
   } else {
-    const info2 = await readFile17(infoPath, "utf8");
+    const info2 = await readFile18(infoPath, "utf8");
     checks.push(/<key>NSAllowsArbitraryLoads<\/key>\s*<true\s*\/>/u.test(info2) ? fail5("ios.transport-security", "iOS App Transport Security permits arbitrary network loads.", infoPath, "Remove NSAllowsArbitraryLoads from the release Info.plist.") : pass("ios.transport-security", "iOS App Transport Security does not permit arbitrary loads.", infoPath));
   }
   const hmrAsset = await findHmrAsset(publicRoot);
   checks.push(hmrAsset ? fail5("ios.hmr-assets", "A packaged iOS asset contains the development HMR client.", hmrAsset, "Rebuild the production mobile bundle and run Capacitor sync again.") : pass("ios.hmr-assets", "Packaged iOS assets contain no development HMR markers.", publicRoot));
-  checks.push(await embeddedBundleReleaseCheck(config, projectRoot, "ios", publicRoot), await contentSecurityPolicyCheck(config, "ios", publicRoot), await iosNativeSecurityCheck(join50(config.nativeProjectDirectory, "ios")), await iosDeepLinkProjectionCheck(config, join50(config.nativeProjectDirectory, "ios")));
+  checks.push(await embeddedBundleReleaseCheck(config, projectRoot, "ios", publicRoot), await contentSecurityPolicyCheck(config, "ios", publicRoot), await iosNativeSecurityCheck(join51(config.nativeProjectDirectory, "ios")), await iosDeepLinkProjectionCheck(config, join51(config.nativeProjectDirectory, "ios")));
   return checks.map((check2) => ({
     ...check2,
-    path: check2.path ? relative25(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
+    path: check2.path ? relative26(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
   }));
 }, createAbsoluteMobileComplianceReport = (config, result) => {
   const summary = {
@@ -18631,7 +19196,7 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   ]);
   const checks = globalChecks.map((check2) => ({
     ...check2,
-    path: check2.path ? relative25(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
+    path: check2.path ? relative26(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
   }));
   if (config.platforms.includes("android"))
     checks.push(...await inspectAndroidRelease(config, projectRoot));
@@ -18642,13 +19207,13 @@ var ABSOLUTE_MOBILE_COMPLIANCE_REPORT_FORMAT = 1, HMR_ASSET_PATTERN, RELEASE_ASS
   if (syncSchema) {
     checks.push({
       ...syncSchema,
-      path: syncSchema.path ? relative25(projectRoot, syncSchema.path).replaceAll("\\", "/") || "." : undefined
+      path: syncSchema.path ? relative26(projectRoot, syncSchema.path).replaceAll("\\", "/") || "." : undefined
     });
   }
   const deviceCapabilities = await deviceCapabilityReleaseCheck(config, projectRoot);
   checks.push({
     ...deviceCapabilities,
-    path: deviceCapabilities.path ? relative25(projectRoot, deviceCapabilities.path).replaceAll("\\", "/") || "." : undefined
+    path: deviceCapabilities.path ? relative26(projectRoot, deviceCapabilities.path).replaceAll("\\", "/") || "." : undefined
   });
   return {
     checks,
@@ -18687,19 +19252,19 @@ var init_releaseDoctor = __esm(() => {
 });
 
 // src/mobile/androidRelease.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import {
-  access as access10,
+  access as access11,
   copyFile as copyFile5,
-  mkdir as mkdir12,
-  mkdtemp as mkdtemp5,
-  readFile as readFile18,
-  rename as rename12,
-  rm as rm8,
+  mkdir as mkdir13,
+  mkdtemp as mkdtemp6,
+  readFile as readFile19,
+  rename as rename13,
+  rm as rm9,
   stat as stat3,
-  writeFile as writeFile14
+  writeFile as writeFile15
 } from "fs/promises";
-import { dirname as dirname30, isAbsolute as isAbsolute7, join as join51, relative as relative26, resolve as resolve40, sep as sep6 } from "path";
+import { dirname as dirname31, isAbsolute as isAbsolute7, join as join52, relative as relative27, resolve as resolve41, sep as sep6 } from "path";
 var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), requireManifest2 = (value) => {
   if (!isRecord13(value) || typeof value.appBuild !== "string" || typeof value.appId !== "string" || typeof value.runtime !== "string") {
     throw new TypeError("Invalid embedded AbsoluteJS mobile manifest.");
@@ -18711,7 +19276,7 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
   };
 }, pathExists7 = async (path) => {
   try {
-    await access10(path);
+    await access11(path);
     return true;
   } catch {
     return false;
@@ -18763,20 +19328,20 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
   ]);
   if (result.exitCode !== 0)
     throw new TypeError("jarsigner could not sign the Android App Bundle with the configured CI identity.");
-}, sha256File2 = async (path) => createHash13("sha256").update(await readFile18(path)).digest("hex"), safeOutputDirectory2 = (projectRoot, requested) => {
-  const root = resolve40(projectRoot);
-  const output = resolve40(root, requested ?? ".absolutejs/mobile/releases/android");
-  const projectRelative = relative26(root, output);
+}, sha256File2 = async (path) => createHash14("sha256").update(await readFile19(path)).digest("hex"), safeOutputDirectory2 = (projectRoot, requested) => {
+  const root = resolve41(projectRoot);
+  const output = resolve41(root, requested ?? ".absolutejs/mobile/releases/android");
+  const projectRelative = relative27(root, output);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute7(projectRelative)) {
     throw new TypeError("mobile build --outdir must remain inside the project.");
   }
   return output;
 }, installRelease2 = async (artifactPath, metadata, outputRoot) => {
-  const releaseRoot = join51(outputRoot, metadata.releaseId);
+  const releaseRoot = join52(outputRoot, metadata.releaseId);
   const artifactName = "app-release.aab";
-  const destination = join51(releaseRoot, artifactName);
+  const destination = join52(releaseRoot, artifactName);
   if (await pathExists7(releaseRoot)) {
-    const existing = requireManifestIdentity(JSON.parse(await readFile18(join51(releaseRoot, "release.json"), "utf8")), metadata);
+    const existing = requireManifestIdentity(JSON.parse(await readFile19(join52(releaseRoot, "release.json"), "utf8")), metadata);
     const [installedBytes, installedSha256] = await Promise.all([
       stat3(destination).then(({ size }) => size),
       sha256File2(destination)
@@ -18786,20 +19351,20 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
     }
     return { artifactPath: destination, metadata: existing, releaseRoot };
   }
-  await mkdir12(dirname30(releaseRoot), { recursive: true });
-  const staging = await mkdtemp5(join51(dirname30(releaseRoot), ".android-stage-"));
+  await mkdir13(dirname31(releaseRoot), { recursive: true });
+  const staging = await mkdtemp6(join52(dirname31(releaseRoot), ".android-stage-"));
   try {
-    await copyFile5(artifactPath, join51(staging, artifactName));
+    await copyFile5(artifactPath, join52(staging, artifactName));
     const complete = {
       ...metadata,
       artifact: artifactName
     };
-    await writeFile14(join51(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+    await writeFile15(join52(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
 `, { flag: "wx" });
-    await rename12(staging, releaseRoot);
+    await rename13(staging, releaseRoot);
     return { artifactPath: destination, metadata: complete, releaseRoot };
   } finally {
-    await rm8(staging, { force: true, recursive: true }).catch(() => {
+    await rm9(staging, { force: true, recursive: true }).catch(() => {
       return;
     });
   }
@@ -18819,18 +19384,18 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
   if (options.versionCode !== undefined && (!Number.isSafeInteger(options.versionCode) || options.versionCode < 1 || options.versionCode > 2100000000)) {
     throw new TypeError("Android versionCode must be an integer from 1 through 2100000000.");
   }
-  const projectRoot = resolve40(options.projectRoot);
+  const projectRoot = resolve41(options.projectRoot);
   const host2 = options.host ?? detectAbsoluteMobileHost();
   const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host2);
-  const nativeDirectory = join51(options.config.nativeProjectDirectory, "android");
-  const manifest = requireManifest2(JSON.parse(await readFile18(join51(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  const nativeDirectory = join52(options.config.nativeProjectDirectory, "android");
+  const manifest = requireManifest2(JSON.parse(await readFile19(join52(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
   if (manifest.appId !== options.config.appId) {
     throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
   }
   let { versionCode } = options;
   if (options.prepareVersionCode) {
     const nativeFingerprint = await fingerprintAbsoluteAndroidNativeProject({ nativeDirectory });
-    const buildIdentity = createHash13("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}`).digest("hex");
+    const buildIdentity = createHash14("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}`).digest("hex");
     versionCode = await options.prepareVersionCode(buildIdentity);
   }
   if (versionCode !== undefined && (!Number.isSafeInteger(versionCode) || versionCode < 1 || versionCode > 2100000000)) {
@@ -18934,7 +19499,7 @@ var absoluteIosDeviceAcceptanceCommands = (options) => {
 };
 
 // src/mobile/iosConformance.ts
-import { readFile as readFile19, stat as stat4 } from "fs/promises";
+import { readFile as readFile20, stat as stat4 } from "fs/promises";
 var HMR_LINE, parseAbsoluteIosHmrLog = (line) => {
   const match = HMR_LINE.exec(line);
   if (!match)
@@ -18969,7 +19534,7 @@ var HMR_LINE, parseAbsoluteIosHmrLog = (line) => {
     if (Date.now() > deadline)
       throw new Error(`No iOS native HMR acknowledgement was observed within ${timeoutMs}ms.`);
     options.signal?.throwIfAborted();
-    const contents = await readFile19(options.logPath).catch(() => Buffer.alloc(0));
+    const contents = await readFile20(options.logPath).catch(() => Buffer.alloc(0));
     if (contents.byteLength < offset) {
       offset = 0;
       buffered = "";
@@ -18993,8 +19558,8 @@ var init_iosConformance = __esm(() => {
 });
 
 // src/mobile/nativeTestReport.ts
-import { mkdir as mkdir13, readFile as readFile20, writeFile as writeFile15 } from "fs/promises";
-import { join as join52 } from "path";
+import { mkdir as mkdir14, readFile as readFile21, writeFile as writeFile16 } from "fs/promises";
+import { join as join53 } from "path";
 var secretPattern, bearerPattern, coordinatePattern, nativeCredentialPattern, sanitizeNativeReportText = (value) => value.replace(nativeCredentialPattern, "[REDACTED]").replace(bearerPattern, "Bearer [REDACTED]").replace(secretPattern, "$1$2[REDACTED]").replace(coordinatePattern, "$1$2[REDACTED]").replace(/(https?:\/\/[^\s?#]+)[?#][^\s]*/giu, "$1?[REDACTED]"), markdownCell = (value) => sanitizeNativeReportText(value).replaceAll("|", "\\|").replaceAll(`
 `, "<br>"), createAbsoluteNativeAutomatedChecks = (run) => {
   const target = `${run.targetKind} ${run.targetId}`;
@@ -19096,7 +19661,7 @@ var secretPattern, bearerPattern, coordinatePattern, nativeCredentialPattern, sa
   reportVersion: 1,
   run: options.run
 }), readPackageVersionForNativeReport = async (packageJsonPath) => {
-  const manifest = JSON.parse(await readFile20(packageJsonPath, "utf8"));
+  const manifest = JSON.parse(await readFile21(packageJsonPath, "utf8"));
   if (typeof manifest !== "object" || manifest === null)
     return "unknown";
   const version2 = Reflect.get(manifest, "version");
@@ -19132,13 +19697,13 @@ Replace each \`NOT_RUN\` with \`PASS\`, \`FAIL\`, or \`SKIPPED\` after completin
 ${table(report.manualChecks)}
 `;
 }, writeAbsoluteNativeTestReport = async (directory, report) => {
-  await mkdir13(directory, { recursive: true });
-  const jsonPath = join52(directory, "report.json");
-  const markdownPath = join52(directory, "report.md");
+  await mkdir14(directory, { recursive: true });
+  const jsonPath = join53(directory, "report.json");
+  const markdownPath = join53(directory, "report.md");
   await Promise.all([
-    writeFile15(jsonPath, `${JSON.stringify(report, null, 2)}
+    writeFile16(jsonPath, `${JSON.stringify(report, null, 2)}
 `),
-    writeFile15(markdownPath, renderAbsoluteNativeTestReport(report))
+    writeFile16(markdownPath, renderAbsoluteNativeTestReport(report))
   ]);
   return { directory, jsonPath, markdownPath };
 };
@@ -19352,8 +19917,8 @@ var init_androidTestReport = __esm(() => {
 });
 
 // src/mobile/releasePublisher.ts
-import { access as access11 } from "fs/promises";
-import { isAbsolute as isAbsolute8, relative as relative27, resolve as resolve41, sep as sep7 } from "path";
+import { access as access12 } from "fs/promises";
+import { isAbsolute as isAbsolute8, relative as relative28, resolve as resolve42, sep as sep7 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -19375,16 +19940,16 @@ var prepareAbsoluteIosRelease = async (publisher, options) => {
   }
   return versionCode;
 }, isRecord14 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), isPublisher = (value) => isRecord14(value) && typeof value.publish === "function", publisherModulePath = (projectRoot, requested) => {
-  const root = resolve41(projectRoot);
-  const path = resolve41(root, requested);
-  const projectRelative = relative27(root, path);
+  const root = resolve42(projectRoot);
+  const path = resolve42(root, requested);
+  const projectRelative = relative28(root, path);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep7}`) || isAbsolute8(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
   return path;
 }, loadAbsoluteNativeReleasePublisher = async (projectRoot, requestedModulePath) => {
   const modulePath = publisherModulePath(projectRoot, requestedModulePath);
-  await access11(modulePath).catch(() => {
+  await access12(modulePath).catch(() => {
     throw new TypeError(`Native release registry module does not exist: ${modulePath}`);
   });
   const loaded = await import(pathToFileURL2(modulePath).href);
@@ -19445,20 +20010,20 @@ var prepareAbsoluteIosRelease = async (publisher, options) => {
 var init_releasePublisher = () => {};
 
 // src/mobile/mobileInspect.ts
-import { access as access12, readFile as readFile21 } from "fs/promises";
-import { join as join53, relative as relative28, resolve as resolve42 } from "path";
+import { access as access13, readFile as readFile22 } from "fs/promises";
+import { join as join54, relative as relative29, resolve as resolve43 } from "path";
 var ABSOLUTE_MOBILE_INSPECTION_FORMAT = 1, MOBILE_PACKAGE_NAMES, isObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), portablePath2 = (projectRoot, path) => {
-  const value = relative28(resolve42(projectRoot), resolve42(path)).replaceAll("\\", "/");
+  const value = relative29(resolve43(projectRoot), resolve43(path)).replaceAll("\\", "/");
   return value || ".";
 }, pathExists8 = async (path) => {
   try {
-    await access12(path);
+    await access13(path);
     return true;
   } catch {
     return false;
   }
 }, readObject2 = async (path) => {
-  const value = JSON.parse(await readFile21(path, "utf8"));
+  const value = JSON.parse(await readFile22(path, "utf8"));
   if (!isObject3(value))
     throw new TypeError("JSON root must be an object.");
   return value;
@@ -19468,13 +20033,13 @@ var ABSOLUTE_MOBILE_INSPECTION_FORMAT = 1, MOBILE_PACKAGE_NAMES, isObject3 = (va
   for (const [name, declared] of Object.entries(value).filter((entry) => typeof entry[1] === "string"))
     declarations.set(name, declared);
 }, packageInspections = async (projectRoot, additionalNames) => {
-  const project = await readObject2(join53(projectRoot, "package.json"));
+  const project = await readObject2(join54(projectRoot, "package.json"));
   const declarations = new Map;
   for (const field of ["dependencies", "devDependencies"])
     addPackageDeclarations(declarations, project[field]);
   const names = [...new Set([...declarations.keys(), ...additionalNames])].filter((name) => MOBILE_PACKAGE_NAMES.has(name) || name.startsWith("@capacitor/") || additionalNames.includes(name)).sort();
   return Promise.all(names.map(async (name) => {
-    const installedManifest = await readObject2(join53(projectRoot, "node_modules", name, "package.json")).catch(() => {
+    const installedManifest = await readObject2(join54(projectRoot, "node_modules", name, "package.json")).catch(() => {
       return;
     });
     const installed = installedManifest?.version;
@@ -19523,7 +20088,7 @@ var ABSOLUTE_MOBILE_INSPECTION_FORMAT = 1, MOBILE_PACKAGE_NAMES, isObject3 = (va
     },
     format: ABSOLUTE_MOBILE_INSPECTION_FORMAT,
     nativeProjects: await Promise.all(config.platforms.map(async (platform6) => {
-      const path = join53(config.nativeProjectDirectory, platform6);
+      const path = join54(config.nativeProjectDirectory, platform6);
       return {
         initialized: await pathExists8(path),
         path: portablePath2(projectRoot, path),
@@ -19594,19 +20159,19 @@ var init_mobileInspect = __esm(() => {
 
 // src/mobile/ciWorkflow.ts
 import { existsSync as existsSync42 } from "fs";
-import { access as access13, mkdir as mkdir14, readFile as readFile22, writeFile as writeFile16 } from "fs/promises";
-import { dirname as dirname31, extname as extname9, relative as relative29, resolve as resolve43, sep as sep8 } from "path";
-var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1, SECRET_NAME_PATTERN, CI_ENV_INDENTATION = 6, RESERVED_SECRET_NAMES, exists3 = async (path) => {
+import { access as access14, mkdir as mkdir15, readFile as readFile23, writeFile as writeFile17 } from "fs/promises";
+import { dirname as dirname32, extname as extname9, relative as relative30, resolve as resolve44, sep as sep8 } from "path";
+var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1, SECRET_NAME_PATTERN, CI_ENV_INDENTATION = 6, RESERVED_SECRET_NAMES, exists4 = async (path) => {
   try {
-    await access13(path);
+    await access14(path);
     return true;
   } catch {
     return false;
   }
 }, yamlString = (value) => `'${value.replaceAll("'", "''")}'`, projectPath = (projectRoot, value, field, options = {}) => {
-  const root = resolve43(projectRoot);
-  const path = resolve43(root, value);
-  const portable = relative29(root, path).replaceAll("\\", "/");
+  const root = resolve44(projectRoot);
+  const path = resolve44(root, value);
+  const portable = relative30(root, path).replaceAll("\\", "/");
   if (portable === ".." || portable.startsWith(`..${sep8}`) || portable.startsWith("../") || portable === "") {
     throw new TypeError(`${field} must remain inside the project root.`);
   }
@@ -19616,10 +20181,10 @@ var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1, SECRET_NAME_PATTERN, CI_ENV_INDENTAT
     throw new TypeError(`${field} does not exist inside the project.`);
   return portable;
 }, workflowOutputPath = (projectRoot, value) => {
-  const root = resolve43(projectRoot);
-  const workflows = resolve43(root, ".github/workflows");
-  const path = resolve43(root, value ?? ".github/workflows/absolute-mobile.yml");
-  const portable = relative29(workflows, path);
+  const root = resolve44(projectRoot);
+  const workflows = resolve44(root, ".github/workflows");
+  const path = resolve44(root, value ?? ".github/workflows/absolute-mobile.yml");
+  const portable = relative30(workflows, path);
   if (portable === ".." || portable.startsWith(`..${sep8}`) || extname9(path) !== ".yml" && extname9(path) !== ".yaml") {
     throw new TypeError("mobile ci github --output must be a .yml or .yaml file inside .github/workflows.");
   }
@@ -20008,12 +20573,12 @@ ${bundleAuditSteps}${platforms.includes("android") ? androidJob({ customSecrets,
 }, writeAbsoluteMobileGithubWorkflow = async (options) => {
   const path = workflowOutputPath(options.projectRoot, options.outputPath);
   const generated = createAbsoluteMobileGithubWorkflow(options);
-  const previous = await exists3(path) ? await readFile22(path, "utf8") : undefined;
+  const previous = await exists4(path) ? await readFile23(path, "utf8") : undefined;
   if (previous !== undefined && previous !== generated.workflow && !options.force)
-    throw new TypeError(`${relative29(options.projectRoot, path)} already exists and differs. Rerun with --force to replace the generated workflow.`);
+    throw new TypeError(`${relative30(options.projectRoot, path)} already exists and differs. Rerun with --force to replace the generated workflow.`);
   if (previous !== generated.workflow) {
-    await mkdir14(dirname31(path), { recursive: true });
-    await writeFile16(path, generated.workflow);
+    await mkdir15(dirname32(path), { recursive: true });
+    await writeFile17(path, generated.workflow);
   }
   return {
     changed: previous !== generated.workflow,
@@ -20075,11 +20640,11 @@ var exports_mobile = {};
 __export(exports_mobile, {
   runMobile: () => runMobile
 });
-import { access as access14, mkdir as mkdir15, readFile as readFile23, writeFile as writeFile17 } from "fs/promises";
-import { join as join54, relative as relative30, resolve as resolve44 } from "path";
+import { access as access15, mkdir as mkdir16, readFile as readFile24, writeFile as writeFile18 } from "fs/promises";
+import { join as join55, relative as relative31, resolve as resolve45 } from "path";
 import { createInterface } from "readline/promises";
 var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), CAPACITOR_PACKAGES, CAPACITOR_PACKAGE_SPECS, CAPACITOR_SYNC_PACKAGE_SPECS, packageNameFromSpec = (spec) => spec.slice(0, spec.lastIndexOf("@")), directProjectPackages = async (projectRoot) => {
-  const manifest = JSON.parse(await readFile23(join54(projectRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(await readFile24(join55(projectRoot, "package.json"), "utf8"));
   if (!isRecord15(manifest))
     throw new TypeError("Application package.json must contain an object.");
   const names = new Set;
@@ -20092,7 +20657,7 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
   return names;
 }, resolvedPackageVersion = async (projectRoot, packageName) => {
   try {
-    const manifest = JSON.parse(await readFile23(join54(projectRoot, "node_modules", packageName, "package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile24(join55(projectRoot, "node_modules", packageName, "package.json"), "utf8"));
     return isRecord15(manifest) && typeof manifest.version === "string" ? manifest.version : undefined;
   } catch {
     return;
@@ -20133,9 +20698,9 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
   }
   return value;
 }, capacitorExecutable = async (projectRoot) => {
-  const executable = join54(projectRoot, "node_modules", ".bin", "cap");
+  const executable = join55(projectRoot, "node_modules", ".bin", "cap");
   try {
-    await access14(executable);
+    await access15(executable);
     return executable;
   } catch {
     throw new TypeError(`Capacitor is not installed in this app. Run: bun add ${CAPACITOR_PACKAGES.join(" ")}`);
@@ -20152,13 +20717,54 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
   if (exitCode !== 0) {
     throw new TypeError(`Capacitor exited with status ${exitCode}.`);
   }
-}, runCapacitorForPlatforms = (projectRoot, command, platforms) => platforms.reduce((pending, platform6) => pending.then(() => runCapacitor(projectRoot, [command, platform6])), Promise.resolve()), loadMobile = async (configPath2) => {
+}, runCapacitorForPlatforms = (projectRoot, command, platforms) => platforms.reduce((pending, platform6) => pending.then(() => runCapacitor(projectRoot, [command, platform6])), Promise.resolve()), expoExecutable = async (project) => {
+  const executable = join55(project, "node_modules", ".bin", "expo");
+  try {
+    await access15(executable);
+    return executable;
+  } catch {
+    throw new TypeError("Expo dependencies are not installed in the generated shell. Run `absolute mobile init --yes`.");
+  }
+}, runExpo = async (project, args) => {
+  const executable = await expoExecutable(project);
+  const process2 = Bun.spawn([executable, ...args], {
+    cwd: project,
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  const exitCode = await process2.exited;
+  if (exitCode !== 0)
+    throw new TypeError(`Expo exited with status ${exitCode}.`);
+}, ensureExpoPackages = async (project, args) => {
+  try {
+    await access15(join55(project, "node_modules", "expo", "package.json"));
+    return;
+  } catch {}
+  const approved = args.includes("--yes") || await confirmInstall("The experimental Expo shell dependencies are missing. Install the pinned Expo SDK 57 toolchain now?");
+  if (!approved)
+    throw new TypeError(`Expo initialization requires running \`bun install\` in ${project}.`);
+  const process2 = Bun.spawn(["bun", "install"], {
+    cwd: project,
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  const exitCode = await process2.exited;
+  if (exitCode !== 0)
+    throw new TypeError(`Expo dependency installation exited with status ${exitCode}.`);
+}, loadMobile = async (configPath2) => {
   const projectRoot = process.cwd();
   const config = await loadConfig(configPath2);
   const mobile = normalizeAbsoluteMobileConfig(requireMobileConfig(config.mobile), projectRoot);
   return { mobile, projectRoot };
+}, requireCapacitorEngine = (mobile, command) => {
+  if (mobile.engine === "capacitor")
+    return;
+  throw new TypeError(`${command} is not available for the experimental Expo engine yet. Use mobile init/sync and Expo CLI from the generated shell; Capacitor remains the release-capable engine.`);
 }, inspectMobile = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
+  requireCapacitorEngine(mobile, "mobile inspect");
   const report = await inspectAbsoluteMobileProject(mobile, projectRoot, {
     absolutejsVersion: await absolutejsVersionForReport()
   });
@@ -20213,6 +20819,24 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
   console.log(removed ? `Removed remote Mac profile ${args[1]}.` : `Remote Mac profile ${args[1]} was not found.`);
 }, initialize = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
+  if (mobile.engine === "expo") {
+    console.warn("Experimental: Expo Auth, Sync, release publishing, and physical-device acceptance are not complete.");
+    const generated2 = await writeAbsoluteExpoProject(mobile, {
+      force: args.includes("--force"),
+      projectRoot
+    });
+    console.log(`${generated2.changed > 0 ? "Generated" : "Verified"} Expo shell ${generated2.path}`);
+    await ensureExpoPackages(generated2.path, args);
+    if (args.includes("--no-native"))
+      return;
+    await runExpo(generated2.path, [
+      "prebuild",
+      "--no-install",
+      "--platform",
+      mobile.platforms.length === 2 ? "all" : mobile.platforms[0] ?? "all"
+    ]);
+    return;
+  }
   await ensureCapacitorPackages(projectRoot, args);
   const generated = await writeAbsoluteCapacitorConfig(mobile, {
     force: args.includes("--force"),
@@ -20227,6 +20851,25 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
   await applyAbsoluteNativeBackgroundSync(projectRoot, mobile);
 }, sync = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
+  if (mobile.engine === "expo") {
+    console.warn("Experimental: syncing the Expo CNG shell and embedded AbsoluteJS bundle.");
+    await writeAbsoluteExpoProject(mobile, {
+      force: args.includes("--force"),
+      projectRoot
+    });
+    await ensureExpoPackages(mobile.nativeProjectDirectory, args);
+    const assets = await syncAbsoluteExpoWebAssets(mobile);
+    console.log(`Synced ${assets.assets} embedded AbsoluteJS assets for ${assets.appBuild}.`);
+    const platform7 = args.find((value) => value === "android" || value === "ios");
+    const platforms2 = platform7 ? [platform7] : mobile.platforms;
+    await runExpo(mobile.nativeProjectDirectory, [
+      "prebuild",
+      "--no-install",
+      "--platform",
+      platforms2.length === 2 ? "all" : platforms2[0] ?? "all"
+    ]);
+    return;
+  }
   await ensureCapacitorPackages(projectRoot, args);
   const platform6 = args.find((value) => value === "android" || value === "ios");
   const platforms = platform6 ? [platform6] : mobile.platforms;
@@ -20240,7 +20883,7 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
   await applyAbsoluteNativeBackgroundSync(projectRoot, mobile, platforms);
 }, associations = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
-  const outputDirectory = resolve44(projectRoot, valueAfter(args, "--outdir") ?? ".absolutejs/mobile/associations");
+  const outputDirectory = resolve45(projectRoot, valueAfter(args, "--outdir") ?? ".absolutejs/mobile/associations");
   if (args.includes("--verify")) {
     const result2 = await verifyAbsoluteMobileAssociationFiles(mobile);
     console.log(`Verified ${result2.results.length} hosted association files`);
@@ -20271,6 +20914,7 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
     throw new TypeError("Usage: absolute mobile ci github [server-entry] [--publish] [--registry module] [--secret-env NAME] [--output path] [--force] [--json] [--config path]");
   const configPath2 = valueAfter(args, "--config");
   const { mobile, projectRoot } = await loadMobile(configPath2);
+  requireCapacitorEngine(mobile, "mobile ci github");
   const result = await writeAbsoluteMobileGithubWorkflow({
     config: mobile,
     configPath: configPath2,
@@ -20290,7 +20934,7 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
   const publicResult = {
     changed: result.changed,
     format: result.format,
-    path: relative30(projectRoot, result.path).replaceAll("\\", "/"),
+    path: relative31(projectRoot, result.path).replaceAll("\\", "/"),
     platforms: result.platforms,
     publishing: result.publishing,
     requiredSecrets: result.requiredSecrets
@@ -20336,6 +20980,7 @@ var NOT_FOUND4 = -1, isRecord15 = (value) => typeof value === "object" && value
   }
 }, runReleaseDoctor = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
+  requireCapacitorEngine(mobile, "mobile doctor release");
   const platform6 = args.find((value) => value === "android" || value === "ios");
   const effectiveMobile = platform6 ? { ...mobile, platforms: [platform6] } : mobile;
   const result = await inspectAbsoluteMobileRelease(effectiveMobile, projectRoot);
@@ -20520,6 +21165,7 @@ Mobile release security and compliance checks failed.`);
 }, buildAndroid = async (args, prepareVersionCode) => {
   const configPath2 = valueAfter(args, "--config");
   const { mobile, projectRoot } = await loadMobile(configPath2);
+  requireCapacitorEngine(mobile, "mobile build android");
   if (!mobile.platforms.includes("android")) {
     throw new TypeError("mobile build android requires android in mobile.platforms.");
   }
@@ -20550,7 +21196,7 @@ Mobile release security and compliance checks failed.`);
     const durationMs = Math.round(performance.now() - startedAt);
     console.log(`Built ${release.metadata.signed ? "signed" : "unsigned"} Android App Bundle in ${getDurationString(durationMs)}.`);
     console.log(`Artifact: ${release.artifactPath}`);
-    console.log(`Metadata: ${join54(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join55(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:android-release-build", {
@@ -20573,6 +21219,7 @@ Mobile release security and compliance checks failed.`);
   const configPath2 = valueAfter(args, "--config");
   const googlePlay = googlePlayTarget(args);
   const { mobile, projectRoot } = await loadMobile(configPath2);
+  requireCapacitorEngine(mobile, "mobile publish android");
   const startedAt = performance.now();
   let reused = false;
   let success = false;
@@ -20626,6 +21273,7 @@ Mobile release security and compliance checks failed.`);
 }, buildIos = async (args, prepareBuildNumber) => {
   const configPath2 = valueAfter(args, "--config");
   const { mobile, projectRoot } = await loadMobile(configPath2);
+  requireCapacitorEngine(mobile, "mobile build ios");
   if (!mobile.platforms.includes("ios")) {
     throw new TypeError("mobile build ios requires ios in mobile.platforms.");
   }
@@ -20654,7 +21302,7 @@ Mobile release security and compliance checks failed.`);
     const durationMs = Math.round(performance.now() - startedAt);
     console.log(`Built ${release.metadata.signed ? "signed" : "unsigned"} iOS IPA ${release.metadata.marketingVersion}${release.metadata.buildNumber ? ` (${release.metadata.buildNumber})` : ""} in ${getDurationString(durationMs)}.`);
     console.log(`Artifact: ${release.artifactPath}`);
-    console.log(`Metadata: ${join54(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join55(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:ios-release-build", {
@@ -20672,6 +21320,7 @@ Mobile release security and compliance checks failed.`);
   const configPath2 = valueAfter(args, "--config");
   const appStoreConnect = appStoreConnectTarget(args);
   const { mobile, projectRoot } = await loadMobile(configPath2);
+  requireCapacitorEngine(mobile, "mobile publish ios");
   const startedAt = performance.now();
   let reused = false;
   let success = false;
@@ -20761,7 +21410,7 @@ Mobile release security and compliance checks failed.`);
     checks.push({
       id: "sync.storage-schema",
       label: `Offline schema ${schema.components.map((component2) => `${component2.id}@${component2.version}`).join(", ")}`,
-      path: join54(projectRoot, "package.json"),
+      path: join55(projectRoot, "package.json"),
       platform: "host",
       status: "pass"
     });
@@ -20769,7 +21418,7 @@ Mobile release security and compliance checks failed.`);
     checks.push({
       id: "sync.storage-schema",
       label: "Offline schema metadata is invalid",
-      path: join54(projectRoot, "package.json"),
+      path: join55(projectRoot, "package.json"),
       platform: "host",
       remediation: error instanceof Error ? error.message : String(error),
       status: "fail"
@@ -20854,7 +21503,7 @@ Emulator setup verification:`);
     }
     return { https: args.includes("--https"), port };
   }
-  const instances = listLiveInstances().filter((instance2) => resolve44(instance2.cwd) === resolve44(projectRoot) && instance2.source === "dev" && instance2.port !== null);
+  const instances = listLiveInstances().filter((instance2) => resolve45(instance2.cwd) === resolve45(projectRoot) && instance2.source === "dev" && instance2.port !== null);
   if (instances.length !== 1) {
     throw new TypeError(instances.length === 0 ? "No running AbsoluteJS dev server was found for this project. Start `bun dev`, wait for Android to report ready, then run `absolute mobile test android`." : "Multiple dev servers are running for this project. Select one with mobile test android --port <port>.");
   }
@@ -20897,8 +21546,8 @@ Emulator setup verification:`);
   }
   return selected;
 }, safeArtifactRoot = (projectRoot, value) => {
-  const root = resolve44(projectRoot, value ?? ".absolutejs/mobile/test-artifacts");
-  if (root !== projectRoot && !root.startsWith(`${resolve44(projectRoot)}/`)) {
+  const root = resolve45(projectRoot, value ?? ".absolutejs/mobile/test-artifacts");
+  if (root !== projectRoot && !root.startsWith(`${resolve45(projectRoot)}/`)) {
     throw new TypeError("mobile test --artifacts must remain inside the project.");
   }
   return root;
@@ -20922,12 +21571,12 @@ Emulator setup verification:`);
     timeoutMs
   });
 }, writeAndroidFailureArtifacts = async (options) => {
-  await mkdir15(options.artifactRoot, { recursive: true });
-  const screenshot = options.session ? await options.session.screenshot(join54(options.artifactRoot, "android-failure.png")).catch(() => {
+  await mkdir16(options.artifactRoot, { recursive: true });
+  const screenshot = options.session ? await options.session.screenshot(join55(options.artifactRoot, "android-failure.png")).catch(() => {
     return;
   }) : undefined;
-  const diagnosticPath = join54(options.artifactRoot, "android-failure.json");
-  await writeFile17(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join55(options.artifactRoot, "android-failure.json");
+  await writeFile18(diagnosticPath, `${JSON.stringify({
     diagnostics: options.session?.diagnostics ?? [],
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "android",
@@ -20940,6 +21589,7 @@ Emulator setup verification:`);
   return { diagnosticPath, screenshot };
 }, testAndroid = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
+  requireCapacitorEngine(mobile, "mobile test android");
   if (!mobile.platforms.includes("android")) {
     throw new TypeError("mobile test android requires android in mobile.platforms.");
   }
@@ -20990,7 +21640,7 @@ Emulator setup verification:`);
       console.log(JSON.stringify(report, null, 2));
     else
       printAndroidTestReport(report);
-    const screenshot = reportRoot ? await session.screenshot(join54(artifactRoot, "android-emulator.png")) : undefined;
+    const screenshot = reportRoot ? await session.screenshot(join55(artifactRoot, "android-emulator.png")) : undefined;
     await writeRequestedAndroidReport({
       adb,
       args,
@@ -21058,14 +21708,14 @@ Emulator setup verification:`);
     const port = Number(explicit);
     if (!Number.isInteger(port) || port < 1 || port > 65535)
       throw new TypeError("mobile test --port must be a valid TCP port.");
-    const instance2 = listLiveInstances().find((candidate) => resolve44(candidate.cwd) === resolve44(projectRoot) && candidate.source === "dev" && candidate.port === port);
+    const instance2 = listLiveInstances().find((candidate) => resolve45(candidate.cwd) === resolve45(projectRoot) && candidate.source === "dev" && candidate.port === port);
     return {
       https: instance2?.https ?? args.includes("--https"),
       instance: instance2,
       port
     };
   }
-  const instances = listLiveInstances().filter((instance2) => resolve44(instance2.cwd) === resolve44(projectRoot) && instance2.source === "dev" && instance2.port !== null);
+  const instances = listLiveInstances().filter((instance2) => resolve45(instance2.cwd) === resolve45(projectRoot) && instance2.source === "dev" && instance2.port !== null);
   if (instances.length !== 1)
     throw new TypeError(instances.length === 0 ? "No running AbsoluteJS dev server was found for this project. Start `bun dev`, wait for iOS to report ready, then run `absolute mobile test ios`." : "Multiple dev servers are running for this project. Select one with mobile test ios --port <port>.");
   const [instance] = instances;
@@ -21179,8 +21829,8 @@ Emulator setup verification:`);
     throw new Error(`${label} failed: ${result.stderr.trim() || result.stdout.trim() || `status ${result.exitCode}`}`);
   return result;
 }, writeIosFailureArtifacts = async (options) => {
-  await mkdir15(options.artifactRoot, { recursive: true });
-  const screenshot = join54(options.artifactRoot, "ios-failure.png");
+  await mkdir16(options.artifactRoot, { recursive: true });
+  const screenshot = join55(options.artifactRoot, "ios-failure.png");
   const screenshotResult = captureCommand4([
     options.xcrun,
     "simctl",
@@ -21189,8 +21839,8 @@ Emulator setup verification:`);
     "screenshot",
     screenshot
   ]);
-  const diagnosticPath = join54(options.artifactRoot, "ios-failure.json");
-  await writeFile17(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join55(options.artifactRoot, "ios-failure.json");
+  await writeFile18(diagnosticPath, `${JSON.stringify({
     appId: options.appId,
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "ios",
@@ -21215,8 +21865,8 @@ Emulator setup verification:`);
 }, absolutejsVersionForReport = async () => {
   let absolutejsVersion = process.env.ABSOLUTE_VERSION ?? "unknown";
   const versions = await Promise.all([
-    resolve44(import.meta.dir, "..", "..", "package.json"),
-    resolve44(import.meta.dir, "..", "..", "..", "package.json")
+    resolve45(import.meta.dir, "..", "..", "package.json"),
+    resolve45(import.meta.dir, "..", "..", "..", "package.json")
   ].map((candidate) => readPackageVersionForIosReport(candidate).catch(() => "unknown")));
   for (const version2 of versions) {
     if (version2 === "unknown")
@@ -21376,6 +22026,7 @@ Emulator setup verification:`);
   }
 }, testIos = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
+  requireCapacitorEngine(mobile, "mobile test ios");
   const { https, instance, port } = requireIosTestContext(args, projectRoot);
   if (!mobile.platforms.includes("ios"))
     throw new TypeError("mobile test ios requires ios in mobile.platforms.");
@@ -21434,8 +22085,8 @@ Emulator setup verification:`);
       mobile.appId
     ], "iOS app launch");
     await waitForIosHmrClient({ https, port, timeoutMs });
-    await mkdir15(artifactRoot, { recursive: true });
-    const screenshot = join54(artifactRoot, "ios-simulator.png");
+    await mkdir16(artifactRoot, { recursive: true });
+    const screenshot = join55(artifactRoot, "ios-simulator.png");
     requireCapturedCommand([xcrun, "simctl", "io", simulator.udid, "screenshot", screenshot], "iOS simulator screenshot");
     const hmrApply = await waitForRequestedIosHmr(args, instance, timeoutMs);
     const report = {
@@ -21585,6 +22236,7 @@ Emulator setup verification:`);
 var init_mobile = __esm(() => {
   init_dependencies();
   init_capacitorProject();
+  init_expoProject();
   init_config();
   init_nativeDeepLinks();
   init_nativeDeviceCapabilities();
@@ -21651,10 +22303,10 @@ var exports_typecheck = {};
 __export(exports_typecheck, {
   typecheck: () => typecheck
 });
-import { resolve as resolve45, join as join55 } from "path";
+import { resolve as resolve46, join as join56 } from "path";
 import { existsSync as existsSync43, readFileSync as readFileSync40 } from "fs";
-import { mkdir as mkdir16, writeFile as writeFile18 } from "fs/promises";
-var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve45(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
+import { mkdir as mkdir17, writeFile as writeFile19 } from "fs/promises";
+var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve46(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
   if (!existsSync43(resolveConfigPath(configPath2))) {
     const defaultService = {};
     return [defaultService];
@@ -21676,7 +22328,7 @@ var isCommandService3 = (service) => service.kind === "command" || Array.isArray
   const exitCode = await proc.exited;
   return { exitCode, name, output: (stdout + stderr).trim() };
 }, shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`, runShell = async (name, command) => run(name, ["/bin/bash", "-lc", command]), findBin = (name) => {
-  const local = resolve45("node_modules", ".bin", name);
+  const local = resolve46("node_modules", ".bin", name);
   return existsSync43(local) ? local : null;
 }, ANSI_COLOR_REGEX, ANSI_PURPLE_REGEX, ANSI_CYAN_REGEX, ANSI_TOKEN_END_REGEX, stripAnsi4 = (str) => str.replace(ANSI_COLOR_REGEX, ""), formatSvelteOutput = (output) => {
   const cwd = `${process.cwd()}/`;
@@ -21724,15 +22376,15 @@ Found ${errorCount} error${suffix}.`;
   return formatted;
 }, ABSOLUTE_INTERNAL_EXCLUDES, resolveAbsoluteTypeFile = (fileName) => {
   const candidates = [
-    resolve45("node_modules/@absolutejs/absolute/dist/types", fileName),
-    resolve45(import.meta.dir, "../types", fileName),
-    resolve45(import.meta.dir, "../../types", fileName),
-    resolve45(import.meta.dir, "../../../types", fileName)
+    resolve46("node_modules/@absolutejs/absolute/dist/types", fileName),
+    resolve46(import.meta.dir, "../types", fileName),
+    resolve46(import.meta.dir, "../../types", fileName),
+    resolve46(import.meta.dir, "../../../types", fileName)
   ];
   return candidates.find((candidate) => existsSync43(candidate)) ?? candidates[0];
 }, ABSOLUTE_TYPECHECK_FILES, readProjectTsconfig = () => {
   try {
-    return JSON.parse(readFileSync40(resolve45("tsconfig.json"), "utf-8"));
+    return JSON.parse(readFileSync40(resolve46("tsconfig.json"), "utf-8"));
   } catch {
     return {};
   }
@@ -21760,27 +22412,27 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m vue-tsc is required for Vue type checking. Install it: bun add -d vue-tsc");
     process.exit(1);
   }
-  const vueTsconfigPath = join55(cacheDir, "tsconfig.vue-check.json");
-  await writeFile18(vueTsconfigPath, JSON.stringify({
+  const vueTsconfigPath = join56(cacheDir, "tsconfig.vue-check.json");
+  await writeFile19(vueTsconfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve45("tsconfig.json"),
+    extends: resolve46("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t"));
   const base = [
     vueTscBin,
     "--noEmit",
     "--project",
-    resolve45(vueTsconfigPath),
+    resolve46(vueTsconfigPath),
     "--pretty"
   ];
   const cached = await run("vue-tsc", [
     ...base,
     "--incremental",
     "--tsBuildInfoFile",
-    join55(cacheDir, "vue-tsc.tsbuildinfo")
+    join56(cacheDir, "vue-tsc.tsbuildinfo")
   ]);
   if (cached.exitCode === 0 || cached.output.length > 0)
     return cached;
@@ -21791,8 +22443,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m @angular/compiler-cli is required for Angular type checking. Install it: bun add -d @angular/compiler-cli");
     process.exit(1);
   }
-  const angularTsconfigPath = join55(cacheDir, "tsconfig.angular-check.json");
-  await writeFile18(angularTsconfigPath, JSON.stringify({
+  const angularTsconfigPath = join56(cacheDir, "tsconfig.angular-check.json");
+  await writeFile19(angularTsconfigPath, JSON.stringify({
     angularCompilerOptions: {
       strictTemplates: true
     },
@@ -21801,32 +22453,32 @@ Found ${errorCount} error${suffix}.`;
       rootDir: ".."
     },
     exclude: ABSOLUTE_INTERNAL_EXCLUDES.map(toGeneratedConfigPath),
-    extends: resolve45("tsconfig.json"),
+    extends: resolve46("tsconfig.json"),
     include: [`../${angularDir}/**/*`]
   }, null, "\t"));
-  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve45(angularTsconfigPath))}`);
+  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve46(angularTsconfigPath))}`);
 }, buildTscCheck = (cacheDir) => {
   const tscBin = findBin("tsc");
   if (!tscBin) {
     console.error("\x1B[31m\u2717\x1B[0m typescript is required for type checking. Install it: bun add -d typescript");
     process.exit(1);
   }
-  const tscConfigPath = join55(cacheDir, "tsconfig.typecheck.json");
-  return writeFile18(tscConfigPath, JSON.stringify({
+  const tscConfigPath = join56(cacheDir, "tsconfig.typecheck.json");
+  return writeFile19(tscConfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve45("tsconfig.json"),
+    extends: resolve46("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("tsc", [
     tscBin,
     "--noEmit",
     "--project",
-    resolve45(tscConfigPath),
+    resolve46(tscConfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join55(cacheDir, "tsc.tsbuildinfo"),
+    join56(cacheDir, "tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildSvelteCheck = async (cacheDir, svelteDir) => {
@@ -21835,16 +22487,16 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m svelte-check is required for Svelte type checking. Install it: bun add -d svelte-check");
     process.exit(1);
   }
-  const svelteTsconfigPath = join55(cacheDir, "tsconfig.svelte-check.json");
-  await writeFile18(svelteTsconfigPath, JSON.stringify({
-    extends: resolve45("tsconfig.json"),
+  const svelteTsconfigPath = join56(cacheDir, "tsconfig.svelte-check.json");
+  await writeFile19(svelteTsconfigPath, JSON.stringify({
+    extends: resolve46("tsconfig.json"),
     files: ABSOLUTE_TYPECHECK_FILES,
     include: [`../${svelteDir}/**/*`]
   }, null, "\t"));
   return run("svelte-check", [
     svelteBin,
     "--tsconfig",
-    resolve45(svelteTsconfigPath),
+    resolve46(svelteTsconfigPath),
     "--threshold",
     "error",
     "--compiler-warnings",
@@ -21865,7 +22517,7 @@ Found ${errorCount} error${suffix}.`;
     ...new Set(targets.map((config) => config.angularDirectory).filter((dir) => typeof dir === "string" && dir.length > 0))
   ];
   const cacheDir = ".absolutejs";
-  await mkdir16(cacheDir, { recursive: true });
+  await mkdir17(cacheDir, { recursive: true });
   const checks = [];
   checks.push(hasVue ? buildVueTscCheck(cacheDir) : buildTscCheck(cacheDir));
   for (const svelteDir of hasSvelte ? svelteDirs : []) {
@@ -22038,11 +22690,11 @@ var DEFAULT_RELAY_PORT = 8787, DEFAULT_REQUEST_TIMEOUT_MS = 30000, headersToObje
         url: url.pathname + url.search,
         ...bodyBytes && bodyBytes.length > 0 ? { bodyBase64: Buffer.from(bodyBytes).toString("base64") } : {}
       };
-      const responsePromise = new Promise((resolve46) => {
-        pending.set(id, resolve46);
+      const responsePromise = new Promise((resolve47) => {
+        pending.set(id, resolve47);
       });
       client.send(encodeTunnelMessage(message));
-      const timeout = new Promise((resolve46) => setTimeout(() => resolve46({ id, message: "timeout", type: "error" }), requestTimeoutMs));
+      const timeout = new Promise((resolve47) => setTimeout(() => resolve47({ id, message: "timeout", type: "error" }), requestTimeoutMs));
       const result = await Promise.race([responsePromise, timeout]);
       pending.delete(id);
       if (result.type === "error") {
@@ -23015,7 +23667,9 @@ var dev = async (serverEntry, configPath2, options = {}) => {
   if (mobileConfig && mobileInteractive) {
     try {
       const normalized = normalizeAbsoluteMobileConfig(mobileConfig, process.cwd());
-      if (normalized.platforms.includes("android")) {
+      if (normalized.engine === "expo") {
+        console.log(cliTag("\x1B[35m", "Expo hybrid support is experimental. AbsoluteJS web development is running; start Metro from .absolutejs/mobile/expo for the native shell."));
+      } else if (normalized.platforms.includes("android")) {
         const androidTarget = options.androidDevice ? "device" : "emulator";
         let ready = androidToolchainReady(await inspectAbsoluteMobileToolchain(), androidTarget);
         if (!ready) {
@@ -23042,7 +23696,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           }
         }
       }
-      if (normalized.platforms.includes("ios")) {
+      if (normalized.engine === "capacitor" && normalized.platforms.includes("ios")) {
         if (detectAbsoluteMobileHost() !== "macos") {
           const remote = selectedRemoteMacProfile ?? await getAbsoluteRemoteMacProfile();
           if (!remote) {
@@ -24406,7 +25060,7 @@ import {
   writeFileSync as writeFileSync6
 } from "fs";
 import { createConnection } from "net";
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 
 // src/cli/workspaceTui.ts
 init_constants();
@@ -24968,18 +25622,18 @@ var createWorkspaceTui = ({
 
 // src/cli/scripts/workspace.ts
 init_utils();
-var sourceServerBootstrap2 = resolve22(import.meta.dir, "../../dev/serverBootstrap.ts");
-var serverBootstrap2 = existsSync12(sourceServerBootstrap2) ? sourceServerBootstrap2 : resolve22(import.meta.dir, "../dev/serverBootstrap.js");
+var sourceServerBootstrap2 = resolve23(import.meta.dir, "../../dev/serverBootstrap.ts");
+var serverBootstrap2 = existsSync12(sourceServerBootstrap2) ? sourceServerBootstrap2 : resolve23(import.meta.dir, "../dev/serverBootstrap.js");
 var ANSI_REGEX2 = new RegExp(`${String.fromCharCode(ANSI_ESCAPE_CODE)}\\[[0-?]*[ -/]*[@-~]`, "g");
 var sleep = (durationMs) => Bun.sleep(durationMs);
 var stripAnsi3 = (value) => value.replace(ANSI_REGEX2, "");
 var sanitizeLogFileName = (value) => value.replace(/[^a-zA-Z0-9._-]/g, "_") || "unknown";
 var createWorkspaceLogSink = (appendLog) => {
-  const logDirectory = resolve22(".absolutejs", "workspace", "logs");
+  const logDirectory = resolve23(".absolutejs", "workspace", "logs");
   mkdirSync7(logDirectory, { recursive: true });
-  readdirSync2(logDirectory).filter((file) => file.endsWith(".log")).forEach((file) => unlinkSync3(resolve22(logDirectory, file)));
-  writeFileSync6(resolve22(logDirectory, "all.log"), "");
-  writeFileSync6(resolve22(logDirectory, "workspace.log"), "");
+  readdirSync2(logDirectory).filter((file) => file.endsWith(".log")).forEach((file) => unlinkSync3(resolve23(logDirectory, file)));
+  writeFileSync6(resolve23(logDirectory, "all.log"), "");
+  writeFileSync6(resolve23(logDirectory, "workspace.log"), "");
   const initializedSources = new Set(["workspace"]);
   const writeLog = (source, message, level) => {
     const cleanMessage = stripAnsi3(message).trimEnd();
@@ -24989,13 +25643,13 @@ var createWorkspaceLogSink = (appendLog) => {
     const timestamp = new Date().toISOString();
     const line = `[${timestamp}] [${level}] [${source}] ${cleanMessage}
 `;
-    const sourceFile = resolve22(logDirectory, `${sanitizeLogFileName(source)}.log`);
+    const sourceFile = resolve23(logDirectory, `${sanitizeLogFileName(source)}.log`);
     if (!initializedSources.has(source)) {
       writeFileSync6(sourceFile, "");
       initializedSources.add(source);
     }
     appendFileSync(sourceFile, line);
-    appendFileSync(resolve22(logDirectory, "all.log"), line);
+    appendFileSync(resolve23(logDirectory, "all.log"), line);
   };
   return {
     appendLog: (source, message, level = "info") => {
@@ -25019,9 +25673,9 @@ var readPackageVersion3 = (candidate) => {
 };
 var resolvePackageVersion2 = () => {
   const candidates = [
-    resolve22(import.meta.dir, "..", "..", "package.json"),
-    resolve22(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve22(import.meta.dir, "..", "..", "..", "..", "package.json")
+    resolve23(import.meta.dir, "..", "..", "package.json"),
+    resolve23(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve23(import.meta.dir, "..", "..", "..", "..", "package.json")
   ];
   for (const candidate of candidates) {
     const version2 = readPackageVersion3(candidate);
@@ -25375,15 +26029,15 @@ var createWorkspaceServiceEnv = (services) => {
 var getDefinedProcessEnv = () => Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string"));
 var resolveAbsoluteServiceConfigPath = (service, cwd, options) => {
   if (service.config)
-    return resolve22(cwd, service.config);
+    return resolve23(cwd, service.config);
   if (options.configPath)
-    return resolve22(options.configPath);
+    return resolve23(options.configPath);
   if (process.env.ABSOLUTE_CONFIG)
-    return resolve22(process.env.ABSOLUTE_CONFIG);
+    return resolve23(process.env.ABSOLUTE_CONFIG);
   return;
 };
 var resolveService = (name, service, workspaceEnv, options) => {
-  const cwd = resolve22(service.cwd ?? ".");
+  const cwd = resolve23(service.cwd ?? ".");
   const envVars = Object.assign(getDefinedProcessEnv(), workspaceEnv, service.port ? { PORT: String(service.port) } : {}, service.env, {
     ABSOLUTE_INSTANCE_MANAGED: "1",
     ABSOLUTE_WORKSPACE_MANAGED: "1",
@@ -25395,7 +26049,7 @@ var resolveService = (name, service, workspaceEnv, options) => {
   if (isAbsoluteService(service)) {
     const configPath2 = resolveAbsoluteServiceConfigPath(service, cwd, options);
     Object.assign(envVars, configPath2 ? { ABSOLUTE_CONFIG: configPath2 } : {}, {
-      ABSOLUTE_SERVER_ENTRY: resolve22(cwd, service.entry ?? DEFAULT_SERVER_ENTRY)
+      ABSOLUTE_SERVER_ENTRY: resolve23(cwd, service.entry ?? DEFAULT_SERVER_ENTRY)
     });
     const command = [
       process.execPath,
@@ -25425,8 +26079,8 @@ var resolveService = (name, service, workspaceEnv, options) => {
 var resolveServiceBuildDirectory = (service) => {
   if (!isAbsoluteService(service))
     return null;
-  const cwd = resolve22(service.cwd ?? ".");
-  return resolve22(cwd, service.buildDirectory ?? "build");
+  const cwd = resolve23(service.cwd ?? ".");
+  return resolve23(cwd, service.buildDirectory ?? "build");
 };
 var findSharedWorkspaceBuildDirectories = (services) => {
   const byBuildDirectory = new Map;
@@ -25644,7 +26298,7 @@ var workspace = async (subcommand, options) => {
       frameworks: [],
       host: getServicePublicHost(resolved.service),
       https: getServiceProtocol(resolved.service) === "https",
-      logFile: resolve22(workspaceLogs.logDirectory, `${sanitizeLogFileName(name)}.log`),
+      logFile: resolve23(workspaceLogs.logDirectory, `${sanitizeLogFileName(name)}.log`),
       name,
       pid: processHandle.pid,
       port: resolved.service.port ?? null,
@@ -25955,7 +26609,7 @@ if (command === "dev") {
   console.error("  prepare [entry] [--outdir dir] Build production assets and server without launching");
   console.error("  start [entry] [--outdir dir] [--prebuilt] Start production server");
   console.error("  compile [entry] [--outdir dir] [--outfile path] Compile standalone executable");
-  console.error("  mobile <init|sync|inspect|ci|pair|remotes|doctor|test> Manage Capacitor projects, CI, simulators, physical devices, Remote Macs, guided setup, and deep links");
+  console.error("  mobile <init|sync|inspect|ci|pair|remotes|doctor|test> Manage Capacitor apps and the experimental Expo hybrid shell");
   console.error("  config [--port n] Open the unified config UI (ESLint, tsconfig, Prettier)");
   console.error("  db <backup|restore|seed> Backup/restore any Postgres DB (ORM-agnostic, upsert by PK) or run the seed script");
   console.error("  doctor [--fix] [--json] Diagnose the project (bun, type graph, config, framework dirs, env, port)");