rollipop 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/commands.cjs

@@ -0,0 +1,3919 @@
+//#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 __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 ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+require("@commander-js/extra-typings");
+let es_toolkit = require("es-toolkit");
+let chalk = require("chalk");
+chalk = __toESM(chalk);
+let gradient_string = require("gradient-string");
+gradient_string = __toESM(gradient_string);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let dayjs = require("dayjs");
+dayjs = __toESM(dayjs);
+let node_readline = require("node:readline");
+node_readline = __toESM(node_readline);
+let node_tty = require("node:tty");
+let _inquirer_prompts = require("@inquirer/prompts");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let fast_flow_transform = require("fast-flow-transform");
+fast_flow_transform = __toESM(fast_flow_transform);
+let wrap_ansi = require("wrap-ansi");
+wrap_ansi = __toESM(wrap_ansi);
+let c12 = require("c12");
+c12 = __toESM(c12);
+let _rollipop_rolldown = require("@rollipop/rolldown");
+_rollipop_rolldown = __toESM(_rollipop_rolldown);
+let _rollipop_rolldown_experimental = require("@rollipop/rolldown/experimental");
+_rollipop_rolldown_experimental = __toESM(_rollipop_rolldown_experimental);
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+require("@node-rs/xxhash");
+let dedent = require("dedent");
+dedent = __toESM(dedent);
+let dotenv = require("dotenv");
+dotenv = __toESM(dotenv);
+let dotenv_expand = require("dotenv-expand");
+dotenv_expand = __toESM(dotenv_expand);
+let _rollipop_rolldown_pluginutils = require("@rollipop/rolldown-pluginutils");
+let image_size = require("image-size");
+let url = require("url");
+url = __toESM(url);
+let _react_native_community_cli_server_api = require("@react-native-community/cli-server-api");
+let _react_native_dev_middleware = require("@react-native/dev-middleware");
+let fastify = require("fastify");
+fastify = __toESM(fastify);
+let mitt = require("mitt");
+mitt = __toESM(mitt);
+let node_http = require("node:http");
+node_http = __toESM(node_http);
+let node_events = require("node:events");
+node_events = __toESM(node_events);
+let strip_ansi = require("strip-ansi");
+strip_ansi = __toESM(strip_ansi);
+let source_map = require("source-map");
+let _modelcontextprotocol_sdk_server_mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
+let _modelcontextprotocol_sdk_server_streamableHttp_js = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+let _modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
+let fastify_plugin = require("fastify-plugin");
+fastify_plugin = __toESM(fastify_plugin);
+let zod = require("zod");
+let json_schema_to_ts = require("json-schema-to-ts");
+let mime = require("mime");
+mime = __toESM(mime);
+let ajv = require("ajv");
+ajv = __toESM(ajv);
+let _babel_code_frame = require("@babel/code-frame");
+let ws = require("ws");
+ws = __toESM(ws);
+let _babel_core = require("@babel/core");
+_babel_core = __toESM(_babel_core);
+let _swc_core = require("@swc/core");
+_swc_core = __toESM(_swc_core);
+//#region src/common/logo.ts
+const CANDY = `
+    _....._
+  .' _..._ '.
+ / /\`  __ \`\\ \\
+; ;  /\`  \\  | ;
+| | |  (_/  ; |
+; ;  \\_  _.' .;
+ \\ '.  \`\` _.'/
+  '._\`"'"\`_.'`;
+const STICK = `
+    /  /\`\`
+   /  /
+  /__/`;
+const DESCRIPTIONS = [
+	"Rollipop",
+	"Modern build toolkit for React Native",
+	"Powered by Rolldown"
+];
+const PRIMARY_COLOR = "#42A5F5";
+const BASE_GRADIENT_COLORS = [PRIMARY_COLOR, "#BBDEFB"];
+const PADDING = 20;
+function printLogo() {
+	let maxLogoWidth = 0;
+	const padding = " ".repeat(PADDING);
+	const gradientColors = [...BASE_GRADIENT_COLORS];
+	const styledCandy = CANDY.split("\n").map((line) => {
+		maxLogoWidth = Math.max(line.length, maxLogoWidth);
+		return (0, gradient_string.default)(gradientColors.reverse())(line);
+	}).join("\n") + STICK;
+	console.log(styledCandy.split("\n").map((line) => padding + line).join("\n"));
+	console.log("");
+	DESCRIPTIONS.forEach((description, index) => {
+		const descriptionHalfLength = description.length / 2;
+		const logoHalfWidth = maxLogoWidth / 2;
+		const padding = " ".repeat(PADDING - descriptionHalfLength + logoHalfWidth);
+		if (index === 0) console.log(padding + chalk.default.bold.hex(PRIMARY_COLOR)(description));
+		else console.log(padding + description);
+	});
+	console.log("");
+}
+let _printed = false;
+const Logo = {
+	print: printLogo,
+	printOnce: () => {
+		if (_printed) return;
+		_printed = true;
+		printLogo();
+	}
+};
+const SHARED_DATA_PATH = ".rollipop";
+//#endregion
+//#region src/common/env.ts
+const TRUTHY_VALUES = [
+	"yes",
+	"on",
+	"true",
+	"enabled"
+];
+const FALSY_VALUES = [
+	"no",
+	"off",
+	"false",
+	"disabled"
+];
+function parseDebugKeys() {
+	return Object.keys(process.env).filter((key) => /^debug_/i.test(key)).reduce((acc, key) => {
+		const prop = key.slice(6).toLowerCase().replace(/_([a-z])/g, (_, key) => key.toUpperCase());
+		let value = process.env[key];
+		const lowerCase = typeof value === "string" ? value.toLowerCase() : value.toString();
+		if (TRUTHY_VALUES.includes(lowerCase)) value = true;
+		else if (FALSY_VALUES.includes(lowerCase)) value = false;
+		else value = Boolean(Number(value));
+		acc[prop] = value;
+		return acc;
+	}, {});
+}
+let debugKeys = null;
+function isDebugEnabled() {
+	if (debugKeys == null) debugKeys = parseDebugKeys();
+	return debugKeys["rollipop"] ?? false;
+}
+//#endregion
+//#region src/common/logger.ts
+var Logger = class Logger {
+	static blocked = false;
+	static queuedMessages = [];
+	static Colors = {
+		trace: chalk.default.gray,
+		debug: chalk.default.blue,
+		log: chalk.default.green,
+		info: chalk.default.cyan,
+		warn: chalk.default.yellow,
+		error: chalk.default.red
+	};
+	format = "HH:mm:ss.SSS";
+	debugEnabled;
+	static block() {
+		this.blocked = true;
+	}
+	static unblock(flush = true) {
+		this.blocked = false;
+		if (flush) for (const args of Logger.queuedMessages) console.log(...args);
+		Logger.queuedMessages.length = 0;
+	}
+	constructor(scope) {
+		this.scope = scope;
+		this.debugEnabled = isDebugEnabled();
+	}
+	getFormat() {
+		return this.format;
+	}
+	setFormat(format) {
+		this.format = format;
+	}
+	getTimestamp() {
+		return (0, dayjs.default)().format(this.getFormat());
+	}
+	print(logLevel, ...args) {
+		const timestamp = chalk.default.gray(this.getTimestamp());
+		const level = Logger.Colors[logLevel](logLevel);
+		if (this.scope) args = [
+			timestamp,
+			level,
+			chalk.default.magenta(this.scope),
+			...args
+		];
+		else args = [
+			timestamp,
+			level,
+			...args
+		];
+		if (Logger.blocked) Logger.queuedMessages.push(args);
+		else console.log(...args);
+	}
+	trace(...args) {
+		this.debugEnabled && this.print("trace", ...args);
+	}
+	debug(...args) {
+		this.debugEnabled && this.print("debug", ...args);
+	}
+	log(...args) {
+		this.print("log", ...args);
+	}
+	info(...args) {
+		this.print("info", ...args);
+	}
+	warn(...args) {
+		this.print("warn", ...args);
+	}
+	error(...args) {
+		this.print("error", ...args);
+	}
+	child(scope) {
+		(0, es_toolkit.invariant)(this.scope, "Logger must have a scope to create a child logger");
+		return new Logger(`${this.scope}:${scope}`);
+	}
+};
+//#endregion
+//#region src/node/logger.ts
+const logger$2 = new Logger("cli");
+//#endregion
+//#region src/node/utils.ts
+function parseBoolean(value) {
+	return value === "true" || value === "1";
+}
+function resolvePath(value) {
+	return node_path.default.resolve(value);
+}
+//#endregion
+//#region src/core/fs/data.ts
+function getSharedDataPath(basePath) {
+	return node_path.default.join(basePath, SHARED_DATA_PATH);
+}
+//#endregion
+//#region src/core/settings.ts
+function getSettingsPath(basePath) {
+	return node_path.default.join(getSharedDataPath(basePath), "settings.json");
+}
+function loadSettings(basePath) {
+	const settingsPath = getSettingsPath(basePath);
+	if (!node_fs.default.existsSync(settingsPath)) return {};
+	return JSON.parse(node_fs.default.readFileSync(settingsPath, "utf-8"));
+}
+function saveSettings(basePath, settings) {
+	const newSettings = (0, es_toolkit.merge)(loadSettings(basePath), settings);
+	node_fs.default.writeFileSync(getSettingsPath(basePath), JSON.stringify(newSettings, null, 2));
+}
+//#endregion
+//#region src/node/commands/start/debugger.ts
+var DebuggerOpener = class DebuggerOpener {
+	static MAX_TARGETS_SHOWN = 10;
+	_prompting = false;
+	settings;
+	autoOpened = false;
+	static setAutoOpenEnabled(projectRoot, enabled) {
+		saveSettings(projectRoot, { devtools: { autoOpen: enabled } });
+	}
+	constructor(projectRoot, serverUrl) {
+		this.projectRoot = projectRoot;
+		this.serverUrl = serverUrl;
+		this.settings = loadSettings(projectRoot);
+	}
+	async openDebuggerForTarget(target) {
+		logger$2.debug(`Opening debugger for target: ${target.id}`);
+		try {
+			await fetch(new URL("/open-debugger?target=" + encodeURIComponent(target.id), this.serverUrl), { method: "POST" });
+		} catch (error) {
+			logger$2.error(`Failed to open debugger for ${target.title}`);
+			logger$2.debug("Reason", error);
+		}
+	}
+	async autoOpen() {
+		if (this.autoOpened) return;
+		this.autoOpened = true;
+		if (this.isAutoOpenEnabled()) await this.open();
+	}
+	async open() {
+		logger$2.debug("Fetching available debugging targets...");
+		const response = await fetch(new URL("/json/list", this.serverUrl), { method: "POST" });
+		if (response.status !== 200) throw new Error(`Unexpected status code: ${response.status}`);
+		const targets = await response.json();
+		if (!Array.isArray(targets)) throw new Error("Unexpected response format");
+		logger$2.debug(`Found ${targets.length} debugging targets:`);
+		if (targets.length === 0) logger$2.warn("No connected targets");
+		else if (targets.length === 1) {
+			const target = targets[0];
+			await this.openDebuggerForTarget(target);
+		} else {
+			if (targets.length > DebuggerOpener.MAX_TARGETS_SHOWN) logger$2.warn(`More than ${DebuggerOpener.MAX_TARGETS_SHOWN} debug targets available, showing the first ${DebuggerOpener.MAX_TARGETS_SHOWN}.`);
+			const slicedTargets = targets.slice(0, DebuggerOpener.MAX_TARGETS_SHOWN);
+			Logger.block();
+			this._prompting = true;
+			try {
+				const targetIndex = await (0, _inquirer_prompts.select)({
+					message: "Multiple debug targets available, please select:",
+					choices: slicedTargets.map((target, index) => ({
+						value: index,
+						name: `${target.title} (${target.description})`
+					}))
+				});
+				await this.openDebuggerForTarget(slicedTargets[targetIndex]);
+			} catch {} finally {
+				Logger.unblock();
+				this._prompting = false;
+			}
+		}
+	}
+	isPrompting() {
+		return this._prompting;
+	}
+	isAutoOpenEnabled() {
+		return this.settings.devtools?.autoOpen ?? false;
+	}
+	setAutoOpenEnabled(enabled) {
+		const newSettings = this.settings = (0, es_toolkit.merge)(this.settings, { devtools: { autoOpen: enabled } });
+		saveSettings(this.projectRoot, newSettings);
+	}
+};
+//#endregion
+//#region src/node/commands/start/setup-interactive-mode.ts
+const CTRL_C = "";
+const CTRL_D = "";
+const BROADCAST_THROTTLE_DELAY = 500;
+function setupInteractiveMode(options) {
+	const { devServer, extraCommands = [] } = options;
+	if (!devServer.instance.server.listening) throw new Error("Dev server is not listening. Please call `devServer.instance.listen()` first.");
+	if (!(process.stdin.isTTY && process.stdin instanceof node_tty.ReadStream)) {
+		logger$2.warn("Interactive mode is not supported in non-interactive environments");
+		return;
+	}
+	const debuggerOpener = new DebuggerOpener(devServer.config.root, devServer.instance.listeningOrigin);
+	const defaultCommands = getDefaultCommands(devServer, debuggerOpener);
+	const allCommands = [...defaultCommands, ...extraCommands];
+	assertHasNoDuplicateCommands(defaultCommands, extraCommands);
+	node_readline.default.emitKeypressEvents(process.stdin);
+	process.stdin.setRawMode(true);
+	devServer.on("device.connected", () => {
+		debuggerOpener.autoOpen().catch(() => {
+			logger$2.error("Failed to open debugger");
+		});
+	});
+	process.stdin.on("keypress", (_, key) => {
+		const { ctrl = false, shift = false } = key;
+		const sequence = key.sequence?.toLowerCase();
+		if (sequence == null || debuggerOpener.isPrompting()) return;
+		if (ctrl && [CTRL_C, CTRL_D].includes(sequence)) {
+			process.stdin.setRawMode(false);
+			process.stdin.pause();
+			process.emit("SIGINT");
+			process.exit(0);
+		}
+		const targetCommand = allCommands.find((command) => command.key === sequence && (command.shift ?? false) === shift);
+		if (targetCommand) targetCommand.handler.call({
+			server: devServer,
+			logger: logger$2
+		});
+	});
+	console.log();
+	allCommands.forEach((command, index) => {
+		if (defaultCommands.length === index) console.log();
+		const leadingLabel = command.shift ? "»" : "» Press";
+		const shortcut = chalk.default.bold(shortcutLabel(command.key, command.shift));
+		console.log(`${leadingLabel} ${shortcut} │ ${typeof command.description === "function" ? command.description() : command.description}`);
+	});
+}
+function getDefaultCommands(devServer, debuggerOpener) {
+	return [
+		{
+			key: "r",
+			description: "Reload app",
+			handler: (0, es_toolkit.throttle)(() => {
+				logger$2.info("Reloading app...");
+				devServer.message.broadcast("reload");
+			}, BROADCAST_THROTTLE_DELAY)
+		},
+		{
+			key: "j",
+			description: "Open DevTools",
+			handler: () => {
+				debuggerOpener.open().catch(() => {
+					logger$2.error("Failed to open debugger");
+				});
+			}
+		},
+		{
+			key: "d",
+			description: "Show developer menu",
+			handler: (0, es_toolkit.throttle)(() => {
+				logger$2.info("Showing developer menu...");
+				devServer.message.broadcast("devMenu");
+			}, BROADCAST_THROTTLE_DELAY)
+		},
+		{
+			key: "d",
+			shift: true,
+			description: () => {
+				const autoOpenEnabled = debuggerOpener.isAutoOpenEnabled();
+				return `Toggle auto opening developer tools on startup (${chalk.default.bold(autoOpenEnabled ? "enabled" : "disabled")})`;
+			},
+			handler: () => {
+				const newAutoOpenEnabled = !debuggerOpener.isAutoOpenEnabled();
+				debuggerOpener.setAutoOpenEnabled(newAutoOpenEnabled);
+				logger$2.info(`Auto opening developer tools: ${chalk.default.bold(newAutoOpenEnabled ? "enabled" : "disabled")}`);
+			}
+		}
+	];
+}
+function shortcutLabel(key, shift) {
+	if (shift) return `shift+${key}`;
+	return key;
+}
+function assertHasNoDuplicateCommands(defaultCommands, commands) {
+	const defaultCommandKeys = defaultCommands.map(({ key, shift }) => shortcutLabel(key, shift));
+	const duplicateKeys = commands.map(({ key, shift }) => shortcutLabel(key, shift)).filter((key) => defaultCommandKeys.includes(key));
+	const invalidCommandKeys = commands.filter(({ key }) => key.length > 1).map(({ key, shift }) => shortcutLabel(key, shift));
+	if (invalidCommandKeys.length > 0) throw new Error(`Invalid commands: ${invalidCommandKeys.join(", ")}`);
+	if (duplicateKeys.length > 0) throw new Error(`Duplicate commands: ${duplicateKeys.join(", ")}`);
+}
+//#endregion
+//#region src/node/cli-utils.ts
+function createReactNativeCliCommand(commandDefinition) {
+	return {
+		name: commandDefinition.name,
+		description: commandDefinition.description,
+		options: commandDefinition.options?.map((option) => (0, es_toolkit.omit)(option, ["required"])),
+		func: (_argv, cliConfig, args) => {
+			Logo.printOnce();
+			return commandDefinition.action.call({ platforms: Object.keys(cliConfig.platforms) }, args);
+		}
+	};
+}
+//#endregion
+//#region src/node/constants.ts
+const UNSUPPORTED_OPTION_DESCRIPTION = "This option is not supported by Rollipop.";
+//#endregion
+//#region src/common/transformer.ts
+async function stripFlowTypes(id, code) {
+	return await (0, fast_flow_transform.default)({
+		filename: id,
+		source: code,
+		sourcemap: true,
+		dialect: "flow",
+		format: "pretty"
+	});
+}
+//#endregion
+//#region src/constants.ts
+const ROLLIPOP_VERSION = globalThis.__ROLLIPOP_VERSION__;
+const GLOBAL_IDENTIFIER = "global";
+/**
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/docs/Configuration.md#resolvermainfields}
+*/
+const DEFAULT_RESOLVER_MAIN_FIELDS = [
+	"react-native",
+	"browser",
+	"main"
+];
+const DEFAULT_RESOLVER_CONDITION_NAMES = [
+	"react-native",
+	"import",
+	"require"
+];
+/**
+* Unlike the Metro bundler configuration, this prioritizes resolving TypeScript and ESM first.
+*
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/packages/metro-config/src/defaults/defaults.js}
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/packages/metro-file-map/src/workerExclusionList.js}
+*/
+const DEFAULT_SOURCE_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"json"
+];
+const DEFAULT_ASSET_EXTENSIONS = [
+	"bmp",
+	"gif",
+	"jpg",
+	"jpeg",
+	"png",
+	"psd",
+	"svg",
+	"webp",
+	"xml",
+	"m4v",
+	"mov",
+	"mp4",
+	"mpeg",
+	"mpg",
+	"webm",
+	"aac",
+	"aiff",
+	"caf",
+	"m4a",
+	"mp3",
+	"wav",
+	"html",
+	"pdf",
+	"yaml",
+	"yml",
+	"otf",
+	"ttf",
+	"zip"
+];
+const DEFAULT_ASSET_REGISTRY_PATH = "react-native/Libraries/Image/AssetRegistry.js";
+const DEFAULT_HMR_CLIENT_PATH = "react-native/Libraries/Utilities/HMRClient.js";
+const DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS = [
+	GLOBAL_IDENTIFIER,
+	"Promise",
+	"regeneratorRuntime",
+	"XMLHttpRequest",
+	"FormData",
+	"fetch",
+	"Headers",
+	"Request",
+	"Response",
+	"WebSocket",
+	"Blob",
+	"File",
+	"FileReader",
+	"URL",
+	"URLSearchParams",
+	"AbortController",
+	"AbortSignal",
+	"queueMicrotask",
+	"setImmediate",
+	"clearImmediate",
+	"requestIdleCallback",
+	"cancelIdleCallback",
+	"setTimeout",
+	"clearTimeout",
+	"setInterval",
+	"clearInterval",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"DOMRect",
+	"DOMRectReadOnly",
+	"DOMRectList",
+	"HTMLCollection",
+	"NodeList",
+	"Node",
+	"Document",
+	"CharacterData",
+	"Text",
+	"Element",
+	"HTMLElement",
+	"IntersectionObserver",
+	"MutationObserver",
+	"MutationRecord",
+	"EventCounts",
+	"Performance",
+	"PerformanceEntry",
+	"PerformanceEventTiming",
+	"PerformanceLongTaskTiming",
+	"PerformanceMark",
+	"PerformanceMeasure",
+	"PerformanceObserver",
+	"PerformanceObserverEntryList",
+	"PerformanceResourceTiming",
+	"TaskAttributionTiming"
+];
+const DEFAULT_ENV_PREFIX = "ROLLIPOP_";
+const DEFAULT_RUNTIME_TARGET = "hermes-v1";
+//#endregion
+//#region src/internal/react-native.ts
+function getInitializeCorePath(basePath) {
+	return require.resolve("react-native/Libraries/Core/InitializeCore", { paths: [basePath] });
+}
+function getPolyfillScriptPaths(reactNativePath) {
+	const scriptPath = node_path.default.join(reactNativePath, "rn-get-polyfills");
+	return require(scriptPath)();
+}
+function getGlobalVariables(dev, buildType) {
+	const isDevServerMode = dev && buildType === "serve";
+	return [
+		`var __BUNDLE_START_TIME__=globalThis.nativePerformanceNow?nativePerformanceNow():Date.now();`,
+		`var __DEV__=${dev};`,
+		`var ${GLOBAL_IDENTIFIER}=typeof globalThis!=='undefined'?globalThis:typeof global !== 'undefined'?global:typeof window!=='undefined'?window:this;`,
+		`var process=globalThis.process||{};process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"${dev ? "development" : "production"}";`,
+		isDevServerMode ? `var $RefreshReg$ = () => {};` : null,
+		isDevServerMode ? `var $RefreshSig$ = () => (v) => v;` : null
+	].filter(es_toolkit.isNotNil);
+}
+//#endregion
+//#region src/utils/node-resolve.ts
+function resolveFrom(basePath, lookupPath) {
+	if (node_path.default.isAbsolute(lookupPath)) return lookupPath;
+	return require.resolve(lookupPath, { paths: [basePath] });
+}
+function resolvePackagePath(basePath, packageName) {
+	let packagePath = null;
+	try {
+		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName, "package.json");
+		if (packagePath) return packagePath;
+	} catch {}
+	try {
+		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName);
+		if (packagePath) return packagePath;
+	} catch {}
+	throw new Error(`Failed to resolve package path for '${packageName}'`);
+}
+function resolvePackageJson(basePath, packageName) {
+	try {
+		const packagePath = resolvePackagePath(basePath, packageName);
+		const packageJsonPath = node_path.default.join(packagePath, "package.json");
+		const rawPackageJson = node_fs.default.readFileSync(packageJsonPath, "utf-8");
+		return JSON.parse(rawPackageJson);
+	} catch {
+		return null;
+	}
+}
+function resolvePackagePathWithNodeRequire(basePath, packageName, subpath) {
+	const resolvedPath = require.resolve(subpath ? `${packageName}/${subpath}` : packageName, { paths: [basePath] });
+	const root = node_path.default.parse(resolvedPath).root;
+	let currentPath = node_path.default.dirname(resolvedPath);
+	while (currentPath !== root) {
+		if (node_fs.default.existsSync(node_path.default.join(currentPath, "package.json"))) return currentPath;
+		currentPath = node_path.default.dirname(currentPath);
+	}
+	return null;
+}
+//#endregion
+//#region src/utils/terminal.ts
+/**
+* Based on https://github.com/sindresorhus/log-update/blob/master/index.js
+* Based on https://github.com/unjs/webpackbar
+*/
+function eraseLines(count) {
+	let clear = "";
+	for (let i = 0; i < count; i++) clear += `\u001B[2K` + (i < count - 1 ? `\u001B[1A` : "");
+	if (count) clear += `\u001B[G`;
+	return clear;
+}
+function ellipsisLeft(value, maxLength) {
+	if (value.length <= maxLength - 3) return value;
+	return `...${value.slice(value.length - maxLength - 1)}`;
+}
+const originalWrite = Symbol("original-write");
+var StreamManager = class {
+	prevLineCount;
+	listening;
+	extraLines;
+	_streams;
+	constructor() {
+		this.prevLineCount = 0;
+		this.listening = false;
+		this.extraLines = "";
+		this._onData = this._onData.bind(this);
+		this._streams = [process.stdout, process.stderr];
+	}
+	render(lines) {
+		this.listen();
+		const wrappedLines = (0, wrap_ansi.default)(lines, this.columns, {
+			trim: false,
+			hard: true,
+			wordWrap: false
+		});
+		const data = eraseLines(this.prevLineCount) + wrappedLines + "\n" + this.extraLines;
+		this.write(data);
+		this.prevLineCount = data.split("\n").length;
+	}
+	get columns() {
+		return (process.stderr.columns || 80) - 2;
+	}
+	write(data) {
+		const stream = process.stderr;
+		if (stream.write[originalWrite]) stream.write[originalWrite].call(stream, data, "utf8");
+		else stream.write(data, "utf8");
+	}
+	clear() {
+		this.done();
+		this.write(eraseLines(this.prevLineCount));
+	}
+	done() {
+		this.stopListen();
+		this.prevLineCount = 0;
+		this.extraLines = "";
+	}
+	_onData(data) {
+		const lines = String(data).split("\n").length - 1;
+		if (lines > 0) {
+			this.prevLineCount += lines;
+			this.extraLines += data;
+		}
+	}
+	listen() {
+		if (this.listening) return;
+		for (const stream of this._streams) {
+			if (stream.write[originalWrite]) continue;
+			const write = (data, ...args) => {
+				if (!stream.write[originalWrite]) return stream.write(data, ...args);
+				this._onData(data);
+				return stream.write[originalWrite].call(stream, data, ...args);
+			};
+			write[originalWrite] = stream.write;
+			stream.write = write;
+		}
+		this.listening = true;
+	}
+	stopListen() {
+		for (const stream of this._streams) if (stream.write[originalWrite]) stream.write = stream.write[originalWrite];
+		this.listening = false;
+	}
+};
+//#endregion
+//#region src/common/progress-bar.ts
+const BAR_LENGTH = 25;
+const BLOCK_CHAR = "█";
+const idleRenderer = { render(_state, context) {
+	return `  ${chalk.default.gray("Waiting...")} ${chalk.default.gray(context.label)}\n`;
+} };
+const runningRenderer = { render(state, context) {
+	const { label, current, total, columns } = context;
+	const unknownTotal = total === 0;
+	const progress = unknownTotal ? 0 : current / total * 100;
+	const width = unknownTotal ? 0 : progress * (BAR_LENGTH / 100);
+	const bg = chalk.default.white(BLOCK_CHAR);
+	const fg = chalk.default.cyan(BLOCK_CHAR);
+	const bar = (0, es_toolkit.range)(BAR_LENGTH).map((n) => n < width ? fg : bg).join("");
+	const progressLabel = unknownTotal ? chalk.default.gray("(calculating...)") : `(${progress.toFixed(2)}%)`;
+	const moduleCountLabel = unknownTotal ? `${current} modules` : `${current}/${total} modules`;
+	return `${[
+		chalk.default.cyan("●"),
+		bar,
+		progressLabel,
+		chalk.default.gray(moduleCountLabel),
+		chalk.default.gray(label)
+	].join(" ")}\n${state.moduleId ? "  " + chalk.default.grey(ellipsisLeft(state.moduleId, columns - 10)) : ""}`;
+} };
+const completedRenderer = { render(state, context) {
+	if (state.hasErrors) return `${chalk.default.red("✘")} Build failed ${chalk.default.gray(context.label)}`;
+	else {
+		const icon = chalk.default.green("✔");
+		const durationInSeconds = (state.duration / 1e3).toFixed(2);
+		return `${`${icon} Build completed ${chalk.default.gray(context.label)}`}\n${chalk.default.grey(`  Built in ${durationInSeconds}s (${context.current}/${context.total} modules)`)}`;
+	}
+} };
+var ProgressBarRenderer = class {
+	renderers = {
+		idle: idleRenderer,
+		running: runningRenderer,
+		completed: completedRenderer
+	};
+	render(state, context) {
+		return this.renderers[state.type].render(state, context);
+	}
+};
+var ProgressBar = class {
+	columns = (process.stderr.columns || 80) - 2;
+	renderer;
+	label;
+	state = { type: "idle" };
+	current = 0;
+	total;
+	stale = false;
+	constructor(options) {
+		this.total = options.total;
+		this.label = options.label;
+		this.renderer = options.renderer ?? new ProgressBarRenderer();
+	}
+	get done() {
+		return this.state.type === "completed";
+	}
+	setCurrent(current) {
+		this.current = current;
+		this.stale = true;
+		return this;
+	}
+	setTotal(total) {
+		this.total = total;
+		this.stale = true;
+		return this;
+	}
+	start() {
+		this.state = { type: "running" };
+		this.stale = true;
+		return this;
+	}
+	setModuleId(moduleId) {
+		if (this.state.type !== "running") return this;
+		this.state = {
+			type: "running",
+			moduleId
+		};
+		this.stale = true;
+		return this;
+	}
+	complete(duration, hasErrors = false) {
+		this.state = {
+			type: "completed",
+			duration,
+			hasErrors
+		};
+		this.stale = true;
+		return this;
+	}
+	render() {
+		this.stale = false;
+		const context = {
+			label: this.label,
+			current: this.current,
+			total: this.total,
+			columns: this.columns
+		};
+		return this.renderer.render(this.state, context);
+	}
+};
+var ProgressBarRenderManager = class ProgressBarRenderManager {
+	static instance = null;
+	streamManager = new StreamManager();
+	progressBars = /* @__PURE__ */ new Map();
+	throttledRender;
+	static getInstance() {
+		if (!ProgressBarRenderManager.instance) ProgressBarRenderManager.instance = new ProgressBarRenderManager();
+		return ProgressBarRenderManager.instance;
+	}
+	constructor() {
+		this.throttledRender = (0, es_toolkit.throttle)(this._render.bind(this), 50);
+	}
+	_render() {
+		const renderedLines = Array.from(this.progressBars.values().filter((progressBar) => progressBar.stale).map((progressBar) => progressBar.render()));
+		if (renderedLines.length > 0) this.streamManager.render(renderedLines.join("\n\n"));
+	}
+	register(key, options) {
+		const progressBar = this.progressBars.get(key);
+		if (progressBar == null) {
+			const newProgressBar = new ProgressBar(options);
+			this.progressBars.set(key, newProgressBar);
+			return newProgressBar;
+		}
+		return progressBar;
+	}
+	start() {
+		console.log();
+		this.streamManager.listen();
+		this._render();
+	}
+	render() {
+		this.throttledRender();
+	}
+	release() {
+		if (this.progressBars.values().every((progressBar) => progressBar.done)) {
+			this._render();
+			this.streamManager.done();
+			console.log();
+		}
+	}
+	clear() {
+		this.streamManager.clear();
+	}
+};
+//#endregion
+//#region src/logger.ts
+const logger$1 = new Logger("bundler");
+//#endregion
+//#region src/utils/reporters.ts
+function mergeReporters(reporters) {
+	return { update(event) {
+		reporters.forEach((reporter) => reporter.update(event));
+	} };
+}
+var ClientLogReporter = class {
+	logger = new Logger("app");
+	update(event) {
+		if (event.type === "client_log") {
+			if (event.level === "group" || event.level === "groupCollapsed") {
+				this.logger.info(...event.data);
+				return;
+			} else if (event.level === "groupEnd") return;
+			this.logger[event.level](...event.data);
+		}
+	}
+};
+var ProgressFlags = /* @__PURE__ */ function(ProgressFlags) {
+	ProgressFlags[ProgressFlags["NONE"] = 0] = "NONE";
+	ProgressFlags[ProgressFlags["BUILD_IN_PROGRESS"] = 1] = "BUILD_IN_PROGRESS";
+	ProgressFlags[ProgressFlags["FILE_CHANGED"] = 2] = "FILE_CHANGED";
+	return ProgressFlags;
+}(ProgressFlags || {});
+var ProgressBarStatusReporter = class {
+	renderManager = ProgressBarRenderManager.getInstance();
+	progressBar;
+	flags = ProgressFlags.NONE;
+	constructor(id, label, initialTotalModules) {
+		this.progressBar = this.renderManager.register(id, {
+			label,
+			total: initialTotalModules
+		});
+	}
+	renderProgress(id, totalModules, transformedModules) {
+		if (totalModules != null) this.progressBar.setTotal(totalModules);
+		this.progressBar.setCurrent(transformedModules).setModuleId(id);
+		this.renderManager.render();
+	}
+	update(event) {
+		switch (event.type) {
+			case "bundle_build_started":
+				this.flags |= ProgressFlags.BUILD_IN_PROGRESS;
+				this.progressBar.start();
+				this.renderManager.start();
+				break;
+			case "bundle_build_failed":
+				this.flags = ProgressFlags.NONE;
+				this.progressBar.complete(0, true);
+				this.renderManager.release();
+				break;
+			case "bundle_build_done":
+				this.flags = ProgressFlags.NONE;
+				this.progressBar.setTotal(event.totalModules).complete(event.duration, false);
+				this.renderManager.release();
+				break;
+			case "transform":
+				const { id, totalModules, transformedModules } = event;
+				if (this.flags & ProgressFlags.FILE_CHANGED) {
+					logger$1.debug("Transformed changed file", { id });
+					return;
+				}
+				this.renderProgress(id, totalModules, transformedModules);
+				break;
+			case "watch_change":
+				this.flags |= ProgressFlags.FILE_CHANGED;
+				break;
+		}
+	}
+};
+var CompatStatusReporter = class {
+	update(event) {
+		switch (event.type) {
+			case "bundle_build_started":
+				logger$1.info("Build started...");
+				break;
+			case "bundle_build_failed":
+				logger$1.error(`Build failed`);
+				break;
+			case "bundle_build_done":
+				const { duration, totalModules } = event;
+				const time = chalk.default.blue(`${duration.toFixed(2)}ms`);
+				const modules = chalk.default.blue(`(${totalModules} modules)`);
+				logger$1.info(`Build completed in ${time} ${modules}`);
+				break;
+		}
+	}
+};
+//#endregion
+//#region src/config/defaults.ts
+async function getDefaultConfig(projectRoot, mode) {
+	let reactNativePath;
+	try {
+		reactNativePath = process.env.ROLLIPOP_REACT_NATIVE_PATH ?? resolvePackagePath(projectRoot, "react-native");
+	} catch {
+		throw new Error(`Could not resolve 'react-native' package path. Please check your project path.`);
+	}
+	return {
+		root: projectRoot,
+		mode: mode ?? "development",
+		entry: "index.js",
+		resolver: {
+			sourceExtensions: DEFAULT_SOURCE_EXTENSIONS,
+			assetExtensions: DEFAULT_ASSET_EXTENSIONS,
+			mainFields: DEFAULT_RESOLVER_MAIN_FIELDS,
+			conditionNames: DEFAULT_RESOLVER_CONDITION_NAMES,
+			preferNativePlatform: true,
+			symlinks: true
+		},
+		transformer: { flow: { filter: {
+			id: /\.jsx?$/,
+			code: /@flow/
+		} } },
+		serializer: {
+			prelude: [getInitializeCorePath(projectRoot)],
+			polyfills: await Promise.all(getPolyfillScriptPaths(reactNativePath).map(async (path) => {
+				return {
+					type: "iife",
+					code: (await stripFlowTypes(path, node_fs.default.readFileSync(path, "utf-8"))).code
+				};
+			}))
+		},
+		watcher: {
+			skipWrite: true,
+			useDebounce: true,
+			debounceDuration: 50
+		},
+		optimization: { treeshake: true },
+		reactNative: {
+			reactNativePath,
+			codegen: { filter: { code: /\bcodegenNativeComponent</ } },
+			assetRegistryPath: DEFAULT_ASSET_REGISTRY_PATH,
+			hmrClientPath: DEFAULT_HMR_CLIENT_PATH,
+			globalIdentifiers: DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS
+		},
+		devMode: { hmr: true },
+		reporter: new ClientLogReporter(),
+		terminal: { status: (() => {
+			if (isDebugEnabled()) return "compat";
+			if (process.stderr.isTTY) return "progress";
+			return "compat";
+		})() },
+		envDir: projectRoot,
+		envPrefix: DEFAULT_ENV_PREFIX,
+		runtimeTarget: DEFAULT_RUNTIME_TARGET,
+		experimental: { nativeTransformPipeline: false }
+	};
+}
+//#endregion
+//#region src/core/plugins/context.ts
+const pluginLogger = new Logger();
+function createPluginContext(name) {
+	return {
+		debug: (log) => {
+			printPluginLog("debug", log, name);
+		},
+		info: (log) => {
+			printPluginLog("info", log, name);
+		},
+		warn: (log) => {
+			printPluginLog("warn", log, name);
+		}
+	};
+}
+function printPluginLog(level, log, pluginName = "unknown") {
+	const pluginLabel = chalk.default.magenta(`plugin:${pluginName}`);
+	if (typeof log === "string") pluginLogger[level](pluginLabel, log);
+	else pluginLogger[level](pluginLabel, log.stack ?? log.message);
+}
+//#endregion
+//#region src/config/compose-override.ts
+async function applyOverrideRolldownOptions(override, rolldownOptions) {
+	if (typeof override === "function") return await override(rolldownOptions);
+	return {
+		input: (0, es_toolkit.merge)(rolldownOptions.input ?? {}, override.input ?? {}),
+		output: (0, es_toolkit.merge)(rolldownOptions.output ?? {}, override.output ?? {})
+	};
+}
+function composeOverrideRolldownOptions(target, source) {
+	if (source == null) return target;
+	if (target == null) return source;
+	return async (rolldownOptions) => {
+		return await applyOverrideRolldownOptions(source, await applyOverrideRolldownOptions(target, rolldownOptions));
+	};
+}
+//#endregion
+//#region src/config/merge-config.ts
+function mergeConfig(baseConfig, ...overrideConfigs) {
+	let mergedConfig = baseConfig;
+	for (const overrideConfig of overrideConfigs) mergedConfig = (0, es_toolkit.mergeWith)(mergedConfig, overrideConfig, (target, source, key) => {
+		if ([
+			"sourceExtensions",
+			"assetExtensions",
+			"polyfills",
+			"prelude",
+			"plugins"
+		].includes(key)) return Array.from(new Set([...target ?? [], ...source ?? []]));
+		if (key === "reporter") return source ?? target;
+		if (key === "dangerously_overrideRolldownOptions") return composeOverrideRolldownOptions(target, source);
+	});
+	return mergedConfig;
+}
+//#endregion
+//#region src/config/load-config.ts
+const CONFIG_FILE_NAME = "rollipop";
+async function loadConfig(options = {}) {
+	const { cwd = process.cwd(), configFile, mode, context = {} } = options;
+	const defaultConfig = await getDefaultConfig(cwd, mode);
+	const commonOptions = {
+		context: {
+			...context,
+			defaultConfig
+		},
+		rcFile: false
+	};
+	const { config: userConfig } = await c12.loadConfig(configFile ? {
+		configFile: node_path.default.resolve(cwd, configFile),
+		configFileRequired: true
+	} : {
+		cwd,
+		defaultConfig,
+		name: CONFIG_FILE_NAME,
+		...commonOptions
+	});
+	const plugins = await flattenPluginOption(userConfig.plugins);
+	const resolvedConfig = {
+		...await resolvePluginConfig(mergeConfig(defaultConfig, {
+			...userConfig,
+			plugins
+		}), plugins),
+		plugins
+	};
+	await invokeConfigResolved(resolvedConfig, plugins);
+	return resolvedConfig;
+}
+async function flattenPluginOption(pluginOption) {
+	const awaitedPluginOption = await pluginOption;
+	if (Array.isArray(awaitedPluginOption)) return (await Promise.all(awaitedPluginOption.map(flattenPluginOption))).flat();
+	if (awaitedPluginOption == null || awaitedPluginOption === false) return [];
+	return [awaitedPluginOption];
+}
+async function resolvePluginConfig(baseConfig, plugins) {
+	let mergedConfig = (0, es_toolkit.omit)(baseConfig, ["plugins"]);
+	for (const plugin of plugins) {
+		const context = createPluginContext(plugin.name);
+		const overrideBefore = mergedConfig.dangerously_overrideRolldownOptions;
+		if (typeof plugin.config === "function") {
+			const config = await plugin.config.call(context, mergedConfig);
+			if (config != null) mergedConfig = mergeConfig(mergedConfig, config);
+		} else if (typeof plugin.config === "object") mergedConfig = mergeConfig(mergedConfig, plugin.config);
+		const overrideAfter = mergedConfig.dangerously_overrideRolldownOptions;
+		if (overrideAfter != null && overrideAfter !== overrideBefore) context.debug({ message: `set 'dangerously_overrideRolldownOptions'` });
+	}
+	return mergedConfig;
+}
+async function invokeConfigResolved(config, plugins) {
+	await Promise.all(plugins.map((plugin) => {
+		const context = createPluginContext(plugin.name);
+		return plugin.configResolved?.call(context, config);
+	}));
+}
+//#endregion
+//#region src/utils/reset-cache.ts
+/**
+* Resolve the build cache directory for the given project root. The cache
+* itself is owned by rolldown's native implementation; we keep the path
+* here only because `resetCache` — and any tooling that wants to inspect
+* the on-disk layout — needs to know where to look.
+*/
+function getCacheDirectory(projectRoot) {
+	return node_path.default.join(getSharedDataPath(projectRoot), "cache");
+}
+/**
+* Remove the entire build cache directory for the given project root.
+* Backs the `/reset-cache` control endpoint, the `reset_cache` MCP tool,
+* and the `--reset-cache` CLI flag.
+*/
+function resetCache(projectRoot) {
+	node_fs.default.rmSync(getCacheDirectory(projectRoot), {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/utils/build-options.ts
+const DEFAULT_BUILD_OPTIONS = {
+	cache: true,
+	minify: false
+};
+function resolveBuildOptions(config, buildOptions) {
+	if (buildOptions.outfile) buildOptions.outfile = node_path.default.resolve(config.root, buildOptions.outfile);
+	if ((buildOptions.sourcemap === true || buildOptions.sourcemap === "hidden") && buildOptions.sourcemapOutfile) buildOptions.sourcemapOutfile = node_path.default.resolve(config.root, buildOptions.sourcemapOutfile);
+	return (0, es_toolkit.merge)(DEFAULT_BUILD_OPTIONS, {
+		...buildOptions,
+		dev: buildOptions.dev ?? config.mode === "development"
+	});
+}
+//#endregion
+//#region src/utils/hash.ts
+function md5(data) {
+	return node_crypto.default.createHash("md5").update(data).digest("hex");
+}
+//#endregion
+//#region src/utils/serialize.ts
+function serialize(value) {
+	return JSON.stringify(value, (_, value) => {
+		if (typeof value === "function") return value.toString();
+		if (value instanceof RegExp) return value.toString();
+		return value;
+	});
+}
+//#endregion
+//#region src/utils/id.ts
+function createId(config, buildOptions) {
+	return md5(serialize([
+		ROLLIPOP_VERSION,
+		filterTransformAffectedOptions(buildOptions),
+		filterTransformAffectedConfig(config)
+	]));
+}
+function filterTransformAffectedOptions(buildOptions) {
+	return (0, es_toolkit.pick)(buildOptions, ["platform", "dev"]);
+}
+function filterTransformAffectedConfig(config) {
+	const { transformer, serializer, reactNative, devMode, plugins = [] } = config;
+	return [
+		transformer,
+		serializer.polyfills,
+		serializer.prelude,
+		reactNative.assetRegistryPath,
+		devMode,
+		plugins.map((plugin, index) => `${plugin.name}#${index}`)
+	];
+}
+//#endregion
+//#region src/core/fs/storage.ts
+const DEFAULT_DATA = { build: {} };
+var FileStorage = class FileStorage {
+	static instance = null;
+	dataFilePath;
+	data;
+	static getInstance(basePath) {
+		if (FileStorage.instance == null) FileStorage.instance = new FileStorage(basePath);
+		return FileStorage.instance;
+	}
+	constructor(basePath) {
+		this.basePath = basePath;
+		this.dataFilePath = node_path.default.join(getSharedDataPath(basePath), "rollipop.json");
+		if (node_fs.default.existsSync(this.dataFilePath)) this.data = JSON.parse(node_fs.default.readFileSync(this.dataFilePath, "utf-8"));
+		else this.data = DEFAULT_DATA;
+	}
+	get() {
+		return this.data;
+	}
+	set(data) {
+		this.data = (0, es_toolkit.merge)(this.data, data);
+		node_fs.default.writeFileSync(this.dataFilePath, JSON.stringify(this.data, null, 2));
+	}
+};
+//#endregion
+//#region src/utils/string.ts
+function indent(text, indent, space = " ") {
+	return text.replace(/^/gm, space.repeat(indent));
+}
+//#endregion
+//#region src/common/code.ts
+function asLiteral(value) {
+	return JSON.stringify(value);
+}
+function nodeEnvironment(dev) {
+	return dev ? "development" : "production";
+}
+function iife(body, path = "<unknown>") {
+	const bodyPlaceholder = "__BODY__";
+	return dedent.default`
+  // ${path}
+  (function (global) {
+  ${bodyPlaceholder}
+  })(${GLOBAL_IDENTIFIER});
+  `.replace(bodyPlaceholder, indent(body, 1));
+}
+//#endregion
+//#region src/utils/config.ts
+function bindReporter(config, eventSource, onEvent) {
+	const originalReporter = config.reporter;
+	config.reporter = { update(event) {
+		switch (event.type) {
+			case "bundle_build_started":
+				eventSource.emit("buildStart");
+				break;
+			case "bundle_build_done":
+				eventSource.emit("buildDone");
+				break;
+			case "bundle_build_failed":
+				eventSource.emit("buildFailed", event.error);
+				break;
+			case "transform":
+				eventSource.emit("transform", event.id, event.totalModules, event.transformedModules);
+				break;
+			case "watch_change":
+				eventSource.emit("watchChange", event.id);
+				break;
+		}
+		originalReporter?.update(event);
+		onEvent?.(event);
+	} };
+	return config;
+}
+function resolveHmrConfig(config) {
+	if (config.mode !== "development") return null;
+	const defaultRuntimeImplements = getDefaultRuntimeImplements();
+	if (typeof config.devMode.hmr === "boolean") return config.devMode.hmr ? defaultRuntimeImplements : null;
+	const { runtimeImplement = defaultRuntimeImplements.runtimeImplement, clientImplement = defaultRuntimeImplements.clientImplement } = config.devMode.hmr;
+	return {
+		runtimeImplement,
+		clientImplement
+	};
+}
+getDefaultRuntimeImplements.cache = null;
+function getDefaultRuntimeImplements() {
+	if (getDefaultRuntimeImplements.cache == null) getDefaultRuntimeImplements.cache = {
+		runtimeImplement: node_fs.default.readFileSync(require.resolve("rollipop/hmr-runtime"), "utf-8"),
+		clientImplement: node_fs.default.readFileSync(require.resolve("rollipop/hmr-client"), "utf-8")
+	};
+	return getDefaultRuntimeImplements.cache;
+}
+//#endregion
+//#region src/utils/env.ts
+function defineEnvFromObject(env) {
+	return Object.fromEntries(Object.entries(env).map(([key, value]) => [`import.meta.env.${key}`, asLiteral(value)]));
+}
+//#endregion
+//#region src/utils/runtime-target.ts
+function resolveRuntimeTarget(target) {
+	switch (target) {
+		case "hermes": return "Hermes";
+		default: return "HermesV1";
+	}
+}
+//#endregion
+//#region src/utils/server.ts
+function getBaseUrl(host, port, https) {
+	return `${https ? "https" : "http"}://${host}:${port}`;
+}
+//#endregion
+//#region src/utils/storage.ts
+function getBuildTotalModules(storage, id) {
+	return storage.get().build[id]?.totalModules ?? 0;
+}
+//#endregion
+//#region src/core/env.ts
+function loadEnv(options) {
+	const { envDir, envPrefix, mode } = options;
+	(0, es_toolkit.invariant)(envPrefix.length > 0, "`envPrefix` is required");
+	const env = {};
+	const envFilesToLoad = [
+		`.env`,
+		`.env.local`,
+		mode ? `.env.${mode}` : null,
+		mode ? `.env.${mode}.local` : null
+	].filter(es_toolkit.isNotNil);
+	for (const envFile of envFilesToLoad) {
+		const envPath = node_path.default.resolve(envDir, envFile);
+		if (!node_fs.default.existsSync(envPath)) continue;
+		logger$1.trace(`Loading environment variables from ${envPath}`);
+		const parsed = dotenv.default.parse(node_fs.default.readFileSync(envPath, "utf-8"));
+		const expanded = dotenv_expand.default.expand({
+			parsed,
+			processEnv: {}
+		});
+		if (expanded.parsed) Object.entries(expanded.parsed).forEach(([key, value]) => {
+			if (key.startsWith(envPrefix)) env[key] = key in process.env ? process.env[key] : value;
+		});
+	}
+	logger$1.trace("Loaded environment variables:", env);
+	return env;
+}
+//#endregion
+//#region src/server/logger.ts
+const logger = new Logger("dev-server");
+var DevServerLogger = class {
+	level = "trace";
+	trace(...args) {
+		logger.trace(...args);
+	}
+	debug(...args) {
+		logger.debug(...args);
+	}
+	info(...args) {
+		logger.info(...args);
+	}
+	warn(...args) {
+		logger.warn(...args);
+	}
+	error(...args) {
+		logger.error(...args);
+	}
+	silent(...args) {
+		logger.trace(chalk.default.gray("(silent)"), ...args);
+	}
+	fatal(...args) {
+		logger.error(chalk.default.magenta("(fatal)"), ...args);
+	}
+	child(_bindings) {
+		return this;
+	}
+};
+//#endregion
+//#region src/utils/dev-server.ts
+async function assertDevServerStatus(options) {
+	const { devServerUrl, projectRoot, port } = options;
+	const status = await getDevServerStatus(devServerUrl, projectRoot);
+	let shouldExit = false;
+	switch (status) {
+		case DevServerStatus.MATCHED_SERVER_RUNNING:
+			logger.warn(`A dev server is already running for this project on port ${port}. Exiting.`);
+			shouldExit = true;
+			break;
+		case DevServerStatus.PORT_TAKEN:
+			logger.error(`Another process is running on port ${port}. Please terminate this process and try again, or use another port with "--port".`);
+			shouldExit = true;
+			break;
+	}
+	if (shouldExit) process.exit(1);
+}
+var DevServerStatus = /* @__PURE__ */ function(DevServerStatus) {
+	DevServerStatus[DevServerStatus["NOT_RUNNING"] = 0] = "NOT_RUNNING";
+	DevServerStatus[DevServerStatus["MATCHED_SERVER_RUNNING"] = 1] = "MATCHED_SERVER_RUNNING";
+	DevServerStatus[DevServerStatus["PORT_TAKEN"] = 2] = "PORT_TAKEN";
+	DevServerStatus[DevServerStatus["UNKNOWN"] = 3] = "UNKNOWN";
+	return DevServerStatus;
+}(DevServerStatus || {});
+async function getDevServerStatus(devServerUrl, projectRoot) {
+	const { hostname, port } = new URL(devServerUrl);
+	try {
+		if (!await isPortOccupied(hostname, port)) return DevServerStatus.NOT_RUNNING;
+		const statusResponse = await fetch(`${devServerUrl}/status`);
+		return await statusResponse.text() === "packager-status:running" && statusResponse.headers.get("X-React-Native-Project-Root") === projectRoot ? DevServerStatus.MATCHED_SERVER_RUNNING : DevServerStatus.PORT_TAKEN;
+	} catch {
+		return DevServerStatus.UNKNOWN;
+	}
+}
+async function isPortOccupied(host, port) {
+	let result = false;
+	const server = node_http.default.createServer();
+	return new Promise((resolve, reject) => {
+		server.once("error", (error) => {
+			server.close();
+			if (error.code === "EADDRINUSE") result = true;
+			else reject(error);
+		});
+		server.once("listening", () => {
+			result = false;
+			server.close();
+		});
+		server.once("close", () => resolve(result));
+		server.listen({
+			host,
+			port
+		});
+	});
+}
+//#endregion
+//#region src/utils/bundle.ts
+function getBaseBundleName(name) {
+	return name.replace(/^\//, "").replace(/\.bundle$/, "");
+}
+//#endregion
+//#region src/utils/errors.ts
+function normalizeRolldownError(error) {
+	const normalizedError = new Error((0, strip_ansi.default)(error.message));
+	normalizedError.stack = error.stack;
+	return normalizedError;
+}
+//#endregion
+//#region src/utils/promise.ts
+function taskHandler() {
+	let resolver;
+	let rejector;
+	return {
+		task: new Promise((resolve, reject) => {
+			resolver = resolve;
+			rejector = reject;
+		}),
+		resolve: () => resolver?.(void 0),
+		reject: (reason) => rejector?.(reason)
+	};
+}
+//#endregion
+//#region src/server/bundle.ts
+var FileSystemBundleStore = class {
+	bundleFilePath;
+	_sourceMap;
+	lazySourceMapConsumer = null;
+	holder;
+	constructor(projectRoot, id, code, sourceMap) {
+		const sharedDataPath = getSharedDataPath(projectRoot);
+		const bundlesPath = node_path.default.join(sharedDataPath, "bundles");
+		const bundleFilePath = node_path.default.join(bundlesPath, `${id}.bundle`);
+		if (!node_fs.default.existsSync(bundlesPath)) node_fs.default.mkdirSync(bundlesPath, { recursive: true });
+		node_fs.default.writeFileSync(bundleFilePath, code, { encoding: "utf-8" });
+		const stats = node_fs.default.statSync(bundleFilePath);
+		this.bundleFilePath = bundleFilePath;
+		this._sourceMap = sourceMap;
+		this.holder = {
+			code,
+			mtimeMs: stats.mtimeMs
+		};
+		logger$1.debug(`File system bundle created at ${bundleFilePath}`);
+	}
+	update() {
+		this.holder = {
+			code: node_fs.default.readFileSync(this.bundleFilePath, { encoding: "utf-8" }),
+			mtimeMs: node_fs.default.statSync(this.bundleFilePath).mtimeMs
+		};
+	}
+	get code() {
+		if (this.isStale()) {
+			logger$1.info("File system bundle is stale, updating...");
+			this.update();
+		} else logger$1.trace("File system bundle is up to date");
+		return this.holder.code;
+	}
+	get sourceMap() {
+		return this.isStale() ? void 0 : this._sourceMap;
+	}
+	get sourceMapConsumer() {
+		if (this.isStale() || this._sourceMap == null) return;
+		if (this.lazySourceMapConsumer == null) this.lazySourceMapConsumer = new source_map.SourceMapConsumer(this._sourceMap);
+		return this.lazySourceMapConsumer;
+	}
+	isStale() {
+		return this.holder.mtimeMs !== node_fs.default.statSync(this.bundleFilePath).mtimeMs;
+	}
+};
+//#endregion
+//#region src/server/bundler-pool.ts
+var BundlerDevEngine = class extends node_events.default {
+	initializeHandle;
+	isHmrEnabled;
+	_id;
+	bundleStore = null;
+	buildFailedError = null;
+	_devEngine = null;
+	_state = "idle";
+	_status = "idle";
+	constructor(options, config, buildOptions, onReporterEvent) {
+		super();
+		this.options = options;
+		this.config = config;
+		this.buildOptions = buildOptions;
+		this.onReporterEvent = onReporterEvent;
+		this._id = Bundler.createId(config, buildOptions);
+		this.initializeHandle = taskHandler();
+		this.isHmrEnabled = Boolean(buildOptions.dev && config.devMode.hmr);
+		this.on("buildStart", () => {
+			this._status = "building";
+		});
+		this.on("buildDone", () => {
+			this._status = "build-done";
+		});
+		this.on("buildFailed", () => {
+			this._status = "build-failed";
+		});
+		this.initialize();
+	}
+	get id() {
+		return this._id;
+	}
+	/** Snapshot of the bundler's current lifecycle state. */
+	get status() {
+		return this._status;
+	}
+	get devEngine() {
+		(0, es_toolkit.invariant)(this._devEngine, "DevEngine is not initialized");
+		return this._devEngine;
+	}
+	get ensureInitialized() {
+		return this.initializeHandle.task;
+	}
+	async initialize() {
+		if (this._state !== "idle" || this._devEngine != null) return this;
+		this._state = "initializing";
+		const onEvent = this.onReporterEvent ? (event) => this.onReporterEvent(this._id, event) : void 0;
+		const devEngine = await Bundler.devEngine(bindReporter(this.config, this, onEvent), this.buildOptions, {
+			host: this.options.server.host,
+			port: this.options.server.port,
+			onHmrUpdates: (errorOrResult) => {
+				if (!this.isHmrEnabled) return;
+				if (errorOrResult instanceof Error) {
+					logger.error("Failed to handle HMR updates", {
+						bundlerId: this.id,
+						error: errorOrResult
+					});
+					const normalizedError = normalizeRolldownError(errorOrResult);
+					this.config.reporter?.update({
+						type: "bundle_build_failed",
+						error: normalizedError
+					});
+				} else {
+					logger.trace("Detected changed files", {
+						bundlerId: this.id,
+						changedFiles: errorOrResult.changedFiles
+					});
+					this.emit("hmrUpdates", errorOrResult.updates);
+				}
+			},
+			onOutput: (errorOrResult) => {
+				if (errorOrResult instanceof Error) {
+					const normalizedError = normalizeRolldownError(errorOrResult);
+					logger.trace("onOutput", { bundlerId: this.id });
+					logger.error(errorOrResult.message);
+					this.buildFailedError = normalizedError;
+					this.emit("buildFailed", normalizedError);
+				} else {
+					const output = errorOrResult.output[0];
+					this.updateBundleStore(output);
+					this.buildFailedError = null;
+					logger.debug("Build completed", {
+						bundlerId: this.id,
+						bundleName: output.name
+					});
+				}
+			},
+			rebuildStrategy: "auto"
+		});
+		await devEngine.run();
+		this._devEngine = devEngine;
+		this._state = "ready";
+		this.initializeHandle.resolve();
+	}
+	updateBundleStore(output) {
+		this.bundleStore = new FileSystemBundleStore(this.config.root, this.id, output.code, output.map?.toString());
+	}
+	async getBundle() {
+		await this.ensureInitialized;
+		const state = await this.devEngine.getBundleState();
+		logger.debug("Bundle state", {
+			bundlerId: this.id,
+			state
+		});
+		if (state.lastFullBuildFailed) throw new Error(this.buildFailedError?.message ?? "Build failed");
+		if (state.hasStaleOutput || this.bundleStore == null) await this.devEngine.ensureLatestBuildOutput();
+		(0, es_toolkit.invariant)(this.bundleStore, "Bundle is not available");
+		return this.bundleStore;
+	}
+};
+var BundlerPool = class BundlerPool {
+	static instances = /* @__PURE__ */ new Map();
+	constructor(config, resolvedServerOptions, onReporterEvent) {
+		this.config = config;
+		this.resolvedServerOptions = resolvedServerOptions;
+		this.onReporterEvent = onReporterEvent;
+	}
+	instanceKey(bundleName, buildOptions) {
+		return `${bundleName}-${Bundler.createId(this.config, buildOptions)}`;
+	}
+	get(bundleName, buildOptions) {
+		const key = this.instanceKey(getBaseBundleName(bundleName), buildOptions);
+		const instance = BundlerPool.instances.get(key);
+		if (instance) return instance;
+		else {
+			logger.debug("Preparing new bundler instance", {
+				bundleName,
+				key
+			});
+			const instance = new BundlerDevEngine({ server: this.resolvedServerOptions }, this.config, buildOptions, this.onReporterEvent);
+			logger.debug("Setting new bundler instance", { key });
+			BundlerPool.instances.set(key, instance);
+			return instance;
+		}
+	}
+	/**
+	* Look up a cached bundler by its reporter-facing id (the same id carried
+	* in SSE events such as `bundle_build_done`). Returns `undefined` when no
+	* instance with that id has been created yet.
+	*/
+	getInstanceById(id) {
+		for (const instance of BundlerPool.instances.values()) if (instance.id === id) return instance;
+	}
+};
+//#endregion
+//#region src/server/constants.ts
+const DEFAULT_PORT = 8081;
+const DEFAULT_HOST = "localhost";
+const DEV_SERVER_ASSET_PATH = "assets";
+//#endregion
+//#region src/server/error.ts
+function errorHandler(error, request, reply) {
+	logger.error(`An error occurred while processing the request (${request.method} ${request.url}):`, error.message);
+	logger.debug(error);
+	reply.status(500).send("Internal Server Error");
+}
+//#endregion
+//#region src/server/mcp/server.ts
+function createMcpServer(options) {
+	const { projectRoot, eventBus } = options;
+	const server = new _modelcontextprotocol_sdk_server_mcp_js.McpServer({
+		name: "rollipop",
+		version: "0.1.0"
+	}, { capabilities: { logging: {} } });
+	server.registerTool("reset_cache", {
+		title: "Reset Cache",
+		description: "Clear the entire build cache. The bundler will rebuild from scratch on next change."
+	}, async () => {
+		resetCache(projectRoot);
+		eventBus.emit({ type: "cache_reset" });
+		return { content: [{
+			type: "text",
+			text: "Cache cleared successfully."
+		}] };
+	});
+	server.registerTool("get_build_events", {
+		title: "Get Build Events",
+		description: "Subscribe to bundler events for a duration. Returns all events (build start/done/fail, watch changes, client logs, device connections) collected during the wait period.",
+		inputSchema: { duration: zod.z.number().min(1e3).max(6e4).default(1e4).describe("How long to listen for events in milliseconds (1000-60000, default 10000)") }
+	}, async ({ duration }) => {
+		const events = [];
+		const unsubscribe = eventBus.collect(events);
+		await new Promise((resolve) => setTimeout(resolve, duration));
+		unsubscribe();
+		if (events.length === 0) return { content: [{
+			type: "text",
+			text: "No events received during the listening period."
+		}] };
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(events, null, 2)
+		}] };
+	});
+	return server;
+}
+const sessions = /* @__PURE__ */ new Map();
+const plugin$6 = (0, fastify_plugin.default)((fastify, options) => {
+	fastify.addContentTypeParser("application/json", { parseAs: "string" }, (_req, body, done) => {
+		try {
+			done(null, JSON.parse(body));
+		} catch (error) {
+			done(error, void 0);
+		}
+	});
+	fastify.post("/mcp", async (request, reply) => {
+		const sessionId = request.headers["mcp-session-id"];
+		if (sessionId && sessions.has(sessionId)) {
+			const { transport } = sessions.get(sessionId);
+			await transport.handleRequest(request.raw, reply.raw, request.body);
+			return reply;
+		}
+		if (!sessionId && (0, _modelcontextprotocol_sdk_types_js.isInitializeRequest)(request.body)) {
+			const transport = new _modelcontextprotocol_sdk_server_streamableHttp_js.StreamableHTTPServerTransport({
+				sessionIdGenerator: () => (0, node_crypto.randomUUID)(),
+				onsessioninitialized: (sid) => {
+					sessions.set(sid, {
+						transport,
+						server
+					});
+				}
+			});
+			transport.onclose = () => {
+				const sid = transport.sessionId;
+				if (sid) sessions.delete(sid);
+			};
+			const server = createMcpServer(options);
+			await server.connect(transport);
+			await transport.handleRequest(request.raw, reply.raw, request.body);
+			return reply;
+		}
+		return reply.status(400).send({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Bad Request: invalid or missing session"
+			},
+			id: null
+		});
+	});
+	fastify.get("/mcp", async (request, reply) => {
+		const sessionId = request.headers["mcp-session-id"];
+		if (!sessionId || !sessions.has(sessionId)) return reply.status(400).send("Missing or invalid session ID");
+		await sessions.get(sessionId).transport.handleRequest(request.raw, reply.raw);
+		return reply;
+	});
+	fastify.delete("/mcp", async (request, reply) => {
+		const sessionId = request.headers["mcp-session-id"];
+		if (!sessionId || !sessions.has(sessionId)) return reply.status(404).send("Session not found");
+		await sessions.get(sessionId).transport.handleRequest(request.raw, reply.raw);
+		return reply;
+	});
+}, { name: "mcp" });
+//#endregion
+//#region src/server/middlewares/bundlers.ts
+const routeParamSchema$1 = (0, json_schema_to_ts.asConst)({
+	type: "object",
+	required: ["id"],
+	properties: { id: { type: "string" } }
+});
+const plugin$5 = (0, fastify_plugin.default)((fastify, { bundlerPool }) => {
+	fastify.get("/bundlers/:id/status", { schema: { params: routeParamSchema$1 } }, (request, reply) => {
+		const instance = bundlerPool.getInstanceById(request.params.id);
+		if (!instance) return reply.status(404).send({ error: "not found" });
+		return reply.send({
+			id: instance.id,
+			status: instance.status
+		});
+	});
+}, { name: "bundlers" });
+//#endregion
+//#region src/server/middlewares/control.ts
+const plugin$4 = (0, fastify_plugin.default)((fastify, { projectRoot, eventBus }) => {
+	fastify.all("/reset-cache", async (_request, reply) => {
+		resetCache(projectRoot);
+		eventBus.emit({ type: "cache_reset" });
+		return reply.send({
+			success: true,
+			message: "Cache cleared"
+		});
+	});
+}, { name: "control" });
+//#endregion
+//#region src/server/middlewares/request-logger.ts
+const requestLogger = (req, _res, next) => {
+	if (isDebugEnabled()) {
+		logger.trace(chalk.default.bgBlue(` ${req.method} `), chalk.default.gray(req.url));
+		Object.entries(req.headers).forEach(([key, value]) => {
+			logger.trace(`${chalk.default.bold(key)}: ${chalk.default.gray(value)}`);
+		});
+	}
+	next();
+};
+//#endregion
+//#region src/server/middlewares/serve-assets.ts
+const queryParamSchema = (0, json_schema_to_ts.asConst)({
+	type: "object",
+	properties: {
+		platform: { type: "string" },
+		hash: { type: "string" }
+	},
+	required: ["platform"]
+});
+const plugin$3 = (0, fastify_plugin.default)((fastify, options) => {
+	const { projectRoot, host, port, https, preferNativePlatform } = options;
+	const baseUrl = https ? `https://${host}:${port}` : `http://${host}:${port}`;
+	function resolveAsset(asset) {
+		return node_path.default.resolve(projectRoot, asset);
+	}
+	fastify.get(`/${DEV_SERVER_ASSET_PATH}/*`, {
+		schema: { querystring: queryParamSchema },
+		async handler(request, reply) {
+			const { url, query } = request;
+			const { pathname } = new URL(url, baseUrl);
+			const assetPath = resolveAsset(pathname.replace(new RegExp(`^/${DEV_SERVER_ASSET_PATH}/?`), ""));
+			let handle = null;
+			try {
+				handle = await node_fs.default.promises.open(resolveAssetPath(assetPath, {
+					platform: query.platform,
+					preferNativePlatform
+				}, 1), "r");
+				const assetData = await handle.readFile();
+				const { size } = await handle.stat();
+				await reply.header("Content-Type", mime.default.getType(assetPath) ?? "").header("Content-Length", size).send(assetData);
+			} catch (error) {
+				fastify.log.error(error, "Failed to serve asset (scale assets resolving is not implemented yet)");
+				await reply.status(500).send();
+			} finally {
+				await handle?.close();
+			}
+		}
+	});
+}, { name: "serve-assets" });
+//#endregion
+//#region src/utils/response.ts
+var BundleResponse = class BundleResponse {
+	static CRLF = "\r\n";
+	static THROTTLE_DELAY = 10;
+	done = 0;
+	total = 0;
+	boundary;
+	throttleTimer = null;
+	constructor(reply) {
+		this.reply = reply;
+		const boundary = performance.now().toString();
+		this.boundary = boundary;
+		this.reply.raw.writeHead(200, { "Content-Type": `multipart/mixed; boundary="${boundary}"` });
+	}
+	writeChunk(data, headers, end = false) {
+		if (this.reply.raw.writableEnded) return;
+		const CRLF = BundleResponse.CRLF;
+		this.reply.raw.write(`${CRLF}--${this.boundary}${CRLF}`);
+		this.reply.raw.write(Object.entries(headers).map(([key, value]) => `${key}: ${value}`).join(CRLF) + CRLF + CRLF);
+		if (data) this.reply.raw.write(data);
+		if (end) {
+			this.reply.raw.write(`${CRLF}--${this.boundary}--${CRLF}`);
+			this.reply.raw.end();
+		}
+	}
+	/**
+	* Sample
+	*
+	* ```
+	* --boundary
+	*
+	* Content-Type: application/json
+	*
+	* {"done":10,"total":100}
+	* ```
+	*/
+	writeBundleState(done, total) {
+		const previousProgress = this.done / this.total;
+		const currentProgress = done / total;
+		this.done = done;
+		this.total = total;
+		if (total < 10 || this.throttleTimer != null || previousProgress >= currentProgress) return;
+		this.writeChunk(JSON.stringify({
+			done,
+			total
+		}), { "Content-Type": "application/json" });
+		this.throttleTimer = setTimeout(() => {
+			this.throttleTimer = null;
+		}, BundleResponse.THROTTLE_DELAY);
+	}
+	/**
+	* Sample
+	*
+	* ```
+	* --boundary
+	*
+	* X-Metro-Files-Changed-Count: 0
+	* Content-Type: application/json
+	* Content-Length: 100
+	* Last-Modified: Thu, 10 Aug 2023 12:00:00 GMT
+	*
+	* <bundle result>
+	* ```
+	*/
+	endWithBundle(bundle) {
+		this.writeChunk(JSON.stringify({
+			done: this.total,
+			total: this.total
+		}), { "Content-Type": "application/json" });
+		this.writeChunk(bundle, {
+			"X-Metro-Files-Changed-Count": String(0),
+			"Content-Type": "application/javascript; charset=UTF-8",
+			"Content-Length": String(Buffer.byteLength(bundle)),
+			"Last-Modified": (/* @__PURE__ */ new Date()).toUTCString()
+		}, true);
+	}
+	endWithError(error) {
+		const errorData = JSON.stringify({
+			type: error?.name ?? "InternalError",
+			message: error?.message ?? "internal error",
+			errors: []
+		});
+		this.writeChunk(errorData, {
+			"Content-Type": "application/json",
+			"X-Http-Status": "500"
+		}, true);
+	}
+};
+//#endregion
+//#region src/server/common/schema.ts
+const bundleRequestSchema = (0, json_schema_to_ts.asConst)({
+	type: "object",
+	properties: {
+		platform: { type: "string" },
+		app: { type: "string" },
+		dev: { type: "boolean" },
+		minify: { type: "boolean" },
+		runModule: { type: "boolean" },
+		inlineSourceMap: { type: "boolean" },
+		modulesOnly: { type: "boolean" }
+	},
+	required: ["platform"]
+});
+new ajv.default().compile(bundleRequestSchema);
+//#endregion
+//#region src/server/middlewares/serve-bundle.ts
+const routeParamSchema = (0, json_schema_to_ts.asConst)({
+	type: "object",
+	properties: { name: { type: "string" } }
+});
+function withGetBundleErrorHandler(reply, task) {
+	return task.catch((error) => {
+		return reply.status(500).send(error instanceof Error ? error.message : "Internal Server Error");
+	});
+}
+const plugin$2 = (0, fastify_plugin.default)((fastify, options) => {
+	const { getBundler } = options;
+	const getBundleOptions = (buildOptions) => {
+		return {
+			platform: buildOptions.platform,
+			dev: buildOptions.dev,
+			minify: buildOptions.minify,
+			sourcemap: buildOptions.inlineSourceMap ? "inline" : true
+		};
+	};
+	fastify.get("/:name.bundle", {
+		schema: {
+			params: routeParamSchema,
+			querystring: bundleRequestSchema
+		},
+		async handler(request, reply) {
+			const { params, query, headers: { accept } } = request;
+			if (!params.name) {
+				await reply.status(400).send("invalid bundle name");
+				return;
+			}
+			const buildOptions = getBundleOptions(query);
+			const bundler = getBundler(params.name, buildOptions);
+			if (accept?.includes("multipart/mixed") ?? false) {
+				const bundleResponse = new BundleResponse(reply);
+				const transformHandler = (_id, totalModules = 0, transformedModules) => {
+					bundleResponse.writeBundleState(transformedModules, totalModules);
+				};
+				bundler.on("transform", transformHandler);
+				await bundler.getBundle().then((bundle) => bundleResponse.endWithBundle(bundle.code)).catch((error) => bundleResponse.endWithError(error)).finally(() => bundler.off("transform", transformHandler));
+			} else {
+				this.log.debug(`client is not support multipart/mixed content: ${accept ?? "<empty>"}`);
+				const code = (await withGetBundleErrorHandler(reply, bundler.getBundle())).code;
+				await reply.header("Content-Type", "application/javascript").header("Content-Length", Buffer.byteLength(code)).status(200).send(code);
+			}
+		}
+	});
+	fastify.get("/:name.map", {
+		schema: {
+			params: routeParamSchema,
+			querystring: bundleRequestSchema
+		},
+		async handler(request, reply) {
+			const { params, query } = request;
+			if (!params.name) {
+				await reply.status(400).send("invalid bundle name");
+				return;
+			}
+			const buildOptions = getBundleOptions(query);
+			const sourceMap = (await withGetBundleErrorHandler(reply, getBundler(params.name, buildOptions).getBundle())).sourceMap;
+			(0, es_toolkit.invariant)(sourceMap, "Source map is not available");
+			await reply.header("Access-Control-Allow-Origin", "devtools://devtools").header("Content-Type", "application/json").header("Content-Length", Buffer.byteLength(sourceMap)).status(200).send(sourceMap);
+		}
+	});
+}, { name: "serve-bundle" });
+//#endregion
+//#region src/server/middlewares/sse.ts
+const plugin$1 = (0, fastify_plugin.default)((fastify, { eventBus }) => {
+	fastify.get("/sse/events", (request, reply) => {
+		const res = reply.raw;
+		res.writeHead(200, {
+			Connection: "keep-alive",
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			"X-Accel-Buffering": "no"
+		});
+		request.raw.socket.setNoDelay(true);
+		res.write(":ok\n\n");
+		eventBus.addClient(res);
+		request.raw.on("close", () => eventBus.removeClient(res));
+	});
+}, { name: "sse" });
+//#endregion
+//#region src/utils/url.ts
+function parseUrl(value) {
+	if (value.startsWith("/")) {
+		const [pathname, query] = value.split("?");
+		return {
+			pathname,
+			query: query ? toQueryObject(new URLSearchParams(query)) : {}
+		};
+	}
+	const url = new URL(value);
+	return {
+		pathname: url.pathname,
+		query: toQueryObject(url.searchParams)
+	};
+}
+function toQueryObject(searchParams) {
+	return searchParams.entries().reduce((acc, [key, value]) => ({
+		...acc,
+		[key]: value
+	}), {});
+}
+//#endregion
+//#region src/server/symbolicate.ts
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/metro-config/src/index.flow.js#L17
+*/
+const INTERNAL_CALLSITES_REGEX = new RegExp([
+	"/Libraries/BatchedBridge/MessageQueue\\.js$",
+	"/Libraries/Core/.+\\.js$",
+	"/Libraries/LogBox/.+\\.js$",
+	"/Libraries/Network/.+\\.js$",
+	"/Libraries/Pressability/.+\\.js$",
+	"/Libraries/Renderer/implementations/.+\\.js$",
+	"/Libraries/Utilities/.+\\.js$",
+	"/Libraries/vendor/.+\\.js$",
+	"/Libraries/WebSocket/.+\\.js$",
+	"/src/private/renderer/errorhandling/.+\\.js$",
+	"/metro-runtime/.+\\.js$",
+	"/node_modules/@babel/runtime/.+\\.js$",
+	"/node_modules/@react-native/js-polyfills/.+\\.js$",
+	"/node_modules/invariant/.+\\.js$",
+	"/node_modules/react-devtools-core/.+\\.js$",
+	"/node_modules/react-native/index.js$",
+	"/node_modules/react-refresh/.+\\.js$",
+	"/node_modules/scheduler/.+\\.js$",
+	"^\\[native code\\]$"
+].map((pathPattern) => pathPattern.replaceAll("/", "[/\\\\]")).join("|"));
+async function symbolicate(bundleStore, stack) {
+	const sourceMapConsumer = await bundleStore.sourceMapConsumer;
+	const symbolicatedStack = stack.filter((frame) => frame.file?.startsWith("http")).map((frame) => sourceMapConsumer ? originalPositionFor(sourceMapConsumer, frame) : frame).map((frame) => collapseFrame(frame));
+	return {
+		stack: symbolicatedStack,
+		codeFrame: getCodeFrame(symbolicatedStack, bundleStore, sourceMapConsumer)
+	};
+}
+function originalPositionFor(sourceMapConsumer, frame) {
+	if (frame.column == null || frame.lineNumber == null) return frame;
+	const originalPosition = sourceMapConsumer.originalPositionFor({
+		column: frame.column,
+		line: frame.lineNumber
+	});
+	return Object.entries(originalPosition).reduce((frame, [key, value]) => {
+		const targetKey = convertFrameKey(key);
+		return {
+			...frame,
+			...value ? { [targetKey]: value } : null
+		};
+	}, frame);
+}
+function collapseFrame(frame) {
+	return {
+		...frame,
+		collapse: Boolean(frame.file && INTERNAL_CALLSITES_REGEX.test(frame.file))
+	};
+}
+function isCollapsed(frame) {
+	return "collapse" in frame && frame.collapse;
+}
+function convertFrameKey(key) {
+	if (key === "line") return "lineNumber";
+	else if (key === "source") return "file";
+	else if (key === "name") return "methodName";
+	return key;
+}
+function getCodeFrame(frames, bundleStore, sourceMapConsumer) {
+	const frame = frames.find((frame) => {
+		return frame.lineNumber != null && frame.column != null && !isCollapsed(frame);
+	});
+	if (frame?.file == null || frame.column == null || frame.lineNumber == null) return null;
+	try {
+		const { lineNumber, column, file } = frame;
+		const unresolved = file.startsWith("http");
+		const source = sourceMapConsumer == null || unresolved ? bundleStore.code : sourceMapConsumer.sourceContentFor(frame.file);
+		const fileName = unresolved ? parseUrl(file).pathname ?? "unknown" : file;
+		let content = "";
+		if (source) content = (0, _babel_code_frame.codeFrameColumns)(source, { start: {
+			column,
+			line: lineNumber
+		} }, { highlightCode: true });
+		return {
+			content,
+			fileName,
+			location: {
+				column,
+				row: lineNumber
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/server/middlewares/symbolicate.ts
+const bodySchema = (0, json_schema_to_ts.asConst)({
+	type: "object",
+	properties: {
+		stack: {
+			type: "array",
+			items: {}
+		},
+		extraData: {}
+	},
+	required: ["stack"]
+});
+const plugin = (0, fastify_plugin.default)((fastify, options) => {
+	const { getBundler } = options;
+	fastify.post("/symbolicate", {
+		schema: { body: bodySchema },
+		async handler(request, reply) {
+			const { stack } = request.body;
+			const bundleUrl = stack.find((frame) => frame.file?.startsWith("http"));
+			(0, es_toolkit.invariant)(bundleUrl?.file, "No bundle URL found in stack frames");
+			const { pathname, query } = parseUrl(bundleUrl.file);
+			(0, es_toolkit.invariant)(pathname, "No pathname found in bundle URL");
+			(0, es_toolkit.invariant)(query.platform, "No platform found in query");
+			(0, es_toolkit.invariant)(query.dev, "No dev found in query");
+			const symbolicateResult = await symbolicate(await getBundler(getBaseBundleName(pathname), {
+				platform: query.platform,
+				dev: query.dev === "true"
+			}).getBundle(), stack);
+			if (isDebugEnabled()) printSymbolicateResult(stack, symbolicateResult);
+			await reply.header("Content-Type", "application/json").send(symbolicateResult);
+		}
+	});
+}, { name: "symbolicate" });
+function printSymbolicateResult(rawStackFrame, symbolicateResult) {
+	console.log();
+	console.log("Symbolicate result:");
+	console.log();
+	if (symbolicateResult.codeFrame != null) {
+		console.log(symbolicateResult.codeFrame.content);
+		console.log();
+	}
+	console.log("Stack trace:");
+	symbolicateResult.stack.forEach((stackFrame) => {
+		const symbol = stackFrame.methodName ?? "<anonymous>";
+		const file = stackFrame.file ?? "unknown";
+		const location = stackFrame.lineNumber != null && stackFrame.column != null ? `(${chalk.default.gray.underline(`${file}:${stackFrame.lineNumber}:${stackFrame.column}`)})` : "";
+		console.log(`  at ${symbol} ${location}`);
+	});
+	console.log();
+	console.log("Raw stack trace:");
+	rawStackFrame.filter((stackFrame) => stackFrame.file?.startsWith("http")).forEach((stackFrame) => {
+		const bundleName = new URL(stackFrame.file).pathname.slice(1);
+		const symbol = stackFrame.methodName ?? "<anonymous>";
+		const location = stackFrame.lineNumber != null && stackFrame.column != null ? `(${chalk.default.gray.underline(`${bundleName}:${stackFrame.lineNumber}:${stackFrame.column}`)})` : "";
+		console.log(`  at ${symbol} ${location}`);
+	});
+	console.log();
+}
+//#endregion
+//#region src/server/sse/event-bus.ts
+var SSEEventBus = class {
+	clients = /* @__PURE__ */ new Set();
+	listeners = /* @__PURE__ */ new Set();
+	emit(event) {
+		const data = JSON.stringify(event);
+		const message = `event: ${event.type}\ndata: ${data}\n\n`;
+		for (const client of this.clients) if (!client.closed) client.write(message);
+		for (const listener of this.listeners) listener(event);
+	}
+	/**
+	* Subscribe an SSE HTTP response client.
+	*/
+	addClient(res) {
+		this.clients.add(res);
+	}
+	/**
+	* Unsubscribe an SSE HTTP response client.
+	*/
+	removeClient(res) {
+		this.clients.delete(res);
+	}
+	/**
+	* Subscribe a listener that collects events into the given array.
+	* Returns an unsubscribe function.
+	*/
+	collect(collector) {
+		const listener = (event) => collector.push(event);
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	get clientCount() {
+		return this.clients.size;
+	}
+};
+//#endregion
+//#region src/server/sse/reporter.ts
+function toSSEEvent(id, event) {
+	switch (event.type) {
+		case "bundle_build_started": return {
+			type: "bundle_build_started",
+			id
+		};
+		case "bundle_build_done": return {
+			type: "bundle_build_done",
+			id,
+			totalModules: event.totalModules,
+			duration: event.duration
+		};
+		case "bundle_build_failed": return {
+			type: "bundle_build_failed",
+			id,
+			error: (0, strip_ansi.default)(event.error.message)
+		};
+		case "watch_change": return {
+			type: "watch_change",
+			id,
+			file: event.id
+		};
+		case "client_log": return {
+			type: "client_log",
+			data: event.data
+		};
+		case "transform": return null;
+	}
+}
+//#endregion
+//#region src/server/wss/server.ts
+var WebSocketServer = class extends node_events.default {
+	clientId = 0;
+	wss;
+	logger;
+	constructor(name, options) {
+		super();
+		const logger$3 = logger.child(name);
+		const wss = new ws.WebSocketServer(options);
+		wss.on("connection", (socket) => {
+			const client = Object.defineProperty(socket, "id", {
+				value: this.clientId++,
+				writable: false
+			});
+			this.onConnection(client);
+			this.emit("connection", client);
+			client.on("message", (data) => {
+				this.onMessage(client, data);
+				this.emit("message", client, data);
+			});
+			client.on("error", (error) => {
+				this.onError(client, error);
+				this.emit("error", client, error);
+			});
+			client.on("close", () => {
+				this.onClose(client);
+				this.emit("close", client);
+			});
+		});
+		this.wss = wss;
+		this.logger = logger$3;
+	}
+	get server() {
+		return this.wss;
+	}
+	send(client, data) {
+		if (client.readyState === ws.WebSocket.OPEN) client.send(data);
+	}
+	sendAll(data) {
+		this.wss.clients.forEach((client) => {
+			if (client.readyState === ws.WebSocket.OPEN) client.send(data);
+		});
+	}
+	rawDataToString(data) {
+		if (Buffer.isBuffer(data)) return data.toString("utf8");
+		if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+		return Buffer.from(data).toString("utf8");
+	}
+};
+function getWebSocketUpgradeHandler(websocketEndpoints) {
+	return (request, socket, head) => {
+		if (request.url == null) {
+			socket.destroy();
+			return;
+		}
+		const { pathname } = parseUrl(request.url);
+		if (pathname != null && websocketEndpoints[pathname]) {
+			const wss = websocketEndpoints[pathname];
+			wss.handleUpgrade(request, socket, head, (socket) => {
+				wss.emit("connection", socket, request);
+			});
+		} else socket.destroy();
+	};
+}
+//#endregion
+//#region src/server/wss/hmr-server.ts
+var HMRServer = class extends WebSocketServer {
+	bundlerPool;
+	reportEvent;
+	instances = /* @__PURE__ */ new Map();
+	bindings = /* @__PURE__ */ new Map();
+	constructor({ bundlerPool, reportEvent }) {
+		super("hmr", { noServer: true });
+		this.bundlerPool = bundlerPool;
+		this.reportEvent = reportEvent;
+	}
+	parseClientMessage(data) {
+		const parsedData = JSON.parse(this.rawDataToString(data));
+		const clientMessage = "type" in parsedData ? parsedData : null;
+		(0, es_toolkit.invariant)(clientMessage, "Invalid HMR client message");
+		return clientMessage;
+	}
+	async handleConnected(client, platform, bundleEntry) {
+		try {
+			this.logger.trace(`HMR client connected (clientId: ${client.id})`, {
+				platform,
+				bundleEntry
+			});
+			const devEngineInstance = this.bundlerPool.get(bundleEntry, {
+				platform,
+				dev: true
+			});
+			this.bindEvents(client, devEngineInstance);
+			this.instances.set(client.id, devEngineInstance);
+			this.logger.trace(`Bundler instance prepared (bundlerId: ${devEngineInstance.id})`);
+		} catch (error) {
+			this.logger.error(`Failed to prepare bundler instance`, error);
+		}
+	}
+	bindEvents(client, instance) {
+		if (this.bindings.get(client.id) == null) {
+			const handleHmrUpdates = (updates) => {
+				this.handleUpdates(client, updates);
+			};
+			const handleWatchChange = () => {
+				this.send(client, JSON.stringify({ type: "hmr:update-start" }));
+			};
+			const handleBuildFailed = (error) => {
+				this.send(client, JSON.stringify({
+					type: "hmr:error",
+					payload: {
+						type: "BuildError",
+						errors: [{ description: error.message }],
+						message: error.message
+					}
+				}));
+			};
+			instance.addListener("hmrUpdates", handleHmrUpdates);
+			instance.addListener("watchChange", handleWatchChange);
+			instance.addListener("buildFailed", handleBuildFailed);
+			this.bindings.set(client.id, {
+				hmrUpdates: handleHmrUpdates,
+				watchChange: handleWatchChange,
+				buildFailed: handleBuildFailed
+			});
+			this.logger.trace(`HMR event binding established (clientId: ${client.id})`);
+		}
+	}
+	async handleModuleRegistered(client, modules) {
+		try {
+			const instance = this.instances.get(client.id);
+			(0, es_toolkit.invariant)(instance != null, `Bundler instance not found for client clientId: ${client.id}`);
+			await instance.ensureInitialized;
+			await instance.devEngine.registerModules(client.id.toString(), modules);
+		} catch (error) {
+			this.logger.error(`Failed to handle module registered`, error);
+		}
+	}
+	async handleInvalidate(client, moduleId) {
+		try {
+			const instance = this.instances.get(client.id);
+			(0, es_toolkit.invariant)(instance != null, `Bundler instance not found for client clientId: ${client.id}`);
+			await instance.ensureInitialized;
+			const updates = await instance.devEngine.invalidate(moduleId);
+			await this.handleUpdates(client, updates);
+		} catch (error) {
+			this.logger.error(`Failed to handle invalidate`, error);
+		}
+	}
+	async handleUpdates(client, updates) {
+		this.logger.trace(`HMR updates found (clientId: ${client.id})`, { updatesCount: updates.length });
+		for (const clientUpdate of updates) {
+			const update = clientUpdate.update;
+			switch (update.type) {
+				case "Patch":
+					this.sendUpdateToClient(client, update);
+					break;
+				case "FullReload":
+					this.sendReloadToClient(client);
+					break;
+				case "Noop":
+					this.logger.warn(`Client ${clientUpdate.clientId} received noop update`);
+					break;
+			}
+		}
+	}
+	sendUpdateToClient(client, update) {
+		(0, es_toolkit.invariant)(update.type === "Patch", "Invalid HMR update type");
+		const updateMessage = {
+			type: "hmr:update",
+			code: update.code
+		};
+		this.send(client, JSON.stringify(updateMessage));
+		this.done(client);
+	}
+	sendReloadToClient(client) {
+		this.logger.trace(`Sending HMR reload message to client (clientId: ${client.id})`);
+		this.send(client, JSON.stringify({ type: "hmr:reload" }));
+		this.done(client);
+	}
+	done(client) {
+		this.send(client, JSON.stringify({ type: "hmr:update-done" }));
+	}
+	sendError(client, error) {
+		try {
+			this.send(client, JSON.stringify(error));
+		} catch (error) {
+			this.logger.error(`Failed to send HMR error message to client (clientId: ${client.id})`, error);
+		}
+	}
+	cleanup(client) {
+		this.logger.trace(`HMR client cleanup (clientId: ${client.id})`);
+		const binding = this.bindings.get(client.id);
+		const instance = this.instances.get(client.id);
+		if (binding != null && instance != null) {
+			instance.removeListener("hmrUpdates", binding.hmrUpdates);
+			instance.removeListener("watchChange", binding.watchChange);
+			instance.removeListener("buildFailed", binding.buildFailed);
+		}
+		if (instance != null) try {
+			instance.devEngine.removeClient(String(client.id));
+		} catch (error) {
+			this.logger.warn(`Skipped devEngine.removeClient for client ${client.id}: ` + (error instanceof Error ? error.message : String(error)));
+		}
+		this.bindings.delete(client.id);
+		this.instances.delete(client.id);
+	}
+	onMessage(client, data) {
+		let message;
+		try {
+			message = this.parseClientMessage(data);
+			let traceMessage = message;
+			if (message.type === "hmr:module-registered") traceMessage = {
+				...message,
+				modules: `[${message.modules.length} modules]`
+			};
+			else if (message.type === "hmr:log") traceMessage = {
+				...message,
+				data: `(${message.data.length} items)`
+			};
+			this.logger.trace("HMR client message received", traceMessage);
+		} catch (error) {
+			const message = "Failed to parse HMR client message";
+			this.logger.error(message, error);
+			this.sendError(client, {
+				type: "InternalError",
+				errors: [{ description: error instanceof Error ? error.message : String(error) }],
+				message
+			});
+			return;
+		}
+		if (isCustomHMRMessage(message)) {
+			this.wss.emit(message.type, message.payload);
+			return;
+		}
+		switch (message.type) {
+			case "hmr:connected":
+				this.handleConnected(client, message.platform, message.bundleEntry);
+				break;
+			case "hmr:module-registered":
+				this.handleModuleRegistered(client, message.modules);
+				break;
+			case "hmr:invalidate":
+				this.handleInvalidate(client, message.moduleId);
+				break;
+			case "hmr:log":
+				this.reportEvent({
+					type: "client_log",
+					level: message.level,
+					data: message.data
+				});
+				break;
+		}
+	}
+	onConnection(client) {
+		this.logger.trace(`connection established (clientId: ${client.id})`);
+	}
+	onError(client, error) {
+		this.logger.error(`connection error (clientId: ${client.id})`, error);
+		this.cleanup(client);
+	}
+	onClose(client) {
+		this.logger.trace(`connection closed (clientId: ${client.id})`);
+		this.cleanup(client);
+	}
+};
+function isCustomHMRMessage(message) {
+	if (typeof message !== "object" || message == null) return false;
+	if ("type" in message && typeof message.type === "string" && message.type.startsWith("hmr:")) return false;
+	return true;
+}
+//#endregion
+//#region src/server/create-dev-server.ts
+async function createDevServer(config, options) {
+	const projectRoot = config.root;
+	const { port = DEFAULT_PORT, host = DEFAULT_HOST, https = false } = options ?? {};
+	if (https) throw new Error("HTTPS is not supported yet");
+	const serverBaseUrl = url.default.format({
+		protocol: https ? "https" : "http",
+		hostname: host,
+		port
+	});
+	await assertDevServerStatus({
+		devServerUrl: serverBaseUrl,
+		projectRoot,
+		port
+	});
+	const emitter = (0, mitt.default)();
+	const fastify$1 = (0, fastify.default)({
+		loggerInstance: new DevServerLogger(),
+		disableRequestLogging: true
+	});
+	const sseEventBus = new SSEEventBus();
+	const bundlerPool = new BundlerPool(config, {
+		host,
+		port
+	}, (id, event) => {
+		const sseEvent = toSSEEvent(id, event);
+		if (sseEvent) sseEventBus.emit(sseEvent);
+	});
+	const getBundler = (bundleName, buildOptions) => {
+		return bundlerPool.get(bundleName, (0, es_toolkit.merge)(options?.buildOptions ?? {}, buildOptions));
+	};
+	const { middleware: communityMiddleware, websocketEndpoints: communityWebsocketEndpoints, messageSocketEndpoint: { server: messageServer, broadcast }, eventsSocketEndpoint: { server: eventsServer, reportEvent } } = (0, _react_native_community_cli_server_api.createDevServerMiddleware)({
+		port,
+		host,
+		watchFolders: []
+	});
+	const { middleware: devMiddleware, websocketEndpoints } = (0, _react_native_dev_middleware.createDevMiddleware)({
+		serverBaseUrl,
+		logger: {
+			info(...args) {
+				if (args[0].includes("JavaScript logs have moved")) return;
+				logger.info(...args);
+			},
+			warn: logger.warn.bind(logger),
+			error: logger.error.bind(logger)
+		},
+		unstable_experiments: {
+			enableNetworkInspector: true,
+			enableStandaloneFuseboxShell: true
+		}
+	});
+	const hmrServer = new HMRServer({
+		bundlerPool,
+		reportEvent: (event) => {
+			reportEvent?.(event);
+			config.reporter?.update(event);
+		}
+	}).on("connection", (client) => {
+		emitter.emit("device.connected", { client });
+		sseEventBus.emit({
+			type: "device_connected",
+			clientId: client.id
+		});
+	}).on("message", (client, data) => emitter.emit("device.message", {
+		client,
+		data
+	})).on("error", (client, error) => emitter.emit("device.error", {
+		client,
+		error
+	})).on("close", (client) => {
+		emitter.emit("device.disconnected", { client });
+		sseEventBus.emit({
+			type: "device_disconnected",
+			clientId: client.id
+		});
+	});
+	await fastify$1.register(import("@fastify/middie"));
+	const devServer = {
+		...emitter,
+		config,
+		instance: fastify$1,
+		middlewares: { use: fastify$1.use.bind(fastify$1) },
+		message: Object.assign(messageServer, { broadcast }),
+		events: Object.assign(eventsServer, { reportEvent }),
+		hot: Object.assign(hmrServer.server, {
+			send: (client, eventName, payload) => {
+				hmrServer.send(client, JSON.stringify({
+					type: eventName,
+					payload
+				}));
+			},
+			sendAll: (eventName, payload) => {
+				hmrServer.sendAll(JSON.stringify({
+					type: eventName,
+					payload
+				}));
+			}
+		})
+	};
+	const { invokePostConfigureServer } = await invokeConfigureServer(devServer, config.plugins ?? []);
+	fastify$1.use(requestLogger).use(communityMiddleware).use(devMiddleware).register(plugin$1, { eventBus: sseEventBus }).register(plugin$4, {
+		projectRoot,
+		eventBus: sseEventBus
+	}).register(plugin$5, { bundlerPool }).register(plugin$6, {
+		projectRoot,
+		eventBus: sseEventBus
+	}).register(plugin, { getBundler }).register(plugin$2, { getBundler }).register(plugin$3, {
+		projectRoot,
+		host,
+		port,
+		https,
+		preferNativePlatform: config.resolver.preferNativePlatform
+	}).setErrorHandler(errorHandler);
+	fastify$1.server.on("upgrade", getWebSocketUpgradeHandler({
+		...communityWebsocketEndpoints,
+		...websocketEndpoints,
+		"/hot": hmrServer.server
+	}));
+	await invokePostConfigureServer();
+	sseEventBus.emit({
+		type: "server_ready",
+		host,
+		port
+	});
+	return devServer;
+}
+async function invokeConfigureServer(server, plugins) {
+	const postConfigureServerHandlers = [];
+	for (const plugin of plugins) {
+		const context = createPluginContext(plugin.name);
+		const result = await plugin.configureServer?.call(context, server);
+		if (typeof result === "function") postConfigureServerHandlers.push(result);
+	}
+	return { invokePostConfigureServer: async () => {
+		for (const handler of postConfigureServerHandlers) await handler();
+	} };
+}
+//#endregion
+//#region src/core/assets.ts
+/**
+* **NOTE**: Type definitions are ported from `metro` implementation.
+*
+* @see https://github.com/facebook/metro/blob/0.81.x/packages/metro/src/Assets.js
+*/
+const SCALE_PATTERN = "@(\\d+\\.?\\d*)x";
+/**
+* key: platform,
+* value: allowed scales
+*
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/filterPlatformAssetScales.js#L11
+*/
+const ALLOW_SCALES = { ios: [
+	1,
+	2,
+	3
+] };
+/**
+* @see https://developer.android.com/training/multiscreen/screendensities#TaskProvideAltBmp
+*/
+const ANDROID_ASSET_QUALIFIER = {
+	.75: "ldpi",
+	1: "mdpi",
+	1.5: "hdpi",
+	2: "xhdpi",
+	3: "xxhdpi",
+	4: "xxxhdpi"
+};
+async function resolveScaledAssets(options) {
+	const { projectRoot, assetPath, platform, preferNativePlatform } = options;
+	const context = {
+		platform,
+		preferNativePlatform
+	};
+	const extension = node_path.default.extname(assetPath);
+	const relativePath = node_path.default.relative(projectRoot, assetPath);
+	const dirname = node_path.default.dirname(assetPath);
+	const files = node_fs.default.readdirSync(dirname);
+	const stripedBasename = stripSuffix(assetPath, context);
+	const suffixPattern = platformSuffixPattern(context);
+	const assetRegExp = new RegExp(`${stripedBasename}(${SCALE_PATTERN})?(?:${suffixPattern})?${extension}$`);
+	const scaledAssets = {};
+	for (const file of files.sort((a, b) => getAssetPriority(b, context) - getAssetPriority(a, context))) {
+		const match = assetRegExp.exec(file);
+		if (match) {
+			const [, , scale = "1"] = match;
+			if (scaledAssets[scale]) continue;
+			scaledAssets[scale] = file;
+		}
+	}
+	if (!(Object.keys(scaledAssets).length && scaledAssets[1])) throw new Error(`cannot resolve base asset of ${assetPath}`);
+	const imageData = node_fs.default.readFileSync(assetPath);
+	const dimensions = (0, image_size.imageSize)(imageData);
+	const filteredScaledAssets = Object.entries(scaledAssets).map(([scale, file]) => ({
+		scale: parseFloat(scale),
+		file
+	})).filter(({ scale }) => ALLOW_SCALES[platform]?.includes(scale) ?? true).reduce((acc, { scale, file }) => {
+		acc.files.push(file);
+		acc.scales.push(scale);
+		return acc;
+	}, {
+		scales: [],
+		files: []
+	});
+	return {
+		__packager_asset: true,
+		id: assetPath,
+		name: stripedBasename.replace(extension, ""),
+		type: extension.substring(1),
+		width: dimensions.width,
+		height: dimensions.height,
+		files: filteredScaledAssets.files,
+		scales: filteredScaledAssets.scales,
+		fileSystemLocation: node_path.default.dirname(assetPath),
+		httpServerLocation: node_path.default.join(DEV_SERVER_ASSET_PATH, node_path.default.dirname(relativePath)),
+		hash: md5(imageData)
+	};
+}
+function platformSuffixPattern(context) {
+	return [context.platform, context.preferNativePlatform ? "native" : null].filter(es_toolkit.isNotNil).map((platform) => `.${platform}`).join("|");
+}
+function stripSuffix(assetPath, context) {
+	const basename = node_path.default.basename(assetPath);
+	const extension = node_path.default.extname(assetPath);
+	const suffixPattern = platformSuffixPattern(context);
+	return basename.replace(new RegExp(`(${SCALE_PATTERN})?(?:${suffixPattern})?${extension}$`), "");
+}
+function getAssetPriority(assetPath, context) {
+	const suffixPattern = platformSuffixPattern(context);
+	if (new RegExp(`${SCALE_PATTERN}(?:${suffixPattern})`).test(assetPath)) return 3;
+	else if (new RegExp(`(?:${suffixPattern})`).test(assetPath)) return 2;
+	else if (new RegExp(`${SCALE_PATTERN}`).test(assetPath)) return 1;
+	return 0;
+}
+function addSuffix(assetPath, context, options) {
+	const extension = node_path.default.extname(assetPath);
+	return stripSuffix(assetPath, context).concat(options?.scale ? `@${options.scale}x` : "").concat(options?.platform ? `.${options.platform}${extension}` : extension);
+}
+/**
+* add suffix to asset path
+*
+* ```js
+* // assetPath input
+* '/path/to/assets/image.png'
+*
+* // `platform` suffixed
+* '/path/to/assets/image.android.png'
+*
+* // `scale` suffixed
+* '/path/to/assets/image@1x.png'
+*
+* // both `platform` and `scale` suffixed
+* '/path/to/assets/image@1x.android.png'
+* ```
+*/
+function getSuffixedPath(assetPath, context, options) {
+	const suffixedBasename = addSuffix(assetPath, context, {
+		scale: options?.scale,
+		platform: options?.platform
+	});
+	const dirname = node_path.default.dirname(assetPath);
+	return node_path.default.join(dirname, suffixedBasename);
+}
+function resolveAssetPath(assetPath, context, scale) {
+	const suffixedPaths = [
+		getSuffixedPath(assetPath, context, {
+			scale,
+			platform: context.platform
+		}),
+		context.preferNativePlatform ? getSuffixedPath(assetPath, context, {
+			scale,
+			platform: "native"
+		}) : null,
+		getSuffixedPath(assetPath, context, { scale })
+	].filter(es_toolkit.isNotNil);
+	/**
+	* When scale is 1, filename can be suffixed or non-suffixed(`image.png`).
+	*
+	* - Suffixed
+	*   - `filename.<platform>@<scale>x.ext`
+	*   - `filename.<platform>.ext`
+	*   - `filename@<scale>x.ext`
+	* - Non suffixed
+	*   - `filename.ext`
+	*
+	* 1. Resolve non-suffixed asset first.
+	* 2. If file is not exist, resolve suffixed path.
+	*/
+	if (scale === 1) try {
+		node_fs.default.statSync(assetPath);
+		return assetPath;
+	} catch {}
+	for (const suffixedPath of suffixedPaths) try {
+		node_fs.default.statSync(suffixedPath);
+		return suffixedPath;
+	} catch {}
+	throw new Error(`cannot resolve asset path for ${assetPath}`);
+}
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/assetPathUtils.js
+*/
+async function copyAssetsToDestination(options) {
+	const { assets, platform, assetsDir, preferNativePlatform } = options;
+	const context = {
+		platform,
+		preferNativePlatform
+	};
+	const mkdirWithAssertPath = (targetPath) => {
+		const dirname = node_path.default.dirname(targetPath);
+		node_fs.default.mkdirSync(dirname, { recursive: true });
+	};
+	return Promise.all(assets.map((asset) => {
+		return Promise.all(asset.scales.map(async (scale) => {
+			if (platform !== "android") {
+				const from = resolveAssetPath(asset.id, context, scale);
+				const to = node_path.default.join(assetsDir, getIosAssetDestinationPath(asset, scale));
+				mkdirWithAssertPath(to);
+				return node_fs.default.copyFileSync(from, to);
+			}
+			const from = resolveAssetPath(asset.id, context, scale);
+			const to = node_path.default.join(assetsDir, getAndroidAssetDestinationPath(asset, scale));
+			mkdirWithAssertPath(to);
+			node_fs.default.copyFileSync(from, to);
+		})).then(() => void 0);
+	})).then(() => void 0);
+}
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/getAssetDestPathIOS.js
+*/
+function getIosAssetDestinationPath(asset, scale) {
+	const suffix = scale === 1 ? "" : `@${scale}x`;
+	const fileName = `${asset.name + suffix}.${asset.type}`;
+	const devServerBasePath = asset.httpServerLocation.at(0) === "/" ? asset.httpServerLocation.slice(1) : asset.httpServerLocation;
+	return node_path.default.join(devServerBasePath.replace(/\.\.\//g, "_"), fileName);
+}
+function getAndroidAssetDestinationPath(asset, scale) {
+	const assetQualifierSuffix = ANDROID_ASSET_QUALIFIER[scale];
+	const assetName = `${asset.httpServerLocation.at(0) === "/" ? asset.httpServerLocation.slice(1) : asset.httpServerLocation}/${asset.name}`.toLowerCase().replace(/\//g, "_").replace(/(?:[^a-z0-9_])/g, "").replace(/^assets_/, "");
+	if (!assetQualifierSuffix) throw new Error(`invalid asset qualifier: ${asset.id}`);
+	return node_path.default.join(isDrawable(asset.type) ? `drawable-${assetQualifierSuffix}` : "raw", `${assetName}.${asset.type}`);
+}
+/**
+* @see https://developer.android.com/guide/topics/resources/drawable-resource
+*/
+function isDrawable(type) {
+	return [
+		"gif",
+		"heic",
+		"heif",
+		"jpeg",
+		"jpg",
+		"ktx",
+		"png",
+		"webp",
+		"xml"
+	].includes(type);
+}
+function generateAssetRegistryCode(assetRegistryPath, asset) {
+	return `module.exports = require('${assetRegistryPath}').registerAsset(${JSON.stringify(asset)});`;
+}
+//#endregion
+//#region src/core/plugins/utils/transform-utils.ts
+const TRANSFORM_FLAGS_KEY = Symbol("transform-flags");
+let TransformFlag = /* @__PURE__ */ function(TransformFlag) {
+	TransformFlag[TransformFlag["NONE"] = 0] = "NONE";
+	TransformFlag[TransformFlag["CODEGEN_REQUIRED"] = 1] = "CODEGEN_REQUIRED";
+	TransformFlag[TransformFlag["STRIP_FLOW_REQUIRED"] = 2] = "STRIP_FLOW_REQUIRED";
+	TransformFlag[TransformFlag["SKIP_ALL"] = 128] = "SKIP_ALL";
+	return TransformFlag;
+}({});
+function setFlag(context, id, flag, options) {
+	const moduleInfo = context.getModuleInfo(id);
+	if (moduleInfo && hasFlag(moduleInfo.meta)) {
+		if (options?.override) moduleInfo.meta[TRANSFORM_FLAGS_KEY] = flag;
+		else moduleInfo.meta[TRANSFORM_FLAGS_KEY] |= flag;
+		return moduleInfo.meta;
+	} else return { [TRANSFORM_FLAGS_KEY]: flag };
+}
+function hasFlag(meta) {
+	return TRANSFORM_FLAGS_KEY in meta;
+}
+function getFlag(context, id) {
+	return getFlagFromModuleInfo(context.getModuleInfo(id));
+}
+function getFlagFromModuleInfo(moduleInfo) {
+	if (moduleInfo && hasFlag(moduleInfo.meta)) return moduleInfo.meta[TRANSFORM_FLAGS_KEY];
+	return TransformFlag.NONE;
+}
+function withTransformBoundary(context, plugins) {
+	return [
+		{
+			name: "rollipop:transform-initializer",
+			transform: {
+				order: "pre",
+				handler(_code, id) {
+					if (context.state.hmrUpdates.has(id)) {
+						context.state.hmrUpdates.delete(id);
+						return { meta: setFlag(this, id, TransformFlag.NONE, { override: true }) };
+					}
+				}
+			}
+		},
+		{
+			name: "rollipop:transform-change-watcher",
+			watchChange(id) {
+				context.state.hmrUpdates.add(id);
+			}
+		},
+		plugins
+	];
+}
+//#endregion
+//#region src/core/plugins/react-native-plugin.ts
+function reactNativePlugin(options) {
+	const { projectRoot, platform, preferNativePlatform, buildType, assetsDir, assetExtensions, assetRegistryPath, flowFilter, codegenFilter, builtinPluginConfig } = options;
+	const codegenPlugin = {
+		name: "rollipop:react-native-codegen-marker",
+		transform: {
+			order: "pre",
+			filter: codegenFilter,
+			handler(_code, id) {
+				return { meta: setFlag(this, id, TransformFlag.CODEGEN_REQUIRED) };
+			}
+		}
+	};
+	const stripFlowSyntaxPlugin = {
+		name: "rollipop:react-native-strip-flow-syntax",
+		transform: {
+			order: "pre",
+			filter: flowFilter,
+			async handler(code, id) {
+				const flags = getFlag(this, id);
+				if (flags & TransformFlag.SKIP_ALL) return;
+				if (flags & TransformFlag.CODEGEN_REQUIRED) return { meta: setFlag(this, id, TransformFlag.STRIP_FLOW_REQUIRED) };
+				const result = await stripFlowTypes(id, code);
+				return {
+					code: result.code,
+					map: result.map,
+					moduleType: "tsx"
+				};
+			}
+		}
+	};
+	const assets = [];
+	const assetPlugin = {
+		name: "rollipop:react-native-asset",
+		load: {
+			filter: [(0, _rollipop_rolldown_pluginutils.include)((0, _rollipop_rolldown_pluginutils.id)(new RegExp(`\\.(?:${assetExtensions.join("|")})$`)))],
+			async handler(id) {
+				this.debug(`Asset ${id} found`);
+				const assetData = await resolveScaledAssets({
+					projectRoot,
+					assetPath: id,
+					platform,
+					preferNativePlatform
+				});
+				assets.push(assetData);
+				return {
+					code: generateAssetRegistryCode(assetRegistryPath, assetData),
+					meta: setFlag(this, id, TransformFlag.SKIP_ALL),
+					moduleType: "js"
+				};
+			}
+		},
+		buildStart() {
+			assets.length = 0;
+		},
+		async buildEnd(error) {
+			if (error || buildType === "serve") return;
+			if (assetsDir != null) {
+				this.debug(`Copying assets to ${assetsDir}`);
+				await copyAssetsToDestination({
+					assets,
+					assetsDir,
+					platform,
+					preferNativePlatform
+				});
+			}
+		}
+	};
+	return [...builtinPluginConfig ? [(0, _rollipop_rolldown_experimental.rollipopReactNativePlugin)(builtinPluginConfig)] : [codegenPlugin, stripFlowSyntaxPlugin], assetPlugin];
+}
+//#endregion
+//#region src/core/plugins/prelude-plugin.ts
+const IS_ENTRY = Symbol("IS_ENTRY");
+function preludePlugin(options) {
+	if (options.modulePaths.length === 0) return null;
+	const preludeImportStatements = options.modulePaths.map((modulePath) => `import '${modulePath}';`).join("\n");
+	let processed = false;
+	return {
+		name: "rollipop:prelude",
+		buildStart() {
+			processed = false;
+		},
+		resolveId: { handler: (source, _importer, extraOptions) => {
+			if (extraOptions.isEntry) return {
+				id: source,
+				meta: { [IS_ENTRY]: true }
+			};
+		} },
+		load: { handler(id) {
+			if (processed) return;
+			const moduleInfo = this.getModuleInfo(id);
+			if (moduleInfo && isEntry(moduleInfo.meta)) {
+				this.debug(`Prelude plugin found entry ${id}`);
+				const modifiedSource = [preludeImportStatements, node_fs.default.readFileSync(id, "utf-8")].join("\n");
+				processed = true;
+				return modifiedSource;
+			}
+		} }
+	};
+}
+function isEntry(meta) {
+	return IS_ENTRY in meta;
+}
+//#endregion
+//#region src/core/plugins/json-plugin.ts
+function jsonPlugin() {
+	return {
+		name: "rollipop:json",
+		load: {
+			filter: [(0, _rollipop_rolldown_pluginutils.include)((0, _rollipop_rolldown_pluginutils.id)(/\.json$/))],
+			handler(id) {
+				return {
+					code: `export = ${node_fs.default.readFileSync(id, "utf-8")};`,
+					meta: setFlag(this, id, TransformFlag.SKIP_ALL),
+					moduleType: "ts"
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/utils/babel.ts
+function mergeBabelOptions(options) {
+	return options.reduce((acc, options) => (0, es_toolkit.mergeWith)(acc, options, merge$3), {});
+}
+function merge$3(target, source, key) {
+	if (key === "plugins") return [...target ?? [], ...source ?? []];
+	if (key === "presets") return [...target ?? [], ...source ?? []];
+}
+//#endregion
+//#region src/core/plugins/utils/source.ts
+const TS_EXTENSION_REGEXP = /\.tsx?$/;
+function isTS(id) {
+	return TS_EXTENSION_REGEXP.test(id);
+}
+function isJSX(id) {
+	return id.endsWith("x");
+}
+//#endregion
+//#region src/core/plugins/babel-plugin.ts
+function babelPlugin({ useNativeTransformPipeline, transformConfig }) {
+	const { rules = [] } = transformConfig ?? {};
+	const babelOptionsById = /* @__PURE__ */ new Map();
+	const babelRules = rules.map(({ filter, options }, index) => {
+		return {
+			name: `rollipop:babel-rule-${index}`,
+			transform: {
+				filter,
+				handler(code, id) {
+					const existingBabelOptions = babelOptionsById.get(id);
+					const resolvedOptions = typeof options === "function" ? options(code, id) : options;
+					existingBabelOptions ? existingBabelOptions.push(resolvedOptions) : babelOptionsById.set(id, [resolvedOptions]);
+				}
+			}
+		};
+	});
+	const babelPlugin = {
+		name: "rollipop:babel",
+		buildStart() {
+			babelOptionsById.clear();
+		},
+		transform: { handler(code, id) {
+			const flags = getFlag(this, id);
+			if (flags & TransformFlag.SKIP_ALL) return;
+			const babelOptions = babelOptionsById.get(id) ?? [];
+			if (!(useNativeTransformPipeline ? babelOptions.length > 0 : flags & TransformFlag.CODEGEN_REQUIRED || babelOptions.length > 0)) return;
+			const baseOptions = useNativeTransformPipeline ? [] : [getPreset(flags, id)];
+			const result = _babel_core.transformSync(code, {
+				filename: id,
+				babelrc: false,
+				configFile: false,
+				sourceMaps: true,
+				...mergeBabelOptions([...baseOptions, ...babelOptions])
+			});
+			(0, es_toolkit.invariant)(result?.code, `Failed to transform with babel: ${id}`);
+			return {
+				code: result.code,
+				map: result.map
+			};
+		} }
+	};
+	return [...babelRules, babelPlugin];
+}
+function getPreset(flags, id) {
+	const presets = [];
+	const plugins = [];
+	let parserOpts = null;
+	if (flags & TransformFlag.STRIP_FLOW_REQUIRED) {
+		parserOpts = { flow: "all" };
+		plugins.push([require.resolve("babel-plugin-syntax-hermes-parser"), {
+			parseLangTypes: "flow",
+			reactRuntimeTarget: "19"
+		}], require.resolve("@babel/plugin-transform-flow-strip-types"));
+	} else if (isTS(id)) plugins.push([require.resolve("@babel/plugin-transform-typescript"), {
+		isTSX: isJSX(id),
+		allowNamespaces: true
+	}]);
+	if (flags & TransformFlag.CODEGEN_REQUIRED) plugins.push([require.resolve("@react-native/babel-plugin-codegen")]);
+	const options = {
+		presets,
+		plugins
+	};
+	if (parserOpts) options.parserOpts = parserOpts;
+	return options;
+}
+//#endregion
+//#region src/utils/swc.ts
+function mergeSwcOptions(options) {
+	return options.reduce((acc, options) => (0, es_toolkit.mergeWith)(acc, options, merge$2), {});
+}
+function merge$2(target, source, key) {
+	if (key === "plugins") return [...target ?? [], ...source ?? []];
+}
+//#endregion
+//#region src/core/plugins/shared/filters.ts
+const ROLLDOWN_RUNTIME_EXCLUDE_FILTER = (0, _rollipop_rolldown_pluginutils.exclude)((0, _rollipop_rolldown_pluginutils.or)((0, _rollipop_rolldown_pluginutils.id)(/rolldown\/runtime/), (0, _rollipop_rolldown_pluginutils.id)(/@oxc-project\+runtime/)));
+//#endregion
+//#region src/core/plugins/swc-plugin.ts
+function swcPlugin({ useNativeTransformPipeline, runtimeTarget, transformConfig }) {
+	const { rules = [] } = transformConfig ?? {};
+	const swcOptionsById = /* @__PURE__ */ new Map();
+	const swcHelpersResolvePlugin = {
+		name: "rollipop:swc-helpers-resolve",
+		resolveId: {
+			order: "pre",
+			filter: [(0, _rollipop_rolldown_pluginutils.include)((0, _rollipop_rolldown_pluginutils.id)(/^@swc\/helpers/)), ROLLDOWN_RUNTIME_EXCLUDE_FILTER],
+			handler(source, _importer, extraOptions) {
+				return this.resolve(source, __dirname, extraOptions);
+			}
+		}
+	};
+	const swcRules = rules.map(({ filter, options }, index) => {
+		return {
+			name: `rollipop:swc-rule-${index}`,
+			transform: {
+				filter,
+				handler(code, id) {
+					const existingBabelOptions = swcOptionsById.get(id);
+					const resolvedOptions = typeof options === "function" ? options(code, id) : options;
+					existingBabelOptions ? existingBabelOptions.push(resolvedOptions) : swcOptionsById.set(id, [resolvedOptions]);
+				}
+			}
+		};
+	});
+	const getSwcPreset = useNativeTransformPipeline ? null : presets[runtimeTarget];
+	const swcPlugin = {
+		name: "rollipop:swc",
+		buildStart() {
+			swcOptionsById.clear();
+		},
+		transform: {
+			filter: [ROLLDOWN_RUNTIME_EXCLUDE_FILTER],
+			handler(code, id) {
+				if (getFlag(this, id) & TransformFlag.SKIP_ALL) return;
+				const swcOptions = swcOptionsById.get(id) ?? [];
+				if (getSwcPreset == null && swcOptions.length === 0) return;
+				const baseOptions = getSwcPreset != null ? [getSwcPreset(id)] : [];
+				const result = _swc_core.transformSync(code, {
+					filename: id,
+					configFile: false,
+					swcrc: false,
+					sourceMaps: true,
+					inputSourceMap: false,
+					...mergeSwcOptions([...baseOptions, ...swcOptions])
+				});
+				return {
+					code: result.code,
+					map: result.map
+				};
+			}
+		}
+	};
+	return [
+		swcHelpersResolvePlugin,
+		...swcRules,
+		swcPlugin
+	];
+}
+const presets = {
+	"hermes-v1": (id) => ({
+		env: {
+			targets: { node: 9999 },
+			include: [
+				"transform-block-scoping",
+				"transform-class-properties",
+				"transform-private-methods",
+				"transform-private-property-in-object"
+			]
+		},
+		jsc: {
+			parser: {
+				syntax: "typescript",
+				tsx: true
+			},
+			transform: { react: { runtime: "preserve" } },
+			externalHelpers: true
+		},
+		isModule: id.endsWith(".cjs") ? "commonjs" : true
+	}),
+	hermes: (id) => ({
+		jsc: {
+			parser: {
+				syntax: "typescript",
+				tsx: true
+			},
+			transform: { react: { runtime: "preserve" } },
+			externalHelpers: true,
+			keepClassNames: true,
+			loose: false,
+			assumptions: {
+				setPublicClassFields: true,
+				privateFieldsAsProperties: true
+			},
+			target: "es5"
+		},
+		isModule: id.endsWith(".cjs") ? "commonjs" : true
+	})
+};
+//#endregion
+//#region src/core/plugins/reporter-plugin.ts
+function reporterPlugin(options) {
+	const { reporter, initialTotalModules = 0 } = options ?? {};
+	let totalModules = initialTotalModules;
+	let startedAt = 0;
+	let transformedModules = 0;
+	let unknownTotalModules = totalModules === 0;
+	return {
+		name: "rollipop:status",
+		buildStart() {
+			startedAt = performance.now();
+			transformedModules = 0;
+			reporter?.update({ type: "bundle_build_started" });
+		},
+		buildEnd(error) {
+			const endedAt = performance.now();
+			if (transformedModules !== 0) totalModules = transformedModules;
+			unknownTotalModules = false;
+			reporter?.update(error == null ? {
+				type: "bundle_build_done",
+				totalModules,
+				duration: endedAt - startedAt
+			} : {
+				type: "bundle_build_failed",
+				error
+			});
+		},
+		transform: {
+			order: "post",
+			handler(_code, id) {
+				++transformedModules;
+				if (!unknownTotalModules && totalModules < transformedModules) totalModules = transformedModules;
+				reporter?.update({
+					type: "transform",
+					id,
+					totalModules: unknownTotalModules ? void 0 : totalModules,
+					transformedModules
+				});
+			}
+		},
+		watchChange(id) {
+			reporter?.update({
+				type: "watch_change",
+				id
+			});
+		}
+	};
+}
+//#endregion
+//#region src/core/plugins/dev-server-plugin.ts
+async function devServerPlugin(options) {
+	const { cwd, hmrClientPath, hmrConfig } = options;
+	if (hmrConfig == null) return null;
+	return [{
+		name: "rollipop:replace-hmr-client",
+		load: {
+			filter: [(0, _rollipop_rolldown_pluginutils.include)((0, _rollipop_rolldown_pluginutils.id)((0, _rollipop_rolldown_pluginutils.exactRegex)(resolveFrom(cwd, typeof hmrClientPath === "function" ? await hmrClientPath(cwd) : hmrClientPath))))],
+			handler(id) {
+				this.debug(`Replacing HMR client: ${id}`);
+				return {
+					code: hmrConfig.clientImplement,
+					moduleType: "ts"
+				};
+			}
+		}
+	}, (0, _rollipop_rolldown_experimental.rollipopReactRefreshWrapperPlugin)({
+		cwd,
+		include: [/\.[tj]sx?(?:$|\?)/],
+		exclude: [/\/node_modules\//]
+	})];
+}
+//#endregion
+//#region src/core/rolldown.ts
+resolveRolldownOptions.cache = /* @__PURE__ */ new Map();
+async function resolveRolldownOptions(context, config, buildOptions, devEngineOptions) {
+	const cachedOptions = resolveRolldownOptions.cache.get(context.id);
+	if (cachedOptions != null) return cachedOptions;
+	const { platform, dev, cache } = buildOptions;
+	const isDevServerMode = dev && context.buildType === "serve";
+	(0, es_toolkit.invariant)(isDevServerMode ? devEngineOptions != null : true, "devEngineOptions is required in dev server mode");
+	const env = loadEnv(config);
+	const builtInEnv = {
+		MODE: config.mode,
+		...isDevServerMode ? { BASE_URL: getBaseUrl(devEngineOptions.host, devEngineOptions.port, devEngineOptions.https) } : null
+	};
+	const hmrConfig = resolveHmrConfig(config);
+	const hmrEnabled = hmrConfig != null;
+	const { sourceExtensions, assetExtensions, preferNativePlatform, external: rolldownExternal, ...rolldownResolve } = config.resolver;
+	const { polyfills, banner: rolldownBanner, footer: rolldownFooter, postBanner: rolldownPostBanner, postFooter: rolldownPostFooter, intro: rolldownIntro, outro: rolldownOutro, shimMissingExports: rolldownShimMissingExports } = config.serializer;
+	const { flow: _flow, babel: _babel, swc: _swc, ...rolldownTransform } = config.transformer;
+	const { treeshake: rolldownTreeshake, minify: rolldownMinify, lazyBarrel: rolldownLazyBarrel, ...rolldownOptimization } = config.optimization;
+	const { globalIdentifiers: rolldownGlobalIdentifiers } = config.reactNative;
+	const { sourcemap: rolldownSourcemap, sourcemapBaseUrl: rolldownSourcemapBaseUrl, sourcemapDebugIds: rolldownSourcemapDebugIds, sourcemapIgnoreList: rolldownSourcemapIgnoreList, sourcemapPathTransform: rolldownSourcemapPathTransform } = config;
+	const userPlugins = config.plugins;
+	const mergedResolveOptions = (0, es_toolkit.merge)({ extensions: getResolveExtensions({
+		sourceExtensions,
+		assetExtensions,
+		platform,
+		preferNativePlatform
+	}) }, rolldownResolve);
+	const mergedTransformOptions = (0, es_toolkit.merge)({
+		cwd: config.root,
+		target: "esnext",
+		jsx: {
+			runtime: "automatic",
+			development: dev
+		},
+		define: {
+			__DEV__: asLiteral(dev),
+			"process.env.NODE_ENV": asLiteral(nodeEnvironment(dev)),
+			"process.env.DEBUG_ROLLIPOP": asLiteral(isDebugEnabled()),
+			...hmrEnabled ? null : { "import.meta.hot": "{}" },
+			...defineEnvFromObject(env),
+			...defineEnvFromObject(builtInEnv)
+		},
+		helpers: { mode: "Runtime" }
+	}, rolldownTransform);
+	const preludePluginOptions = resolvePreludePluginOptions(config);
+	const reactNativePluginOptions = await resolveReactNativePluginOptions(config, context, buildOptions);
+	const babelPluginOptions = resolveBabelPluginOptions(config);
+	const swcPluginOptions = resolveSwcPluginOptions(config);
+	const devServerPluginOptions = resolveDevServerPluginOptions(config, hmrConfig);
+	const reporterPluginOptions = resolveReporterPluginOptions(config, context, buildOptions);
+	const finalOptions = await applyDangerouslyOverrideOptionsFinalizer(config, {
+		platform: "neutral",
+		cwd: config.root,
+		input: config.entry,
+		tsconfig: config.tsconfig,
+		resolve: mergedResolveOptions,
+		transform: mergedTransformOptions,
+		treeshake: rolldownTreeshake,
+		external: rolldownExternal,
+		shimMissingExports: rolldownShimMissingExports,
+		optimization: rolldownOptimization,
+		experimental: {
+			lazyBarrel: rolldownLazyBarrel,
+			...isDevServerMode ? { devMode: hmrConfig ? { implement: hmrConfig.runtimeImplement } : false } : null
+		},
+		plugins: withTransformBoundary(context, [
+			preludePlugin(preludePluginOptions),
+			reactNativePlugin(reactNativePluginOptions),
+			jsonPlugin(),
+			babelPlugin(babelPluginOptions),
+			swcPlugin(swcPluginOptions),
+			devServerPlugin(devServerPluginOptions),
+			reporterPlugin(reporterPluginOptions),
+			userPlugins
+		]),
+		checks: {
+			eval: false,
+			pluginTimings: isDebugEnabled()
+		},
+		logLevel: isDebugEnabled() ? "debug" : "info",
+		onLog(level, log, defaultHandler) {
+			if (log.code?.startsWith("PLUGIN_")) printPluginLog(level, log, log.plugin);
+			else defaultHandler(level, log);
+		},
+		id: context.id
+	}, {
+		format: "esm",
+		file: buildOptions.outfile,
+		banner: rolldownBanner,
+		footer: rolldownFooter,
+		postFooter: rolldownPostFooter,
+		postBanner: rolldownPostBanner,
+		outro: rolldownOutro,
+		intro: async (chunk) => {
+			return [
+				...getGlobalVariables(dev, context.buildType),
+				...loadPolyfills(polyfills),
+				typeof rolldownIntro === "function" ? await rolldownIntro(chunk) : rolldownIntro
+			].filter(es_toolkit.isNotNil).join("\n");
+		},
+		minify: buildOptions.minify ?? rolldownMinify,
+		sourcemap: buildOptions.sourcemap ?? rolldownSourcemap,
+		sourcemapBaseUrl: rolldownSourcemapBaseUrl,
+		sourcemapDebugIds: rolldownSourcemapDebugIds,
+		sourcemapIgnoreList: rolldownSourcemapIgnoreList,
+		sourcemapPathTransform: rolldownSourcemapPathTransform ?? createProjectRootSourcemapPathTransform(config.root),
+		codeSplitting: false,
+		strictExecutionOrder: true,
+		globalIdentifiers: rolldownGlobalIdentifiers,
+		persistentCache: cache
+	});
+	resolveRolldownOptions.cache.set(context.id, finalOptions);
+	return finalOptions;
+}
+function resolvePreludePluginOptions(config) {
+	return { modulePaths: config.serializer.prelude };
+}
+async function resolveReactNativePluginOptions(config, context, buildOptions) {
+	return {
+		projectRoot: config.root,
+		platform: buildOptions.platform,
+		preferNativePlatform: config.resolver.preferNativePlatform,
+		buildType: context.buildType,
+		assetsDir: buildOptions.assetsDir,
+		assetExtensions: config.resolver.assetExtensions,
+		assetRegistryPath: await resolveAssetRegistryPath(config),
+		flowFilter: config.transformer.flow?.filter ?? [],
+		codegenFilter: config.reactNative.codegen?.filter ?? [],
+		builtinPluginConfig: resolveReactNativeBuiltinPluginConfig(config)
+	};
+}
+async function resolveAssetRegistryPath(config) {
+	const { assetRegistryPath } = config.reactNative;
+	const path = typeof assetRegistryPath === "function" ? await assetRegistryPath(config.root) : assetRegistryPath;
+	return resolveFrom(config.root, path);
+}
+function resolveReactNativeBuiltinPluginConfig(config) {
+	if (!config.experimental?.nativeTransformPipeline) return null;
+	return {
+		envName: config.mode,
+		runtimeTarget: resolveRuntimeTarget(config.runtimeTarget),
+		worklets: resolveWorkletsConfig(config),
+		plugins: []
+	};
+}
+function resolveWorkletsConfig(config) {
+	const { worklets } = config.experimental ?? {};
+	if (worklets == null) return;
+	return (0, es_toolkit.merge)({
+		isRelease: config.mode === "production",
+		pluginVersion: resolvePackageJson(config.root, "react-native-worklets")?.version
+	}, worklets);
+}
+function resolveBabelPluginOptions(config) {
+	return {
+		useNativeTransformPipeline: config.experimental?.nativeTransformPipeline,
+		transformConfig: config.transformer.babel
+	};
+}
+function resolveSwcPluginOptions(config) {
+	return {
+		useNativeTransformPipeline: config.experimental?.nativeTransformPipeline,
+		runtimeTarget: config.runtimeTarget,
+		transformConfig: config.transformer.swc
+	};
+}
+function resolveDevServerPluginOptions(config, hmrConfig) {
+	return {
+		cwd: config.root,
+		hmrClientPath: config.reactNative.hmrClientPath,
+		hmrConfig
+	};
+}
+function resolveReporterPluginOptions(config, context, buildOptions) {
+	const statusReporter = createStatusReporter(config, context, buildOptions);
+	return {
+		initialTotalModules: getBuildTotalModules(context.storage, context.id),
+		reporter: mergeReporters([statusReporter, config.reporter].filter(es_toolkit.isNotNil))
+	};
+}
+function createStatusReporter(config, context, buildOptions) {
+	switch (config.terminal.status) {
+		case "compat": return new CompatStatusReporter();
+		case "progress": return new ProgressBarStatusReporter(context.id, `[${buildOptions.platform}, ${buildOptions.dev ? "dev" : "prod"}]`, getBuildTotalModules(context.storage, context.id));
+	}
+}
+function getResolveExtensions({ platform, sourceExtensions, assetExtensions, preferNativePlatform }) {
+	const supportedExtensions = [...sourceExtensions, ...assetExtensions];
+	return [...[platform, preferNativePlatform ? "native" : null].filter(es_toolkit.isNotNil).map((platform) => {
+		return supportedExtensions.map((extension) => `.${platform}.${extension}`);
+	}), ...supportedExtensions.map((extension) => `.${extension}`)].flat();
+}
+/**
+* Default sourcemap path transform.
+*
+* Rolldown emits `sources` relative to the bundle output's directory, which
+* yields paths like `../App.tsx` when the bundle lives under e.g. `dist/`.
+* RN tooling (symbolication, devtools) expects project-root-relative paths,
+* so this rewrites each entry to be relative to `projectRoot`.
+*/
+function createProjectRootSourcemapPathTransform(projectRoot) {
+	return (source, sourcemapPath) => {
+		const absolute = node_path.default.resolve(node_path.default.dirname(sourcemapPath), source);
+		return node_path.default.relative(projectRoot, absolute);
+	};
+}
+function loadPolyfills(polyfills) {
+	return polyfills.map((polyfill) => {
+		if (typeof polyfill === "string") return node_fs.default.readFileSync(polyfill, "utf-8");
+		const path = "path" in polyfill ? polyfill.path : void 0;
+		const content = "code" in polyfill ? polyfill.code : node_fs.default.readFileSync(polyfill.path, "utf-8");
+		return polyfill.type === "iife" ? iife(content, path) : content;
+	});
+}
+async function applyDangerouslyOverrideOptionsFinalizer(config, inputOptions, outputOptions) {
+	const override = config.dangerously_overrideRolldownOptions;
+	if (override == null) return {
+		input: inputOptions,
+		output: outputOptions
+	};
+	return await applyOverrideRolldownOptions(override, {
+		input: inputOptions,
+		output: outputOptions
+	});
+}
+function getOverrideOptionsForDevServer(buildOptions) {
+	return {
+		input: {
+			transform: { jsx: { development: true } },
+			experimental: {
+				incrementalBuild: true,
+				nativeMagicString: true
+			},
+			treeshake: false
+		},
+		output: {
+			minify: buildOptions.minify ?? false,
+			sourcemap: buildOptions.sourcemap ?? true,
+			generatedCode: {
+				symbols: buildOptions.dev,
+				profilerNames: buildOptions.dev
+			}
+		}
+	};
+}
+//#endregion
+//#region src/core/bundler.ts
+var Bundler = class Bundler {
+	static async devEngine(config, buildOptions, devEngineOptions) {
+		const buildType = "serve";
+		const resolvedBuildOptions = resolveBuildOptions(config, buildOptions);
+		const context = Bundler.createContext(buildType, config, resolvedBuildOptions);
+		const { input = {}, output = {} } = await resolveRolldownOptions(context, config, resolvedBuildOptions, devEngineOptions);
+		const devServerOptions = getOverrideOptionsForDevServer(resolvedBuildOptions);
+		const devEngine = await (0, _rollipop_rolldown_experimental.dev)((0, es_toolkit.merge)(input, devServerOptions.input), (0, es_toolkit.merge)(output, devServerOptions.output), {
+			watch: config.watcher,
+			...devEngineOptions
+		});
+		Object.defineProperty(devEngine, "getContext", {
+			value: () => context,
+			enumerable: true,
+			configurable: false
+		});
+		return devEngine;
+	}
+	static createId(config, buildOptions) {
+		return createId(config, buildOptions);
+	}
+	static createContext(buildType, config, buildOptions) {
+		return {
+			id: Bundler.createId(config, buildOptions),
+			root: config.root,
+			storage: FileStorage.getInstance(config.root),
+			buildType,
+			state: { hmrUpdates: /* @__PURE__ */ new Set() }
+		};
+	}
+	constructor(config) {
+		this.config = config;
+		Logo.printOnce();
+	}
+	async build(buildOptions) {
+		const buildType = "build";
+		const resolvedBuildOptions = resolveBuildOptions(this.config, buildOptions);
+		const context = Bundler.createContext(buildType, this.config, resolvedBuildOptions);
+		const sourcemap = resolvedBuildOptions.sourcemap ? true : false;
+		const { input, output } = await resolveRolldownOptions(context, this.config, resolvedBuildOptions);
+		const rolldownBuildOptions = {
+			...input,
+			output: {
+				...output,
+				sourcemap
+			},
+			write: Boolean(resolvedBuildOptions.outfile)
+		};
+		const chunk = (await _rollipop_rolldown.build(rolldownBuildOptions)).output[0];
+		(0, es_toolkit.invariant)(chunk, "Bundled chunk is not found");
+		if (resolvedBuildOptions.outfile && chunk.sourcemapFileName && resolvedBuildOptions.sourcemapOutfile) {
+			const outputDir = node_path.default.dirname(resolvedBuildOptions.outfile);
+			const sourcemapDir = node_path.default.dirname(resolvedBuildOptions.sourcemapOutfile);
+			const sourcemapFile = node_path.default.join(outputDir, chunk.sourcemapFileName);
+			if (!node_fs.default.existsSync(sourcemapDir)) node_fs.default.mkdirSync(sourcemapDir, { recursive: true });
+			node_fs.default.renameSync(sourcemapFile, resolvedBuildOptions.sourcemapOutfile);
+		}
+		return chunk;
+	}
+};
+//#endregion
+//#region src/utils/run-build.ts
+async function runBuild(config, options) {
+	return await new Bundler(config).build(options);
+}
+//#endregion
+//#region src/utils/run-server.ts
+async function runServer(config, options) {
+	const { port, host } = options;
+	const devServer = await createDevServer(config, options);
+	await devServer.instance.listen({
+		port,
+		host
+	});
+	return devServer;
+}
+//#endregion
+//#region src/node/commands/start/action.ts
+const action$1 = async function(options) {
+	const cwd = process.cwd();
+	const config = await loadConfig({
+		cwd,
+		mode: "development",
+		configFile: options.config,
+		context: { command: "start" }
+	});
+	if (options.resetCache) {
+		resetCache(cwd);
+		logger$2.info("The transform cache was reset");
+	}
+	if (options.clientLogs === false) config.reporter = { update: es_toolkit.noop };
+	const devServer = await runServer(config, {
+		buildOptions: { cache: options.cache },
+		port: options.port,
+		host: options.host,
+		https: options.https,
+		key: options.key,
+		cert: options.cert
+	});
+	if (options.interactive) setupInteractiveMode({
+		devServer,
+		extraCommands: config.terminal?.extraCommands
+	});
+};
+//#endregion
+//#region src/node/commands/start/command.ts
+const command$1 = {
+	name: "start",
+	description: "Start the React Native development server.",
+	action: action$1,
+	options: [
+		{
+			name: "--config <string>",
+			description: "Path to the CLI configuration file",
+			parse: resolvePath
+		},
+		{
+			name: "--host <string>",
+			description: "Host to start the development server on",
+			default: DEFAULT_HOST
+		},
+		{
+			name: "--port <number>",
+			description: "Port to start the development server on",
+			default: DEFAULT_PORT,
+			parse: Number
+		},
+		{
+			name: "--reset-cache, --resetCache",
+			description: "Removes cached files"
+		},
+		{
+			name: "--https",
+			description: "Enables https connections to the server"
+		},
+		{
+			name: "--key <path>",
+			description: "Path to custom SSL key"
+		},
+		{
+			name: "--cert <path>",
+			description: "Path to custom SSL cert"
+		},
+		{
+			name: "--no-interactive",
+			description: "Disables interactive mode"
+		},
+		{
+			name: "--client-logs",
+			description: "[Deprecated] Enable plain text JavaScript log streaming for all connected apps. This feature is deprecated and will be removed in future.",
+			default: false
+		},
+		{
+			name: "--cache [boolean]",
+			description: "If false, the bundler will not load or store any cache",
+			parse: parseBoolean
+		},
+		{
+			name: "--projectRoot <path>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--watchFolders <list>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--assetPlugins <list>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--sourceExts <list>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--max-workers <number>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--transformer <string>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--custom-log-reporter-path, --customLogReporterPath <string>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		}
+	]
+};
+//#endregion
+//#region src/node/commands/bundle/action.ts
+const action = async function(options) {
+	if (!this.platforms.includes(options.platform)) throw new Error(`Unrecognized platform: ${options.platform}`);
+	const cwd = process.cwd();
+	const config = await loadConfig({
+		cwd,
+		mode: "production",
+		configFile: options.config,
+		context: { command: "bundle" }
+	});
+	if (options.resetCache) {
+		resetCache(cwd);
+		logger$2.info("The transform cache was reset");
+	}
+	if (options.entryFile) config.entry = options.entryFile;
+	await runBuild(config, {
+		platform: options.platform,
+		dev: options.dev,
+		minify: options.minify,
+		cache: options.cache,
+		outfile: options.bundleOutput,
+		sourcemapOutfile: options.sourcemapOutput,
+		assetsDir: options.assetsDest
+	});
+};
+//#endregion
+//#region src/node/commands/bundle/command.ts
+const command = {
+	name: "bundle",
+	description: "Build the bundle for the provided JavaScript entry file.",
+	action,
+	options: [
+		{
+			name: "--config <string>",
+			description: "Path to the CLI configuration file",
+			parse: resolvePath
+		},
+		{
+			name: "--entry-file <path>",
+			description: "Path to the root JS file, either absolute or relative to JS root"
+		},
+		{
+			name: "--platform <string>",
+			description: "Either \"ios\" or \"android\"",
+			default: "ios"
+		},
+		{
+			name: "--dev [boolean]",
+			description: "If false, warnings are disabled and the bundle is minified",
+			parse: parseBoolean
+		},
+		{
+			name: "--minify [boolean]",
+			description: "Allows overriding whether bundle is minified. This defaults to false if dev is true, and true if dev is false. Disabling minification can be useful for speeding up production builds for testing purposes.",
+			parse: parseBoolean
+		},
+		{
+			name: "--cache [boolean]",
+			description: "If false, the bundler will not load or store any cache",
+			parse: parseBoolean
+		},
+		{
+			name: "--bundle-output <string>",
+			description: "File name where to store the resulting bundle, ex. /tmp/groups.bundle",
+			required: true
+		},
+		{
+			name: "--sourcemap-output <string>",
+			description: "File name where to store the sourcemap file for resulting bundle, ex. /tmp/groups.map"
+		},
+		{
+			name: "--sourcemap-sources-root <string>",
+			description: `Path to make sourcemap's sources entries relative to, ex. /root/dir`
+		},
+		{
+			name: "--sourcemap-use-absolute-path",
+			description: "Report SourceMapURL using its full path"
+		},
+		{
+			name: "--assets-dest <string>",
+			description: "Directory name where to store assets referenced in the bundle"
+		},
+		{
+			name: "--reset-cache",
+			description: "Removes cached files",
+			default: false
+		},
+		{
+			name: "--transformer <string>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--bundle-encoding <string>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--max-workers <number>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--unstable-transform-profile <string>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--asset-catalog-dest [string]",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--read-global-cache",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		},
+		{
+			name: "--resolver-option <string...>",
+			description: UNSUPPORTED_OPTION_DESCRIPTION
+		}
+	]
+};
+//#endregion
+//#region src/commands.ts
+const commands = [createReactNativeCliCommand(command$1), createReactNativeCliCommand(command)];
+//#endregion
+module.exports = commands;