@reckona/mreact-router 0.0.208 → 0.0.210

package/src/build.ts

@@ -16,6 +16,7 @@ import { builtinModules } from "node:module";
 import { availableParallelism } from "node:os";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { gzipSync } from "node:zlib";
 import type { DehydrateOptions } from "@reckona/mreact-query";
 import {
   collectStaticImportReferences,
@@ -41,7 +42,11 @@ import {
   type ClientRouteInferenceDiagnostic,
   type ClientRouteInferenceCache,
 } from "./client-route-inference.js";
-import { createBoundaryReport, type BoundaryReport } from "./boundaries.js";
+import {
+  createBoundaryReport,
+  validateBoundaryExecutionContracts,
+  type BoundaryReport,
+} from "./boundaries.js";
 import {
   buildClientRouteBatchOutput,
   buildNavigationRuntimeBundle,
@@ -140,12 +145,19 @@ export type AwsLambdaGeneratedHandlerPreloadMode =
   | "middleware"
   | "none";
 
+/** Supplies observed dynamic imports when boundary navigation costs are measured. */
+export interface BoundaryCostOptions {
+  /** Maps a route path to dynamic import entry files fetched during navigation. */
+  fetchedDynamicImports?: Readonly<Record<string, readonly string[]>> | undefined;
+}
+
 /**
  * Configures an app-router production build and its deployment targets.
  */
 export interface BuildAppOptions extends AppRouterProjectOptions {
   awsLambdaPreload?: AwsLambdaGeneratedHandlerPreloadMode | undefined;
   awsLambdaPreloadRoutes?: readonly string[] | undefined;
+  boundaryCost?: BoundaryCostOptions | undefined;
   /** Receives the full route and component boundary report after source analysis. */
   onBoundaryReport?: ((report: BoundaryReport) => void) | undefined;
   onBuildProgress?: ((event: BuildAppProgressEvent) => void) | undefined;
@@ -263,9 +275,15 @@ interface IncrementalBuildServerManifestOutputs {
 
 interface IncrementalBuildClientManifestOutputs {
   assets?: readonly string[];
+  chunks?: readonly {
+    dynamicImports?: readonly string[];
+    file: string;
+    imports?: readonly string[];
+  }[];
   publicAssets?: readonly string[];
   routes: readonly {
     css?: readonly string[];
+    dynamicImports?: readonly string[];
     imports?: readonly string[];
     navigationScript?: string | undefined;
     script?: string | undefined;
@@ -522,7 +540,7 @@ async function buildAppWithResolvedProject(
             vitePlugins,
           }),
         );
-  options.onBoundaryReport?.(sourceAnalysis.boundaryReport);
+  validateBoundaryExecutionContracts(sourceAnalysis.boundaryReport, project.executionContracts);
 
   if (shouldTrackBuildPhases === false) {
     await validateProductionRoutes({
@@ -558,6 +576,19 @@ async function buildAppWithResolvedProject(
       outDir: options.outDir,
     }))
   ) {
+    if (options.onBoundaryReport !== undefined) {
+      const clientManifest = await readJsonBuildOutput<ClientArtifactManifest>(
+        join(options.outDir, "client", "manifest.json"),
+      );
+      options.onBoundaryReport(
+        await boundaryReportWithArtifactCosts({
+          boundaryCost: options.boundaryCost,
+          clientDir,
+          manifest: clientManifest,
+          report: sourceAnalysis.boundaryReport,
+        }),
+      );
+    }
     return { routes };
   }
 
@@ -852,6 +883,7 @@ async function buildAppWithResolvedProject(
   } satisfies BuiltServerManifest;
   const clientManifest = {
     ...(clientManifestAssets.length === 0 ? {} : { assets: clientManifestAssets }),
+    ...(clientBundle.chunks.length === 0 ? {} : { chunks: clientBundle.chunks }),
     ...(publicAssets.length === 0 ? {} : { publicAssets }),
     routes: clientManifestRoutes,
     ...(clientBundle.styles.length === 0 ? {} : { styles: clientBundle.styles }),
@@ -933,9 +965,296 @@ async function buildAppWithResolvedProject(
     await writeIncrementalBuildCacheManifest(options.outDir, incrementalBuildFingerprint);
   }
 
+  if (options.onBoundaryReport !== undefined) {
+    options.onBoundaryReport(
+      await boundaryReportWithArtifactCosts({
+        boundaryCost: options.boundaryCost,
+        clientDir,
+        manifest: clientManifest,
+        report: sourceAnalysis.boundaryReport,
+      }),
+    );
+  }
+
   return { routes };
 }
 
+async function boundaryReportWithArtifactCosts(options: {
+  boundaryCost: BoundaryCostOptions | undefined;
+  clientDir: string;
+  manifest: ClientArtifactManifest | undefined;
+  report: BoundaryReport;
+}): Promise<BoundaryReport> {
+  if (options.manifest === undefined) {
+    return {
+      ...options.report,
+      routes: options.report.routes.map((route) => ({
+        ...route,
+        cost: {
+          reason: "Production client manifest is unavailable.",
+          status: "unavailable",
+        },
+      })),
+    };
+  }
+
+  const manifest = options.manifest;
+  const chunks = new Map((manifest.chunks ?? []).map((chunk) => [chunk.file, chunk]));
+  const routeClosures = options.report.routes.map((route) => {
+    const manifestRoute = manifest.routes.find((candidate) => candidate.path === route.path);
+
+    if (manifestRoute === undefined) {
+      return { initial: undefined, navigation: undefined, route };
+    }
+
+    const initial = clientArtifactStaticClosure(manifestRoute, chunks);
+    const navigation = new Set(initial);
+    addFetchedDynamicImportClosures({
+      chunks,
+      fetchedDynamicImports: options.boundaryCost?.fetchedDynamicImports?.[route.path] ?? [],
+      navigation,
+      routeDynamicImports: manifestRoute.dynamicImports ?? [],
+    });
+
+    return { initial, navigation, route };
+  });
+  const availableClosures = routeClosures.flatMap((entry) =>
+    entry.initial === undefined ? [] : [entry.initial],
+  );
+  const sharedPaths = intersectionOfPathSets(availableClosures);
+  const allPaths = new Set<string>();
+  for (const entry of routeClosures) {
+    for (const path of entry.navigation ?? []) {
+      allPaths.add(path);
+    }
+  }
+  const measurements = await measureClientArtifactPaths(options.clientDir, allPaths);
+
+  return {
+    ...options.report,
+    routes: routeClosures.map((entry) => {
+      if (entry.initial === undefined || entry.navigation === undefined) {
+        return {
+          ...entry.route,
+          cost: {
+            reason: "No client route artifact was generated for this route.",
+            status: "unavailable",
+          },
+        };
+      }
+
+      const routePaths = new Set(entry.navigation);
+      const unavailable = [...routePaths]
+        .filter((path) => measurements.get(path)?.available !== true)
+        .sort();
+      if (unavailable.length > 0) {
+        return {
+          ...entry.route,
+          cost: {
+            reason: `Missing client artifacts: ${unavailable.join(", ")}.`,
+            status: "unavailable",
+          },
+        };
+      }
+
+      const initial = byteCostForPaths(entry.initial, measurements);
+      const navigation = byteCostForPaths(
+        new Set([...entry.navigation].filter((path) => !sharedPaths.has(path))),
+        measurements,
+      );
+      const shared = byteCostForPaths(sharedPaths, measurements);
+
+      return {
+        ...entry.route,
+        cost: {
+          baseline: {
+            initialGzipDeltaBytes: initial.gzipEstimateBytes - shared.gzipEstimateBytes,
+            navigationGzipDeltaBytes: navigation.gzipEstimateBytes,
+          },
+          initial,
+          navigation,
+          status: "available",
+        },
+      };
+    }),
+  };
+}
+
+interface ClientArtifactMeasurement {
+  available: boolean;
+  gzipEstimateBytes?: number;
+  rawBytes?: number;
+}
+
+function clientArtifactStaticClosure(
+  route: ClientRouteManifestEntry,
+  chunks: ReadonlyMap<string, ClientArtifactChunkManifest>,
+): Set<string> {
+  const paths = new Set<string>();
+  for (const path of route.css ?? []) {
+    paths.add(path);
+  }
+  if (route.navigation === true && route.navigationScript !== undefined) {
+    paths.add(route.navigationScript);
+  }
+  for (const path of route.imports ?? []) {
+    addClientArtifactStaticClosure(paths, path, chunks);
+  }
+  if (route.script !== undefined) {
+    addClientArtifactStaticClosure(paths, route.script, chunks);
+  }
+  return paths;
+}
+
+function addFetchedDynamicImportClosures(options: {
+  chunks: ReadonlyMap<string, ClientArtifactChunkManifest>;
+  fetchedDynamicImports: readonly string[];
+  navigation: Set<string>;
+  routeDynamicImports: readonly string[];
+}): void {
+  const fetchedDynamicImports = new Set(options.fetchedDynamicImports);
+  const acceptedDynamicImports = new Set<string>();
+  const reachableDynamicImports = new Set(options.routeDynamicImports);
+
+  for (;;) {
+    for (const dynamicImport of dynamicImportsReachableFromStaticClosure(
+      options.navigation,
+      options.chunks,
+    )) {
+      reachableDynamicImports.add(dynamicImport);
+    }
+
+    let added = false;
+    for (const dynamicImport of fetchedDynamicImports) {
+      if (
+        acceptedDynamicImports.has(dynamicImport) ||
+        !reachableDynamicImports.has(dynamicImport) ||
+        !options.chunks.has(dynamicImport)
+      ) {
+        continue;
+      }
+
+      acceptedDynamicImports.add(dynamicImport);
+      addClientArtifactStaticClosure(options.navigation, dynamicImport, options.chunks);
+      added = true;
+    }
+
+    if (!added) {
+      return;
+    }
+  }
+}
+
+function dynamicImportsReachableFromStaticClosure(
+  paths: ReadonlySet<string>,
+  chunks: ReadonlyMap<string, ClientArtifactChunkManifest>,
+): Set<string> {
+  const pending = [...paths];
+  const visited = new Set<string>();
+  const dynamicImports = new Set<string>();
+
+  while (pending.length > 0) {
+    const path = pending.pop();
+    if (path === undefined || visited.has(path)) {
+      continue;
+    }
+
+    visited.add(path);
+    const chunk = chunks.get(path);
+    if (chunk === undefined) {
+      continue;
+    }
+
+    for (const imported of chunk.imports ?? []) {
+      pending.push(imported);
+    }
+    for (const dynamicImport of chunk.dynamicImports ?? []) {
+      dynamicImports.add(dynamicImport);
+    }
+  }
+
+  return dynamicImports;
+}
+
+function addClientArtifactStaticClosure(
+  paths: Set<string>,
+  path: string,
+  chunks: ReadonlyMap<string, ClientArtifactChunkManifest>,
+): void {
+  if (path === "" || paths.has(path)) {
+    return;
+  }
+
+  paths.add(path);
+  for (const imported of chunks.get(path)?.imports ?? []) {
+    addClientArtifactStaticClosure(paths, imported, chunks);
+  }
+}
+
+function intersectionOfPathSets(sets: readonly Set<string>[]): Set<string> {
+  const [first, ...rest] = sets;
+  if (first === undefined || sets.length < 2) {
+    return new Set();
+  }
+
+  return new Set([...first].filter((path) => rest.every((set) => set.has(path))));
+}
+
+async function measureClientArtifactPaths(
+  clientDir: string,
+  paths: ReadonlySet<string>,
+): Promise<ReadonlyMap<string, ClientArtifactMeasurement>> {
+  const measurements = await Promise.all(
+    [...paths].map(async (path) => {
+      const absolutePath = safeClientArtifactPath(clientDir, path);
+      if (absolutePath === undefined) {
+        return [path, { available: false }] as [string, ClientArtifactMeasurement];
+      }
+
+      try {
+        const content = await readFile(absolutePath);
+        return [
+          path,
+          {
+            available: true,
+            gzipEstimateBytes: gzipSync(content).byteLength,
+            rawBytes: content.byteLength,
+          },
+        ] as [string, ClientArtifactMeasurement];
+      } catch {
+        return [path, { available: false }] as [string, ClientArtifactMeasurement];
+      }
+    }),
+  );
+
+  return new Map(measurements);
+}
+
+function safeClientArtifactPath(clientDir: string, path: string): string | undefined {
+  const absolutePath = resolve(clientDir, path);
+  const relativePath = relative(resolve(clientDir), absolutePath);
+
+  return relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`)
+    ? undefined
+    : absolutePath;
+}
+
+function byteCostForPaths(
+  paths: ReadonlySet<string>,
+  measurements: ReadonlyMap<string, ClientArtifactMeasurement>,
+): { gzipEstimateBytes: number; rawBytes: number } {
+  return [...paths].reduce(
+    (cost, path) => {
+      const measurement = measurements.get(path);
+      return {
+        gzipEstimateBytes: cost.gzipEstimateBytes + (measurement?.gzipEstimateBytes ?? 0),
+        rawBytes: cost.rawBytes + (measurement?.rawBytes ?? 0),
+      };
+    },
+    { gzipEstimateBytes: 0, rawBytes: 0 },
+  );
+}
+
 const incrementalBuildCacheFilename = "build-cache.json";
 const incrementalBuildCacheVersion = 2;
 
@@ -1090,6 +1409,11 @@ function collectClientManifestOutputFiles(
     files.add(asset);
     files.add(`public/${asset}`);
   }
+  for (const chunk of manifest.chunks ?? []) {
+    for (const file of [chunk.file, ...(chunk.imports ?? []), ...(chunk.dynamicImports ?? [])]) {
+      files.add(file);
+    }
+  }
   for (const route of manifest.routes) {
     for (const file of [
       route.script,
@@ -1097,6 +1421,7 @@ function collectClientManifestOutputFiles(
       route.navigationScript,
       ...(route.css ?? []),
       ...(route.imports ?? []),
+      ...(route.dynamicImports ?? []),
     ]) {
       if (file !== undefined) {
         files.add(file);
@@ -1473,6 +1798,7 @@ async function analyzeBuildRouteSources(options: {
         diagnostics: analysis.diagnostics,
         entry: analysis.route.file,
         path: analysis.route.path,
+        source: analysis.source,
       })),
     }),
     byFile,
@@ -4056,14 +4382,14 @@ const componentGenerateMetadata = readComponentModuleExport(componentModule, "ge
 const componentMetadata = readComponentModuleExport(componentModule, "metadata");
 const componentSecurityHeadersApplied = readComponentModuleExport(componentModule, "__mreactSecurityHeadersApplied");
 
-export function App(props) {
-  return renderCloudflareRouteComponent(props);
+export function App(props, request) {
+  return renderCloudflareRouteComponent(props, request);
 }
-export default function CloudflareDefaultRouteComponent(props) {
-  return renderCloudflareRouteComponent(props);
+export default function CloudflareDefaultRouteComponent(props, request) {
+  return renderCloudflareRouteComponent(props, request);
 }
-export function CloudflareRouteComponent(props) {
-  return renderCloudflareRouteComponent(props);
+export function CloudflareRouteComponent(props, request) {
+  return renderCloudflareRouteComponent(props, request);
 }
 export const slots = componentSlots === undefined ? undefined : { ...componentSlots };
 export const generateMetadata =
@@ -4071,13 +4397,13 @@ export const generateMetadata =
 export const metadata = componentMetadata;
 export const __mreactSecurityHeadersApplied = componentSecurityHeadersApplied === true;
 
-function renderCloudflareRouteComponent(props) {
+function renderCloudflareRouteComponent(props, request) {
   const routeComponent = resolveCloudflareRouteComponent();
   if (routeComponent === undefined) {
     throw new Error("No Cloudflare component export was found for ${componentImport}.");
   }
 
-  return routeComponent(props);
+  return routeComponent(props, request);
 }
 
 function resolveCloudflareRouteComponent() {
@@ -4443,14 +4769,14 @@ ${shellModules.join("\n")}
 const pageComponent = selectComponent(pageModule, ${JSON.stringify(options.filename)});
 const shells = [${shellDefinitions.join(", ")}];
 export const slots = pageModule.slots;
-export default function CloudflareStringRouteComponent(props) {
-  return renderCloudflareStringRoute(props);
+export default function CloudflareStringRouteComponent(props, request) {
+  return renderCloudflareStringRoute(props, request);
 }
 
-async function renderCloudflareStringRoute(props) {
+async function renderCloudflareStringRoute(props, request) {
   const slotHtml = await renderRouteSlots(pageModule.slots, props);
   const layoutShells = await renderLayoutShells(shells, props, slotHtml);
-  const metadata = await resolveRouteMetadata([...shells.map((shell) => shell.module), pageModule], props);
+  const metadata = await resolveRouteMetadata([...shells.map((shell) => shell.module), pageModule], { ...props, request });
   let html = "<!DOCTYPE html>";
   for (const shell of layoutShells) {
     html += shell.prefix;
@@ -4461,7 +4787,7 @@ async function renderCloudflareStringRoute(props) {
   }
   html = injectCloudflareHead(html, metadata, cloudflareRouteHeadTags(props.clientManifest, props.route.path));
   return new Response(html, {
-    headers: cloudflareMetadataHeaders(metadata, props.request, {
+    headers: cloudflareMetadataHeaders(metadata, request, {
       "content-type": "text/html; charset=utf-8"
     })
   });
@@ -4627,14 +4953,14 @@ ${shellImports.join("\n")}
 const pageComponent = selectComponent(pageModule, ${JSON.stringify(options.filename)});
 const shells = [${shellDefinitions.join(", ")}];
 export const slots = pageModule.slots;
-export default function CloudflareStringRouteComponent(props) {
-  return renderCloudflareStringRoute(props);
+export default function CloudflareStringRouteComponent(props, request) {
+  return renderCloudflareStringRoute(props, request);
 }
 
-async function renderCloudflareStringRoute(props) {
+async function renderCloudflareStringRoute(props, request) {
   const slotHtml = await renderRouteSlots(pageModule.slots, props);
   const layoutShells = await renderLayoutShells(shells, props, slotHtml);
-  const metadata = await resolveRouteMetadata([...shells.map((shell) => shell.module), pageModule], props);
+  const metadata = await resolveRouteMetadata([...shells.map((shell) => shell.module), pageModule], { ...props, request });
   let html = "<!DOCTYPE html>";
   for (const shell of layoutShells) {
     html += shell.prefix;
@@ -4645,7 +4971,7 @@ async function renderCloudflareStringRoute(props) {
   }
   html = injectCloudflareHead(html, metadata, cloudflareRouteHeadTags(props.clientManifest, props.route.path));
   return new Response(html, {
-    headers: cloudflareMetadataHeaders(metadata, props.request, {
+    headers: cloudflareMetadataHeaders(metadata, request, {
       "content-type": "text/html; charset=utf-8"
     })
   });
@@ -4740,8 +5066,8 @@ export const slots = pageModule.slots;
 export const App = renderCloudflareStreamRoute;
 export default renderCloudflareStreamRoute;
 
-async function renderCloudflareStreamRoute(props) {
-  const metadata = await resolveRouteMetadata([...shells.map((shell) => shell.module), pageModule], props);
+async function renderCloudflareStreamRoute(props, request) {
+  const metadata = await resolveRouteMetadata([...shells.map((shell) => shell.module), pageModule], { ...props, request });
   const body = renderToReadableStream(async ($sink) => {
     const slotHtml = await renderRouteSlots(pageModule.slots, props);
     const layoutShells = await renderLayoutShells(shells, props, slotHtml);
@@ -4764,7 +5090,7 @@ async function renderCloudflareStreamRoute(props) {
     }
   });
   return new Response(body, {
-    headers: cloudflareMetadataHeaders(metadata, props.request, {
+    headers: cloudflareMetadataHeaders(metadata, request, {
       "content-type": "text/html; charset=utf-8",
       "x-mreact-stream": "1"
     })
@@ -4895,9 +5221,15 @@ function cloudflareHydrationMarkerParts(props) {
   }
   const routeId = route.routeId ?? cloudflareRouteIdForPath(props.route.path);
   const escapedRouteId = escapeHtmlAttribute(routeId);
+  const requestUrl = new URL(props.request.url);
   const propsJson = escapeScriptJson(JSON.stringify({
     params: props.params,
-    request: { url: new URL(props.request.url).pathname },
+    request: {
+      hash: "",
+      pathname: requestUrl.pathname,
+      search: "",
+      url: requestUrl.pathname,
+    },
     data: props.data,
   }));
   const clientReferencesJson = route.clientReferenceManifest === undefined || route.clientReferenceManifest.length === 0
@@ -6279,10 +6611,24 @@ function viteManifestFromClientRoutes(routes: ClientRouteManifestEntry[]): Recor
 
 interface ClientRouteBundleManifest {
   assets: string[];
+  chunks: ClientArtifactChunkManifest[];
   routes: ClientRouteManifestEntry[];
   styles: ClientStyleManifestEntry[];
 }
 
+interface ClientArtifactChunkManifest {
+  dynamicImports?: readonly string[];
+  file: string;
+  imports?: readonly string[];
+}
+
+interface ClientArtifactManifest {
+  assets?: readonly string[];
+  chunks?: readonly ClientArtifactChunkManifest[];
+  routes: readonly ClientRouteManifestEntry[];
+  styles?: readonly ClientStyleManifestEntry[];
+}
+
 interface ClientStyleManifestEntry {
   css: string[];
   file: string;
@@ -6442,6 +6788,7 @@ async function writeClientRouteBundles(options: {
   if (clientEntries.length === 0) {
     return {
       assets: [...routeCssAssets.assets, ...specialCssAssets.assets].sort(),
+      chunks: [],
       routes: entries.flatMap((entry) => ("manifest" in entry ? [entry.manifest] : [])),
       styles: specialCssAssets.styles,
     };
@@ -6552,6 +6899,9 @@ async function writeClientRouteBundles(options: {
         ? {}
         : { clientReferenceManifest: entry.build.clientReferenceManifest }),
       ...(entry.css.length === 0 ? {} : { css: entry.css }),
+      ...(routeOutput.chunk.dynamicImports.length === 0
+        ? {}
+        : { dynamicImports: routeOutput.chunk.dynamicImports }),
       ...(routeOutput.chunk.imports.length === 0 ? {} : { imports: routeOutput.chunk.imports }),
       ...(navigation ? { navigation } : {}),
       routeId,
@@ -6563,6 +6913,11 @@ async function writeClientRouteBundles(options: {
 
   return {
     assets: Array.from(generatedAssets).sort(),
+    chunks: output.chunks.map((chunk) => ({
+      ...(chunk.dynamicImports.length === 0 ? {} : { dynamicImports: chunk.dynamicImports }),
+      file: chunk.fileName,
+      ...(chunk.imports.length === 0 ? {} : { imports: chunk.imports }),
+    })),
     routes,
     styles: specialCssAssets.styles,
   };

package/src/bundle-pipeline.ts

@@ -73,6 +73,7 @@ export interface RouterBundleModulesOutput {
 
 export interface RouterBundleChunkOutput {
   code: string;
+  dynamicImports: string[];
   fileName: string;
   imports: string[];
   isEntry: boolean;
@@ -87,6 +88,7 @@ export interface RouterBundleAssetOutput {
 
 interface RouterBundlerChunk {
   code: string;
+  dynamicImports?: string[] | undefined;
   fileName: string;
   imports?: string[] | undefined;
   isEntry?: boolean | undefined;
@@ -282,7 +284,8 @@ async function bundleRouterModuleUncached(
     plugins: [
       nodeBuiltinsForBrowserPlugin(options.platform, options.nodeBuiltins ?? "reject"),
       mreactJsxRuntimeAliasPlugin({
-        externalize: options.platform === "node" && options.externalizeMreactRuntimeAliases === true,
+        externalize:
+          options.platform === "node" && options.externalizeMreactRuntimeAliases === true,
       }),
       ...(options.vitePlugins ?? []),
       virtualEntryPlugin(entryId, options.code),
@@ -369,8 +372,7 @@ function cloneRouterBundleOutput(output: RouterBundleOutput): RouterBundleOutput
       : {
           assets: output.assets.map((asset) => ({
             fileName: asset.fileName,
-            source:
-              typeof asset.source === "string" ? asset.source : new Uint8Array(asset.source),
+            source: typeof asset.source === "string" ? asset.source : new Uint8Array(asset.source),
           })),
         }),
     code: output.code,
@@ -459,6 +461,7 @@ export async function bundleRouterModules(
           options.sourceRegionModulePaths,
           options.root ?? dirname(options.entries[0]?.filename ?? process.cwd()),
         ),
+        dynamicImports: chunk.dynamicImports ?? [],
         fileName: chunk.fileName,
         imports: chunk.imports ?? [],
         isEntry: chunk.isEntry === true,
@@ -490,7 +493,9 @@ function mreactJsxRuntimeAliasPlugin(options?: { externalize?: boolean | undefin
         return undefined;
       }
 
-      return options?.externalize === true ? { external: true, id: pathToFileURL(path).href } : path;
+      return options?.externalize === true
+        ? { external: true, id: pathToFileURL(path).href }
+        : path;
     },
   };
 }