rsbuild-plugin-react-router 0.1.1 → 0.3.0

package/src/index.ts

@@ -0,0 +1,1025 @@
+import { existsSync, readFileSync } from 'node:fs';
+import fsExtra from 'fs-extra';
+import type { Config } from './react-router-config.js';
+import type { RouteConfigEntry } from '@react-router/dev/routes';
+import {
+  rspack,
+  type RsbuildEntryDescription,
+  type RsbuildPlugin,
+  type Rspack,
+} from '@rsbuild/core';
+import { createJiti } from 'jiti';
+import { relative, resolve } from 'pathe';
+
+import {
+  BUILD_CLIENT_ROUTE_QUERY_STRING,
+  JS_EXTENSIONS,
+  PLUGIN_NAME,
+} from './constants.js';
+import { guardReactRouterLazyCompilation } from './lazy-compilation.js';
+import { createDevServerMiddleware } from './dev-server.js';
+import {
+  generateWithProps,
+  findEntryFile,
+  normalizeAssetPrefix,
+} from './plugin-utils.js';
+import type { PluginOptions } from './types.js';
+import {
+  generateServerBuild,
+  resolveReactRouterServerBuild,
+} from './server-utils.js';
+import { resolvePrerenderPaths, validatePrerenderConfig } from './prerender.js';
+import { runReactRouterPrerenderBuild } from './prerender-build.js';
+import {
+  resolveReactRouterConfig,
+  type ResolvedReactRouterConfig,
+} from './react-router-config.js';
+import {
+  getReactRouterManifestForDev,
+  configRoutesToRouteManifest,
+  configRoutesToRouteManifestEntries,
+  createReactRouterManifestStats,
+  type ReactRouterManifestStats,
+  type RouteManifestModuleExports,
+} from './manifest.js';
+import { registerModifyBrowserManifestAssets } from './modify-browser-manifest.js';
+import { registerBuildOutputTransforms } from './build-output-transforms.js';
+import {
+  getRouteChunkEntryName,
+  getRouteChunkModuleId,
+  routeChunkExportNames,
+  type RouteChunkCache,
+  type RouteChunkConfig,
+} from './route-chunks.js';
+import {
+  createRouteTransformExecutor,
+  shouldParallelizeRouteTransforms,
+} from './parallel-route-transforms.js';
+import {
+  createRouteTopologyWatcher,
+  createRouteManifestSnapshot,
+  ensureDevRestartMarker,
+  getRouteRestartMarkerPath,
+  mergeWatchFiles,
+  type WatchFileConfig,
+} from './route-watch.js';
+import { validateRouteConfig } from './route-config.js';
+import {
+  getBuildManifest,
+  getRoutesByServerBundleId,
+} from './build-manifest.js';
+import {
+  createReactRouterNodeEntries,
+  createReactRouterServerBuildPlan,
+} from './server-build-plan.js';
+import { warnOnClientSourceMaps } from './warnings/warn-on-client-source-maps.js';
+import { validatePluginOrderFromConfig } from './validation/validate-plugin-order.js';
+import { getSsrExternals } from './ssr-externals.js';
+import {
+  createReactRouterPerformanceProfiler,
+  roundMs,
+} from './performance.js';
+import { mapVirtualModules } from './virtual-modules.js';
+import { createReactRouterDevRuntimeController } from './dev-runtime-controller.js';
+import { registerReactRouterTypegen } from './typegen.js';
+import {
+  clearConfigImportCache,
+  collectConfigImportWatchPaths,
+} from './config-imports.js';
+
+export { loadReactRouterServerBuild } from './dev-generation.js';
+export { resolveReactRouterServerBuild };
+
+type ModuleFederationPluginLike = {
+  name?: string;
+  _options?: { experiments?: { asyncStartup?: boolean } };
+  options?: { experiments?: { asyncStartup?: boolean } };
+};
+
+const ensureFederationAsyncStartup = (
+  rspackConfig: Rspack.Configuration | undefined
+): void => {
+  if (!rspackConfig?.plugins?.length) {
+    return;
+  }
+
+  for (const plugin of rspackConfig.plugins) {
+    if (!plugin || typeof plugin !== 'object') {
+      continue;
+    }
+    const pluginName = (plugin as ModuleFederationPluginLike).name;
+    if (pluginName !== 'ModuleFederationPlugin') {
+      continue;
+    }
+
+    const pluginOptions =
+      (plugin as ModuleFederationPluginLike)._options ??
+      (plugin as ModuleFederationPluginLike).options;
+    if (!pluginOptions) {
+      continue;
+    }
+
+    pluginOptions.experiments = {
+      ...pluginOptions.experiments,
+      asyncStartup: true,
+    };
+  }
+};
+
+const cssUrlAssetExtensions =
+  /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)$/;
+const urlAssetResourceQuery =
+  /^(?=.*(?:\?|&)url(?:&|$))(?!.*(?:\?|&)(?:raw|inline)(?:&|$))/;
+
+export const pluginReactRouter = (
+  options: PluginOptions = {}
+): RsbuildPlugin => ({
+  name: PLUGIN_NAME,
+
+  async setup(api) {
+    const defaultOptions = {
+      customServer: false,
+      serverOutput: 'module' as const,
+    };
+
+    const pluginOptions = {
+      ...defaultOptions,
+      ...options,
+    };
+    const logPerformance = pluginOptions.logPerformance === true;
+    const setupStartMs = logPerformance ? performance.now() : 0;
+    const performanceProfiler = createReactRouterPerformanceProfiler({
+      enabled: logPerformance,
+      log: message => api.logger.info(message),
+    });
+    const nodeExternals = Array.from(
+      new Set(['express', ...getSsrExternals(process.cwd())])
+    );
+
+    let assetPrefix = '/';
+
+    // Best-effort configuration validation (upstream: validate-plugin-order).
+    // Run during config modification phase so we don't rely on `getRsbuildConfig()`
+    // being available during `setup()`.
+    api.modifyRsbuildConfig({
+      order: 'pre',
+      handler(config) {
+        const issues = validatePluginOrderFromConfig(config);
+        for (const issue of issues) {
+          if (issue.kind === 'error') {
+            throw new Error(issue.message);
+          }
+          api.logger.warn(issue.message);
+        }
+        assetPrefix = normalizeAssetPrefix(config.output?.assetPrefix);
+        return config;
+      },
+    });
+
+    api.onBeforeBuild(() => {
+      const normalized = api.getNormalizedConfig();
+      warnOnClientSourceMaps(normalized, msg => api.logger.warn(msg), 'web');
+    });
+
+    registerReactRouterTypegen(api);
+
+    const configPath = findEntryFile(resolve('react-router.config'));
+    const configExists = existsSync(configPath);
+    let configWatchPaths: string | string[] = configExists
+      ? configPath
+      : JS_EXTENSIONS.map(extension =>
+          resolve(`react-router.config${extension}`)
+        );
+    let reactRouterUserConfig: Config = {};
+    if (!configExists) {
+      console.warn(
+        'No react-router.config found, using default configuration.'
+      );
+    } else {
+      const displayPath = relative(process.cwd(), configPath);
+      const configJiti = createJiti(process.cwd(), {
+        moduleCache: true,
+      });
+      const cacheKeysBeforeImport = new Set(Object.keys(configJiti.cache));
+      try {
+        const imported = await configJiti.import<Config>(configPath, {
+          default: true,
+        });
+        const importedConfigPaths = collectConfigImportWatchPaths(
+          configPath,
+          configJiti.cache,
+          cacheKeysBeforeImport
+        );
+        if (importedConfigPaths.length > 0) {
+          configWatchPaths = [configPath, ...importedConfigPaths];
+        }
+        if (imported === undefined) {
+          throw new Error(`${displayPath} must provide a default export`);
+        }
+        if (typeof imported !== 'object') {
+          throw new Error(`${displayPath} must export a config`);
+        }
+        reactRouterUserConfig = imported;
+      } catch (error) {
+        throw new Error(`Error loading ${displayPath}: ${error}`);
+      } finally {
+        clearConfigImportCache(configJiti.cache, [
+          configPath,
+          ...collectConfigImportWatchPaths(
+            configPath,
+            configJiti.cache,
+            cacheKeysBeforeImport
+          ),
+        ]);
+      }
+    }
+
+    const jiti = createJiti(process.cwd(), {
+      moduleCache: false,
+    });
+
+    const {
+      resolved: resolvedConfig,
+      presets: configPresets,
+      hasConfiguredServerModuleFormat,
+    } = await resolveReactRouterConfig(reactRouterUserConfig);
+
+    const {
+      appDirectory,
+      basename,
+      buildDirectory,
+      future,
+      allowedActionOrigins,
+      routeDiscovery: userRouteDiscovery,
+      ssr,
+      prerender: prerenderConfig,
+      serverBuildFile,
+      serverModuleFormat,
+      splitRouteModules,
+      buildEnd,
+    } = resolvedConfig;
+
+    const hasExplicitServerOutput = Object.prototype.hasOwnProperty.call(
+      options,
+      'serverOutput'
+    );
+    let resolvedServerOutput = pluginOptions.serverOutput;
+    if (!hasExplicitServerOutput) {
+      resolvedServerOutput =
+        serverModuleFormat === 'cjs' ? 'commonjs' : 'module';
+    }
+
+    if (
+      hasExplicitServerOutput &&
+      hasConfiguredServerModuleFormat &&
+      serverModuleFormat &&
+      (resolvedServerOutput === 'commonjs' ? 'cjs' : 'esm') !==
+        serverModuleFormat
+    ) {
+      api.logger.warn(
+        `[${PLUGIN_NAME}] Both \`serverOutput\` and \`serverModuleFormat\` are set. ` +
+          `Using \`serverOutput=${resolvedServerOutput}\` and ignoring ` +
+          `\`serverModuleFormat=${serverModuleFormat}\`.`
+      );
+    }
+
+    if (serverBuildFile && !serverBuildFile.endsWith('.js')) {
+      throw new Error('The `serverBuildFile` config must end in `.js`.');
+    }
+
+    if (serverModuleFormat !== 'esm' && serverModuleFormat !== 'cjs') {
+      throw new Error(
+        'The `serverModuleFormat` config must be "esm" or "cjs".'
+      );
+    }
+
+    const prerenderConfigError = validatePrerenderConfig(prerenderConfig);
+    if (prerenderConfigError) {
+      throw new Error(prerenderConfigError);
+    }
+
+    // React Router defaults to "lazy" route discovery, but "ssr:false" builds
+    // have no runtime server to serve manifest patch requests, so we force
+    // `mode:"initial"` in SPA mode to avoid any `/__manifest` fetches.
+    let routeDiscovery: Config['routeDiscovery'];
+    if (!userRouteDiscovery) {
+      routeDiscovery = ssr
+        ? ({ mode: 'lazy', manifestPath: '/__manifest' } as const)
+        : ({ mode: 'initial' } as const);
+    } else if (userRouteDiscovery.mode === 'initial') {
+      routeDiscovery = userRouteDiscovery;
+    } else if (userRouteDiscovery.mode === 'lazy') {
+      if (!ssr) {
+        throw new Error(
+          'The `routeDiscovery.mode` config cannot be set to "lazy" when setting `ssr:false`'
+        );
+      }
+      const manifestPath = userRouteDiscovery.manifestPath;
+      if (manifestPath && !manifestPath.startsWith('/')) {
+        throw new Error(
+          'The `routeDiscovery.manifestPath` config must be a root-relative pathname beginning with a slash (i.e., "/__manifest")'
+        );
+      }
+      routeDiscovery = userRouteDiscovery;
+    }
+
+    (globalThis as any).__reactRouterAppDirectory = resolve(appDirectory);
+    const routesPath = findEntryFile(resolve(appDirectory, 'routes'));
+    if (!existsSync(routesPath)) {
+      throw new Error(
+        `Route config file not found at "${relative(
+          process.cwd(),
+          routesPath
+        )}".`
+      );
+    }
+
+    const loadRouteConfig = async (): Promise<RouteConfigEntry[]> => {
+      const routeConfigExport = await jiti.import<RouteConfigEntry[]>(
+        routesPath,
+        {
+          default: true,
+        }
+      );
+      const routeConfigValue = await routeConfigExport;
+      const validation = validateRouteConfig({
+        routeConfigFile: relative(process.cwd(), routesPath),
+        routeConfig: routeConfigValue,
+      });
+      if (!validation.valid) {
+        throw new Error(validation.message);
+      }
+      return validation.routeConfig;
+    };
+    const routeConfig = await loadRouteConfig();
+
+    const entryClientPath = findEntryFile(
+      resolve(appDirectory, 'entry.client')
+    );
+    const entryServerPath = findEntryFile(
+      resolve(appDirectory, 'entry.server')
+    );
+
+    const serverAppPath = findEntryFile(
+      resolve(appDirectory, '../server/index')
+    );
+    const hasServerApp = existsSync(serverAppPath);
+    const devServerBuildEntryName = hasServerApp
+      ? 'static/js/react-router-server-build'
+      : 'static/js/app';
+
+    const templateDir = resolve(__dirname, 'templates');
+    const templateClientPath = resolve(templateDir, 'entry.client.js');
+    const templateServerPath = resolve(templateDir, 'entry.server.js');
+
+    const finalEntryClientPath = existsSync(entryClientPath)
+      ? entryClientPath
+      : templateClientPath;
+    const finalEntryServerPath = existsSync(entryServerPath)
+      ? entryServerPath
+      : templateServerPath;
+
+    const getRootRoutePath = () => findEntryFile(resolve(appDirectory, 'root'));
+    const rootRoutePath = getRootRoutePath();
+    // React Router's server build expects route files relative to `appDirectory`
+    // so it can resolve them correctly during compilation.
+    const rootRouteFile = relative(appDirectory, rootRoutePath);
+    const createRouteTopologySnapshot = (
+      routeFile: string,
+      routeConfig: RouteConfigEntry[]
+    ) =>
+      createRouteManifestSnapshot([
+        ['root', { path: '', id: 'root', file: routeFile }],
+        ...configRoutesToRouteManifestEntries(appDirectory, routeConfig),
+      ]);
+    const getWatchedRouteTopology = async (): Promise<Set<string>> => {
+      const latestRouteConfig = await loadRouteConfig();
+      const latestRootRouteFile = relative(appDirectory, getRootRoutePath());
+      return createRouteTopologySnapshot(
+        latestRootRouteFile,
+        latestRouteConfig
+      );
+    };
+
+    const routes = {
+      root: { path: '', id: 'root', file: rootRouteFile },
+      ...configRoutesToRouteManifest(appDirectory, routeConfig),
+    };
+
+    const resolvedConfigWithRoutes: ResolvedReactRouterConfig = {
+      ...resolvedConfig,
+      appDirectory: resolve(appDirectory),
+      buildDirectory: resolve(buildDirectory),
+      routeDiscovery,
+      prerender: prerenderConfig,
+      routes,
+      unstable_routeConfig: routeConfig,
+      allowedActionOrigins: allowedActionOrigins ?? false,
+    };
+
+    const { buildEnd: _buildEnd, ...resolvedConfigForPreset } =
+      resolvedConfigWithRoutes;
+    for (const preset of configPresets) {
+      await preset.reactRouterConfigResolved?.({
+        reactRouterConfig: resolvedConfigForPreset,
+      });
+    }
+
+    const isBuild = api.context.action === 'build';
+    const isPrerenderEnabled =
+      prerenderConfig !== undefined && prerenderConfig !== false;
+    const isSpaMode = !ssr && !isPrerenderEnabled;
+    const routeCount = Object.keys(routes).length;
+    const routeChunkConfig: RouteChunkConfig = {
+      splitRouteModules,
+      appDirectory,
+      rootRouteFile,
+    };
+    const routeChunkCache: RouteChunkCache = new Map();
+    const routeTransformExecutor = createRouteTransformExecutor({
+      parallelRouteTransform:
+        pluginOptions.parallelRouteTransform ??
+        shouldParallelizeRouteTransforms(routeCount),
+      routeChunkCache,
+      splitRouteModules: Boolean(splitRouteModules),
+    });
+    const routeChunkOptions = {
+      splitRouteModules,
+      rootRouteFile,
+      isBuild,
+      cache: routeChunkCache,
+    };
+    const outputClientPath = resolve(buildDirectory, 'client');
+    const assetsBuildDirectory = relative(process.cwd(), outputClientPath);
+    const watchDirectory = resolve(appDirectory);
+    const routeRestartMarkerPath = getRouteRestartMarkerPath(outputClientPath);
+    const routeTopologyWatchFiles: WatchFileConfig[] =
+      pluginOptions.onRouteTopologyChange
+        ? []
+        : [
+            {
+              paths: routesPath,
+              type: 'reload-server',
+            },
+            {
+              paths: routeRestartMarkerPath,
+              type: 'reload-server',
+            },
+          ];
+    const routeWatchFiles: WatchFileConfig[] = [
+      {
+        paths: configWatchPaths,
+        type: 'reload-server',
+      },
+      ...routeTopologyWatchFiles,
+    ];
+    let closeRouteTopologyWatcher: (() => Promise<void>) | undefined;
+
+    api.onBeforeStartDevServer(async () => {
+      await ensureDevRestartMarker(routeRestartMarkerPath);
+      closeRouteTopologyWatcher = await createRouteTopologyWatcher({
+        watchDirectory,
+        getRouteTopology: getWatchedRouteTopology,
+        initialRouteTopology: createRouteTopologySnapshot(
+          rootRouteFile,
+          routeConfig
+        ),
+        restartMarkerPath: routeRestartMarkerPath,
+        onRouteTopologyChange: pluginOptions.onRouteTopologyChange,
+        onError: error => {
+          api.logger.warn(
+            `[${PLUGIN_NAME}] Failed to watch route topology changes: ${error}`
+          );
+        },
+      });
+    });
+
+    api.onCloseDevServer(async () => {
+      await closeRouteTopologyWatcher?.();
+      closeRouteTopologyWatcher = undefined;
+    });
+    api.onCloseBuild(async () => {
+      await routeTransformExecutor.close();
+    });
+    api.onCloseDevServer(async () => {
+      await routeTransformExecutor.close();
+    });
+
+    type ReactRouterManifest = Awaited<
+      ReturnType<typeof getReactRouterManifestForDev>
+    >;
+    let latestBrowserManifest: ReactRouterManifest | null = null;
+    let latestBrowserManifestModuleExports: RouteManifestModuleExports = {};
+    let latestServerManifest: ReactRouterManifest | null = null;
+    const latestServerManifestsByBundleId: Record<string, ReactRouterManifest> =
+      {};
+
+    const stageLatestManifests = (
+      manifest: ReactRouterManifest,
+      sri: ReactRouterManifest['sri'],
+      moduleExportsByRouteId: RouteManifestModuleExports,
+      compilation: Rspack.Compilation
+    ) => {
+      performanceProfiler.recordSync(
+        'web',
+        'manifest:stage',
+        'virtual/react-router/browser-manifest',
+        () => {
+          latestBrowserManifest = manifest;
+          latestBrowserManifestModuleExports = moduleExportsByRouteId;
+          const baseServerManifest = {
+            ...manifest,
+            sri,
+          };
+          latestServerManifest = baseServerManifest;
+          const manifestsByEntryName: Record<string, ReactRouterManifest> = {
+            [devServerBuildEntryName]: baseServerManifest,
+          };
+
+          for (const { bundleId, entryName } of serverBundleEntries) {
+            const bundleRoutes = routesByServerBundleId[bundleId];
+            if (!bundleRoutes) {
+              continue;
+            }
+
+            const routeIds = new Set(Object.keys(bundleRoutes));
+            const filteredRoutes = Object.fromEntries(
+              Object.entries(manifest.routes).filter(([routeId]) =>
+                routeIds.has(routeId)
+              )
+            );
+            const bundleManifest = {
+              ...baseServerManifest,
+              routes: filteredRoutes,
+            };
+            latestServerManifestsByBundleId[bundleId] = bundleManifest;
+            manifestsByEntryName[entryName] = bundleManifest;
+          }
+
+          if (!isBuild) {
+            devRuntime.captureWeb(compilation, manifestsByEntryName);
+          }
+        }
+      );
+    };
+
+    const routeByFilePath = new Map(
+      Object.values(routes).map(route => [
+        resolve(appDirectory, route.file),
+        route,
+      ])
+    );
+
+    const manifestChunkNames = new Set<string>(['entry.client']);
+    const webRouteEntries = Object.values(routes).reduce(
+      (acc, route) => {
+        const entryName = route.file.slice(0, route.file.lastIndexOf('.'));
+        const routeFilePath = resolve(appDirectory, route.file);
+        manifestChunkNames.add(entryName);
+        acc[entryName] = {
+          import: `${routeFilePath}${BUILD_CLIENT_ROUTE_QUERY_STRING}`,
+          html: false,
+        };
+
+        if (isBuild && splitRouteModules && route.id !== 'root') {
+          let source: string;
+          try {
+            source = readFileSync(routeFilePath, 'utf8');
+          } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+              return acc;
+            }
+            throw error;
+          }
+          for (const exportName of routeChunkExportNames) {
+            if (!source.includes(exportName)) {
+              continue;
+            }
+            const chunkEntryName = getRouteChunkEntryName(route.id, exportName);
+            manifestChunkNames.add(chunkEntryName);
+            acc[chunkEntryName] = {
+              import: getRouteChunkModuleId(routeFilePath, exportName),
+              html: false,
+            };
+          }
+        }
+
+        return acc;
+      },
+      {} as Record<string, RsbuildEntryDescription>
+    );
+    const buildManifest = await getBuildManifest({
+      reactRouterConfig: resolvedConfigWithRoutes,
+      routes,
+      rootDirectory: process.cwd(),
+    });
+    const routesByServerBundleId = getRoutesByServerBundleId(
+      buildManifest,
+      routes
+    );
+    const serverBuildPlan = createReactRouterServerBuildPlan({
+      routesByServerBundleId,
+      serverBuildFile,
+      defaultEntryName: devServerBuildEntryName,
+    });
+    const { serverBundleEntries } = serverBuildPlan;
+    const devRuntime = createReactRouterDevRuntimeController({
+      api,
+      isBuild,
+      buildPlan: serverBuildPlan,
+    });
+
+    let clientStats: ReactRouterManifestStats | undefined;
+    api.onAfterEnvironmentCompile(({ stats, environment }) => {
+      if (environment.name === 'web') {
+        clientStats = createReactRouterManifestStats(
+          stats?.compilation,
+          manifestChunkNames
+        );
+      }
+      if (pluginOptions.federation && ssr) {
+        const serverBuildDir = resolve(buildDirectory, 'server');
+        const clientBuildDir = resolve(buildDirectory, 'client');
+        if (existsSync(serverBuildDir)) {
+          const ssrDir = resolve(clientBuildDir, 'static');
+          fsExtra.copySync(serverBuildDir, ssrDir);
+        }
+      }
+      if (logPerformance) {
+        performanceProfiler.flush(environment.name, {
+          compilerLifecycleMs: roundMs(performance.now() - setupStartMs),
+        });
+      }
+    });
+
+    const prerenderPaths = await resolvePrerenderPaths(
+      prerenderConfig,
+      ssr,
+      routeConfig,
+      {
+        logWarning: true,
+        warn: message => api.logger.warn(message),
+      }
+    );
+
+    api.onAfterBuild(async ({ environments }) => {
+      await runReactRouterPrerenderBuild({
+        api,
+        hasWebEnvironment: Boolean(environments.web),
+        buildDirectory,
+        serverBuildFile,
+        ssr,
+        isPrerenderEnabled,
+        prerenderConfig,
+        prerenderPaths,
+        basename,
+        future,
+        routes,
+        latestBrowserManifest,
+        latestBrowserManifestModuleExports,
+        clientStats,
+        pluginOptions,
+        appDirectory,
+        assetPrefix,
+        routeChunkOptions,
+        buildManifest,
+        resolvedConfigWithRoutes,
+        buildEnd,
+      });
+    });
+
+    const allowedActionOriginsForBuild =
+      allowedActionOrigins === false ? undefined : allowedActionOrigins;
+
+    // Public requests stay bare while Rspack resolves seeded virtual files.
+    const createVirtualModulePlugin = (publicPath: string) => {
+      const bundleVirtualModules = Object.fromEntries(
+        Object.entries(routesByServerBundleId).map(
+          ([bundleId, bundleRoutes]) => [
+            `virtual/react-router/server-build-${bundleId}`,
+            generateServerBuild(bundleRoutes, {
+              entryServerPath: finalEntryServerPath,
+              assetsBuildDirectory,
+              basename,
+              appDirectory,
+              ssr,
+              federation: options.federation,
+              future,
+              allowedActionOrigins: allowedActionOriginsForBuild,
+              prerender: prerenderPaths,
+              routeDiscovery,
+              publicPath,
+              serverManifestId: `virtual/react-router/server-manifest-${bundleId}`,
+            }),
+          ]
+        )
+      );
+      const bundleManifestModules = Object.fromEntries(
+        Object.entries(routesByServerBundleId)
+          .filter(
+            ([, bundleRoutes]) =>
+              bundleRoutes && Object.keys(bundleRoutes).length > 0
+          )
+          .map(([bundleId]) => [
+            `virtual/react-router/server-manifest-${bundleId}`,
+            'export default {};',
+          ])
+      );
+
+      return new rspack.experiments.VirtualModulesPlugin(
+        mapVirtualModules({
+          'virtual/react-router/browser-manifest': 'export default {};',
+          'virtual/react-router/server-manifest': 'export default {};',
+          'virtual/react-router/server-build': generateServerBuild(routes, {
+            entryServerPath: finalEntryServerPath,
+            assetsBuildDirectory,
+            basename,
+            appDirectory,
+            ssr,
+            federation: options.federation,
+            future,
+            allowedActionOrigins: allowedActionOriginsForBuild,
+            prerender: prerenderPaths,
+            routeDiscovery,
+            publicPath,
+          }),
+          ...bundleVirtualModules,
+          ...bundleManifestModules,
+          'virtual/react-router/with-props': generateWithProps(),
+        })
+      );
+    };
+
+    api.modifyRsbuildConfig(async (config, { mergeRsbuildConfig }) => {
+      assetPrefix = normalizeAssetPrefix(config.output?.assetPrefix);
+      const vmodPlugin = createVirtualModulePlugin(assetPrefix);
+      const useAsyncNodeChunkLoading =
+        options.federation && resolvedServerOutput === 'commonjs';
+      let nodeChunkLoading: 'import' | 'async-node' | 'require' = 'require';
+      if (resolvedServerOutput === 'module') {
+        nodeChunkLoading = 'import';
+      } else if (useAsyncNodeChunkLoading) {
+        nodeChunkLoading = 'async-node';
+      }
+      const nodeEntries = createReactRouterNodeEntries({
+        hasServerApp,
+        isBuild,
+        serverAppPath,
+        entryServerPath: finalEntryServerPath,
+        defaultEntryName: devServerBuildEntryName,
+        serverBundleEntries,
+      });
+
+      const configuredLazyCompilation =
+        pluginOptions.lazyCompilation === undefined
+          ? config.dev?.lazyCompilation
+          : pluginOptions.lazyCompilation;
+      const guardedLazyCompilation = guardReactRouterLazyCompilation({
+        lazyCompilation: configuredLazyCompilation,
+        entryClientPath: finalEntryClientPath,
+      });
+      const lazyCompilation =
+        guardedLazyCompilation === undefined
+          ? {}
+          : { lazyCompilation: guardedLazyCompilation };
+      const shouldCompactFileSizeReport =
+        isBuild &&
+        routeCount >= 256 &&
+        (config.performance?.printFileSize === undefined ||
+          config.performance.printFileSize === true);
+
+      return mergeRsbuildConfig(config, {
+        ...(shouldCompactFileSizeReport
+          ? {
+              performance: {
+                printFileSize: {
+                  total: true,
+                  detail: false,
+                  compressed: false,
+                },
+              },
+            }
+          : {}),
+        output: {
+          assetPrefix: config.output?.assetPrefix || '/',
+        },
+        dev: {
+          writeToDisk: true,
+          ...lazyCompilation,
+          watchFiles: mergeWatchFiles(config.dev?.watchFiles, routeWatchFiles),
+          setupMiddlewares:
+            pluginOptions.customServer || !ssr
+              ? []
+              : [
+                  middlewares => {
+                    middlewares.push(
+                      createDevServerMiddleware({
+                        loadBuild: devRuntime.createBuildLoader(),
+                      })
+                    );
+                  },
+                ],
+        },
+        tools: {
+          rspack: {
+            plugins: [vmodPlugin],
+          },
+        },
+        environments: {
+          web: {
+            ...(resolvedConfigWithRoutes.subResourceIntegrity
+              ? {
+                  security: {
+                    sri: {
+                      enable: true,
+                    },
+                  },
+                }
+              : {}),
+            source: {
+              entry: {
+                // no query needed when federation is disabled
+                'entry.client': finalEntryClientPath,
+                'virtual/react-router/browser-manifest': {
+                  import: 'virtual/react-router/browser-manifest',
+                  html: false,
+                },
+                ...webRouteEntries,
+              },
+            },
+            output: {
+              filename: {
+                js: '[name].js',
+              },
+              distPath: {
+                root: outputClientPath,
+              },
+            },
+            tools: {
+              rspack: {
+                name: 'web',
+                module: {
+                  rules: [
+                    {
+                      resourceQuery: urlAssetResourceQuery,
+                      exclude: cssUrlAssetExtensions,
+                      type: 'asset/resource',
+                    },
+                  ],
+                },
+                ...(options.federation
+                  ? {
+                      output: {
+                        chunkLoading: 'import',
+                      },
+                    }
+                  : {}),
+                externalsType: 'module',
+                output: {
+                  chunkFormat: 'module',
+                  chunkLoading: 'import',
+                  workerChunkLoading: 'import',
+                  wasmLoading: 'fetch',
+                  library: { type: 'module' },
+                  module: true,
+                },
+                optimization: {
+                  avoidEntryIife: true,
+                  runtimeChunk: 'single',
+                },
+              },
+            },
+          },
+          // Always include node environment, even for SPA mode (`ssr:false`),
+          // because React Router still needs a server build to prerender the
+          // root route into a hydratable `index.html` at build time.
+          node: {
+            source: {
+              entry: nodeEntries,
+            },
+            output: {
+              distPath: {
+                root: resolve(buildDirectory, 'server'),
+              },
+              target: config.environments?.node?.output?.target || 'node',
+              filename: {
+                js: '[name].js',
+              },
+            },
+            tools: {
+              rspack: {
+                target: options.federation ? 'async-node' : 'node',
+                module: {
+                  rules: [
+                    {
+                      resourceQuery: urlAssetResourceQuery,
+                      exclude: cssUrlAssetExtensions,
+                      type: 'asset/resource',
+                    },
+                  ],
+                },
+                externals: nodeExternals,
+                dependencies: ['web'],
+                externalsType: resolvedServerOutput,
+                output: {
+                  chunkFormat: resolvedServerOutput,
+                  chunkLoading: nodeChunkLoading,
+                  workerChunkLoading: nodeChunkLoading,
+                  wasmLoading: 'fetch',
+                  module: resolvedServerOutput === 'module',
+                },
+              },
+            },
+          },
+        },
+      });
+    });
+
+    api.modifyEnvironmentConfig(
+      async (config, { name, mergeEnvironmentConfig }) => {
+        if (name !== 'web' && name !== 'node') {
+          return config;
+        }
+
+        return mergeEnvironmentConfig(config, {
+          tools: {
+            rspack: rspackConfig => {
+              if (pluginOptions.federation) {
+                ensureFederationAsyncStartup(rspackConfig);
+              }
+
+              if (name === 'node') {
+                const output = rspackConfig.output;
+                if (output) {
+                  const library = output.library;
+                  const libraryOptions =
+                    library &&
+                    typeof library === 'object' &&
+                    !Array.isArray(library)
+                      ? library
+                      : {};
+                  rspackConfig.output = {
+                    ...output,
+                    library: {
+                      ...libraryOptions,
+                      type:
+                        resolvedServerOutput === 'module'
+                          ? 'module'
+                          : 'commonjs2',
+                    },
+                  };
+                }
+              }
+
+              return rspackConfig;
+            },
+          },
+        });
+      }
+    );
+
+    registerModifyBrowserManifestAssets(
+      api,
+      routes,
+      pluginOptions,
+      appDirectory,
+      () => assetPrefix,
+      routeChunkOptions,
+      {
+        subResourceIntegrity: resolvedConfigWithRoutes.subResourceIntegrity,
+        future,
+        manifestChunkNames,
+        onManifest: (manifest, sri, moduleExportsByRouteId, context) =>
+          stageLatestManifests(
+            manifest,
+            sri,
+            moduleExportsByRouteId,
+            context.compilation
+          ),
+      }
+    );
+
+    registerBuildOutputTransforms({
+      api,
+      resolvedServerOutput,
+      performanceProfiler,
+      getLatestServerManifest: () => latestServerManifest,
+      getLatestServerManifestByBundleId: bundleId =>
+        latestServerManifestsByBundleId[bundleId],
+      routes,
+      pluginOptions,
+      getClientStats: () => clientStats,
+      appDirectory,
+      getAssetPrefix: () => assetPrefix,
+      routeChunkOptions,
+      routeTransformExecutor,
+      routeByFilePath,
+      routeChunkConfig,
+      isBuild,
+      splitRouteModules: Boolean(splitRouteModules),
+      ssr,
+      isSpaMode,
+      rootRoutePath,
+    });
+  },
+});