rollipop 1.0.0-alpha.31 → 1.0.0-alpha.33

package/dist/common/transformer.js

@@ -1,13 +1,40 @@
+import * as swc from "@swc/core";
 import transform from "fast-flow-transform";
 //#region src/common/transformer.ts
 async function stripFlowTypes(id, code) {
-	return await transform({
-		filename: id,
-		source: code,
-		sourcemap: true,
-		dialect: "flow",
-		format: "pretty"
-	});
+	try {
+		return await transform({
+			filename: id,
+			source: code,
+			sourcemap: true,
+			dialect: "flow",
+			format: "pretty"
+		});
+	} catch {
+		const result = swc.transformSync(code, {
+			filename: id,
+			configFile: false,
+			swcrc: false,
+			sourceMaps: true,
+			inputSourceMap: false,
+			jsc: {
+				target: "esnext",
+				parser: {
+					syntax: "flow",
+					all: true,
+					jsx: true,
+					enums: true,
+					components: true,
+					patternMatching: true
+				},
+				minify: { format: { comments: false } }
+			}
+		});
+		return {
+			code: result.code,
+			map: result.map ? JSON.parse(result.map) : void 0
+		};
+	}
 }
 //#endregion
 export { stripFlowTypes };

package/dist/config/defaults.js

@@ -1,8 +1,8 @@
 import { stripFlowTypes } from "../common/transformer.js";
-import { DEFAULT_ANALYZE_FILE, DEFAULT_ANALYZE_REPORT_FILE, DEFAULT_ASSET_EXTENSIONS, DEFAULT_ASSET_REGISTRY_PATH, DEFAULT_ENV_FILE, DEFAULT_ENV_PREFIX, DEFAULT_HMR_CLIENT_PATH, DEFAULT_RESOLVER_ALIAS_FIELDS, DEFAULT_RESOLVER_CONDITION_NAMES, DEFAULT_RESOLVER_MAIN_FIELDS, DEFAULT_RUNTIME_TARGET, DEFAULT_SOURCE_EXTENSIONS } from "../constants.js";
+import { DEFAULT_ANALYZE_FILE, DEFAULT_ANALYZE_REPORT_FILE, DEFAULT_ASSET_EXTENSIONS, DEFAULT_ENV_FILE, DEFAULT_ENV_PREFIX, DEFAULT_HMR_CLIENT_PATH, DEFAULT_RESOLVER_ALIAS_FIELDS, DEFAULT_RESOLVER_CONDITION_NAMES, DEFAULT_RESOLVER_MAIN_FIELDS, DEFAULT_RUNTIME_TARGET, DEFAULT_SOURCE_EXTENSIONS } from "../constants.js";
 import { ClientLogReporter } from "../events/builtin-reporters.js";
-import { getInitializeCorePath, getPolyfillScriptPaths } from "../internal/react-native.js";
 import { resolvePackagePath } from "../utils/node-resolve.js";
+import { resolveAssetRegistryPath, resolveInitializeCorePath, resolvePolyfillScriptPaths } from "../internal/react-native.js";
 import fs from "node:fs";
 //#region src/config/defaults.ts
 async function getDefaultConfig(projectRoot, mode) {
@@ -26,8 +26,8 @@ async function getDefaultConfig(projectRoot, mode) {
 			symlinks: true
 		},
 		transform: { swc: { native: { externalHelpers: true } } },
-		prelude: [getInitializeCorePath(projectRoot)],
-		polyfills: await Promise.all(getPolyfillScriptPaths(reactNativePath).map(async (path) => {
+		prelude: [resolveInitializeCorePath(projectRoot)],
+		polyfills: await Promise.all(resolvePolyfillScriptPaths(projectRoot, reactNativePath).map(async (path) => {
 			const code = fs.readFileSync(path, "utf-8");
 			return {
 				type: "iife",
@@ -38,7 +38,7 @@ async function getDefaultConfig(projectRoot, mode) {
 		treeshake: true,
 		reactNative: {
 			reactNativePath,
-			assetRegistryPath: DEFAULT_ASSET_REGISTRY_PATH,
+			assetRegistryPath: resolveAssetRegistryPath(projectRoot),
 			hmrClientPath: DEFAULT_HMR_CLIENT_PATH
 		},
 		dev: {

package/dist/config/types.d.ts

@@ -5,11 +5,11 @@ import "../core/plugins/index.js";
 import { InteractiveCommand } from "../node/commands/start/setup-interactive-mode.js";
 import "../node/cli-utils.js";
 import { Plugin } from "../core/plugins/types.js";
+import * as swc from "@swc/core";
 import { DevWatchOptions, RollipopReactNativeFlowConfig, RollipopReactNativeSwcConfig, RollipopReactNativeWorkletsConfig } from "@rollipop/rolldown/experimental";
 import * as rolldown from "@rollipop/rolldown";
 import { TopLevelFilterExpression } from "@rollipop/rolldown/filter";
 import * as babel from "@babel/core";
-import * as swc from "@swc/core";
 //#region src/config/types.d.ts
 type RolldownExperimentalOptions = NonNullable<rolldown.InputOptions['experimental']>;
 type RolldownTransformOptions = NonNullable<rolldown.InputOptions['transform']>;
@@ -267,7 +267,8 @@ export interface ReactNativeConfig {
   /**
    * Path to asset registry file.
    *
-   * Defaults to: `react-native/Libraries/Image/AssetRegistry.js`
+   * Defaults to: `react-native/asset-registry`,
+   * with the legacy `react-native/Libraries/Image/AssetRegistry.js` path as a fallback.
    */
   assetRegistryPath?: string | ((root: string) => MaybePromise<string>);
   /**

package/dist/constants.js

@@ -20,7 +20,7 @@ var constants_exports = /* @__PURE__ */ __exportAll({
 	ROLLIPOP_VIRTUAL_ENTRY_ID: () => ROLLIPOP_VIRTUAL_ENTRY_ID,
 	ROLLIPOP_VIRTUAL_PREFIX: () => ROLLIPOP_VIRTUAL_PREFIX
 });
-const ROLLIPOP_VERSION = "1.0.0-alpha.31";
+const ROLLIPOP_VERSION = "1.0.0-alpha.33";
 const ROLLIPOP_VIRTUAL_PREFIX = "\0rollipop/";
 const ROLLIPOP_VIRTUAL_BOOTSTRAP_ID = `${ROLLIPOP_VIRTUAL_PREFIX}bootstrap`;
 const ROLLIPOP_VIRTUAL_ENTRY_ID = `${ROLLIPOP_VIRTUAL_PREFIX}entry`;

package/dist/core/bundler.js

@@ -3,6 +3,7 @@ import { EventBus } from "../events/event-bus.js";
 import { FileStorage } from "../storage/file-storage.js";
 import { resolveBuildOptions } from "../utils/build-options.js";
 import { createId } from "../utils/id.js";
+import { replaceSourceMappingUrl } from "../utils/source-map.js";
 import { resolveRolldownOptions } from "./rolldown.js";
 import fs from "node:fs";
 import path from "node:path";
@@ -81,6 +82,18 @@ var Bundler = class Bundler {
 			const sourcemapFile = path.join(outputDir, chunk.sourcemapFileName);
 			if (!fs.existsSync(sourcemapDir)) fs.mkdirSync(sourcemapDir, { recursive: true });
 			fs.renameSync(sourcemapFile, resolvedBuildOptions.sourcemapOutfile);
+			const sourcemapFileName = path.relative(outputDir, resolvedBuildOptions.sourcemapOutfile).split(path.sep).join("/");
+			let code = chunk.code;
+			if (output.sourcemap !== "hidden") {
+				const sourceMapUrl = sourcemapFileName.split("/").map(encodeURIComponent).join("/");
+				code = replaceSourceMappingUrl(code, output.sourcemapBaseUrl ? new URL(sourceMapUrl, output.sourcemapBaseUrl).href : sourceMapUrl);
+				fs.writeFileSync(resolvedBuildOptions.outfile, code);
+			}
+			return {
+				...chunk,
+				code,
+				sourcemapFileName
+			};
 		}
 		return chunk;
 	}

package/dist/core/env.js

@@ -10,6 +10,7 @@ function loadEnv(options) {
 	invariant(envPrefix.length > 0, "`envPrefix` is required");
 	invariant(envFile.length > 0, "`envFile` is required");
 	const env = {};
+	const parsed = {};
 	const envFilesToLoad = [
 		envFile,
 		`${envFile}.local`,
@@ -20,15 +21,18 @@ function loadEnv(options) {
 		const envPath = path.resolve(envDir, file);
 		if (!fs.existsSync(envPath)) continue;
 		logger.trace(`Loading environment variables from ${envPath}`);
-		const parsed = dotenv.parse(fs.readFileSync(envPath, "utf-8"));
-		const expanded = dotenvExpand.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;
-		});
+		Object.assign(parsed, dotenv.parse(fs.readFileSync(envPath, "utf-8")));
 	}
+	const processEnv = {};
+	for (const [key, value] of Object.entries(process.env)) if (value !== void 0) {
+		processEnv[key] = value;
+		if (key in parsed) parsed[key] = value;
+	}
+	const expanded = dotenvExpand.expand({
+		parsed,
+		processEnv
+	});
+	for (const [key, value] of Object.entries(expanded.parsed ?? {})) if (key.startsWith(envPrefix)) env[key] = process.env[key] ?? value;
 	logger.trace("Loaded environment variables:", env);
 	return env;
 }

package/dist/core/plugins/react-native-plugin.d.ts

@@ -5,6 +5,7 @@ import * as rolldown from "@rollipop/rolldown";
 export interface ReactNativePluginOptions {
   context: BundlerContext;
   projectRoot: string;
+  reactNativePath: string;
   platform: string;
   preferNativePlatform: boolean;
   buildType: BuildType;

package/dist/core/plugins/react-native-plugin.js

@@ -1,10 +1,32 @@
 import { copyAssetsToDestination, generateAssetRegistryCode, resolveScaledAssets } from "../assets.js";
 import { setFlag } from "./utils/transform-utils.js";
+import path from "node:path";
 import { rollipopReactNativePlugin } from "@rollipop/rolldown/experimental";
 import { id, include } from "@rollipop/rolldown/filter";
 //#region src/core/plugins/react-native-plugin.ts
 function reactNativePlugin(options) {
-	const { projectRoot, platform, preferNativePlatform, buildType, context, assetsDir, assetExtensions, assetRegistryPath, builtinPluginConfig } = options;
+	const { projectRoot, reactNativePath, platform, preferNativePlatform, buildType, context, assetsDir, assetExtensions, assetRegistryPath, builtinPluginConfig } = options;
+	const privateModulePlugin = {
+		name: "rollipop:react-native-private-module",
+		resolveId: {
+			order: "post",
+			filter: [include(id(new RegExp(`^react-native/src/private/`)))],
+			async handler(source, importer, extraOptions) {
+				const resolved = await this.resolve(source, importer, {
+					...extraOptions,
+					skipSelf: true
+				});
+				if (resolved != null) return resolved;
+				const candidate = path.resolve(reactNativePath, source.slice(13));
+				const relativeCandidate = path.relative(reactNativePath, candidate);
+				if (relativeCandidate.startsWith("..") || path.isAbsolute(relativeCandidate)) return null;
+				return this.resolve(candidate, importer, {
+					...extraOptions,
+					skipSelf: true
+				});
+			}
+		}
+	};
 	const assets = [];
 	const assetPlugin = {
 		name: "rollipop:react-native-asset",
@@ -42,7 +64,11 @@ function reactNativePlugin(options) {
 			}
 		}
 	};
-	return [rollipopReactNativePlugin(builtinPluginConfig), assetPlugin];
+	return [
+		privateModulePlugin,
+		rollipopReactNativePlugin(builtinPluginConfig),
+		assetPlugin
+	];
 }
 //#endregion
 export { reactNativePlugin as reactNative };

package/dist/core/plugins/swc-plugin.js

@@ -1,9 +1,9 @@
 import { getFlag } from "./utils/transform-utils.js";
 import { ROLLDOWN_RUNTIME_EXCLUDE_FILTER, withRuntimeExclude } from "./shared/filters.js";
 import { mergeSwcOptions } from "../../utils/swc.js";
+import * as swc from "@swc/core";
 import { partition } from "es-toolkit";
 import { id, include } from "@rollipop/rolldown/filter";
-import * as swc from "@swc/core";
 //#region src/core/plugins/swc-plugin.ts
 function swcPlugin({ context, transformConfig }) {
 	const { rules = [] } = transformConfig ?? {};

package/dist/core/rolldown.js

@@ -2,8 +2,8 @@ import { ROLLIPOP_VIRTUAL_ENTRY_ID } from "../constants.js";
 import { isDebugEnabled } from "../common/env.js";
 import { CompatStatusReporter, ProgressBarStatusReporter } from "../events/builtin-reporters.js";
 import { asLiteral, iife, nodeEnvironment } from "../common/code.js";
-import { getGlobalVariables } from "../internal/react-native.js";
 import { resolveFrom, resolvePackageJson } from "../utils/node-resolve.js";
+import { getGlobalVariables } from "../internal/react-native.js";
 import { printPluginLog } from "./plugins/context.js";
 import { applyRolldownOptionsConfig } from "../config/compose-override.js";
 import { createVirtualModuleId, escapeVirtualModuleId } from "../utils/id.js";
@@ -200,6 +200,7 @@ async function resolveReactNativePluginOptions(config, context, buildOptions) {
 	return {
 		context,
 		projectRoot: config.root,
+		reactNativePath: config.reactNative.reactNativePath,
 		platform: buildOptions.platform,
 		preferNativePlatform: config.resolve.preferNativePlatform,
 		buildType: context.buildType,

package/dist/hmr-runtime.iife.js

@@ -261,6 +261,14 @@ var __rolldown_runtime__ = (function() {
 		} });
 		if (t) _set_prototype_of(e, t);
 	}
+	function _is_native_reflect_construct() {
+		try {
+			var e = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+		} catch (e) {}
+		return (_is_native_reflect_construct = function() {
+			return !!e;
+		})();
+	}
 	function _iterable_to_array(e) {
 		if (typeof Symbol !== "undefined" && e[Symbol.iterator] != null || e["@@iterator"] != null) return Array.from(e);
 	}
@@ -289,10 +297,10 @@ var __rolldown_runtime__ = (function() {
 		return n;
 	}
 	function _non_iterable_rest() {
-		throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+		throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 	}
 	function _non_iterable_spread() {
-		throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+		throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 	}
 	function _possible_constructor_return(e, t) {
 		if (t && (_type_of(t) === "object" || typeof t === "function")) return t;
@@ -311,26 +319,6 @@ var __rolldown_runtime__ = (function() {
 	function _to_consumable_array(e) {
 		return _array_without_holes(e) || _iterable_to_array(e) || _unsupported_iterable_to_array(e) || _non_iterable_spread();
 	}
-	function _type_of(e) {
-		"@swc/helpers - typeof";
-		return e && typeof Symbol !== "undefined" && e.constructor === Symbol ? "symbol" : typeof e;
-	}
-	function _unsupported_iterable_to_array(e, t) {
-		if (!e) return;
-		if (typeof e === "string") return _array_like_to_array(e, t);
-		var r = Object.prototype.toString.call(e).slice(8, -1);
-		if (r === "Object" && e.constructor) r = e.constructor.name;
-		if (r === "Map" || r === "Set") return Array.from(r);
-		if (r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)) return _array_like_to_array(e, t);
-	}
-	function _is_native_reflect_construct() {
-		try {
-			var e = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-		} catch (e) {}
-		return (_is_native_reflect_construct = function() {
-			return !!e;
-		})();
-	}
 	function _ts_generator(e, t) {
 		var r, n, o, a = {
 			label: 0,
@@ -411,6 +399,18 @@ var __rolldown_runtime__ = (function() {
 			};
 		}
 	}
+	function _type_of(e) {
+		"@swc/helpers - typeof";
+		return e && typeof Symbol !== "undefined" && e.constructor === Symbol ? "symbol" : typeof e;
+	}
+	function _unsupported_iterable_to_array(e, t) {
+		if (!e) return;
+		if (typeof e === "string") return _array_like_to_array(e, t);
+		var r = Object.prototype.toString.call(e).slice(8, -1);
+		if (r === "Object" && e.constructor) r = e.constructor.name;
+		if (r === "Map" || r === "Set") return Array.from(r);
+		if (r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)) return _array_like_to_array(e, t);
+	}
 	var _globalThis;
 	var ___rollipop_runtime__;
 	var BaseDevRuntime = DevRuntime;
@@ -616,14 +616,14 @@ var __rolldown_runtime__ = (function() {
 		]);
 		return e;
 	}();
-	var ReactNativeDevRuntime = /*#__PURE__*/ function(BaseDevRuntime1) {
+	var ReactNativeDevRuntime = /*#__PURE__*/ function(BaseDevRuntime) {
 		"use strict";
-		_inherits(ReactNativeDevRuntime1, BaseDevRuntime1);
-		function ReactNativeDevRuntime1() {
-			_class_call_check(this, ReactNativeDevRuntime1);
+		_inherits(ReactNativeDevRuntime, BaseDevRuntime);
+		function ReactNativeDevRuntime() {
+			_class_call_check(this, ReactNativeDevRuntime);
 			var e;
 			var t = new SocketHolder();
-			e = _call_super(this, ReactNativeDevRuntime1, [createClientId()]), e.moduleHotContexts = /* @__PURE__ */ new Map(), e.moduleHotContextsToBeUpdated = /* @__PURE__ */ new Map(), e.moduleHotData = /* @__PURE__ */ new Map(), e.applyQueue = Promise.resolve(), e.updatesEnabled = Promise.resolve(), e.reloadRequested = false, e.lastSeq = 0;
+			e = _call_super(this, ReactNativeDevRuntime, [createClientId()]), e.moduleHotContexts = /* @__PURE__ */ new Map(), e.moduleHotContextsToBeUpdated = /* @__PURE__ */ new Map(), e.moduleHotData = /* @__PURE__ */ new Map(), e.applyQueue = Promise.resolve(), e.updatesEnabled = Promise.resolve(), e.reloadRequested = false, e.lastSeq = 0;
 			e.socketHolder = t;
 			e.hooks = {
 				createModuleHotContext: function t(t) {
@@ -635,7 +635,7 @@ var __rolldown_runtime__ = (function() {
 			};
 			return e;
 		}
-		_create_class(ReactNativeDevRuntime1, [
+		_create_class(ReactNativeDevRuntime, [
 			{
 				key: "createHotContext",
 				value: function e(e) {
@@ -1025,7 +1025,7 @@ var __rolldown_runtime__ = (function() {
 				}
 			}
 		]);
-		return ReactNativeDevRuntime1;
+		return ReactNativeDevRuntime;
 	}(BaseDevRuntime);
 	function createClientId() {
 		return "".concat(Date.now().toString(36), "-").concat(Math.random().toString(36).slice(2));

package/dist/internal/react-native.js

@@ -1,14 +1,45 @@
-import { __require } from "../_virtual/_rolldown/runtime.js";
 import { asLiteral } from "../common/code.js";
+import { resolvePackagePath } from "../utils/node-resolve.js";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { isNotNil } from "es-toolkit";
 //#region src/internal/react-native.ts
-function getInitializeCorePath(basePath) {
-	return __require.resolve("react-native/Libraries/Core/InitializeCore", { paths: [basePath] });
+const ASSET_REGISTRY_PATH = "react-native/asset-registry";
+const LEGACY_ASSET_REGISTRY_PATH = "react-native/Libraries/Image/AssetRegistry.js";
+const require = createRequire(import.meta.url);
+function resolveInitializeCorePath(basePath) {
+	return resolveOptional("react-native/setup-env", [basePath]) ?? require.resolve("react-native/Libraries/Core/InitializeCore", { paths: [basePath] });
 }
-function getPolyfillScriptPaths(reactNativePath) {
-	const scriptPath = path.join(reactNativePath, "rn-get-polyfills");
-	return __require(scriptPath)();
+function resolveAssetRegistryPath(basePath) {
+	return resolveOptional(ASSET_REGISTRY_PATH, [basePath]) ? ASSET_REGISTRY_PATH : LEGACY_ASSET_REGISTRY_PATH;
+}
+function resolvePolyfillScriptPaths(basePath, reactNativePath) {
+	const polyfillPath = resolveOptional("@react-native/js-polyfills", [reactNativePath, basePath]);
+	if (polyfillPath) return loadPolyfillScriptPaths(polyfillPath);
+	let metroConfigPath;
+	try {
+		metroConfigPath = resolvePackagePath(basePath, "@react-native/metro-config");
+	} catch {}
+	if (metroConfigPath) {
+		const requireFromMetroConfig = createRequire(path.join(metroConfigPath, "package.json"));
+		const metroPolyfillPath = resolveOptionalWith(() => requireFromMetroConfig.resolve("@react-native/js-polyfills"));
+		if (metroPolyfillPath) return loadPolyfillScriptPaths(metroPolyfillPath, requireFromMetroConfig);
+	}
+	return loadPolyfillScriptPaths(require.resolve(path.join(reactNativePath, "rn-get-polyfills")));
+}
+function loadPolyfillScriptPaths(modulePath, load = require) {
+	return load(modulePath)();
+}
+function resolveOptional(moduleId, paths) {
+	return resolveOptionalWith(() => require.resolve(moduleId, { paths }));
+}
+function resolveOptionalWith(resolve) {
+	try {
+		return resolve();
+	} catch (error) {
+		if (error instanceof Error && "code" in error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED")) return;
+		throw error;
+	}
 }
 function getGlobalVariables(dev) {
 	return [
@@ -20,4 +51,4 @@ function getGlobalVariables(dev) {
 	].filter(isNotNil);
 }
 //#endregion
-export { getGlobalVariables, getInitializeCorePath, getPolyfillScriptPaths };
+export { getGlobalVariables, resolveAssetRegistryPath, resolveInitializeCorePath, resolvePolyfillScriptPaths };

package/dist/node/commands/bundle/command.js

@@ -25,12 +25,12 @@ const command = {
 		},
 		{
 			name: "--dev [boolean]",
-			description: "If false, warnings are disabled and the bundle is minified",
+			description: "Build in development mode. Defaults to whether config.mode is development",
 			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.",
+			description: "Override output.minify from the configuration. Defaults to false when not configured, regardless of --dev.",
 			parse: parseBoolean
 		},
 		{

package/dist/package.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "1.0.0-alpha.31";
+var version = "1.0.0-alpha.33";
 //#endregion
 export { version };

package/dist/server/bundler-pool.js

@@ -1,7 +1,7 @@
 import { resolveBuildOptions } from "../utils/build-options.js";
+import { replaceSourceMappingUrl } from "../utils/source-map.js";
 import { bindReporter } from "../utils/config.js";
 import { getBaseUrl } from "../utils/server.js";
-import { replaceSourceMappingUrl } from "../utils/source-map.js";
 import { Bundler } from "../core/bundler.js";
 import { logger } from "./logger.js";
 import { getBaseBundleName } from "../utils/bundle.js";

package/dist/server/create-dev-server.js

@@ -17,6 +17,7 @@ import { DevServerState } from "./state/store.js";
 import { getWebSocketUpgradeHandler } from "./wss/server.js";
 import { HMRServer } from "./wss/hmr-server.js";
 import url from "node:url";
+import { format } from "node:util";
 import { createDevServerMiddleware } from "@react-native-community/cli-server-api";
 import { createDevMiddleware } from "@react-native/dev-middleware";
 import Fastify, { LogController } from "fastify";
@@ -61,10 +62,14 @@ async function createDevServer(config, options) {
 		logger: {
 			info(...args) {
 				if (args[0].includes("JavaScript logs have moved")) return;
-				logger.info(...args);
+				logger.info(format(...args));
 			},
-			warn: logger.warn.bind(logger),
-			error: logger.error.bind(logger)
+			warn(...args) {
+				logger.warn(format(...args));
+			},
+			error(...args) {
+				logger.error(format(...args));
+			}
 		},
 		unstable_experiments: {
 			enableNetworkInspector: true,
@@ -121,7 +126,7 @@ async function createDevServer(config, options) {
 		middlewares: { use: fastify.use.bind(fastify) }
 	};
 	const { invokePostConfigureServer } = await invokeConfigureServer(devServer, config.plugins ?? []);
-	const devframeMiddleware = await setupDevframe(context, devServer);
+	const devframeMiddleware = await setupDevframe(context, devServer, websocketEndpoints["/inspector/device"]);
 	fastify.use(requestLogger).use(devframeMiddleware).use(communityMiddleware).use(devMiddleware).register(plugin, { context }).register(plugin$3, { hotUpdateStore: bundlerPool.hotUpdateStore }).register(plugin$4, { context }).register(plugin$2, { context }).register(plugin$1, { context });
 	fastify.setErrorHandler(errorHandler);
 	const upgradeHandler = getWebSocketUpgradeHandler({

package/dist/server/devframe/index.js

@@ -4,27 +4,23 @@ import { parseUrl } from "../../utils/url.js";
 import { symbolicate } from "../symbolicate.js";
 import { toDevframeEvent } from "./events.js";
 import { registerAgentTools } from "./agent/tools/index.js";
-import { getBuildSummary, getBundlers, getConfigInfo, getDevice, getFeatureFlags, getProjectInfo, getSnapshot } from "./data.js";
+import { getConfigInfo, getDevice, getFeatureFlags, getSnapshot } from "./data.js";
 import { defineDevframe, defineRpcFunction } from "devframe";
 //#region src/server/devframe/index.ts
 const ROLLIPOP_DEVFRAME_SCOPE = "rollipop";
-const DASHBOARD_SHARED_STATE_KEY = "dashboard";
+const DASHBOARD_EVENTS_STATE_KEY = "events";
 var RollipopDevframeController = class {
 	context;
 	sequence = 0;
-	lastEvent = null;
-	updateSharedState;
+	updateEventState;
 	unsubscribeEventBus;
-	refreshQueue;
 	definition;
 	constructor(context, agentToolContext) {
 		this.context = context;
-		const initialState = createInitialDashboardState(context);
-		this.refreshQueue = Promise.resolve(initialState);
 		this.definition = defineDevframe({
 			id: "rollipop",
 			name: "Rollipop",
-			version: "1.0.0-alpha.31",
+			version: "1.0.0-alpha.33",
 			packageName: "rollipop",
 			homepage: "https://github.com/rollipop-dev/rollipop",
 			description: "React Native development dashboard powered by Rollipop.",
@@ -34,13 +30,10 @@ var RollipopDevframeController = class {
 			},
 			setup: async (devframeContext) => {
 				const scope = devframeContext.scope(ROLLIPOP_DEVFRAME_SCOPE);
-				const sharedState = await scope.rpc.sharedState(DASHBOARD_SHARED_STATE_KEY, { initialValue: initialState });
-				this.updateSharedState = (state) => {
+				const sharedState = await scope.rpc.sharedState(DASHBOARD_EVENTS_STATE_KEY, { initialValue: { lastEvent: null } });
+				this.updateEventState = (event) => {
 					sharedState.mutate((current) => {
-						current.snapshot = state.snapshot;
-						current.builds = state.builds;
-						current.featureFlags = state.featureFlags;
-						current.lastEvent = state.lastEvent;
+						current.lastEvent = event;
 					});
 				};
 				registerDashboardRpcFunctions(scope.rpc, this);
@@ -48,26 +41,19 @@ var RollipopDevframeController = class {
 				this.unsubscribeEventBus = context.eventBus.subscribe((event) => {
 					const data = toDevframeEvent(event);
 					if (data == null) return;
-					this.lastEvent = {
-						sequence: ++this.sequence,
-						data
-					};
-					this.refresh();
+					this.notify(data);
 				});
 			}
 		});
 	}
-	async refresh() {
-		const lastEvent = this.lastEvent;
-		this.refreshQueue = this.refreshQueue.catch(() => createInitialDashboardState(this.context)).then(async () => {
-			const state = await this.readDashboardState(lastEvent);
-			this.updateSharedState?.(state);
-			return state;
+	notify(data) {
+		this.updateEventState?.({
+			sequence: ++this.sequence,
+			data
 		});
-		return this.refreshQueue;
 	}
-	async getSnapshot() {
-		return (await this.refresh()).snapshot;
+	getSnapshot() {
+		return getSnapshot(this.context);
 	}
 	getBuilds() {
 		return this.context.state.getBuilds();
@@ -78,9 +64,8 @@ var RollipopDevframeController = class {
 		if (this.context.bundlerPool.getInstanceById(bundlerId) == null) throw new Error(`Build logs not found: ${bundlerId}`);
 		return [];
 	}
-	async deleteBuildLogs(bundlerId) {
+	deleteBuildLogs(bundlerId) {
 		if (!this.context.state.clearBuildLogs(bundlerId) && this.context.bundlerPool.getInstanceById(bundlerId) == null) throw new Error(`Build logs not found: ${bundlerId}`);
-		await this.refresh();
 	}
 	getConfig() {
 		return getConfigInfo(this.context);
@@ -111,33 +96,21 @@ var RollipopDevframeController = class {
 		if (bundler == null) throw new Error(`Bundler not found: ${bundlerId}`);
 		setTimeout(() => this.context.message.broadcast("reload"), 0);
 		await bundler.triggerFullBuild();
-		await this.refresh();
 	}
-	async reload() {
+	reload() {
 		this.context.message.broadcast("reload");
-		await this.refresh();
 	}
 	async resetCache() {
 		await resetCache();
 		this.context.eventBus.emit({ type: "cache_reset" });
-		await this.refresh();
 	}
-	async resetBundlerState() {
+	resetBundlerState() {
 		this.context.state.resetBufferedState();
-		await this.refresh();
 	}
 	dispose() {
 		this.unsubscribeEventBus?.();
 		this.unsubscribeEventBus = void 0;
 	}
-	async readDashboardState(lastEvent) {
-		return {
-			snapshot: await getSnapshot(this.context),
-			builds: this.context.state.getBuilds(),
-			featureFlags: getFeatureFlags(this.context),
-			lastEvent
-		};
-	}
 };
 function registerDashboardRpcFunctions(rpc, controller) {
 	rpc.register(defineRpcFunction({
@@ -201,18 +174,5 @@ function registerDashboardRpcFunctions(rpc, controller) {
 		handler: () => controller.resetBundlerState()
 	}));
 }
-function createInitialDashboardState(context) {
-	return {
-		snapshot: {
-			project: getProjectInfo(context),
-			bundlers: getBundlers(context),
-			devices: [],
-			buildSummary: getBuildSummary(context)
-		},
-		builds: context.state.getBuilds(),
-		featureFlags: getFeatureFlags(context),
-		lastEvent: null
-	};
-}
 //#endregion
-export { DASHBOARD_SHARED_STATE_KEY, ROLLIPOP_DEVFRAME_SCOPE, RollipopDevframeController };
+export { DASHBOARD_EVENTS_STATE_KEY, ROLLIPOP_DEVFRAME_SCOPE, RollipopDevframeController };

package/dist/server/devframe/setup.js

@@ -11,12 +11,12 @@ const DEVFRAME_NAME = "Rollipop";
 const ROLLIPOP_DEVFRAME_BASE = "/__rollipop/";
 const ROLLIPOP_DEVFRAME_SSE_ROUTE = "__sse";
 const ROLLIPOP_DEVFRAME_MCP_PATH = "__mcp";
-async function setupDevframe(context, server) {
+async function setupDevframe(context, server, inspectorDeviceServer) {
 	const mcpEnabled = isAgenticInstalled();
 	const controller = new RollipopDevframeController(context, createAgentToolContext(context));
 	const devtools = initHub({
 		name: DEVFRAME_NAME,
-		version: "1.0.0-alpha.31",
+		version: "1.0.0-alpha.33",
 		base: ROLLIPOP_DEVFRAME_BASE,
 		cwd: context.config.root,
 		ui: createUi({
@@ -44,14 +44,22 @@ async function setupDevframe(context, server) {
 		}
 	});
 	await devtools.ready;
+	const notifyDevicesChanged = () => {
+		controller.notify({ type: "devices_changed" });
+	};
+	const onDeviceConnection = (socket) => {
+		socket.once("close", notifyDevicesChanged);
+	};
+	inspectorDeviceServer?.on("connection", onDeviceConnection);
 	server.instance.addHook("onListen", () => {
 		if (mcpEnabled) {
 			const mcpUrl = getServerDisplayUrl(server.instance.listeningOrigin, "/__rollipop/__mcp");
 			logger.info(`MCP server listening at ${mcpUrl}`);
 		}
-		controller.refresh();
 	});
 	server.instance.addHook("preClose", async () => {
+		inspectorDeviceServer?.off("connection", onDeviceConnection);
+		for (const socket of inspectorDeviceServer?.clients ?? []) socket.off("close", notifyDevicesChanged);
 		controller.dispose();
 		await devtools.close();
 	});

package/dist/server/middlewares/serve-assets.js

@@ -16,20 +16,34 @@ const queryParamSchema = asConst({
 });
 const plugin = fp((fastify, options) => {
 	const { context } = options;
-	function resolveAsset(asset) {
-		return path.resolve(context.config.root, asset);
-	}
+	const projectRoot = path.resolve(context.config.root);
+	const workspaceRoot = findWorkspaceRoot(projectRoot);
+	const assetExtensions = new Set(context.config.resolve.assetExtensions);
 	fastify.get(`/${DEV_SERVER_ASSET_PATH}/*`, {
 		schema: { querystring: queryParamSchema },
 		async handler(request, reply) {
 			const { params, query } = request;
-			const assetPath = resolveAsset(params["*"]);
+			const assetPath = path.resolve(projectRoot, params["*"]);
+			if (!assetExtensions.has(path.extname(assetPath).slice(1))) {
+				await reply.status(403).send();
+				return;
+			}
 			try {
+				const realWorkspaceRoot = await fs.promises.realpath(workspaceRoot);
+				if (!isWithin(realWorkspaceRoot, await fs.promises.realpath(path.dirname(assetPath)))) {
+					await reply.status(403).send();
+					return;
+				}
 				const resolvedAssetPath = resolveAssetPath(assetPath, {
 					platform: query.platform,
 					preferNativePlatform: context.config.resolve.preferNativePlatform
 				});
-				const [assetData, { size }] = await Promise.all([fs.promises.readFile(resolvedAssetPath), fs.promises.stat(resolvedAssetPath)]);
+				const realAssetPath = await fs.promises.realpath(resolvedAssetPath);
+				if (!isWithin(realWorkspaceRoot, realAssetPath)) {
+					await reply.status(403).send();
+					return;
+				}
+				const [assetData, { size }] = await Promise.all([fs.promises.readFile(realAssetPath), fs.promises.stat(realAssetPath)]);
 				await reply.header("Content-Type", mime.getType(resolvedAssetPath) ?? "").header("Content-Length", size).send(assetData);
 			} catch (error) {
 				fastify.log.error(error, "Failed to serve asset");
@@ -38,5 +52,19 @@ const plugin = fp((fastify, options) => {
 		}
 	});
 }, { name: "serve-assets" });
+function isWithin(root, file) {
+	const relative = path.relative(root, file);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function findWorkspaceRoot(projectRoot) {
+	let directory = projectRoot;
+	while (true) {
+		const packageJson = path.join(directory, "package.json");
+		if (fs.existsSync(path.join(directory, "pnpm-workspace.yaml")) || fs.existsSync(packageJson) && JSON.parse(fs.readFileSync(packageJson, "utf-8")).workspaces) return directory;
+		const parent = path.dirname(directory);
+		if (parent === directory) return projectRoot;
+		directory = parent;
+	}
+}
 //#endregion
 export { plugin as serveAssets };

package/dist/storage/file-storage.js

@@ -28,7 +28,7 @@ var FileStorage = class FileStorage {
 		this.dataFilePath = path.join(FileStorage.getPath(basePath, { prepare: true }), DATA_FILENAME);
 		if (fs.existsSync(this.dataFilePath)) {
 			const loadedData = JSON.parse(fs.readFileSync(this.dataFilePath, "utf-8"));
-			if ("version" in loadedData && loadedData.version === "1.0.0-alpha.31") this.data = loadedData;
+			if ("version" in loadedData && loadedData.version === "1.0.0-alpha.33") this.data = loadedData;
 			else {
 				this.data = createDefaultData();
 				this.flush();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollipop",
-  "version": "1.0.0-alpha.31",
+  "version": "1.0.0-alpha.33",
   "homepage": "https://github.com/rollipop-dev/rollipop#readme",
   "bugs": {
     "url": "https://github.com/rollipop-dev/rollipop/issues"
@@ -67,9 +67,9 @@
     "@react-native-community/cli-server-api": "20.2.0",
     "@react-native-community/cli-types": "20.2.0",
     "@react-native/dev-middleware": "0.87.1",
-    "@rollipop/dashboard": "1.0.0-alpha.31",
+    "@rollipop/dashboard": "1.0.0-alpha.33",
     "@rollipop/rolldown": "1.0.32",
-    "@swc/core": "1.15.43",
+    "@swc/core": "1.16.13",
     "@swc/helpers": "0.5.23",
     "@types/ws": "8.18.1",
     "arktype": "2.2.3",