rollipop 1.0.0-alpha.25 → 1.0.0-alpha.27

package/dist/config/load-config.js

@@ -1,6 +1,7 @@
 import { getDefaultConfig } from "./defaults.js";
 import { createPluginContext } from "../core/plugins/context.js";
 import { mergeConfig } from "./merge-config.js";
+import { printConfigNotice } from "./notice.js";
 import path from "node:path";
 import { invariant, omit } from "es-toolkit";
 import * as c12 from "c12";
@@ -38,6 +39,7 @@ async function loadConfig(options = {}) {
 	};
 	if (!path.isAbsolute(resolvedConfig.entry)) resolvedConfig.entry = path.resolve(resolvedConfig.root, resolvedConfig.entry);
 	await invokeConfigResolved(resolvedConfig, plugins);
+	printConfigNotice(resolvedConfig);
 	return resolvedConfig;
 }
 async function flattenPluginOption(pluginOption) {

package/dist/config/notice.js

@@ -0,0 +1,7 @@
+import { logger } from "../logger.js";
+//#region src/config/notice.ts
+function printConfigNotice(config) {
+	if (config.transformer.reactCompiler != null) logger.info("✨ React Compiler is enabled");
+}
+//#endregion
+export { printConfigNotice };

package/dist/constants.js

@@ -19,7 +19,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.25";
+const ROLLIPOP_VERSION = "1.0.0-alpha.27";
 const ROLLIPOP_VIRTUAL_PREFIX = "\0rollipop/";
 const ROLLIPOP_VIRTUAL_ENTRY_ID = `${ROLLIPOP_VIRTUAL_PREFIX}entry`;
 /**

package/dist/core/assets.d.ts

@@ -1,5 +1,5 @@
 declare namespace assets_d_exports {
-  export { AssetContext, AssetData, AssetDataFiltered, AssetDataWithoutFiles, AssetInfo, AssetScale, copyAssetsToDestination, generateAssetRegistryCode, getAssetPriority, getSuffixedPath, platformSuffixPattern, resolveAssetPath, resolveScaledAssets, stripSuffix };
+  export { AssetContext, AssetData, AssetDataFiltered, AssetDataWithoutFiles, AssetInfo, AssetScale, copyAssetsToDestination, filterPlatformAssetScales, generateAssetRegistryCode, getAssetPriority, getSuffixedPath, platformSuffixPattern, resolveAssetPath, resolveScaledAssets, stripSuffix };
 }
 /**
  * **NOTE**: Type definitions are ported from `metro` implementation.
@@ -42,7 +42,7 @@ interface AssetData extends AssetDataWithoutFiles {
   id: string;
   files: string[];
 }
-type AssetScale = 0.75 | 1 | 1.5 | 2 | 3;
+type AssetScale = number;
 interface ResolveScaledAssetsOptions {
   projectRoot: string;
   assetPath: string;
@@ -75,7 +75,7 @@ interface GetSuffixedPathOptions {
  * ```
  */
 declare function getSuffixedPath(assetPath: string, context: AssetContext, options: GetSuffixedPathOptions): string;
-declare function resolveAssetPath(assetPath: string, context: AssetContext, scale: AssetScale): string;
+declare function resolveAssetPath(assetPath: string, context: AssetContext, scale?: AssetScale): string;
 interface CopyAssetsToDestinationOptions {
   assets: AssetData[];
   assetsDir: string;
@@ -86,6 +86,7 @@ interface CopyAssetsToDestinationOptions {
  * @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/assetPathUtils.js
  */
 declare function copyAssetsToDestination(options: CopyAssetsToDestinationOptions): Promise<undefined>;
+declare function filterPlatformAssetScales(platform: string, scales: readonly AssetScale[]): AssetScale[];
 declare function generateAssetRegistryCode(assetRegistryPath: string, asset: AssetData): string;
 //#endregion
 export { assets_d_exports };

package/dist/core/assets.js

@@ -15,6 +15,7 @@ import { imageSize } from "image-size";
 */
 var assets_exports = /* @__PURE__ */ __exportAll({
 	copyAssetsToDestination: () => copyAssetsToDestination,
+	filterPlatformAssetScales: () => filterPlatformAssetScales,
 	generateAssetRegistryCode: () => generateAssetRegistryCode,
 	getAssetPriority: () => getAssetPriority,
 	getSuffixedPath: () => getSuffixedPath,
@@ -24,6 +25,8 @@ var assets_exports = /* @__PURE__ */ __exportAll({
 	stripSuffix: () => stripSuffix
 });
 const SCALE_PATTERN = "@(\\d+\\.?\\d*)x";
+const ASSET_BASE_NAME_PATTERN = /(.+?)(@([\d.]+)x)?$/;
+const PLATFORM_FILE_PATH_PATTERN = /^(.+?)(\.([^.]+))?\.([^.]+)$/;
 const IMAGE_ASSET_TYPES = new Set(IMAGE_EXTENSIONS);
 /**
 * key: platform,
@@ -53,51 +56,114 @@ async function resolveScaledAssets(options) {
 		platform,
 		preferNativePlatform
 	};
-	const extension = path.extname(assetPath);
-	const type = extension.substring(1);
+	const { name, type } = parseAssetPath(path.basename(assetPath), context);
 	const relativePath = path.relative(projectRoot, assetPath);
-	const dirname = path.dirname(assetPath);
-	const files = fs.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 = fs.readFileSync(assetPath);
-	const dimensions = IMAGE_ASSET_TYPES.has(type) ? imageSize(imageData) : void 0;
-	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: []
-	});
+	const { files, scales } = getAbsoluteAssetRecord(assetPath, context);
+	const fileData = await Promise.all(files.map((file) => fs.promises.readFile(file)));
+	const hash = md5(Buffer.concat(fileData));
+	const firstScale = scales[0] ?? 1;
+	const dimensions = IMAGE_ASSET_TYPES.has(type) ? imageSize(fileData[0]) : void 0;
 	return {
 		__packager_asset: true,
 		id: assetPath,
-		name: stripedBasename.replace(extension, ""),
+		name,
 		type,
-		width: dimensions?.width,
-		height: dimensions?.height,
-		files: filteredScaledAssets.files,
-		scales: filteredScaledAssets.scales,
+		width: dimensions?.width == null ? void 0 : dimensions.width / firstScale,
+		height: dimensions?.height == null ? void 0 : dimensions.height / firstScale,
+		files,
+		scales,
 		fileSystemLocation: path.dirname(assetPath),
-		httpServerLocation: path.join(DEV_SERVER_ASSET_PATH, path.dirname(relativePath)),
-		hash: md5(imageData)
+		httpServerLocation: getHttpServerLocation(relativePath),
+		hash
+	};
+}
+function getHttpServerLocation(relativePath) {
+	const dirname = path.dirname(relativePath);
+	return normalizePathSeparatorsToPosix(relativePath.startsWith("..") ? `/${DEV_SERVER_ASSET_PATH}/${dirname}` : path.join("/", DEV_SERVER_ASSET_PATH, dirname));
+}
+function normalizePathSeparatorsToPosix(filePath) {
+	return filePath.replace(/\\/g, "/");
+}
+function getAssetPlatforms(context) {
+	return [context.platform, context.preferNativePlatform ? "native" : null].filter(isNotNil);
+}
+function parseBaseName(baseName) {
+	const match = ASSET_BASE_NAME_PATTERN.exec(baseName);
+	if (match == null) throw new Error(`invalid asset name: ${baseName}`);
+	const [, rootName, , resolution] = match;
+	if (resolution != null) {
+		const parsedResolution = Number.parseFloat(resolution);
+		if (!Number.isNaN(parsedResolution)) return {
+			resolution: parsedResolution,
+			rootName
+		};
+	}
+	return {
+		resolution: 1,
+		rootName
+	};
+}
+function tryParseAssetPath(filePath, context) {
+	const dirname = path.dirname(filePath);
+	const fileName = path.basename(filePath);
+	const match = PLATFORM_FILE_PATH_PATTERN.exec(fileName);
+	if (match == null) return null;
+	const [, baseName, , platformCandidate, extension] = match;
+	const platforms = new Set(getAssetPlatforms(context));
+	const platform = platformCandidate != null && platforms.has(platformCandidate) ? platformCandidate : void 0;
+	const { resolution, rootName } = parseBaseName(platform == null && platformCandidate != null ? `${baseName}.${platformCandidate}` : baseName);
+	return {
+		assetName: path.join(dirname, `${rootName}.${extension}`),
+		name: rootName,
+		platform,
+		resolution,
+		type: extension
 	};
 }
+function parseAssetPath(filePath, context) {
+	const assetPath = tryParseAssetPath(filePath, context);
+	if (assetPath == null) throw new Error(`invalid asset file path: ${filePath}`);
+	return assetPath;
+}
+function getAssetKey(assetName, platform) {
+	return platform == null ? assetName : `${assetName} : ${platform}`;
+}
+function buildAssetMap(dirname, files, context) {
+	const assetMap = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const asset = tryParseAssetPath(file, context);
+		if (asset == null) continue;
+		const assetKey = getAssetKey(asset.assetName, asset.platform);
+		let record = assetMap.get(assetKey);
+		if (record == null) {
+			record = {
+				files: [],
+				scales: []
+			};
+			assetMap.set(assetKey, record);
+		}
+		let insertIndex = 0;
+		while (insertIndex < record.scales.length && asset.resolution >= record.scales[insertIndex]) insertIndex += 1;
+		record.scales.splice(insertIndex, 0, asset.resolution);
+		record.files.splice(insertIndex, 0, path.join(dirname, file));
+	}
+	return assetMap;
+}
+function getAbsoluteAssetRecord(assetPath, context) {
+	const dirname = path.dirname(assetPath);
+	const files = fs.readdirSync(dirname);
+	const asset = parseAssetPath(path.basename(assetPath), context);
+	const assetMap = buildAssetMap(dirname, files, context);
+	const platformRecord = assetMap.get(getAssetKey(asset.assetName, context.platform));
+	if (platformRecord != null) return platformRecord;
+	if (context.preferNativePlatform) {
+		const nativeRecord = assetMap.get(getAssetKey(asset.assetName, "native"));
+		if (nativeRecord != null) return nativeRecord;
+	}
+	const defaultRecord = assetMap.get(asset.assetName);
+	if (defaultRecord != null) return defaultRecord;
+	throw new Error(`Asset not found: ${assetPath} for platform: ${context.platform}`);
+}
 function platformSuffixPattern(context) {
 	return [context.platform, context.preferNativePlatform ? "native" : null].filter(isNotNil).map((platform) => `.${platform}`).join("|");
 }
@@ -144,68 +210,47 @@ function getSuffixedPath(assetPath, context, options) {
 	return path.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(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 {
-		fs.statSync(assetPath);
-		return assetPath;
-	} catch {}
-	for (const suffixedPath of suffixedPaths) try {
-		fs.statSync(suffixedPath);
-		return suffixedPath;
-	} catch {}
+	const requestedScale = scale ?? parseAssetPath(path.basename(assetPath), context).resolution;
+	const record = getAbsoluteAssetRecord(assetPath, context);
+	for (let index = 0; index < record.scales.length; index += 1) if (record.scales[index] >= requestedScale) return record.files[index];
+	const fallback = record.files.at(-1);
+	if (fallback != null) return fallback;
 	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 { assets, platform, assetsDir } = options;
 	const mkdirWithAssertPath = (targetPath) => {
 		const dirname = path.dirname(targetPath);
 		fs.mkdirSync(dirname, { recursive: true });
 	};
 	return Promise.all(assets.map((asset) => {
-		return Promise.all(asset.scales.map(async (scale) => {
+		const validScales = new Set(filterPlatformAssetScales(platform, asset.scales));
+		return Promise.all(asset.scales.map(async (scale, index) => {
+			if (!validScales.has(scale)) return;
 			if (platform !== "android") {
-				const from = resolveAssetPath(asset.id, context, scale);
+				const from = asset.files[index];
 				const to = path.join(assetsDir, getIosAssetDestinationPath(asset, scale));
 				mkdirWithAssertPath(to);
 				return fs.copyFileSync(from, to);
 			}
-			const from = resolveAssetPath(asset.id, context, scale);
+			const from = asset.files[index];
 			const to = path.join(assetsDir, getAndroidAssetDestinationPath(asset, scale));
 			mkdirWithAssertPath(to);
 			fs.copyFileSync(from, to);
 		})).then(() => void 0);
 	})).then(() => void 0);
 }
+function filterPlatformAssetScales(platform, scales) {
+	const allowlist = ALLOW_SCALES[platform];
+	if (allowlist == null) return [...scales];
+	const filteredScales = scales.filter((scale) => allowlist.includes(scale));
+	if (filteredScales.length > 0 || scales.length === 0) return filteredScales;
+	const maxAllowedScale = allowlist[allowlist.length - 1];
+	return [scales.find((scale) => scale > maxAllowedScale) ?? scales[scales.length - 1]];
+}
 /**
 * @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/getAssetDestPathIOS.js
 */
@@ -238,7 +283,8 @@ function isDrawable(type) {
 	].includes(type);
 }
 function generateAssetRegistryCode(assetRegistryPath, asset) {
-	return `module.exports = require('${assetRegistryPath}').registerAsset(${JSON.stringify(asset)});`;
+	const { files: _files, fileSystemLocation: _fileSystemLocation, id: _id, ...registryAsset } = asset;
+	return `module.exports = require('${assetRegistryPath}').registerAsset(${JSON.stringify(registryAsset)});`;
 }
 //#endregion
 export { assets_exports, copyAssetsToDestination, generateAssetRegistryCode, resolveAssetPath, resolveScaledAssets };

package/dist/core/rolldown.js

@@ -67,7 +67,10 @@ async function resolveRolldownOptions(context, config, buildOptions, devEngineOp
 			...defineEnvFromObject(builtInEnv)
 		},
 		helpers: { mode: "Runtime" }
-	}, rolldownTransform);
+	}, {
+		...rolldownTransform,
+		reactCompiler: resolveReactCompilerTransformOptions(rolldownTransform.reactCompiler)
+	});
 	const entryPluginOptions = resolveEntryPluginOptions(config);
 	const reactNativePluginOptions = await resolveReactNativePluginOptions(config, context, buildOptions);
 	const babelPluginOptions = resolveBabelPluginOptions(config, context);
@@ -195,6 +198,13 @@ function resolveWorkletsConfig(config) {
 		pluginVersion: resolvePackageJson(config.root, "react-native-worklets")?.version
 	}, worklets);
 }
+function resolveReactCompilerTransformOptions(reactCompiler) {
+	if (reactCompiler == null) return;
+	return {
+		...reactCompiler,
+		exclude: reactCompiler.exclude ?? [/node_modules/]
+	};
+}
 function resolveBabelPluginOptions(config, context) {
 	return {
 		context,

package/dist/package.js

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

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

@@ -5,13 +5,11 @@ import { BundlerPool } from "./bundler-pool.js";
 import { DEFAULT_HOST, DEFAULT_PORT } from "./constants.js";
 import { errorHandler } from "./error.js";
 import { ServerEventBus } from "./events/event-bus.js";
-import { toSSEEvent } from "./sse/adapter.js";
 import { plugin } from "./mcp/server.js";
 import { plugin as plugin$1 } from "./middlewares/dashboard.js";
 import { requestLogger } from "./middlewares/request-logger.js";
 import { plugin as plugin$2 } from "./middlewares/serve-assets.js";
 import { plugin as plugin$3 } from "./middlewares/serve-bundle.js";
-import { SSEEventPublisher } from "./sse/event-bus.js";
 import { plugin as plugin$4 } from "./middlewares/sse.js";
 import { plugin as plugin$5 } from "./middlewares/symbolicate.js";
 import { plugin as plugin$6 } from "./rest/index.js";
@@ -49,12 +47,7 @@ async function createDevServer(config, options) {
 		host,
 		port
 	}, eventBus);
-	const ssePublisher = new SSEEventPublisher();
 	const reporter = config.reporter;
-	eventBus.subscribe((event) => {
-		const sseEvent = toSSEEvent(event);
-		if (sseEvent != null) ssePublisher.publish(sseEvent);
-	});
 	const { middleware: communityMiddleware, websocketEndpoints: communityWebsocketEndpoints, messageSocketEndpoint: { server: messageServer, broadcast }, eventsSocketEndpoint: { server: eventsServer, reportEvent } } = createDevServerMiddleware({
 		port,
 		host,

package/dist/server/mcp/server.js

@@ -9,7 +9,7 @@ import fp from "fastify-plugin";
 function createMcpServer(options) {
 	const server = new McpServer({
 		name: "rollipop",
-		version: "1.0.0-alpha.25"
+		version: "1.0.0-alpha.27"
 	}, { capabilities: { logging: {} } });
 	registerTools(server, options);
 	return server;

package/dist/server/middlewares/dashboard.js

@@ -18,8 +18,14 @@ const plugin = fp((fastify, options) => {
 		index: [INDEX_FILE],
 		wildcard: false
 	});
-	fastify.get(DASHBOARD_PATH, (_request, reply) => reply.sendFile(INDEX_FILE));
-	fastify.get(`${DASHBOARD_PATH}/analyze-report/:reportFile`, async (request, reply) => {
+	fastify.get(DASHBOARD_PATH, (_request, reply) => reply.sendFile(INDEX_FILE)).get(`${DASHBOARD_PATH}/*`, (request, reply) => {
+		if (shouldServeNotFoundPage(request)) return reply.sendFile(INDEX_FILE);
+		return reply.status(404).send({
+			statusCode: 404,
+			error: "Not Found",
+			message: "Not Found"
+		});
+	}).get(`${DASHBOARD_PATH}/analyze-report/:reportFile`, async (request, reply) => {
 		const { reportFile } = request.params;
 		if (!reportFile.endsWith(".html")) return reply.status(400).send({ error: {
 			code: "INVALID_ANALYZE_REPORT_ID",

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

@@ -29,15 +29,16 @@ const plugin = fp((fastify, options) => {
 			const assetPath = resolveAsset(pathname.replace(new RegExp(`^/${DEV_SERVER_ASSET_PATH}/?`), ""));
 			let handle = null;
 			try {
-				handle = await fs.promises.open(resolveAssetPath(assetPath, {
+				const resolvedAssetPath = resolveAssetPath(assetPath, {
 					platform: query.platform,
 					preferNativePlatform: context.config.resolver.preferNativePlatform
-				}, 1), "r");
+				});
+				handle = await fs.promises.open(resolvedAssetPath, "r");
 				const assetData = await handle.readFile();
 				const { size } = await handle.stat();
-				await reply.header("Content-Type", mime.getType(assetPath) ?? "").header("Content-Length", size).send(assetData);
+				await reply.header("Content-Type", mime.getType(resolvedAssetPath) ?? "").header("Content-Length", size).send(assetData);
 			} catch (error) {
-				fastify.log.error(error, "Failed to serve asset (scale assets resolving is not implemented yet)");
+				fastify.log.error(error, "Failed to serve asset");
 				await reply.status(500).send();
 			} finally {
 				await handle?.close();

package/dist/server/middlewares/symbolicate.js

@@ -1,7 +1,7 @@
 import { isDebugEnabled } from "../../common/env.js";
 import { getBaseBundleName } from "../../utils/bundle.js";
 import { parseUrl } from "../../utils/url.js";
-import { symbolicate } from "../symbolicate.js";
+import { symbolicateWithBundleResolver } from "../symbolicate.js";
 import chalk from "chalk";
 import fp from "fastify-plugin";
 import { asConst } from "json-schema-to-ts";
@@ -23,31 +23,35 @@ const plugin = fp((fastify, options) => {
 		schema: { body: bodySchema },
 		async handler(request, reply) {
 			const { stack } = request.body;
-			const bundleUrl = findBundleUrl(stack);
-			if (bundleUrl == null) {
+			const bundleStores = getBundleStoresByFrameUrl(stack, context);
+			if (bundleStores.size === 0) {
 				await reply.header("Content-Type", "application/json").send(createFallbackResult(stack));
 				return;
 			}
-			const { pathname, query } = bundleUrl;
-			const platform = query.platform;
-			const dev = query.dev == null ? context.config.mode === "development" : query.dev === "true";
-			const bundleName = getBaseBundleName(pathname);
-			const symbolicateResult = await symbolicate(await context.bundlerPool.get(bundleName, {
-				platform,
-				dev
-			}).getBundle(), stack);
+			const symbolicateResult = await symbolicateWithBundleResolver(stack, async (frame) => frame.file == null ? void 0 : await bundleStores.get(frame.file));
 			if (isDebugEnabled()) printSymbolicateResult(stack, symbolicateResult);
 			await reply.header("Content-Type", "application/json").send(symbolicateResult);
 		}
 	});
 }, { name: "symbolicate" });
-function findBundleUrl(stack) {
+function getBundleStoresByFrameUrl(stack, context) {
+	const bundleStores = /* @__PURE__ */ new Map();
 	for (const frame of stack) {
-		if (!frame.file?.startsWith("http")) continue;
-		const parsed = parseStackFrameFile(frame.file);
-		if (parsed?.query.platform) return parsed;
+		const file = frame.file;
+		if (!file?.startsWith("http") || bundleStores.has(file)) continue;
+		const parsed = parseStackFrameFile(file);
+		if (parsed?.query.platform == null) continue;
+		const { pathname, query } = parsed;
+		const platform = query.platform;
+		const dev = query.dev == null ? context.config.mode === "development" : query.dev === "true";
+		const bundleName = getBaseBundleName(pathname);
+		const bundler = context.bundlerPool.get(bundleName, {
+			platform,
+			dev
+		});
+		bundleStores.set(file, bundler.getBundle());
 	}
-	return null;
+	return bundleStores;
 }
 function parseStackFrameFile(file) {
 	try {

package/dist/server/state/store.js

@@ -28,7 +28,15 @@ var DevServerState = class {
 		this.clearBuilds();
 	}
 	handleEvent(event) {
-		this.builds.handleEvent(event);
+		switch (event.type) {
+			case "bundle_build_started":
+			case "bundle_build_done":
+			case "bundle_build_failed":
+			case "build_log":
+			case "build_error":
+				this.builds.handleEvent(event);
+				break;
+		}
 	}
 };
 var BuildStore = class {

package/dist/server/symbolicate.js

@@ -26,11 +26,21 @@ const INTERNAL_CALLSITES_REGEX = new RegExp([
 	"^\\[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 symbolicateWithBundleResolver(stack, (frame) => frame.file?.startsWith("http") ? bundleStore : void 0);
+}
+async function symbolicateWithBundleResolver(stack, resolveBundleStore) {
+	const symbolicatedStack = await Promise.all(stack.map(async (frame) => {
+		const bundleStore = frame.file?.startsWith("http") ? await resolveBundleStore(frame) : void 0;
+		const sourceMapConsumer = await bundleStore?.sourceMapConsumer;
+		return {
+			bundleStore,
+			frame: collapseFrame(sourceMapConsumer ? originalPositionFor(sourceMapConsumer, frame) : frame),
+			sourceMapConsumer
+		};
+	}));
 	return {
-		stack: symbolicatedStack,
-		codeFrame: getCodeFrame(symbolicatedStack, bundleStore, sourceMapConsumer)
+		stack: symbolicatedStack.map(({ frame }) => frame),
+		codeFrame: getCodeFrame(symbolicatedStack)
 	};
 }
 function originalPositionFor(sourceMapConsumer, frame) {
@@ -43,7 +53,7 @@ function originalPositionFor(sourceMapConsumer, frame) {
 		const targetKey = convertFrameKey(key);
 		return {
 			...frame,
-			...value ? { [targetKey]: value } : null
+			...value != null ? { [targetKey]: value } : null
 		};
 	}, frame);
 }
@@ -62,23 +72,29 @@ function convertFrameKey(key) {
 	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;
+function getCodeFrame(frames) {
+	for (const match of frames) {
+		const frame = match.frame;
+		if (frame.file == null || frame.column == null || frame.lineNumber == null) continue;
+		if (isCollapsed(frame)) continue;
+		const codeFrame = createCodeFrame(match);
+		if (codeFrame != null) return codeFrame;
+	}
+	return null;
+}
+function createCodeFrame({ bundleStore, frame, sourceMapConsumer }) {
 	try {
 		const { lineNumber, column, file } = frame;
-		const unresolved = file.startsWith("http");
-		const source = sourceMapConsumer == null || unresolved ? bundleStore.code : sourceMapConsumer.sourceContentFor(frame.file);
+		if (file == null || lineNumber == null || column == null) return null;
+		const unresolved = file?.startsWith("http") ?? false;
+		const source = sourceMapConsumer == null || unresolved ? bundleStore?.code : sourceMapConsumer.sourceContentFor(file, true);
+		if (!source) return null;
 		const fileName = unresolved ? parseUrl(file).pathname ?? "unknown" : file;
-		let content = "";
-		if (source) content = codeFrameColumns(source, { start: {
-			column,
-			line: lineNumber
-		} }, { highlightCode: true });
 		return {
-			content,
+			content: codeFrameColumns(source, { start: {
+				column: column + 1,
+				line: lineNumber
+			} }, { highlightCode: true }),
 			fileName,
 			location: {
 				column,
@@ -90,4 +106,4 @@ function getCodeFrame(frames, bundleStore, sourceMapConsumer) {
 	}
 }
 //#endregion
-export { symbolicate };
+export { symbolicate, symbolicateWithBundleResolver };

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.25") this.data = loadedData;
+			if ("version" in loadedData && loadedData.version === "1.0.0-alpha.27") this.data = loadedData;
 			else {
 				this.data = createDefaultData();
 				this.flush();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollipop",
-  "version": "1.0.0-alpha.25",
+  "version": "1.0.0-alpha.27",
   "stableVersion": "1.0.0-alpha.23",
   "homepage": "https://github.com/rollipop-dev/rollipop#readme",
   "bugs": {
@@ -70,8 +70,8 @@
     "@react-native-community/cli-types": "20.1.3",
     "@react-native/babel-plugin-codegen": "0.86.0",
     "@react-native/dev-middleware": "0.86.0",
-    "@rollipop/dashboard": "0.0.0",
-    "@rollipop/rolldown": "1.0.19",
+    "@rollipop/dashboard": "1.0.0-alpha.27",
+    "@rollipop/rolldown": "1.0.20",
     "@swc/core": "1.15.41",
     "@swc/helpers": "0.5.23",
     "@types/ws": "8.18.1",