@rollipop/expo 0.0.0 → 1.0.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Geunhyeok LEE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1 +1,91 @@
-# rollipop-empty
+# @rollipop/expo
+
+Use Rollipop for Expo SDK 55–58 native development, exports, and native bundle builds.
+
+Run `npx @rollipop/init@beta` from your Expo project root for automatic JSON config setup and matching `rollipop` and `@rollipop/expo` development dependencies, then install the updated dependencies. Dynamic JS/TS config files receive manual instructions. See the [Expo guide](https://rollipop.dev/docs/experimental/expo) for details.
+
+For manual setup:
+
+```sh
+yarn add -D rollipop@beta @rollipop/expo@beta
+```
+
+Install both packages at the same version. `rollipop` is a required peer dependency of `@rollipop/expo` and must be declared in your project.
+
+Add one plugin entry to your existing Expo configuration:
+
+```json
+{
+  "expo": {
+    "plugins": ["@rollipop/expo"]
+  }
+}
+```
+
+Keep existing plugins such as `expo-router`. Continue using `expo start`, `expo run:ios`, `expo run:android`, and `expo export --platform ios --platform android`.
+
+The plugin also configures Expo Updates resource generation during `expo prebuild`. Regenerate native projects after adding it if you keep `ios/` or `android/` in source control. Continuous Native Generation and EAS prebuild apply the same mods automatically.
+
+## Release status
+
+This integration is a prerelease. Publish this workspace together with the Rollipop inspector integration. Native runtime, builds, and package installation have been verified locally; cloud EAS signing, upload, and store submission have not been verified.
+
+The release workflow uses `id-token: write` and publishes public packages with provenance. Before the first automated release, ensure this package exists on npm and configure its [Trusted Publisher](https://docs.npmjs.com/trusted-publishers/) for GitHub owner `rollipop-dev`, repository `rollipop`, and workflow `release.yml`. This package's repository metadata points to that repository and the `packages/expo` directory.
+
+Known engine limitation: the pinned `@rollipop/rolldown@1.1.1` can shift source locations after Worklets-generated unmapped code. The same `oxc_sourcemap` bug exists upstream; [a proposed fix](https://github.com/oxc-project/oxc-sourcemap/pull/471) was closed without merging. The regression in `test/sourcemap.test.cjs` retains the correct original-location assertions and is marked `it.skip` with the upstream PR context.
+
+## Compatibility
+
+At startup, the adapter checks that `rollipop` is installed in the project and reports matching-version installation commands if it is missing.
+
+The adapter supports Expo SDK 55–58 with the matching `@expo/cli` major. Patch and minor CLI releases are accepted when the required private API contract is available; incompatible SDK/CLI pairs and missing methods fail with a diagnostic. Hooks are scoped to projects that enabled the plugin.
+
+SDK policies and private CLI bindings live in `src/compatibility/`. SDK 55–57 use Expo's source initialization entry, while SDK 58 uses its compiled entry. The development server, Router, exports, and Updates integration share the same implementation.
+
+Hermes syntax targeting follows the SDK default (classic Hermes on SDK 55; V1 on SDK 56–58), `expo-build-properties`, generated native properties, and native build environment settings. When the two platforms use different engines, the shared configuration selects classic Hermes syntax, which also runs on V1. Expo's Hermes compiler helper still selects the project's RN-matched compiler. Configure native engine selection through Expo; the adapter derives Rollipop's `runtimeTarget` from those settings. On classic Hermes, a scoped Constants compatibility transform preserves native HostObject values that SWC's object-rest helper would otherwise drop.
+
+| SDK | Expo / CLI        | React Native | Worklets | Hermes bytecode |
+| --- | ----------------- | ------------ | -------- | --------------- |
+| 55  | 55.0.32 / 55.0.37 | 0.83.10      | 0.7.4    | 96              |
+| 56  | 56.0.24 / 56.1.27 | 0.85.3       | 0.8.3    | 98              |
+| 57  | 57.0.31 / 57.0.32 | 0.86.3       | 0.10.1   | 98              |
+| 58  | 58.0.19 / 58.1.15 | 0.88.0       | 0.13.0   | 99              |
+
+Each matrix entry was checked with an installed package tarball for iOS and Android: development manifests/bundles/maps, native JS/Hermes exports, assets, Router type updates, Inspector connections, React Compiler memoization, Worklets output, and Updates resource generation. These checks reject Metro graph creation. Simulator runtime and native builds were previously verified on SDK 58 with Expo Go 58.0.5; the expanded SDK 55–57 matrix covers the JS build pipeline, without additional native app builds.
+
+Installed Worklets automatically enables Rollipop's native SWC transform. `experiments.reactCompiler` enables the compiler through the existing `transform.jsx.compiler` configuration. Compiler opt-outs include the standard `use no memo` and `use no forget` directives plus `worklet` and `widget`. No additional Babel Worklets plugin or second OXC compiler pass is installed.
+
+Expo Router retains its runtime, dynamic routes, route groups, synchronous native context, and typed routes. Both `app/` and `src/app/` follow Expo's root selection; the Router plugin's custom root is also respected. Typed declarations update when routes are added or removed.
+
+Exports preserve Expo's artifact writers, per-scale asset hashes, native resource names, Hermes compilation, and composed source maps. Expo Updates' separate asset-discovery process is connected through native preloads generated by the config plugin.
+
+## Configuration and limits
+
+An optional `rollipop.config.ts` or supported JS/JSON variant supplies Rollipop plugins, transforms, and resolver settings. Custom Metro and Babel files produce a diagnostic because their plugins are not executed. Migrate those customizations to Rollipop configuration. Default native bundling, Worklets, and React Compiler require no Babel configuration.
+
+This package targets iOS and Android. Web, DOM/CSS components, API route servers, middleware, React Server Components, and server functions are unsupported. The plugin disables SDK 58's implicit API-server export for native-only apps even when the template has `web.output: 'server'`; explicit server configuration and actual server route files fail with a diagnostic. Native async route splitting and tunnel URLs are unsupported; use synchronous routes and `--lan` or `--localhost`.
+
+`EXPO_PUBLIC_*` variables are inlined at startup. Restart the CLI after changing environment files. Expo's LogBox modules and native asset resolver are preserved. The adapter folds LogBox's web-only branches before dependency scanning, including during HMR. As in Expo CLI, the default native warning UI is React Native LogBox; the opt-in `EXPO_UNSTABLE_LOG_BOX` overlay requires Expo's DOM/CSS pipeline and is unsupported.
+
+## Development
+
+The [SDK 58 example](../../examples/expo-58/README.md) exercises Router, a local image, UI-thread Worklets, Reanimated, and React Compiler.
+
+From the repository root:
+
+```sh
+yarn workspace @rollipop/expo test
+yarn workspace @rollipop/expo typecheck
+yarn workspace @rollipop/expo build
+```
+
+The implementation is written in TypeScript under `src/`. The build emits CommonJS modules and type declarations under `dist/`; the root `app.plugin.js` delegates to the compiled config plugin so Expo can discover it. `prepack` builds the package before publishing. Tests exercise the compiled modules, SDK policy selection, CLI contract guards, engine settings, and delegation to projects that did not opt in.
+
+## Programmatic registration
+
+```js
+const register = require('@rollipop/expo');
+register(__dirname);
+```
+
+Use the config plugin for ordinary apps so native Updates preloads and native-only Router configuration are applied as well. Direct registration only installs CLI hooks.

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./dist/app.plugin.cjs');

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,25 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__commonJSMin = __commonJSMin;
+exports.__toESM = __toESM;

package/dist/adapter.cjs

@@ -0,0 +1,171 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_index = require("./compatibility/index.cjs");
+const require_export = require("./export.cjs");
+const require_router = require("./router.cjs");
+const require_config = require("./config.cjs");
+const require_inspector = require("./inspector.cjs");
+const require_updates = require("./updates.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+//#region src/adapter.ts
+const PATCH = Symbol.for("@rollipop/expo");
+/**
+* Register the Expo CLI adapter synchronously for one project in the current Node process.
+* Use the Expo config plugin to also configure native Expo Updates build scripts.
+*/
+function register(projectRoot) {
+	const compatibility = require_index.resolveExpoCompatibility(projectRoot);
+	const { projectRoot: root, expoRequire } = compatibility;
+	const prototype = compatibility.cli.getServerPrototype();
+	const installUpdates = () => require_updates.installUpdatesExports({
+		compatibility,
+		async buildAssetsAsync(options) {
+			const { exp } = expoRequire("@expo/config").getConfig(root);
+			const { convertEntryPointToRelative, resolveEntryPoint } = expoRequire("@expo/config/paths");
+			return (await prototype.nativeExportBundleAsync.call({ projectRoot: root }, exp, {
+				platform: options.platform,
+				mainModuleName: convertEntryPointToRelative(root, options.entryFile ?? resolveEntryPoint(root)),
+				mode: options.dev ? "development" : "production",
+				minify: false,
+				bytecode: false,
+				serializerIncludeMaps: false
+			}, /* @__PURE__ */ new Map())).assets;
+		}
+	});
+	const registeredRoots = prototype[PATCH];
+	if (registeredRoots) {
+		registeredRoots.set(root, compatibility);
+		installUpdates();
+		return;
+	}
+	const roots = /* @__PURE__ */ new Map([[root, compatibility]]);
+	Object.defineProperty(prototype, PATCH, { value: roots });
+	const enabled = (server) => roots.has(node_path.default.resolve(server.projectRoot));
+	const start = prototype.startImplementationAsync;
+	prototype.startImplementationAsync = async function(options) {
+		const compatibility = roots.get(node_path.default.resolve(this.projectRoot));
+		if (!compatibility) return start.call(this, options);
+		const { expoRequire } = compatibility;
+		const { getConfig } = expoRequire("@expo/config");
+		const { exp } = getConfig(this.projectRoot);
+		require_router.configureNativeRouter(exp);
+		if (options.location.hostType === "tunnel") throw new Error("@rollipop/expo does not support tunnel URLs; use --lan or --localhost");
+		const api = await import("rollipop");
+		if (options.resetDevServer) await api.resetCache();
+		await this.initUrlCreator(options);
+		const origin = this.getUrlCreator().constructUrl({ scheme: "http" });
+		const host = new URL(origin).hostname;
+		if (options.isExporting) return {
+			server: {
+				close: (done) => done?.(),
+				addListener() {}
+			},
+			location: {
+				port: options.port,
+				host,
+				url: origin,
+				protocol: "http"
+			},
+			middleware: {},
+			messageSocket: { broadcast() {} }
+		};
+		const manifest = await this.getManifestMiddlewareAsync(options);
+		const config = await require_config.default(api, compatibility, options.mode ?? "development", exp, origin);
+		config.plugins.push({
+			name: "@rollipop/expo:manifest",
+			configureServer(server) {
+				server.middlewares.use(manifest.getHandler());
+			}
+		});
+		const server = await api.createDevServer(config, {
+			host,
+			port: options.port,
+			inspector: require_inspector.default(compatibility, origin)
+		});
+		server.instance.server.prependListener("request", (request) => {
+			const url = new URL(request.url, origin);
+			const extension = node_path.default.extname(url.pathname);
+			if (!url.pathname.startsWith("/hot/") && (extension === ".bundle" || extension === ".map")) request.url = `/index${extension}${url.search}`;
+		});
+		server.instance.addHook("preValidation", (request, _reply, done) => {
+			if (request.url.startsWith("/symbolicate") && Array.isArray(request.body?.stack)) for (const frame of request.body.stack) {
+				const url = URL.parse(frame.file);
+				if (url && !url.pathname.startsWith("/hot/") && url.pathname.endsWith(".bundle")) {
+					url.pathname = "/index.bundle";
+					frame.file = url.href;
+				}
+			}
+			done();
+		});
+		try {
+			await server.instance.listen({
+				host,
+				port: options.port
+			});
+		} catch (error) {
+			await server.instance.close();
+			throw error;
+		}
+		process.env.EXPO_DEV_SERVER_ORIGIN = origin;
+		console.log(`[@rollipop/expo] Rollipop listening at ${origin}`);
+		return {
+			server: { close: (done) => server.instance.close().then(() => done?.(), done) },
+			location: {
+				port: options.port,
+				host,
+				url: origin,
+				protocol: "http"
+			},
+			middleware: server.middlewares,
+			messageSocket: { broadcast: server.message.broadcast }
+		};
+	};
+	for (const method of ["watchEnvironmentVariables", "waitForTypeScriptAsync"]) {
+		const original = prototype[method];
+		prototype[method] = function(...args) {
+			return enabled(this) ? Promise.resolve(false) : original.apply(this, args);
+		};
+	}
+	const nativeExport = prototype.nativeExportBundleAsync;
+	prototype.nativeExportBundleAsync = async function(exp, options, files, extra = {}) {
+		const compatibility = roots.get(node_path.default.resolve(this.projectRoot));
+		if (!compatibility) return nativeExport.call(this, exp, options, files, extra);
+		const { expoRequire } = compatibility;
+		require_router.configureNativeRouter(exp);
+		if (!["ios", "android"].includes(options.platform)) throw new Error("@rollipop/expo supports iOS and Android; use expo export --platform ios --platform android");
+		const api = await import("rollipop");
+		const config = await require_config.default(api, compatibility, options.mode, exp);
+		const { getMetroServerRoot } = expoRequire("@expo/config/paths");
+		config.entry = node_path.default.resolve(getMetroServerRoot(this.projectRoot), options.mainModuleName);
+		const assets = [];
+		config.plugins.push({
+			name: "@rollipop/expo:export-assets",
+			async generateBundle() {
+				for (const id of this.getModuleIds()) if (config.resolve.assetExtensions.includes(node_path.default.extname(id).slice(1))) assets.push(await api.AssetUtils.resolveScaledAssets({
+					projectRoot: config.root,
+					assetPath: id,
+					platform: options.platform,
+					preferNativePlatform: true
+				}));
+			}
+		});
+		const output = await api.runBuild(config, {
+			platform: options.platform,
+			dev: options.mode !== "production",
+			minify: options.minify,
+			sourcemap: !!options.serializerIncludeMaps
+		});
+		console.log(`[@rollipop/expo] Rollipop built ${options.platform} (${options.mode})`);
+		return require_export.createExportArtifactsAsync({
+			compatibility,
+			options,
+			extra,
+			code: output.code,
+			map: output.map,
+			assets
+		});
+	};
+	installUpdates();
+}
+//#endregion
+module.exports = register;

package/dist/adapter.d.cts

@@ -0,0 +1,7 @@
+//#region src/adapter.d.ts
+/**
+ * Register the Expo CLI adapter synchronously for one project in the current Node process.
+ * Use the Expo config plugin to also configure native Expo Updates build scripts.
+ */
+declare function register(projectRoot: string): void;
+export = register;

package/dist/app.plugin.cjs

@@ -0,0 +1,13 @@
+const require_register = require("./register.cjs");
+const require_updates = require("./updates.cjs");
+let node_module = require("node:module");
+//#region src/app.plugin.ts
+/** Enable Rollipop for Expo CLI and configure native Expo Updates build scripts. */
+const withRollipop = (config) => {
+	require_register(config._internal.projectRoot);
+	const { configureNativeRouter } = (0, node_module.createRequire)(__filename)("./router.cjs");
+	configureNativeRouter(config);
+	return require_updates.withUpdatesPreload(config);
+};
+//#endregion
+module.exports = withRollipop;

package/dist/app.plugin.d.cts

@@ -0,0 +1,5 @@
+import { ConfigPlugin } from "expo/config-plugins";
+//#region src/app.plugin.d.ts
+/** Enable Rollipop for Expo CLI and configure native Expo Updates build scripts. */
+declare const withRollipop: ConfigPlugin;
+export = withRollipop;

package/dist/compat.cjs

@@ -0,0 +1,96 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_constants = require("./compatibility/constants.cjs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+let rollipop_filter = require("rollipop/filter");
+//#region src/compat.ts
+const ASSET_RESOLVER = /[/\\]expo-asset[/\\](?:build[/\\]resolveAssetSource\.native\.js|src[/\\]resolveAssetSource\.native\.ts)$/;
+function createExpoCompatPlugins(compatibility, runtimeTarget) {
+	const projectRequire = (0, node_module.createRequire)(node_path.default.join(compatibility.projectRoot, "package.json"));
+	const expoRoot = node_path.default.dirname(projectRequire.resolve("expo/package.json"));
+	const expoHmrPath = node_path.default.join(expoRoot, "src/async-require/hmr.ts");
+	const nativeRoot = node_path.default.dirname(projectRequire.resolve("react-native/package.json"));
+	const nativeHmrPath = node_path.default.join(nativeRoot, "Libraries/Utilities/HMRClient.js");
+	return [
+		{
+			name: "@rollipop/expo:initialization",
+			config: {
+				polyfills: [{
+					type: "plain",
+					path: node_path.default.join(expoRoot, "virtual/streams.js")
+				}],
+				prelude: [compatibility.winterEntry]
+			}
+		},
+		{
+			name: "@rollipop/expo:hmr",
+			load: {
+				filter: [(0, rollipop_filter.include)((0, rollipop_filter.id)((0, rollipop_filter.exactRegex)(expoHmrPath)))],
+				handler() {
+					return `export { default } from ${JSON.stringify(nativeHmrPath)};`;
+				}
+			}
+		},
+		{
+			name: "@rollipop/expo:asset-resolver",
+			load: {
+				filter: [(0, rollipop_filter.include)((0, rollipop_filter.id)(ASSET_RESOLVER))],
+				handler(filename) {
+					return node_fs.default.readFileSync(filename, "utf8") + `
+import { Image as RollipopImage } from 'react-native';
+export const setCustomSourceTransformer = RollipopImage.resolveAssetSource.setCustomSourceTransformer;
+`;
+				}
+			}
+		},
+		...runtimeTarget === "hermes" ? [{
+			name: "@rollipop/expo:classic-hermes-constants",
+			load: {
+				filter: [(0, rollipop_filter.include)((0, rollipop_filter.id)(require_constants.CONSTANTS_MODULE))],
+				handler: require_constants.loadClassicHermesConstants
+			}
+		}] : []
+	];
+}
+function createExpoLogBoxPlugin(api, platform) {
+	return {
+		name: "@rollipop/expo:log-box-platform",
+		transform: {
+			filter: [(0, rollipop_filter.include)((0, rollipop_filter.id)(/[/\\]@expo[/\\]log-box[/\\](?:src|build)[/\\](?:index\.(?:js|tsx)|Data[/\\]LogBoxData\.(?:js|tsx))$/))],
+			handler(code, filename) {
+				const transformed = api.rolldownExperimental.transformSync(filename, code, {
+					define: { "process.env.EXPO_OS": JSON.stringify(platform) },
+					sourcemap: true
+				});
+				if (transformed.errors.length) this.error(transformed.errors[0]);
+				const result = api.rolldownExperimental.minifySync(filename, transformed.code, {
+					mangle: false,
+					compress: {
+						target: "es2015",
+						unused: false,
+						keepNames: {
+							function: true,
+							class: true
+						},
+						joinVars: false,
+						sequences: false
+					},
+					codegen: { removeWhitespace: false },
+					sourcemap: true,
+					inputMap: transformed.map
+				});
+				if (result.errors.length) this.error(result.errors[0]);
+				return {
+					code: result.code,
+					map: result.map
+				};
+			}
+		}
+	};
+}
+//#endregion
+exports.createExpoLogBoxPlugin = createExpoLogBoxPlugin;
+exports.default = createExpoCompatPlugins;

package/dist/compatibility/cli.cjs

@@ -0,0 +1,51 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+//#region src/compatibility/cli.ts
+function createExpoCli(expoRequire, version) {
+	const cliRoot = node_path.default.dirname(expoRequire.resolve("@expo/cli/package.json"));
+	const cliRequire = (0, node_module.createRequire)(node_path.default.join(cliRoot, "package.json"));
+	function loadFunction(filename, name) {
+		const exports = cliRequire(filename);
+		if (typeof exports[name] !== "function") throw new Error(`@rollipop/expo: unsupported @expo/cli ${version}; missing ${name} in ${filename}`);
+		return exports[name];
+	}
+	return {
+		getServerPrototype() {
+			const prototype = loadFunction(node_path.default.join(cliRoot, "build/src/start/server/metro/MetroBundlerDevServer.js"), "MetroBundlerDevServer").prototype;
+			for (const method of [
+				"startImplementationAsync",
+				"nativeExportBundleAsync",
+				"initUrlCreator",
+				"getManifestMiddlewareAsync",
+				"getUrlCreator",
+				"watchEnvironmentVariables",
+				"waitForTypeScriptAsync"
+			]) if (typeof prototype[method] !== "function") throw new Error(`@rollipop/expo: unsupported @expo/cli ${version}; missing ${method}`);
+			return prototype;
+		},
+		getRouterDirectoryModuleIdWithManifest(projectRoot, exp) {
+			return loadFunction(node_path.default.join(cliRoot, "build/src/start/server/metro/router.js"), "getRouterDirectoryModuleIdWithManifest")(projectRoot, exp);
+		},
+		createDebugMiddleware(options) {
+			return loadFunction(node_path.default.join(cliRoot, "build/src/start/server/metro/debugging/createDebugMiddleware.js"), "createDebugMiddleware")(options);
+		},
+		buildHermesBundleAsync(options) {
+			const metroRoot = node_path.default.dirname(expoRequire.resolve("@expo/metro-config/package.json"));
+			return loadFunction(node_path.default.join(metroRoot, "build/serializer/exportHermes.js"), "buildHermesBundleAsync")(options);
+		},
+		getTypedRoutesDeclarationFile(context, options) {
+			return loadFunction("@expo/router-server/build/typed-routes/generate", "getTypedRoutesDeclarationFile")(context, options);
+		},
+		getUpdatesExportPaths() {
+			return [
+				node_path.default.join(cliRoot, "build/src/expoUpdatesExports.js"),
+				expoRequire.resolve("@expo/cli/internal/unstable-expo-updates-exports"),
+				expoRequire.resolve("expo/internal/unstable-expo-updates-cli-exports")
+			];
+		}
+	};
+}
+//#endregion
+exports.createExpoCli = createExpoCli;

package/dist/compatibility/constants.cjs

@@ -0,0 +1,11 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+//#region src/compatibility/constants.ts
+const CONSTANTS_MODULE = /[/\\]expo-constants[/\\]build[/\\]Constants\.js$/;
+function loadClassicHermesConstants(filename) {
+	return node_fs.default.readFileSync(filename, "utf8").replace("const { name, appOwnership, ...nativeConstants } = (ExponentConstants || {});", "const { name, appOwnership, ...nativeConstants } = Object.fromEntries(Object.keys(ExponentConstants || {}).map(key => [key, ExponentConstants[key]]));");
+}
+//#endregion
+exports.CONSTANTS_MODULE = CONSTANTS_MODULE;
+exports.loadClassicHermesConstants = loadClassicHermesConstants;

package/dist/compatibility/index.cjs

@@ -0,0 +1,45 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_cli = require("./cli.cjs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let semver = require("semver");
+//#region src/compatibility/index.ts
+const strategies = [
+	{
+		range: ">=55 <56",
+		winterEntry: "expo/src/winter/index.ts",
+		hermesV1: false
+	},
+	{
+		range: ">=56 <58",
+		winterEntry: "expo/src/winter/index.ts",
+		hermesV1: true
+	},
+	{
+		range: ">=58 <59",
+		winterEntry: "expo/build/winter",
+		hermesV1: true
+	}
+];
+function resolveExpoCompatibility(projectRoot) {
+	const root = node_path.default.resolve(projectRoot);
+	const appRequire = (0, node_module.createRequire)(node_path.default.join(root, "package.json"));
+	const expoRequire = (0, node_module.createRequire)(appRequire.resolve("expo/package.json"));
+	const sdkVersion = appRequire("expo/package.json").version;
+	const cliVersion = expoRequire("@expo/cli/package.json").version;
+	const sdk = (0, semver.parse)(sdkVersion);
+	const strategy = strategies.find(({ range }) => (0, semver.satisfies)(sdkVersion, range));
+	if (!sdk || !strategy || !(0, semver.satisfies)(cliVersion, `>=${sdk.major}.0.0 <${sdk.major + 1}.0.0`)) throw new Error(`@rollipop/expo requires Expo SDK 55–58 with a matching @expo/cli major; found expo ${sdkVersion}, CLI ${cliVersion}`);
+	return {
+		projectRoot: root,
+		sdkVersion,
+		cliVersion,
+		expoRequire,
+		winterEntry: appRequire.resolve(strategy.winterEntry),
+		defaultRuntimeTarget: strategy.hermesV1 ? "hermes-v1" : "hermes",
+		cli: require_cli.createExpoCli(expoRequire, cliVersion)
+	};
+}
+//#endregion
+exports.resolveExpoCompatibility = resolveExpoCompatibility;

package/dist/compatibility/runtime.cjs

@@ -0,0 +1,31 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+//#region src/compatibility/runtime.ts
+function boolean(value) {
+	if (value === true || value === "true" || value === "1") return true;
+	if (value === false || value === "false" || value === "0") return false;
+}
+function resolveRuntimeTarget(compatibility, exp) {
+	const { projectRoot, defaultRuntimeTarget } = compatibility;
+	const defaults = defaultRuntimeTarget === "hermes-v1";
+	let ios = defaults;
+	let android = defaults;
+	for (const plugin of exp.plugins ?? []) {
+		if (!Array.isArray(plugin) || plugin[0] !== "expo-build-properties") continue;
+		const options = plugin[1];
+		ios = boolean(options?.ios?.useHermesV1) ?? boolean(options?.useHermesV1) ?? ios;
+		android = boolean(options?.android?.useHermesV1) ?? boolean(options?.useHermesV1) ?? android;
+	}
+	const podfile = node_path.default.join(projectRoot, "ios/Podfile.properties.json");
+	if (node_fs.default.existsSync(podfile)) ios = boolean(JSON.parse(node_fs.default.readFileSync(podfile, "utf8"))["expo.useHermesV1"]) ?? ios;
+	const gradle = node_path.default.join(projectRoot, "android/gradle.properties");
+	if (node_fs.default.existsSync(gradle)) android = boolean([...node_fs.default.readFileSync(gradle, "utf8").matchAll(/^\s*hermesV1Enabled\s*=\s*(\S+)\s*$/gm)].at(-1)?.[1]) ?? android;
+	ios = boolean(process.env.RCT_HERMES_V1_ENABLED) ?? ios;
+	android = boolean(process.env.ORG_GRADLE_PROJECT_hermesV1Enabled) ?? android;
+	return ios && android ? "hermes-v1" : "hermes";
+}
+//#endregion
+exports.resolveRuntimeTarget = resolveRuntimeTarget;

package/dist/config.cjs

@@ -0,0 +1,93 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_compat = require("./compat.cjs");
+const require_runtime$1 = require("./compatibility/runtime.cjs");
+const require_export = require("./export.cjs");
+const require_hmr = require("./hmr.cjs");
+const require_router = require("./router.cjs");
+const require_services = require("./services.cjs");
+const require_worklets = require("./worklets.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+//#region src/config.ts
+const warned = /* @__PURE__ */ new Set();
+async function makeConfig(api, compatibility, mode, exp, devServerOrigin) {
+	const { projectRoot, expoRequire } = compatibility;
+	const { resolveEntryPoint } = expoRequire("@expo/config/paths");
+	const configFile = [
+		"ts",
+		"mts",
+		"cts",
+		"js",
+		"mjs",
+		"cjs",
+		"json"
+	].map((extension) => node_path.default.join(projectRoot, `rollipop.config.${extension}`)).find((file) => node_fs.default.existsSync(file));
+	const defaults = configFile ? await api.loadConfig({
+		cwd: projectRoot,
+		configFile,
+		mode
+	}) : await api.getDefaultConfig(projectRoot, mode);
+	if (!warned.has(projectRoot)) {
+		const customConfig = [
+			"babel.config.js",
+			"babel.config.cjs",
+			"babel.config.mjs",
+			"babel.config.json",
+			".babelrc",
+			".babelrc.js",
+			".babelrc.cjs",
+			"metro.config.js",
+			"metro.config.cjs",
+			"metro.config.mjs"
+		].filter((file) => node_fs.default.existsSync(node_path.default.join(projectRoot, file)));
+		if (customConfig.length) console.warn(`[@rollipop/expo] ${customConfig.join(", ")} is not executed. Expo defaults and Worklets are automatic; migrate custom transforms/resolvers to rollipop.config.ts.`);
+		warned.add(projectRoot);
+	}
+	const runtimeTarget = require_runtime$1.resolveRuntimeTarget(compatibility, exp);
+	const compat = require_compat.default(compatibility, runtimeTarget);
+	const router = require_router.createRouterPlugin(projectRoot, require_router.getRouterRoot(compatibility, exp));
+	const entry = resolveEntryPoint(projectRoot);
+	const assetRegistryPath = typeof defaults.reactNative.assetRegistryPath === "function" ? await defaults.reactNative.assetRegistryPath(projectRoot) : defaults.reactNative.assetRegistryPath;
+	const overrides = {
+		configFile: configFile ?? node_path.default.join(projectRoot, "app.json"),
+		entry,
+		runtimeTarget,
+		transform: { define: {
+			...Object.fromEntries(Object.entries(process.env).filter(([key]) => key.startsWith("EXPO_PUBLIC_")).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)])),
+			...devServerOrigin ? { "process.env.EXPO_DEV_SERVER_ORIGIN": JSON.stringify(devServerOrigin) } : {}
+		} },
+		dev: { hmr: { runtimeImplement: require_hmr.default } },
+		plugins: [
+			...compat,
+			...router ? [router] : [],
+			require_services.createExpoServicesPlugin(compatibility)
+		],
+		rolldownOptions(options, { platform, buildType }) {
+			if (!["ios", "android"].includes(platform)) throw new Error("@rollipop/expo supports iOS and Android only");
+			Object.assign(options.input.transform.define, {
+				"process.env.EXPO_OS": JSON.stringify(platform),
+				"process.env.EXPO_SERVER": "false",
+				"process.env.EXPO_BASE_URL": "\"\""
+			});
+			options.input.plugins.unshift(require_compat.createExpoLogBoxPlugin(api, platform), require_export.createExpoAssetPlugin({
+				api,
+				projectRoot,
+				platform,
+				assetExtensions: defaults.resolve.assetExtensions,
+				assetRegistryPath,
+				isNativeExport: buildType === "build"
+			}));
+			return options;
+		}
+	};
+	return api.mergeConfig(defaults, ...compat.map((plugin) => plugin.config ?? {}), router?.config ?? {}, require_worklets.default(projectRoot), exp.experiments?.reactCompiler ? { transform: { jsx: { compiler: { customOptOutDirectives: [
+		"use no memo",
+		"use no forget",
+		"worklet",
+		"widget"
+	] } } } } : {}, overrides);
+}
+//#endregion
+exports.default = makeConfig;

package/dist/export.cjs

@@ -0,0 +1,92 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_hermes = require("./hermes.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let rollipop_filter = require("rollipop/filter");
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises);
+//#region src/export.ts
+const md5 = (value) => (0, node_crypto.createHash)("md5").update(value).digest("hex");
+async function enrichExpoAssetAsync(asset, { platform, isNativeExport = false } = {}) {
+	const indices = asset.scales.map((scale, index) => asset.scales.indexOf(scale) === index ? index : -1).filter((index) => index !== -1);
+	const files = indices.map((index) => asset.files[index]);
+	return {
+		...asset,
+		httpServerLocation: platform === "android" && isNativeExport && asset.httpServerLocation.startsWith("/assets/..") ? `/assets/rollipop/${asset.httpServerLocation.slice(8)}` : asset.httpServerLocation,
+		files,
+		scales: indices.map((index) => asset.scales[index]),
+		fileHashes: await Promise.all(files.map(async (file) => md5(await node_fs_promises.default.readFile(file))))
+	};
+}
+function createExpoAssetPlugin({ api, projectRoot, platform, assetExtensions, assetRegistryPath = "react-native/asset-registry", isNativeExport = false }) {
+	return {
+		name: "@rollipop/expo:asset-hashes",
+		load: {
+			order: "pre",
+			filter: [(0, rollipop_filter.include)((0, rollipop_filter.id)(new RegExp(`\\.(?:${assetExtensions.join("|")})$`)))],
+			async handler(id) {
+				if (!assetExtensions.includes(node_path.default.extname(id).slice(1))) return null;
+				const asset = await api.AssetUtils.resolveScaledAssets({
+					projectRoot,
+					assetPath: id,
+					platform,
+					preferNativePlatform: true
+				});
+				return {
+					code: api.AssetUtils.generateAssetRegistryCode(assetRegistryPath, await enrichExpoAssetAsync(asset, {
+						platform,
+						isNativeExport
+					})),
+					moduleType: "js"
+				};
+			}
+		}
+	};
+}
+async function createExportArtifactsAsync({ compatibility, options, extra = {}, code, map, assets }) {
+	const hash = md5(code);
+	const extension = options.bytecode ? "hbc" : "js";
+	const filename = `_expo/static/js/${options.platform}/index-${hash}.${extension}`;
+	const mapFilename = `${filename}.map`;
+	let source = code.replace(/^\/\/# sourceMappingURL=.*$/gm, "");
+	let sourceMap = map ? JSON.parse(map.toString()) : null;
+	if (sourceMap) sourceMap.file = filename;
+	if (sourceMap && !options.inlineSourceMap) source += `\n//# sourceMappingURL=${extra.sourceMapUrl ?? node_path.default.posix.basename(mapFilename)}`;
+	if (options.bytecode) {
+		const result = await require_hermes.default({
+			compatibility,
+			projectRoot: compatibility.projectRoot,
+			code: source,
+			map: sourceMap ? JSON.stringify(sourceMap) : null,
+			filename: options.mainModuleName,
+			minify: options.minify ?? options.mode === "production"
+		});
+		source = result.hbc;
+		sourceMap = result.sourcemap ? JSON.parse(result.sourcemap) : null;
+		if (sourceMap) sourceMap.file = filename;
+	} else if (sourceMap && options.inlineSourceMap) source += `\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(sourceMap)).toString("base64")}`;
+	const artifacts = [{
+		type: "js",
+		filename,
+		source,
+		metadata: {}
+	}];
+	if (sourceMap && !options.inlineSourceMap) artifacts.push({
+		type: "map",
+		filename: mapFilename,
+		source: JSON.stringify(sourceMap),
+		metadata: {}
+	});
+	return {
+		artifacts,
+		assets: await Promise.all(assets.map((asset) => enrichExpoAssetAsync(asset, {
+			platform: options.platform,
+			isNativeExport: true
+		})))
+	};
+}
+//#endregion
+exports.createExpoAssetPlugin = createExpoAssetPlugin;
+exports.createExportArtifactsAsync = createExportArtifactsAsync;
+exports.enrichExpoAssetAsync = enrichExpoAssetAsync;

package/dist/hermes.cjs

@@ -0,0 +1,6 @@
+//#region src/hermes.ts
+async function compileHermesAsync({ compatibility, ...options }) {
+	return compatibility.cli.buildHermesBundleAsync(options);
+}
+//#endregion
+exports.default = compileHermesAsync;

package/dist/hmr.cjs

@@ -0,0 +1,19 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+//#region src/hmr.ts
+var hmr_default = node_fs.default.readFileSync(require.resolve("rollipop/hmr-runtime"), "utf8") + `
+globalThis.__rollipop_runtime__.subscribeGraph(({ runtime }) => {
+  const reload = runtime.reload.bind(runtime);
+  runtime.reload = (reason) => {
+    if (typeof globalThis.expo?.reloadAppAsync === 'function') {
+      if (runtime.reloadRequested) return;
+      runtime.reloadRequested = true;
+      return globalThis.expo.reloadAppAsync(reason || 'Rollipop HMR');
+    }
+    return reload(reason);
+  };
+});
+`;
+//#endregion
+exports.default = hmr_default;

package/dist/inspector.cjs

@@ -0,0 +1,15 @@
+//#region src/inspector.ts
+function createExpoInspector(compatibility, serverBaseUrl) {
+	const { debugMiddleware, debugWebsocketEndpoints } = compatibility.cli.createDebugMiddleware({
+		serverBaseUrl,
+		reporter: { update({ level, data }) {
+			console[level](...data);
+		} }
+	});
+	return {
+		middleware: debugMiddleware,
+		websocketEndpoints: debugWebsocketEndpoints
+	};
+}
+//#endregion
+exports.default = createExpoInspector;

package/dist/package.cjs

@@ -0,0 +1,62 @@
+//#region package.json
+var require_package = /* @__PURE__ */ require("./_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "@rollipop/expo",
+		"version": "1.0.0-beta.2",
+		"description": "Use Rollipop with Expo native apps through an Expo config plugin.",
+		"homepage": "https://github.com/rollipop-dev/rollipop/tree/main/packages/expo#readme",
+		"bugs": { "url": "https://github.com/rollipop-dev/rollipop/issues" },
+		"license": "MIT",
+		"author": "leegeunhyeok <dev.ghlee@gmail.com> (https://github.com/leegeunhyeok)",
+		"repository": {
+			"type": "git",
+			"url": "git+https://github.com/rollipop-dev/rollipop.git",
+			"directory": "packages/expo"
+		},
+		"files": ["dist", "app.plugin.js"],
+		"type": "commonjs",
+		"main": "./dist/register.cjs",
+		"types": "./dist/register.d.cts",
+		"exports": {
+			".": {
+				"types": "./dist/register.d.cts",
+				"default": "./dist/register.cjs"
+			},
+			"./app.plugin.js": {
+				"types": "./dist/app.plugin.d.cts",
+				"default": "./app.plugin.js"
+			},
+			"./updates-preload.cjs": "./dist/updates-preload.cjs",
+			"./package.json": "./package.json"
+		},
+		"scripts": {
+			"prepack": "yarn build",
+			"typecheck": "tsc --noEmit",
+			"build": "vp pack",
+			"test": "yarn build && node --test test/*.test.cjs"
+		},
+		"dependencies": { "semver": "7.8.5" },
+		"devDependencies": {
+			"@types/semver": "7.8.0",
+			"expo": "58.0.17",
+			"rollipop": "workspace:*",
+			"source-map": "0.8.0",
+			"typescript": "catalog:",
+			"vite": "catalog:vp",
+			"vite-plus": "catalog:vp"
+		},
+		"peerDependencies": {
+			"expo": ">=55.0.0 <59.0.0",
+			"rollipop": "workspace:*"
+		},
+		"engines": { "node": "^22.18.0 || ^24.11.0 || >=26.0.0" },
+		"installConfig": { "hoistingLimits": "none" }
+	};
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_package();
+	}
+});

package/dist/register.cjs

@@ -0,0 +1,21 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_package$1 = require("./package.cjs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+//#region src/register.ts
+/** Enable the adapter only after checking the project's required Rollipop peer. */
+function register(projectRoot) {
+	const root = node_path.default.resolve(projectRoot);
+	const projectRequire = (0, node_module.createRequire)(node_path.default.join(root, "package.json"));
+	try {
+		projectRequire.resolve("rollipop/package.json");
+	} catch (error) {
+		if (error.code !== "MODULE_NOT_FOUND") throw error;
+		const { version } = require_package$1.default;
+		throw new Error(`[@rollipop/expo] Missing peer dependency "rollipop" in ${root}.\nInstall it alongside @rollipop/expo, then restart Expo CLI:\n  yarn add -D rollipop@${version}\n  npm install --save-dev rollipop@${version}\n  pnpm add -D rollipop@${version}`);
+	}
+	(0, node_module.createRequire)(__filename)("./adapter.cjs")(root);
+}
+//#endregion
+module.exports = register;

package/dist/register.d.cts

@@ -0,0 +1,4 @@
+//#region src/register.d.ts
+/** Enable the adapter only after checking the project's required Rollipop peer. */
+declare function register(projectRoot: string): void;
+export = register;

package/dist/router.cjs

@@ -0,0 +1,101 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+let rollipop_filter = require("rollipop/filter");
+//#region src/router.ts
+function createRouterPlugin(projectRoot, appRoot) {
+	const projectRequire = (0, node_module.createRequire)(node_path.default.join(projectRoot, "package.json"));
+	let routerRoot;
+	try {
+		routerRoot = node_path.default.dirname(projectRequire.resolve("expo-router/package.json"));
+	} catch (error) {
+		if (error.code !== "MODULE_NOT_FOUND") throw error;
+		return null;
+	}
+	const contexts = new Set([
+		"_ctx.js",
+		"_ctx.ios.js",
+		"_ctx.android.js"
+	].map((file) => node_path.default.join(routerRoot, file)));
+	return {
+		name: "@rollipop/expo:router",
+		config: { rolldownOptions(options) {
+			Object.assign(options.input.transform.define, {
+				"process.env.EXPO_PROJECT_ROOT": JSON.stringify(projectRoot),
+				"process.env.EXPO_ROUTER_ABS_APP_ROOT": JSON.stringify(appRoot),
+				"process.env.EXPO_ROUTER_APP_ROOT": JSON.stringify(node_path.default.relative(routerRoot, appRoot)),
+				"process.env.EXPO_ROUTER_IMPORT_MODE": "\"sync\""
+			});
+			return options;
+		} },
+		load: {
+			filter: [...contexts].map((file) => (0, rollipop_filter.include)((0, rollipop_filter.id)((0, rollipop_filter.exactRegex)(file)))),
+			handler(id) {
+				if (!contexts.has(id)) return;
+				if (!node_fs.default.existsSync(appRoot)) throw new Error(`Expo Router route directory is missing: ${appRoot}`);
+				const files = [];
+				const visit = (directory) => {
+					this.addWatchFile(directory);
+					for (const entry of node_fs.default.readdirSync(directory, { withFileTypes: true })) {
+						const absolute = node_path.default.join(directory, entry.name);
+						if (entry.isDirectory()) visit(absolute);
+						else if (entry.isFile()) {
+							const key = `./${node_path.default.relative(appRoot, absolute).split(node_path.default.sep).join("/")}`;
+							if (/(?:\+api|\+middleware)\.[tj]sx?$/.test(key)) throw new Error(`@rollipop/expo does not support API route servers or middleware: ${key}`);
+							if (/^\.\/(?!(?:(?:.*\+api)|(?:\+html)|(?:\+middleware))\.[tj]sx?$).*\.[tj]sx?$/.test(key)) files.push([key, absolute]);
+						}
+					}
+				};
+				visit(appRoot);
+				files.sort(([left], [right]) => left.localeCompare(right));
+				return `const routes = {\n${files.map(([key, absolute]) => `  ${JSON.stringify(key)}: () => require(${JSON.stringify(absolute)})`).join(",\n")}\n};
+export function ctx(key) {
+  if (!Object.prototype.hasOwnProperty.call(routes, key)) {
+    const error = new Error("Cannot find route module '" + key + "'");
+    error.code = 'MODULE_NOT_FOUND';
+    throw error;
+  }
+  return routes[key]();
+}
+ctx.keys = () => Object.keys(routes);
+ctx.resolve = (key) => {
+  if (!Object.prototype.hasOwnProperty.call(routes, key)) return ctx(key);
+  return key;
+};
+ctx.id = ${JSON.stringify(appRoot)};
+`;
+			}
+		},
+		hotUpdate({ type, file, modules }) {
+			const relative = node_path.default.relative(appRoot, file);
+			if (relative.startsWith(`..${node_path.default.sep}`) || node_path.default.isAbsolute(relative)) return;
+			if (type !== "delete" && node_fs.default.existsSync(file) && !node_fs.default.statSync(file).isDirectory() && this.getModuleInfo(file) != null) return modules.filter((id) => !contexts.has(id));
+			if (type !== "delete" && node_fs.default.existsSync(file)) return;
+			return [.../* @__PURE__ */ new Set([...modules.filter((id) => id !== file), ...[...contexts].filter((id) => this.getModuleInfo(id) != null)])];
+		}
+	};
+}
+function getRouterRoot(compatibility, exp) {
+	const { projectRoot, cli } = compatibility;
+	return node_path.default.resolve(projectRoot, cli.getRouterDirectoryModuleIdWithManifest(projectRoot, exp));
+}
+function configureNativeRouter(config) {
+	if (config.experiments?.reactServerComponentRoutes || config.experiments?.reactServerFunctions) throw new Error("@rollipop/expo does not support React Server Components or server functions");
+	const router = config.extra?.router;
+	if (router?.apiRoutes === true) throw new Error("@rollipop/expo does not support API route servers");
+	config.extra = {
+		...config.extra,
+		router: {
+			...router,
+			apiRoutes: false
+		}
+	};
+	return config;
+}
+//#endregion
+exports.configureNativeRouter = configureNativeRouter;
+exports.createRouterPlugin = createRouterPlugin;
+exports.getRouterRoot = getRouterRoot;

package/dist/services.cjs

@@ -0,0 +1,41 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_router = require("./router.cjs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+//#region src/services.ts
+function createExpoServicesPlugin(compatibility) {
+	const { projectRoot, expoRequire, cli } = compatibility;
+	return {
+		name: "@rollipop/expo:services",
+		configureServer(server) {
+			const { exp } = expoRequire("@expo/config").getConfig(projectRoot);
+			if (!exp.experiments?.typedRoutes) return;
+			const projectRequire = (0, node_module.createRequire)(node_path.default.join(projectRoot, "package.json"));
+			const routerDirectory = require_router.getRouterRoot(compatibility, exp);
+			const { requireContext } = projectRequire("expo-router/internal/testing");
+			const { EXPO_ROUTER_CTX_IGNORE } = projectRequire("expo-router/_ctx-shared");
+			const typesDirectory = node_path.default.join(projectRoot, ".expo/types");
+			const updateRoutes = () => {
+				const context = requireContext(routerDirectory, true, EXPO_ROUTER_CTX_IGNORE);
+				const declaration = cli.getTypedRoutesDeclarationFile(context, exp.extra?.router);
+				node_fs.default.mkdirSync(typesDirectory, { recursive: true });
+				node_fs.default.writeFileSync(node_path.default.join(typesDirectory, "router.d.ts"), declaration);
+			};
+			let timer;
+			const watcher = node_fs.default.watch(routerDirectory, { recursive: true }, () => {
+				clearTimeout(timer);
+				timer = setTimeout(updateRoutes, 100);
+			});
+			server.instance.addHook("onClose", async () => {
+				clearTimeout(timer);
+				watcher.close();
+			});
+			updateRoutes();
+		}
+	};
+}
+//#endregion
+exports.createExpoServicesPlugin = createExpoServicesPlugin;

package/dist/updates-preload.cjs

@@ -0,0 +1,10 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_register = require("./register.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+//#region src/updates-preload.ts
+if (node_path.default.basename(process.argv[1] ?? "") === "createUpdatesResources.js") {
+	const projectRoot = process.argv[3];
+	if (projectRoot) require_register(projectRoot);
+}
+//#endregion

package/dist/updates-preload.d.cts

@@ -0,0 +1 @@
+export {}

package/dist/updates.cjs

@@ -0,0 +1,80 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises);
+//#region src/updates.ts
+const roots = /* @__PURE__ */ new Map();
+const BUILD_ASSETS = Symbol("@rollipop/expo:updates-assets");
+const replacements = /* @__PURE__ */ new Map();
+function installUpdatesExports({ compatibility, buildAssetsAsync }) {
+	const { projectRoot, cli } = compatibility;
+	roots.set(node_path.default.resolve(projectRoot), buildAssetsAsync);
+	const filenames = cli.getUpdatesExportPaths();
+	const cliRoot = filenames[0];
+	const original = require(filenames[0]);
+	for (const name of ["createMetroServerAndBundleRequestAsync", "exportEmbedAssetsAsync"]) if (typeof original[name] !== "function") throw new Error(`@rollipop/expo: unsupported @expo/cli ${compatibility.cliVersion}; missing ${name}`);
+	let replacement = replacements.get(cliRoot);
+	if (!replacement) replacement = {
+		...original,
+		async createMetroServerAndBundleRequestAsync(root, options) {
+			const build = roots.get(node_path.default.resolve(root));
+			if (!build) return original.createMetroServerAndBundleRequestAsync(root, options);
+			return {
+				server: {
+					[BUILD_ASSETS]: () => build(options),
+					end() {}
+				},
+				bundleRequest: options
+			};
+		},
+		async exportEmbedAssetsAsync(server, request, root, options) {
+			const build = server[BUILD_ASSETS];
+			if (build) return build();
+			return original.exportEmbedAssetsAsync(server, request, root, options);
+		}
+	};
+	replacements.set(cliRoot, replacement);
+	for (const filename of filenames) {
+		require(filename);
+		require.cache[filename].exports = replacement;
+	}
+}
+const BEGIN = "# @generated begin @rollipop/expo-updates";
+const END = "# @generated end @rollipop/expo-updates";
+function withUpdatesPreload(config) {
+	const projectRoot = config._internal.projectRoot;
+	const { withDangerousMod, withAppBuildGradle } = (0, node_module.createRequire)(node_path.default.join(projectRoot, "package.json"))("expo/config-plugins");
+	config = withDangerousMod(config, ["ios", async (mod) => {
+		const filename = node_path.default.join(mod.modRequest.platformProjectRoot, ".xcode.env");
+		const clean = (await node_fs_promises.default.readFile(filename, "utf8").catch((error) => {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		})).replace(new RegExp(`${BEGIN}[\\s\\S]*?${END}\\n?`, "g"), "").trimEnd();
+		const generated = [
+			BEGIN,
+			`ROLLIPOP_EXPO_UPDATES_PRELOAD="$("$NODE_BINARY" --print "require.resolve('@rollipop/expo/updates-preload.cjs')")"`,
+			"export NODE_OPTIONS=\"${NODE_OPTIONS:+$NODE_OPTIONS }--require \\\"$ROLLIPOP_EXPO_UPDATES_PRELOAD\\\"\"",
+			END
+		].join("\n");
+		await node_fs_promises.default.writeFile(filename, `${clean}\n${generated}\n`);
+		return mod;
+	}]);
+	return withAppBuildGradle(config, (mod) => {
+		const begin = "// @generated begin @rollipop/expo-updates";
+		const end = "// @generated end @rollipop/expo-updates";
+		const clean = mod.modResults.contents.replace(new RegExp(`${begin}[\\s\\S]*?${end}\\n?`, "g"), "");
+		const generated = [
+			begin,
+			`def rollipopExpoUpdatesPreload = (nodeExecutableAndArgs.get() + ["--print", "require.resolve('@rollipop/expo/updates-preload.cjs')"]).execute(null, rootDir).text.trim()`,
+			"nodeExecutableAndArgs.set(nodeExecutableAndArgs.get() + [\"--require\", rollipopExpoUpdatesPreload])",
+			end
+		].map((line) => `    ${line}`).join("\n");
+		mod.modResults.contents = clean.replace(/react\s*\{/, (match) => `${match}\n${generated}`);
+		return mod;
+	});
+}
+//#endregion
+exports.installUpdatesExports = installUpdatesExports;
+exports.withUpdatesPreload = withUpdatesPreload;

package/dist/worklets.cjs

@@ -0,0 +1,24 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let semver = require("semver");
+//#region src/worklets.ts
+function createWorkletsConfig(projectRoot) {
+	const appRequire = (0, node_module.createRequire)(node_path.default.join(projectRoot, "package.json"));
+	const installed = (name) => {
+		try {
+			return appRequire(`${name}/package.json`);
+		} catch (error) {
+			if (error.code === "MODULE_NOT_FOUND") return null;
+			throw error;
+		}
+	};
+	const reanimated = installed("react-native-reanimated");
+	const worklets = installed("react-native-worklets");
+	if (reanimated && !(0, semver.satisfies)(reanimated.version, ">=4.0.0")) throw new Error("@rollipop/expo requires Reanimated 4+ on Expo SDK 55–58");
+	if (reanimated && !worklets) throw new Error("Reanimated requires react-native-worklets. Run: npx expo install react-native-reanimated react-native-worklets");
+	return worklets ? { experimental: { worklets: {} } } : {};
+}
+//#endregion
+exports.default = createWorkletsConfig;

package/package.json

@@ -1,4 +1,63 @@
 {
   "name": "@rollipop/expo",
-  "version": "0.0.0"
-}
+  "version": "1.0.0-beta.2",
+  "description": "Use Rollipop with Expo native apps through an Expo config plugin.",
+  "homepage": "https://github.com/rollipop-dev/rollipop/tree/main/packages/expo#readme",
+  "bugs": {
+    "url": "https://github.com/rollipop-dev/rollipop/issues"
+  },
+  "license": "MIT",
+  "author": "leegeunhyeok <dev.ghlee@gmail.com> (https://github.com/leegeunhyeok)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rollipop-dev/rollipop.git",
+    "directory": "packages/expo"
+  },
+  "files": [
+    "dist",
+    "app.plugin.js"
+  ],
+  "type": "commonjs",
+  "main": "./dist/register.cjs",
+  "types": "./dist/register.d.cts",
+  "exports": {
+    ".": {
+      "types": "./dist/register.d.cts",
+      "default": "./dist/register.cjs"
+    },
+    "./app.plugin.js": {
+      "types": "./dist/app.plugin.d.cts",
+      "default": "./app.plugin.js"
+    },
+    "./updates-preload.cjs": "./dist/updates-preload.cjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "prepack": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "build": "vp pack",
+    "test": "yarn build && node --test test/*.test.cjs"
+  },
+  "dependencies": {
+    "semver": "7.8.5"
+  },
+  "devDependencies": {
+    "@types/semver": "7.8.0",
+    "expo": "58.0.17",
+    "rollipop": "1.0.0-beta.2",
+    "source-map": "0.8.0",
+    "typescript": "7.0.2",
+    "vite": "@voidzero-dev/vite-plus-core@1.3.0",
+    "vite-plus": "1.3.0"
+  },
+  "peerDependencies": {
+    "expo": ">=55.0.0 <59.0.0",
+    "rollipop": "1.0.0-beta.2"
+  },
+  "engines": {
+    "node": "^22.18.0 || ^24.11.0 || >=26.0.0"
+  },
+  "installConfig": {
+    "hoistingLimits": "none"
+  }
+}

package/.editorconfig

@@ -1,10 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-
-[*.{js,json,yml}]
-charset = utf-8
-indent_style = space
-indent_size = 2

package/.gitattributes

@@ -1,4 +0,0 @@
-/.yarn/**            linguist-vendored
-/.yarn/releases/*    binary
-/.yarn/plugins/**/*  binary
-/.pnp.*              binary linguist-generated