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

package/dist/mobile/index.js

@@ -862,7 +862,7 @@ var init_deviceCapabilities = __esm(() => {
 // src/cli/scripts/telemetry.ts
 import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var configDir, configPath, getTelemetryConfig = () => {
   try {
     if (!existsSync4(configPath))
@@ -875,14 +875,14 @@ var configDir, configPath, getTelemetryConfig = () => {
   }
 };
 var init_telemetry = __esm(() => {
-  configDir = join15(homedir3(), ".absolutejs");
-  configPath = join15(configDir, "telemetry.json");
+  configDir = join16(homedir3(), ".absolutejs");
+  configPath = join16(configDir, "telemetry.json");
 });
 
 // src/cli/telemetryEvent.ts
 import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { arch, platform } from "os";
-import { dirname as dirname11, join as join16, parse } from "path";
+import { dirname as dirname12, join as join17, parse } from "path";
 var checkCandidate = (candidate) => {
   if (!existsSync5(candidate)) {
     return null;
@@ -902,12 +902,12 @@ var checkCandidate = (candidate) => {
 }, findPackageVersion = () => {
   let { dir } = import.meta;
   while (dir !== parse(dir).root) {
-    const candidate = join16(dir, "package.json");
+    const candidate = join17(dir, "package.json");
     const version = checkCandidate(candidate);
     if (version) {
       return version;
     }
-    dir = dirname11(dir);
+    dir = dirname12(dir);
   }
   return "unknown";
 }, sendTelemetryEvent = (event, payload) => {
@@ -4535,6 +4535,26 @@ var normalizeCertificateFingerprints = (values) => [
     return value.match(/.{2}/g)?.join(":") ?? value;
   }))
 ].sort();
+var 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)));
+};
 var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
   const appId = requireText(config.appId, "mobile.appId");
   if (!APP_ID_PATTERN.test(appId)) {
@@ -4553,10 +4573,12 @@ var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
     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")
@@ -4805,8 +4827,8 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
   };
 };
 // src/mobile/buildPipeline.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join14, resolve as resolve12 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join15, resolve as resolve13 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
@@ -5460,6 +5482,12 @@ var shellPushModule = () => {
     return candidate;
   throw new TypeError("AbsoluteJS mobile push shell module is missing.");
 };
+var shellExpoDevicesModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join9(import.meta.dir, `shellExpoDevices.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS Expo device bridge module is missing.");
+};
 var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 var contentSecurityPolicy = (productionOrigin) => {
   const backend = new URL(productionOrigin);
@@ -5520,18 +5548,20 @@ var resolveProjectImport = async (projectRoot, specifier) => {
     throw new TypeError(`${specifier} has an unsafe import entry.`);
   return resolved;
 };
-var buildShellBootstrap = async (staging, auth, sync, storagePrefix, deviceCapabilities, projectRoot) => {
+var 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}.`);
@@ -5541,14 +5571,22 @@ var buildShellBootstrap = async (staging, auth, sync, storagePrefix, deviceCapab
   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 = join9(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 writeFile10(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],
@@ -5712,7 +5750,7 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       writeFile10(join9(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
       writeFile10(join9(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;
@@ -5954,6 +5992,540 @@ var serializeAbsoluteMobileAuthEnvironment = (config, auth) => auth === undefine
 // src/mobile/buildPipeline.ts
 init_syncSchema();
 init_deviceCapabilities();
+
+// src/mobile/expoProject.ts
+import {
+  access as access9,
+  cp as cp2,
+  mkdir as mkdir11,
+  mkdtemp as mkdtemp6,
+  readdir as readdir4,
+  readFile as readFile14,
+  rename as rename11,
+  rm as rm9,
+  writeFile as writeFile12
+} from "fs/promises";
+import { createHash as createHash10 } from "crypto";
+import { basename as basename4, dirname as dirname10, join as join14, relative as relative10, resolve as resolve12 } from "path";
+var EXPO_GENERATED_HEADER = `// Generated by AbsoluteJS. Edit absolute.config.ts, then run absolute mobile sync.
+`;
+var EXPO_ASSET_EXTENSION = ".absasset";
+var EXPO_PROJECT_MARKER = ".absolutejs-expo-project";
+var exists3 = async (path) => {
+  try {
+    await access9(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var portableRelative2 = (from, destination) => {
+  const value = relative10(from, destination).replaceAll("\\", "/");
+  return value.startsWith(".") ? value : `./${value}`;
+};
+var 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;
+});
+var routeFile = (project, route) => join14(project, "app", ...routeSegments(route), "index.tsx");
+var 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"
+});
+var 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"
+  }
+});
+var 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;
+`;
+var layoutSource = `${EXPO_GENERATED_HEADER}import { Stack } from 'expo-router';
+
+export default function AbsoluteLayout() {
+	return <Stack screenOptions={{ headerShown: false }} />;
+}
+`;
+var 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' }
+});
+`;
+var 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 } });
+`;
+};
+var webRouteSource = `${EXPO_GENERATED_HEADER}import { AbsoluteWebHost } from '../src/generated/AbsoluteWebHost';
+
+export default AbsoluteWebHost;
+`;
+var catchAllRouteSource = `${EXPO_GENERATED_HEADER}import { AbsoluteWebHost } from '../src/generated/AbsoluteWebHost';
+
+export default AbsoluteWebHost;
+`;
+var nativeWrapperSource = (wrapper, module) => `${EXPO_GENERATED_HEADER}export { default } from ${JSON.stringify(portableRelative2(dirname10(wrapper), module).replace(/\.(?:[cm]?[jt]sx?)$/u, ""))};
+`;
+var 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"
+});
+var writeManagedFile = async (path, source, force) => {
+  await mkdir11(dirname10(path), { recursive: true });
+  if (await exists3(path)) {
+    const current = await readFile14(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 writeFile12(temporary, source, { flag: "wx" });
+  await rename11(temporary, path);
+  return true;
+};
+var jsonSource = (value) => `${JSON.stringify(value, null, "\t")}
+`;
+var writeAbsoluteExpoProject = async (config, options) => {
+  if (config.engine !== "expo")
+    throw new TypeError("Expo project generation requires mobile.engine: expo.");
+  const projectRoot = resolve12(options.projectRoot);
+  const project = config.nativeProjectDirectory;
+  const routeModules = Object.entries(config.expoNativeRoutes);
+  const moduleChecks = await Promise.all(routeModules.map(async ([route, module]) => ({
+    exists: await exists3(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 = join14(project, EXPO_PROJECT_MARKER);
+  if (await exists3(project) && !await exists3(marker)) {
+    const entries = await readdir4(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 mkdir11(project, { recursive: true });
+  await writeFile12(marker, `format=1
+`);
+  const files = new Map([
+    [
+      join14(project, ".gitignore"),
+      `.expo/
+android/
+ios/
+node_modules/
+`
+    ],
+    [join14(project, "app.json"), jsonSource(expoAppConfig(config))],
+    [join14(project, "package.json"), jsonSource(expoPackage())],
+    [join14(project, "metro.config.js"), metroConfig(projectRoot)],
+    [
+      join14(project, "tsconfig.json"),
+      jsonSource(expoTsConfig(projectRoot, project))
+    ],
+    [join14(project, "app", "_layout.tsx"), layoutSource],
+    [
+      join14(project, "app", "__absolute", "native", "index.tsx"),
+      nativeDiagnosticSource
+    ],
+    [
+      join14(project, "src", "generated", "AbsoluteWebHost.tsx"),
+      webHostSource(config)
+    ]
+  ]);
+  if (!config.expoNativeRoutes["/"]) {
+    files.set(join14(project, "app", "index.tsx"), webRouteSource);
+  }
+  files.set(join14(project, "app", "[...absolute].tsx"), catchAllRouteSource);
+  for (const [route, module] of routeModules) {
+    const wrapper = route === "/" ? join14(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()] };
+};
+var walkFiles = async (root, directory = root) => {
+  const entries = await readdir4(directory, { withFileTypes: true });
+  const nested = await Promise.all(entries.map((entry) => {
+    const path = join14(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();
+};
+var renameIfPresent = async (source, destination) => {
+  try {
+    await rename11(source, destination);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+};
+var installStagedDirectory = async (staging, destination) => {
+  const backup = `${destination}.previous-${crypto.randomUUID()}`;
+  const moved = await renameIfPresent(destination, backup);
+  try {
+    await rename11(staging, destination);
+    if (moved)
+      await rm9(backup, { force: true, recursive: true });
+  } catch (error) {
+    if (moved)
+      await rename11(backup, destination);
+    throw error;
+  }
+};
+var 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;
+};
+`;
+var syncAbsoluteExpoWebAssets = async (config) => {
+  if (config.engine !== "expo")
+    throw new TypeError("Expo asset sync requires mobile.engine: expo.");
+  const marker = join14(config.nativeProjectDirectory, EXPO_PROJECT_MARKER);
+  if (!await exists3(marker)) {
+    throw new TypeError("Expo asset sync requires an AbsoluteJS-managed Expo project. Run mobile init first.");
+  }
+  const manifestPath = join14(config.bundleDirectory, "absolute-mobile-manifest.json");
+  const manifest = JSON.parse(await readFile14(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 = createHash10("sha256");
+  const filesWithContents = await Promise.all(files.map(async (file) => ({ contents: await readFile14(file), file })));
+  filesWithContents.forEach(({ contents, file }) => {
+    bundleHash.update(relative10(config.bundleDirectory, file).replaceAll("\\", "/"));
+    bundleHash.update("\x00");
+    bundleHash.update(contents);
+    bundleHash.update("\x00");
+  });
+  const bundleId = `amexpo_${bundleHash.digest("hex")}`;
+  const destination = join14(config.nativeProjectDirectory, "assets", "absolute");
+  await mkdir11(dirname10(destination), { recursive: true });
+  const staging = await mkdtemp6(join14(dirname10(destination), `.${basename4(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 cp2(source, join14(staging, name));
+      return {
+        asset: portableRelative2(join14(config.nativeProjectDirectory, "src", "generated"), join14(destination, name)),
+        path: relative10(config.bundleDirectory, source).replaceAll("\\", "/")
+      };
+    }));
+    await installStagedDirectory(staging, destination);
+  } catch (error) {
+    await rm9(staging, { force: true, recursive: true });
+    throw error;
+  }
+  const generated = join14(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
+  await writeManagedFile(generated, assetModuleSource(assets, bundleId), true);
+  return { appBuild, assets: assets.length, bundleId, path: destination };
+};
+
+// src/mobile/buildPipeline.ts
 var isElysiaApp = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "compile") === "function" && Array.isArray(Reflect.get(value, "routes"));
 var isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
 var serverExportName = (loaded, app) => {
@@ -5987,11 +6559,11 @@ var loadServerApp = async (producerPath) => {
   return { app, exportName };
 };
 var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve12(options.buildDirectory);
+  const buildDirectory = resolve13(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join14(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join15(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile14(join14(buildDirectory, "manifest.json"), "utf8"),
+    readFile15(join15(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -6004,11 +6576,11 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
   process.env.ABSOLUTE_COMPILED_RUNTIME = "1";
   if (options.configPath) {
-    process.env.ABSOLUTE_CONFIG = resolve12(options.projectRoot, options.configPath);
+    process.env.ABSOLUTE_CONFIG = resolve13(options.projectRoot, options.configPath);
   }
   let loaded;
   try {
-    loaded = await loadServerApp(resolve12(options.producerPath));
+    loaded = await loadServerApp(resolve13(options.producerPath));
   } finally {
     restoreEnvironmentVariable("ABSOLUTE_BUILD_DIR", previousBuildDirectory);
     restoreEnvironmentVariable("ABSOLUTE_COMPILED_RUNTIME", previousCompiledRuntime);
@@ -6021,19 +6593,27 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve12(options.producerPath),
+    producerPath: resolve13(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.");
   }
@@ -6057,6 +6637,12 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     ...sync ? { sync: true } : {},
     ...syncSchema ? { syncSchema: { components: syncSchema.components } } : {}
   });
+  if (mobile.engine === "expo") {
+    await writeAbsoluteExpoProject(mobile, {
+      projectRoot: options.projectRoot
+    });
+    await syncAbsoluteExpoWebAssets(mobile);
+  }
   return current.artifact;
 };
 
@@ -6174,10 +6760,152 @@ var installAbsoluteMobileSyncRemediation = (bridge = {
 // src/mobile/index.ts
 init_deviceCapabilities();
 
+// src/mobile/expoBridge.ts
+var ABSOLUTE_EXPO_BRIDGE_FORMAT = 1;
+var ABSOLUTE_EXPO_BRIDGE_MAX_BYTES = 64 * 1024;
+var ABSOLUTE_EXPO_BRIDGE_METHODS = [
+  "devices.haptics.impact",
+  "http.fetch"
+];
+var isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+var validId = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,80}$/u.test(value);
+var validPath = (value) => typeof value === "string" && value.startsWith("/") && !value.startsWith("//") && value.length <= 4096;
+var parseRequest = (value) => {
+  if (typeof value.id !== "string" || !validId(value.id))
+    throw new TypeError("Expo bridge request id is invalid.");
+  const method = ABSOLUTE_EXPO_BRIDGE_METHODS.find((candidate) => candidate === value.method);
+  if (!method) {
+    throw new TypeError("Expo bridge method is not allowed.");
+  }
+  if (!isRecord8(value.params))
+    throw new TypeError("Expo bridge request params must be an object.");
+  if (typeof value.path !== "string" || !validPath(value.path))
+    throw new TypeError("Expo bridge request path is invalid.");
+  if (method === "devices.haptics.impact") {
+    const styles = new Set([
+      "error",
+      "heavy",
+      "light",
+      "medium",
+      "selection",
+      "success",
+      "vibrate",
+      "warning"
+    ]);
+    if (typeof value.params.style !== "string" || !styles.has(value.params.style))
+      throw new TypeError("Expo bridge haptics style is invalid.");
+    if (value.params.durationMs !== undefined && (typeof value.params.durationMs !== "number" || !Number.isFinite(value.params.durationMs) || value.params.durationMs < 0 || value.params.durationMs > 1e4)) {
+      throw new TypeError("Expo bridge haptics duration is invalid.");
+    }
+  }
+  if (method === "http.fetch") {
+    if (typeof value.params.url !== "string")
+      throw new TypeError("Expo bridge HTTP URL is invalid.");
+    const url = new URL(value.params.url);
+    const loopbackHttp = url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]");
+    if (url.protocol !== "https:" && !loopbackHttp)
+      throw new TypeError("Expo bridge HTTP URL must use HTTPS.");
+    if (value.params.method !== "GET")
+      throw new TypeError("Expo bridge HTTP method is not allowed.");
+    if (!isRecord8(value.params.headers))
+      throw new TypeError("Expo bridge HTTP headers must be an object.");
+    const headersAllowed = Object.entries(value.params.headers).every(([name, header]) => typeof header === "string" && (name.toLowerCase() === "accept" || name.toLowerCase().startsWith("x-absolute-mobile-")));
+    if (!headersAllowed) {
+      throw new TypeError("Expo bridge HTTP header is not allowed.");
+    }
+  }
+  return {
+    format: ABSOLUTE_EXPO_BRIDGE_FORMAT,
+    id: value.id,
+    kind: "request",
+    method,
+    params: value.params,
+    path: value.path
+  };
+};
+var parseResponse = (value) => {
+  if (typeof value.id !== "string" || !validId(value.id))
+    throw new TypeError("Expo bridge response id is invalid.");
+  if (value.error !== undefined) {
+    if (!isRecord8(value.error) || typeof value.error.code !== "string" || typeof value.error.message !== "string") {
+      throw new TypeError("Expo bridge response error is invalid.");
+    }
+    if (value.result !== undefined)
+      throw new TypeError("Expo bridge response cannot contain result and error.");
+  }
+  if (isRecord8(value.error)) {
+    return {
+      error: {
+        code: String(value.error.code),
+        message: String(value.error.message)
+      },
+      format: ABSOLUTE_EXPO_BRIDGE_FORMAT,
+      id: value.id,
+      kind: "response"
+    };
+  }
+  return {
+    format: ABSOLUTE_EXPO_BRIDGE_FORMAT,
+    id: value.id,
+    kind: "response",
+    result: value.result
+  };
+};
+var parseEvent = (value) => {
+  if (value.event !== "ready" && value.event !== "navigation") {
+    throw new TypeError("Expo bridge event is not allowed.");
+  }
+  if (typeof value.path !== "string" || !validPath(value.path))
+    throw new TypeError("Expo bridge event path is invalid.");
+  if (value.payload !== undefined && !isRecord8(value.payload)) {
+    throw new TypeError("Expo bridge event payload must be an object.");
+  }
+  return {
+    event: value.event,
+    format: ABSOLUTE_EXPO_BRIDGE_FORMAT,
+    kind: "event",
+    path: value.path,
+    ...value.payload ? { payload: value.payload } : {}
+  };
+};
+var createAbsoluteExpoBridgeError = (id, code, message) => parseResponse({
+  error: { code, message },
+  format: ABSOLUTE_EXPO_BRIDGE_FORMAT,
+  id,
+  kind: "response"
+});
+var createAbsoluteExpoBridgeResponse = (id, result) => parseResponse({
+  format: ABSOLUTE_EXPO_BRIDGE_FORMAT,
+  id,
+  kind: "response",
+  result
+});
+var parseAbsoluteExpoBridgeMessage = (source) => {
+  if (new TextEncoder().encode(source).byteLength > ABSOLUTE_EXPO_BRIDGE_MAX_BYTES)
+    throw new TypeError("Expo bridge message exceeds 64 KiB.");
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (cause) {
+    throw new TypeError("Expo bridge message is not valid JSON.", {
+      cause
+    });
+  }
+  if (!isRecord8(parsed) || parsed.format !== ABSOLUTE_EXPO_BRIDGE_FORMAT) {
+    throw new TypeError("Expo bridge message format is unsupported.");
+  }
+  if (parsed.kind === "request")
+    return parseRequest(parsed);
+  if (parsed.kind === "response")
+    return parseResponse(parsed);
+  if (parsed.kind === "event")
+    return parseEvent(parsed);
+  throw new TypeError("Expo bridge message kind is unsupported.");
+};
 // src/mobile/ciWorkflow.ts
 import { existsSync as existsSync3 } from "fs";
-import { access as access9, mkdir as mkdir11, readFile as readFile15, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname10, extname as extname4, relative as relative10, resolve as resolve13, sep as sep6 } from "path";
+import { access as access10, mkdir as mkdir12, readFile as readFile16, writeFile as writeFile13 } from "fs/promises";
+import { dirname as dirname11, extname as extname4, relative as relative11, resolve as resolve14, sep as sep6 } from "path";
 var ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT = 1;
 var SECRET_NAME_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
 var CI_ENV_INDENTATION = 6;
@@ -6196,9 +6924,9 @@ var RESERVED_SECRET_NAMES = new Set([
   "APP_STORE_CONNECT_KEY_ID",
   "APP_STORE_CONNECT_PRIVATE_KEY_BASE64"
 ]);
-var exists3 = async (path) => {
+var exists4 = async (path) => {
   try {
-    await access9(path);
+    await access10(path);
     return true;
   } catch {
     return false;
@@ -6206,9 +6934,9 @@ var exists3 = async (path) => {
 };
 var yamlString = (value) => `'${value.replaceAll("'", "''")}'`;
 var projectPath = (projectRoot, value, field2, options = {}) => {
-  const root = resolve13(projectRoot);
-  const path = resolve13(root, value);
-  const portable = relative10(root, path).replaceAll("\\", "/");
+  const root = resolve14(projectRoot);
+  const path = resolve14(root, value);
+  const portable = relative11(root, path).replaceAll("\\", "/");
   if (portable === ".." || portable.startsWith(`..${sep6}`) || portable.startsWith("../") || portable === "") {
     throw new TypeError(`${field2} must remain inside the project root.`);
   }
@@ -6219,10 +6947,10 @@ var projectPath = (projectRoot, value, field2, options = {}) => {
   return portable;
 };
 var workflowOutputPath = (projectRoot, value) => {
-  const root = resolve13(projectRoot);
-  const workflows = resolve13(root, ".github/workflows");
-  const path = resolve13(root, value ?? ".github/workflows/absolute-mobile.yml");
-  const portable = relative10(workflows, path);
+  const root = resolve14(projectRoot);
+  const workflows = resolve14(root, ".github/workflows");
+  const path = resolve14(root, value ?? ".github/workflows/absolute-mobile.yml");
+  const portable = relative11(workflows, path);
   if (portable === ".." || portable.startsWith(`..${sep6}`) || extname4(path) !== ".yml" && extname4(path) !== ".yaml") {
     throw new TypeError("mobile ci github --output must be a .yml or .yaml file inside .github/workflows.");
   }
@@ -6652,12 +7380,12 @@ ${bundleAuditSteps}${platforms.includes("android") ? androidJob({ customSecrets,
 var writeAbsoluteMobileGithubWorkflow = async (options) => {
   const path = workflowOutputPath(options.projectRoot, options.outputPath);
   const generated = createAbsoluteMobileGithubWorkflow(options);
-  const previous = await exists3(path) ? await readFile15(path, "utf8") : undefined;
+  const previous = await exists4(path) ? await readFile16(path, "utf8") : undefined;
   if (previous !== undefined && previous !== generated.workflow && !options.force)
-    throw new TypeError(`${relative10(options.projectRoot, path)} already exists and differs. Rerun with --force to replace the generated workflow.`);
+    throw new TypeError(`${relative11(options.projectRoot, path)} already exists and differs. Rerun with --force to replace the generated workflow.`);
   if (previous !== generated.workflow) {
-    await mkdir11(dirname10(path), { recursive: true });
-    await writeFile12(path, generated.workflow);
+    await mkdir12(dirname11(path), { recursive: true });
+    await writeFile13(path, generated.workflow);
   }
   return {
     changed: previous !== generated.workflow,
@@ -6817,7 +7545,7 @@ init_telemetryEvent();
 import { Elysia as Elysia3 } from "elysia";
 var ABSOLUTE_MOBILE_PREVIEW_PATH = "/__absolute/mobile-preview";
 var escapeHtml2 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
-var isRecord8 = (value) => typeof value === "object" && value !== null;
+var isRecord9 = (value) => typeof value === "object" && value !== null;
 var normalizeEntry2 = (entry) => {
   const parsed = new URL(entry ?? "/", "https://absolute.invalid");
   return `${parsed.pathname}${parsed.search}${parsed.hash}`;
@@ -6868,7 +7596,7 @@ var createAbsoluteMobilePreviewPlugin = (mobile) => {
       "X-Robots-Tag": "noindex, nofollow"
     }
   })).post("/__absolute/mobile-preview-telemetry", ({ body, status }) => {
-    const value = isRecord8(body) ? body : undefined;
+    const value = isRecord9(body) ? body : undefined;
     const durationMs = value?.durationMs;
     const platform2 = value?.platform;
     if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0 || durationMs > 300000 || platform2 !== "android" && platform2 !== "ios") {
@@ -6884,20 +7612,20 @@ var createAbsoluteMobilePreviewPlugin = (mobile) => {
   });
 };
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile16, rename as rename11, writeFile as writeFile13 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile17, rename as rename12, writeFile as writeFile14 } from "fs/promises";
+import { join as join18 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->";
 var END_MARKER = "<!-- absolutejs:deep-links:end -->";
 var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
 var NOT_FOUND = -1;
 var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var writeChangedFile = async (path, source) => {
-  const current = await readFile16(path, "utf8");
+  const current = await readFile17(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile13(temporary, source, { flag: "wx" });
-  await rename11(temporary, path);
+  await writeFile14(temporary, source, { flag: "wx" });
+  await rename12(temporary, path);
   return true;
 };
 var replaceManagedRegion = (source, region, insertAt) => {
@@ -6942,8 +7670,8 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join17(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile16(path, "utf8");
+  const path = join18(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile17(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
     throw new TypeError("Android MainActivity was not found.");
@@ -6968,8 +7696,8 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join17(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile16(path, "utf8");
+  const path = join18(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile17(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
 `;
@@ -6992,10 +7720,10 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join17(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join18(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
-    current = await readFile16(path, "utf8");
+    current = await readFile17(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -7005,13 +7733,13 @@ var configureIosEntitlements = async (config) => {
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile13(temporary, source, { flag: "wx" });
-  await rename11(temporary, path);
+  await writeFile14(temporary, source, { flag: "wx" });
+  await rename12(temporary, path);
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join17(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const source = await readFile16(path, "utf8");
+  const path = join18(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const source = await readFile17(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
   ].map((match) => match[1]);
@@ -7050,8 +7778,8 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
 };
 // src/mobile/nativeDeviceCapabilities.ts
 init_deviceCapabilities();
-import { readFile as readFile17, rename as rename12, writeFile as writeFile14 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile18, rename as rename13, writeFile as writeFile15 } from "fs/promises";
+import { join as join19 } from "path";
 var START_MARKER2 = "<!-- absolutejs:device-capabilities:start -->";
 var END_MARKER2 = "<!-- absolutejs:device-capabilities:end -->";
 var NOT_FOUND2 = -1;
@@ -7061,12 +7789,12 @@ var PUSH_START_MARKER = "absolutejs:push-notifications:start";
 var PUSH_END_MARKER = "absolutejs:push-notifications:end";
 var escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var writeChangedFile2 = async (path, source) => {
-  const current = await readFile17(path, "utf8");
+  const current = await readFile18(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile14(temporary, source, { flag: "wx" });
-  await rename12(temporary, path);
+  await writeFile15(temporary, source, { flag: "wx" });
+  await rename13(temporary, path);
   return true;
 };
 var writeOptionalChangedFile = async (path, source) => {
@@ -7074,14 +7802,14 @@ var writeOptionalChangedFile = async (path, source) => {
   if (current === source)
     return false;
   if (current === null) {
-    await writeFile14(path, source, { flag: "wx" });
+    await writeFile15(path, source, { flag: "wx" });
     return true;
   }
   return writeChangedFile2(path, source);
 };
 var optionalSource = async (path) => {
   try {
-    return await readFile17(path, "utf8");
+    return await readFile18(path, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "ENOENT")
       return null;
@@ -7195,14 +7923,14 @@ var writeIosPrivacyManifest = async (path, current, source) => {
     return false;
   if (current !== null)
     return writeChangedFile2(path, source);
-  await writeFile14(path, source, { flag: "wx" });
+  await writeFile15(path, source, { flag: "wx" });
   return true;
 };
 var configureIosPrivacyProject = async (config, requirements) => {
   if (requirements.iosPrivacyAccessedApis.length === 0)
     return false;
-  const projectPath2 = join18(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const project = await readFile17(projectPath2, "utf8");
+  const projectPath2 = join19(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const project = await readFile18(projectPath2, "utf8");
   return writeChangedFile2(projectPath2, addIosPrivacyProjectReference(project));
 };
 var addIosPrivacyProjectReference = (source) => {
@@ -7254,8 +7982,8 @@ ${next.slice(index)}`;
   return next;
 };
 var configureIos2 = async (config, plan) => {
-  const path = join18(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile17(path, "utf8");
+  const path = join19(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile18(path, "utf8");
   const requirements = absoluteDeviceNativeRequirements(plan);
   const existingSystemBars = source.match(/<key>UIViewControllerBasedStatusBarAppearance<\/key>\s*<(true|false)\s*\/>/u);
   const ownedStart = source.indexOf(START_MARKER2);
@@ -7275,7 +8003,7 @@ ${content}
 	${END_MARKER2}
 ` : "";
   const infoChanged = await writeChangedFile2(path, managed(source, region, source.lastIndexOf("</dict>")));
-  const privacyPath = join18(config.nativeProjectDirectory, "ios/App/App/PrivacyInfo.xcprivacy");
+  const privacyPath = join19(config.nativeProjectDirectory, "ios/App/App/PrivacyInfo.xcprivacy");
   const privacyCurrent = await optionalSource(privacyPath);
   const privacySource = privacyManifestSource(privacyCurrent, requirements);
   const [privacyChanged, projectChanged, pushChanged] = await Promise.all([
@@ -7286,7 +8014,7 @@ ${content}
   return infoChanged || privacyChanged || projectChanged || pushChanged;
 };
 var configureIosPushNotifications = async (config, enabled) => {
-  const entitlementsPath = join18(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const entitlementsPath = join19(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   const entitlements = await optionalSource(entitlementsPath);
   if (entitlements === null && !enabled)
     return false;
@@ -7298,7 +8026,7 @@ var configureIosPushNotifications = async (config, enabled) => {
 	<!-- ${PUSH_END_MARKER} -->
 ` : "";
   const nextEntitlements = replacePushRegion(entitlements, entitlementRegion, entitlements.lastIndexOf("</dict>"));
-  const delegatePath = join18(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
+  const delegatePath = join19(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
   const delegate = await optionalSource(delegatePath);
   if (delegate === null && !enabled)
     return false;
@@ -7347,8 +8075,8 @@ var replacePushRegion = (source, region, insertion) => {
   return `${source.slice(0, insertion)}${region}${source.slice(insertion)}`;
 };
 var configureAndroid2 = async (config, plan) => {
-  const path = join18(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile17(path, "utf8");
+  const path = join19(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile18(path, "utf8");
   const permissions = absoluteDeviceNativeRequirements(plan).androidPermissions;
   const content = permissions.map((permission) => `    <uses-permission android:name="${escapeXml2(permission)}" />`).join(`
 `);
@@ -7383,7 +8111,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(join18(config.nativeProjectDirectory, "android/app/google-services.json"), firebaseSource)
+    writeOptionalChangedFile(join19(config.nativeProjectDirectory, "android/app/google-services.json"), firebaseSource)
   ]);
   return manifestChanged || firebaseChanged;
 };
@@ -7397,8 +8125,8 @@ var applyAbsoluteNativeDeviceCapabilities = async (projectRoot, config, platform
   };
 };
 // src/mobile/releasePublisher.ts
-import { access as access10 } from "fs/promises";
-import { isAbsolute as isAbsolute6, relative as relative11, resolve as resolve14, sep as sep7 } from "path";
+import { access as access11 } from "fs/promises";
+import { isAbsolute as isAbsolute6, relative as relative12, resolve as resolve15, sep as sep7 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -7421,12 +8149,12 @@ var prepareAbsoluteAndroidRelease = async (publisher, options) => {
   }
   return versionCode;
 };
-var isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isPublisher = (value) => isRecord9(value) && typeof value.publish === "function";
+var isRecord10 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPublisher = (value) => isRecord10(value) && typeof value.publish === "function";
 var publisherModulePath = (projectRoot, requested) => {
-  const root = resolve14(projectRoot);
-  const path = resolve14(root, requested);
-  const projectRelative = relative11(root, path);
+  const root = resolve15(projectRoot);
+  const path = resolve15(root, requested);
+  const projectRelative = relative12(root, path);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep7}`) || isAbsolute6(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
@@ -7434,11 +8162,11 @@ var publisherModulePath = (projectRoot, requested) => {
 };
 var loadAbsoluteNativeReleasePublisher = async (projectRoot, requestedModulePath) => {
   const modulePath = publisherModulePath(projectRoot, requestedModulePath);
-  await access10(modulePath).catch(() => {
+  await access11(modulePath).catch(() => {
     throw new TypeError(`Native release registry module does not exist: ${modulePath}`);
   });
   const loaded = await import(pathToFileURL3(modulePath).href);
-  const publisher = isRecord9(loaded) ? loaded.default ?? loaded.registry : undefined;
+  const publisher = isRecord10(loaded) ? loaded.default ?? loaded.registry : undefined;
   if (!isPublisher(publisher)) {
     throw new TypeError("Native release registry module must default-export a registry with publish(options).");
   }
@@ -7496,7 +8224,7 @@ var publishAbsoluteIosRelease = async (options) => {
 };
 // src/mobile/routeMetadataTransform.ts
 import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname12, extname as extname5, relative as relative12, resolve as resolve15 } from "path";
+import { dirname as dirname13, extname as extname5, relative as relative13, resolve as resolve16 } from "path";
 import ts2 from "typescript";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
@@ -7547,7 +8275,7 @@ var PAGE_HANDLERS = new Map([
   ]
 ]);
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts2.findConfigFile(dirname12(entry), existsSync6, "tsconfig.json") ?? ts2.findConfigFile(projectRoot, existsSync6, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => ts2.findConfigFile(dirname13(entry), existsSync6, "tsconfig.json") ?? ts2.findConfigFile(projectRoot, existsSync6, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath2 = findTsconfig(entry, projectRoot);
   if (!configPath2) {
@@ -7559,7 +8287,7 @@ var createProgram = (entry, projectRoot) => {
       target: ts2.ScriptTarget.ESNext
     });
   }
-  const parsed = ts2.parseJsonConfigFileContent(ts2.readConfigFile(configPath2, (path) => readFileSync7(path, "utf8")).config, ts2.sys, dirname12(configPath2));
+  const parsed = ts2.parseJsonConfigFileContent(ts2.readConfigFile(configPath2, (path) => readFileSync7(path, "utf8")).config, ts2.sys, dirname13(configPath2));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts2.createProgram(parsed.fileNames, parsed.options);
@@ -7665,7 +8393,7 @@ var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   const declaration = symbol?.declarations?.[0];
   const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
   const exportedName = symbol?.name ?? expression.getText(sourceFile);
-  const source = posixPath(relative12(projectRoot, file));
+  const source = posixPath(relative13(projectRoot, file));
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
@@ -7904,7 +8632,7 @@ var analyzeProgram = (program, projectRoot) => {
   const checker = program.getTypeChecker();
   const analyzed = new Map;
   for (const sourceFile of program.getSourceFiles()) {
-    const resolvedFile = resolve15(sourceFile.fileName);
+    const resolvedFile = resolve16(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -7997,14 +8725,14 @@ var transformFile = (source, fileName, analysis) => {
 };
 var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
 var createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve15(options.projectRoot ?? process.cwd());
-  const entry = resolve15(options.entry);
+  const projectRoot = resolve16(options.projectRoot ?? process.cwd());
+  const entry = resolve16(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(resolve15(path));
+        const analysis = analyzed.get(resolve16(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
@@ -8017,11 +8745,11 @@ var createAbsoluteMobileRouteMetadataPlugin = (options) => {
   };
 };
 var inspectAbsoluteMobileRouteMetadata = (options) => {
-  const projectRoot = resolve15(options.projectRoot ?? process.cwd());
-  const entry = resolve15(options.entry);
+  const projectRoot = resolve16(options.projectRoot ?? process.cwd());
+  const entry = resolve16(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return [...analyzed.entries()].flatMap(([file, analysis]) => [...analysis.byRouteCall.values()].map(({ metadata }) => ({
-    file: posixPath(relative12(projectRoot, file)),
+    file: posixPath(relative13(projectRoot, file)),
     metadata
   })));
 };
@@ -8230,6 +8958,7 @@ var http = createAbsoluteHttpClient();
 var installAbsoluteMobileShellHttp = (origin, fetch2 = globalThis.fetch) => installAbsoluteHttpTransport(createAbsoluteHttpTransport({ fetch: fetch2, origin, runtime: "native" }));
 export {
   writeAbsoluteMobileGithubWorkflow,
+  writeAbsoluteExpoProject,
   writeAbsoluteCapacitorConfig,
   waitForAbsoluteIosHmrLog,
   verifyAbsoluteMobileCompatibilityProducer,
@@ -8238,6 +8967,7 @@ export {
   validateAbsoluteRemoteMacProfileName,
   testAbsoluteIosPhysicalDevice,
   syncAbsoluteRemoteMacProject,
+  syncAbsoluteExpoWebAssets,
   startAbsoluteRemoteIosDevSession,
   startAbsoluteIosTcpRelay,
   startAbsoluteIosDevSession,
@@ -8273,6 +9003,7 @@ export {
   parseAbsoluteMobileBuildPageMetadata,
   parseAbsoluteIosLogLine,
   parseAbsoluteIosHmrLog,
+  parseAbsoluteExpoBridgeMessage,
   parseAbsoluteAndroidInstalledApp,
   pairAbsoluteRemoteMac,
   normalizeAbsoluteMobileConfig,
@@ -8327,6 +9058,8 @@ export {
   createAbsoluteMobileAssociationPlugin,
   createAbsoluteMobileAssociationDocuments,
   createAbsoluteIosNativeWatcher,
+  createAbsoluteExpoBridgeResponse,
+  createAbsoluteExpoBridgeError,
   carryForwardAbsoluteMobileCompatibilityReleases,
   captureAbsoluteRemoteMacCommand,
   captureAbsoluteMobileRouteGraph,
@@ -8364,9 +9097,12 @@ export {
   ABSOLUTE_MOBILE_CI_WORKFLOW_FORMAT,
   ABSOLUTE_IOS_SIMULATOR_NAME,
   ABSOLUTE_IOS_RELEASE_FORMAT,
+  ABSOLUTE_EXPO_BRIDGE_METHODS,
+  ABSOLUTE_EXPO_BRIDGE_MAX_BYTES,
+  ABSOLUTE_EXPO_BRIDGE_FORMAT,
   ABSOLUTE_AUTH_PACKAGE,
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=1C9BEF9E4B461BFB64756E2164756E21
+//# debugId=81AD994206FFE2B464756E2164756E21
 //# sourceMappingURL=index.js.map