rsbuild-plugin-react-router 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,68 +1,25 @@
-let lexer_C;
-import { __webpack_require__ } from "./0~rslib-runtime.js";
-import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { pathToFileURL, fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { existsSync, readFileSync, realpathSync, watch } from "node:fs";
 import fs_extra from "fs-extra";
+import { rspack } from "@rsbuild/core";
 import { createJiti } from "jiti";
-import jsesc from "jsesc";
-import { basename as external_pathe_basename, dirname, extname, isAbsolute, normalize, relative, resolve } from "pathe";
-import { RspackVirtualModulePlugin } from "rspack-plugin-virtual-module";
-import { parse } from "@babel/parser";
-import { callExpression, functionExpression, identifier as types_identifier, importDeclaration, importSpecifier, isClassDeclaration, isExportAllDeclaration, isExportDeclaration, isExportDefaultDeclaration, isExportNamedDeclaration, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNodesEquivalent, isObjectProperty, isPattern, isRestElement, isStatement, isVariableDeclaration, isVariableDeclarator, stringLiteral, variableDeclaration, variableDeclarator as types_variableDeclarator } from "@babel/types";
-import { deadCodeElimination, findReferencedIdentifiers } from "babel-dead-code-elimination";
+import { dirname, isAbsolute, relative, resolve as external_pathe_resolve } from "pathe";
+import { createRequestHandler as external_react_router_createRequestHandler, matchRoutes } from "react-router";
+import { access, mkdir, readdir, writeFile } from "node:fs/promises";
+import { pathToFileURL, fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
-import { rspack } from "@rsbuild/core";
-import { createRequestHandler, matchRoutes } from "react-router";
-import { sep, dirname as __rspack_dirname } from "node:path";
-import * as __rspack_external_esbuild from "esbuild";
-let generator_namespaceObject = require("@babel/generator");
-var A, A1, ImportType, generator_default = __webpack_require__.n(generator_namespaceObject);
-let traverse_namespaceObject = require("@babel/traverse");
-var traverse_default = __webpack_require__.n(traverse_namespaceObject);
-let traverse = traverse_default().default ?? traverse_default(), generate = generator_default().default ?? generator_default(), PLUGIN_NAME = 'rsbuild:react-router', JS_EXTENSIONS = [
-    '.tsx',
-    '.ts',
-    '.jsx',
-    '.js',
-    '.mjs',
-    '.mts'
-], JS_LOADERS = {
-    '.ts': 'ts',
-    '.tsx': 'tsx',
-    '.js': 'js',
-    '.jsx': 'jsx',
-    '.mjs': 'js',
-    '.mts': 'ts'
-}, BUILD_CLIENT_ROUTE_QUERY_STRING = '?__react-router-build-client-route', SERVER_ONLY_ROUTE_EXPORTS = [
-    'loader',
-    'action',
-    'middleware',
-    'headers'
-], CLIENT_ROUTE_EXPORTS = [
-    'clientAction',
-    'clientLoader',
-    'clientMiddleware',
-    'handle',
-    'meta',
-    'links',
-    'shouldRevalidate',
-    'default',
-    'ErrorBoundary',
-    'HydrateFallback',
-    'Layout'
-], NAMED_COMPONENT_EXPORTS = [
-    'HydrateFallback',
-    'ErrorBoundary'
-];
+import { availableParallelism, cpus } from "node:os";
+import jsesc from "jsesc";
+import { Worker } from "node:worker_threads";
+import { createRequire } from "node:module";
+import { isAbsolute as external_node_path_isAbsolute, relative as external_node_path_relative, sep, dirname as __rspack_dirname } from "node:path";
+import { createRouteId, SERVER_EXPORTS, combineURLs, JS_EXTENSIONS, executeRouteTransformTask, setBoundedCacheEntry, PLUGIN_NAME, generateWithProps, getRouteModuleAnalysis, createEmptyRouteChunkByExportName, findEntryFile, routeChunkExportNames, validateRouteChunks, CLIENT_EXPORTS, buildManifestChunkValidity, BUILD_CLIENT_ROUTE_QUERY_STRING, getRouteChunkEntryName, getRouteChunkModuleId, normalizeAssetPrefix, detectRouteChunksIfEnabled, createBundlerRouteExportResolver } from "./451.js";
 function generateServerBuild(routes, options) {
     let manifestId;
     return manifestId = options.serverManifestId ?? 'virtual/react-router/server-manifest', `
     import * as entryServer from ${JSON.stringify(options.entryServerPath)};
     ${Object.keys(routes).map((key, index)=>{
         let route = routes[key];
-        return `import * as route${index} from ${JSON.stringify(`${resolve(options.appDirectory, route.file)}?react-router-route`)};`;
+        return `import * as route${index} from ${JSON.stringify(`${external_pathe_resolve(options.appDirectory, route.file)}?react-router-route`)};`;
     }).join('\n')}
         
     export { default as assets } from ${JSON.stringify(manifestId)};
@@ -103,7 +60,14 @@ let RESOLVABLE_BUILD_EXPORTS = new Set([
     'routeDiscovery',
     'routes',
     'ssr'
-]), isPromiseLike = (value)=>'function' == typeof value?.then, normalizeBuildModule = (build)=>build && 'object' == typeof build && 'default' in build && 1 === Object.keys(build).length && 'object' == typeof build.default && build.default ? build.default : build, resolveBuildExports = async (build)=>{
+]);
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function isPromiseLike(value) {
+    return isRecord(value) && 'function' == typeof value.then;
+}
+async function resolveBuildExports(build) {
     let resolved = {
         ...build
     };
@@ -118,30 +82,56 @@ let RESOLVABLE_BUILD_EXPORTS = new Set([
         isPromiseLike(value) && (resolved[key] = await value);
     }
     return resolved;
-};
-function invalidDestructureError(name) {
-    return Error(`Cannot remove destructured export "${name}"`);
-}
-function toFunctionExpression(decl) {
-    return functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
 }
-function combineURLs(baseURL, relativeURL) {
-    return relativeURL ? `${baseURL.replace(/\/+$/, '')}/${relativeURL.replace(/^\/+/, '')}` : baseURL;
+async function resolveServerBuildCandidate(candidate) {
+    var value;
+    if (!isRecord(candidate)) return;
+    let resolved = await resolveBuildExports(candidate);
+    return isRecord(resolved) && isRecord(resolved.entry) && isRecord(resolved.entry.module) && 'function' == typeof resolved.entry.module.default && isRecord(resolved.routes) && isRecord(resolved.assets) && 'string' == typeof resolved.assetsBuildDirectory && (void 0 === resolved.basename || 'string' == typeof resolved.basename) && isRecord(resolved.future) && 'boolean' == typeof resolved.isSpaMode && Array.isArray(resolved.prerender) && 'string' == typeof resolved.publicPath && isRecord(value = resolved.routeDiscovery) && ('initial' === value.mode || 'lazy' === value.mode && (void 0 === value.manifestPath || 'string' == typeof value.manifestPath)) && 'boolean' == typeof resolved.ssr ? resolved : void 0;
 }
-function normalizeAssetPrefix(assetPrefix) {
-    return assetPrefix && 'auto' !== assetPrefix ? assetPrefix.endsWith('/') ? assetPrefix : `${assetPrefix}/` : '/';
-}
-function findEntryFile(basePath) {
-    for (let ext of JS_EXTENSIONS){
-        let filePath = `${basePath}${ext}`;
-        if (existsSync(filePath)) return filePath;
+async function resolveServerBuildModule(buildModule, source) {
+    let moduleValue = await buildModule, candidates = [
+        ()=>moduleValue
+    ];
+    for (let getCandidate of (isRecord(moduleValue) && ('default' in moduleValue && candidates.push(()=>moduleValue.default), 'module.exports' in moduleValue && candidates.push(()=>moduleValue['module.exports'])), candidates)){
+        let candidate = await getCandidate(), serverBuild = await resolveServerBuildCandidate(candidate);
+        if (serverBuild) return serverBuild;
     }
-    return `${basePath}.tsx`;
+    throw Error(`[rsbuild-plugin-react-router] ${source} did not contain a valid React Router ServerBuild.`);
 }
-function isNamedComponentExport(name) {
-    return NAMED_COMPONENT_EXPORTS.includes(name);
+function resolveReactRouterServerBuild(buildModule) {
+    return resolveServerBuildModule(buildModule, 'Imported module');
 }
-let normalizePath = (value)=>value.replace(/\/\/+/g, '/').replace(/(.+)\/$/, '$1'), resolvePrerenderPaths = async (prerender, ssr, routes, options = {})=>{
+let normalizePath = (value)=>value.replace(/\/\/+/g, '/').replace(/(.+)\/$/, '$1'), groupRoutesByParentId = (manifest)=>{
+    let grouped = {};
+    return Object.values(manifest).forEach((route)=>{
+        if (!route) return;
+        let parentId = route.parentId || '';
+        grouped[parentId] ??= [], grouped[parentId].push(route);
+    }), grouped;
+}, createPrerenderRoutes = (manifest, parentId = '', grouped = groupRoutesByParentId(manifest))=>(grouped[parentId] || []).map((route)=>{
+        let common = {
+            id: route.id,
+            path: route.path
+        };
+        return route.index ? {
+            index: !0,
+            ...common
+        } : {
+            ...common,
+            children: createPrerenderRoutes(manifest, route.id, grouped)
+        };
+    }), normalizePrerenderMatchPath = (path)=>`/${path}/`.replace(/^\/\/+/, '/'), withBuildRequest = async (input, init, handle)=>{
+    let controller = new AbortController();
+    try {
+        return await handle(new Request(input, {
+            ...init,
+            signal: controller.signal
+        }));
+    } finally{
+        controller.abort();
+    }
+}, resolvePrerenderPaths = async (prerender, ssr, routes, options = {})=>{
     let pathsConfig, paths, paramRoutes, recurse;
     if (null == prerender || !1 === prerender || !1 === (pathsConfig = 'object' == typeof prerender && null !== prerender && 'paths' in prerender ? prerender?.paths : prerender)) return [];
     let { paths: paths1, paramRoutes: paramRoutes1 } = (paths = [
@@ -182,12 +172,392 @@ let normalizePath = (value)=>value.replace(/\/\/+/g, '/').replace(/(.+)\/$/, '$1
         return !0 === resolved ? paths1 : !1 === resolved || null == resolved ? [] : resolved;
     }
     return pathsConfig ?? [];
-}, isValidPrerenderPathsConfig = (value)=>'boolean' == typeof value || 'function' == typeof value || Array.isArray(value), DEFAULT_CONFIG = {
+}, getPrerenderConfigObject = (prerender)=>'object' != typeof prerender || null === prerender || Array.isArray(prerender) ? null : prerender, getPrerenderConcurrencyConfig = (config)=>config?.concurrency !== void 0 ? {
+        key: 'prerender.concurrency',
+        value: config.concurrency
+    } : config?.unstable_concurrency !== void 0 ? {
+        key: 'prerender.unstable_concurrency',
+        value: config.unstable_concurrency
+    } : void 0, getAvailableCpuCount = ()=>'function' == typeof availableParallelism ? availableParallelism() : cpus().length, getDefaultConcurrency = (cpuCount = getAvailableCpuCount())=>Math.max(0, Math.floor(cpuCount) - 2), mapWithConcurrency = async (items, concurrency, worker)=>{
+    let results = Array(items.length), nextIndex = 0, workerCount = Math.max(1, Math.min(concurrency, items.length));
+    return await Promise.all(Array.from({
+        length: workerCount
+    }, async ()=>{
+        for(;;){
+            let index = nextIndex++;
+            if (index >= items.length) return;
+            results[index] = await worker(items[index], index);
+        }
+    })), results;
+}, ROUTE_ANALYSIS_CONCURRENCY = Math.max(1, Math.min(16, getDefaultConcurrency() || 1));
+function configRoutesToRouteManifestEntries(appDirectory, routes, rootId = 'root') {
+    let routeManifestEntries = [], routeIds = new Set();
+    for (let route of routes)!function walk(route, parentId) {
+        let id = route.id || createRouteId(route.file), manifestItem = {
+            id,
+            parentId,
+            file: isAbsolute(route.file) ? relative(appDirectory, route.file) : route.file,
+            path: route.path,
+            index: route.index,
+            caseSensitive: route.caseSensitive
+        };
+        if (routeIds.has(id)) throw Error(`Unable to define routes with duplicate route id: "${id}"`);
+        if (routeIds.add(id), routeManifestEntries.push([
+            id,
+            manifestItem
+        ]), route.children) for (let child of route.children)walk(child, id);
+    }(route, rootId);
+    return routeManifestEntries;
+}
+let orderChunkFiles = (chunkName, files)=>{
+    let ownChunkAsset = `${chunkName}.js`, ownFileIndex = files.findIndex((file)=>file.endsWith(ownChunkAsset));
+    return ownFileIndex <= 0 ? files : [
+        files[ownFileIndex],
+        ...files.slice(0, ownFileIndex),
+        ...files.slice(ownFileIndex + 1)
+    ];
+}, createReactRouterManifestStats = (compilation, chunkNames)=>{
+    if (!compilation) return;
+    let assetsByChunkName = {}, entrypointFilesByName = {}, namedChunks = compilation.namedChunks, entrypoints = compilation.entrypoints;
+    if (chunkNames && 'function' == typeof namedChunks.get) for (let chunkName of chunkNames){
+        let chunk = namedChunks.get(chunkName);
+        if (!chunk) continue;
+        let files = Array.from(chunk.files ?? []);
+        assetsByChunkName[chunkName] = orderChunkFiles(chunkName, files);
+    }
+    else for (let [chunkName, chunk] of namedChunks){
+        if (chunkNames && !chunkNames.has(chunkName)) continue;
+        let files = Array.from(chunk.files ?? []);
+        assetsByChunkName[chunkName] = orderChunkFiles(chunkName, files);
+    }
+    if (entrypoints) if (chunkNames && 'function' == typeof entrypoints.get) for (let entrypointName of chunkNames){
+        let entrypoint = entrypoints.get(entrypointName);
+        entrypoint && (entrypointFilesByName[entrypointName] = Array.from(entrypoint.getFiles?.() ?? []));
+    }
+    else for (let [entrypointName, entrypoint] of entrypoints)(!chunkNames || chunkNames.has(entrypointName)) && (entrypointFilesByName[entrypointName] = Array.from(entrypoint.getFiles?.() ?? []));
+    return Object.keys(entrypointFilesByName).length > 0 ? {
+        assetsByChunkName,
+        entrypointFilesByName
+    } : {
+        assetsByChunkName
+    };
+}, DEFAULT_MANIFEST_DIR = 'static/js', getReactRouterManifestPath = ({ version, isBuild, entryModulePath })=>{
+    if (!isBuild) return 'static/js/virtual/react-router/browser-manifest.js';
+    let dir = ((entryModulePath)=>{
+        if (!entryModulePath) return DEFAULT_MANIFEST_DIR;
+        let dir = dirname(entryModulePath);
+        return '.' === dir ? DEFAULT_MANIFEST_DIR : dir;
+    })(entryModulePath);
+    return `${dir}/manifest-${version}.js`;
+}, getRouteEntryName = (route)=>{
+    let extensionIndex = route.file.lastIndexOf('.');
+    return extensionIndex >= 0 ? route.file.slice(0, extensionIndex) : route.file;
+};
+async function generateReactRouterManifestForDev(routes, _options, clientStats, context, assetPrefix = '/', routeChunkOptions) {
+    let result = {}, splitRouteModules = routeChunkOptions?.splitRouteModules ?? !1, enforceSplitRouteModules = 'enforce' === splitRouteModules, isBuild = routeChunkOptions?.isBuild ?? !1, routeChunkConfig = splitRouteModules && routeChunkOptions?.rootRouteFile ? {
+        splitRouteModules,
+        appDirectory: context,
+        rootRouteFile: routeChunkOptions.rootRouteFile
+    } : null, getAssetsForChunk = (chunkName)=>{
+        let assets = clientStats?.assetsByChunkName?.[chunkName];
+        if (!assets) return [
+            `${DEFAULT_MANIFEST_DIR}/${chunkName}.js`
+        ];
+        let entrypointCssAssets = clientStats?.entrypointFilesByName?.[chunkName]?.filter((asset)=>asset.endsWith('.css')) ?? [], cssAssets = [
+            ...assets.filter((asset)=>asset.endsWith('.css')),
+            ...entrypointCssAssets
+        ].filter((asset, index, all)=>all.indexOf(asset) === index), nonCssAssets = assets.filter((asset)=>!asset.endsWith('.css'));
+        return nonCssAssets.some((asset)=>asset.endsWith('.js')) ? [
+            ...nonCssAssets,
+            ...cssAssets
+        ] : [
+            `${DEFAULT_MANIFEST_DIR}/${chunkName}.js`,
+            ...nonCssAssets,
+            ...cssAssets
+        ];
+    }, getModulePathForChunk = (chunkName)=>{
+        let jsAssets = getAssetsForChunk(chunkName).filter((asset)=>asset.endsWith('.js'));
+        return jsAssets[0] ? combineURLs(assetPrefix, jsAssets[0]) : void 0;
+    }, manifestEntries = await mapWithConcurrency(Object.entries(routes), ROUTE_ANALYSIS_CONCURRENCY, async ([key, route])=>{
+        let routeEntryName = getRouteEntryName(route), assets = getAssetsForChunk(routeEntryName), jsAssets = assets.filter((asset)=>asset.endsWith('.js')), cssAssets = assets.filter((asset)=>asset.endsWith('.css')), routeFilePath = external_pathe_resolve(context, route.file), exports = new Set(), routeModuleExports = [], hasRouteChunkByExportName = null;
+        try {
+            let { code, exports: exportNames } = await getRouteModuleAnalysis(routeFilePath);
+            if (!isBuild && 0 === cssAssets.length && /\.(?:css|less|sass|scss)(?:\?[^'"`]+)?['"`]/.test(code) && (cssAssets = [
+                `${DEFAULT_MANIFEST_DIR.replace('/js', '/css')}/${routeEntryName}.css`
+            ]), routeModuleExports = exportNames, exports = new Set(exportNames), isBuild && routeChunkConfig) {
+                let { hasRouteChunkByExportName: chunkInfo } = await detectRouteChunksIfEnabled(routeChunkOptions?.cache, routeChunkConfig, routeFilePath, code);
+                hasRouteChunkByExportName = chunkInfo;
+            }
+        } catch (error) {
+            if (isBuild) throw error;
+            console.error(`Failed to analyze route file ${routeFilePath}:`, error);
+        }
+        let hasClientAction = exports.has(CLIENT_EXPORTS.clientAction), hasClientLoader = exports.has(CLIENT_EXPORTS.clientLoader), hasClientMiddleware = exports.has(CLIENT_EXPORTS.clientMiddleware), hasDefaultExport = exports.has('default'), routeChunkMap = hasRouteChunkByExportName;
+        return isBuild && enforceSplitRouteModules && routeChunkConfig && validateRouteChunks({
+            config: routeChunkConfig,
+            id: routeFilePath,
+            valid: buildManifestChunkValidity(exports, routeChunkMap ?? createEmptyRouteChunkByExportName())
+        }), [
+            key,
+            {
+                id: route.id,
+                parentId: route.parentId,
+                path: route.path,
+                index: route.index,
+                caseSensitive: route.caseSensitive,
+                module: combineURLs(assetPrefix, jsAssets[0] || ''),
+                clientActionModule: routeChunkMap?.clientAction ? getModulePathForChunk(getRouteChunkEntryName(route.id, 'clientAction')) : void 0,
+                clientLoaderModule: routeChunkMap?.clientLoader ? getModulePathForChunk(getRouteChunkEntryName(route.id, 'clientLoader')) : void 0,
+                clientMiddlewareModule: routeChunkMap?.clientMiddleware ? getModulePathForChunk(getRouteChunkEntryName(route.id, 'clientMiddleware')) : void 0,
+                hydrateFallbackModule: routeChunkMap?.HydrateFallback ? getModulePathForChunk(getRouteChunkEntryName(route.id, 'HydrateFallback')) : void 0,
+                hasAction: exports.has(SERVER_EXPORTS.action),
+                hasLoader: exports.has(SERVER_EXPORTS.loader),
+                hasClientAction,
+                hasClientLoader,
+                hasClientMiddleware,
+                hasDefaultExport,
+                hasErrorBoundary: exports.has(CLIENT_EXPORTS.ErrorBoundary),
+                imports: jsAssets.map((asset)=>combineURLs(assetPrefix, asset)),
+                css: cssAssets.map((asset)=>combineURLs(assetPrefix, asset))
+            },
+            routeModuleExports
+        ];
+    }), routeModuleExportsByRouteId = {};
+    for (let [key, routeManifestItem, routeModuleExports] of manifestEntries)result[key] = routeManifestItem, routeModuleExportsByRouteId[key] = routeModuleExports;
+    let entryAssets = getAssetsForChunk('entry.client'), entryJsAssets = entryAssets.filter((asset)=>asset.endsWith('.js')), entryCssAssets = entryAssets.filter((asset)=>asset.endsWith('.css')), fingerprintedValues = {
+        entry: {
+            module: combineURLs(assetPrefix, entryJsAssets[0] || ''),
+            imports: entryJsAssets.map((asset)=>combineURLs(assetPrefix, asset)),
+            css: entryCssAssets.map((asset)=>combineURLs(assetPrefix, asset))
+        },
+        routes: result
+    }, version = isBuild ? createHash('md5').update(JSON.stringify(fingerprintedValues)).digest('hex').slice(0, 8) : String(Math.random()), manifestPath = getReactRouterManifestPath({
+        version,
+        isBuild,
+        entryModulePath: entryJsAssets[0]
+    });
+    return {
+        manifest: {
+            version,
+            url: combineURLs(assetPrefix, manifestPath),
+            hmr: void 0,
+            entry: fingerprintedValues.entry,
+            sri: void 0,
+            routes: result
+        },
+        moduleExportsByRouteId: routeModuleExportsByRouteId
+    };
+}
+async function getReactRouterManifestForDev(...args) {
+    return (await generateReactRouterManifestForDev(...args)).manifest;
+}
+let redirectStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]), getServerBuildPath = async ({ buildDirectory, serverBuildFile })=>{
+    let serverBuildDir = external_pathe_resolve(buildDirectory, 'server'), defaultServerBuildFile = 'static/js/app.js', configuredServerBuildFile = serverBuildFile || 'index.js', configuredServerBuildPath = external_pathe_resolve(serverBuildDir, configuredServerBuildFile), defaultServerBuildPath = external_pathe_resolve(serverBuildDir, defaultServerBuildFile);
+    return configuredServerBuildFile !== defaultServerBuildFile && existsSync(defaultServerBuildPath) && !existsSync(configuredServerBuildPath) && (await mkdir(dirname(configuredServerBuildPath), {
+        recursive: !0
+    }), await fs_extra.copy(defaultServerBuildPath, configuredServerBuildPath)), {
+        serverBuildDir,
+        serverBuildPath: existsSync(configuredServerBuildPath) ? configuredServerBuildPath : defaultServerBuildPath
+    };
+}, prerenderData = async ({ handler, prerenderPath, onlyRoutes, clientBuildDir, basename, trailingSlashAwareDataRequests, api, requestInit })=>{
+    let dataRequestPath = trailingSlashAwareDataRequests ? prerenderPath.endsWith('/') ? `${prerenderPath}_.data` : `${prerenderPath}.data` : '/' === prerenderPath ? '/_root.data' : `${prerenderPath.replace(/\/$/, '')}.data`, normalizedPath = `${basename}${dataRequestPath}`.replace(/\/\/+/g, '/'), url = new URL(`http://localhost${normalizedPath}`);
+    return onlyRoutes?.length && url.searchParams.set('_routes', onlyRoutes.join(',')), withBuildRequest(url, requestInit, async (request)=>{
+        let response = await handler(request), data = await response.text();
+        if (200 !== response.status && 202 !== response.status) throw Error(`Prerender (data): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${prerenderPath}\` path.\n${normalizedPath}`);
+        let outputPath = external_pathe_resolve(clientBuildDir, ...normalizedPath.split('/'));
+        return await mkdir(dirname(outputPath), {
+            recursive: !0
+        }), await writeFile(outputPath, data), api.logger.info(`Prerender (data): ${prerenderPath} -> ${relative(process.cwd(), outputPath)}`), data;
+    });
+}, prerenderRoute = async ({ handler, prerenderPath, clientBuildDir, basename, api, requestInit })=>{
+    let normalizedPath = `${basename}${prerenderPath}/`.replace(/\/\/+/g, '/');
+    await withBuildRequest(`http://localhost${normalizedPath}`, requestInit, async (request)=>{
+        let response = await handler(request), html = await response.text();
+        if (redirectStatusCodes.has(response.status)) {
+            let location = response.headers.get('Location'), delay = 2 * (302 === response.status);
+            html = `<!doctype html>
+<head>
+<title>Redirecting to: ${location}</title>
+<meta http-equiv="refresh" content="${delay};url=${location}">
+<meta name="robots" content="noindex">
+</head>
+<body>
+\t<a href="${location}">
+    Redirecting from <code>${normalizedPath}</code> to <code>${location}</code>
+  </a>
+</body>
+</html>`;
+        } else if (200 !== response.status) throw Error(`Prerender (html): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${normalizedPath}\` path.\n` + html);
+        let outputPath = external_pathe_resolve(clientBuildDir, ...normalizedPath.split('/'), 'index.html');
+        await mkdir(dirname(outputPath), {
+            recursive: !0
+        }), await writeFile(outputPath, html), api.logger.info(`Prerender (html): ${prerenderPath} -> ${relative(process.cwd(), outputPath)}`);
+    });
+}, prerenderResourceRoute = async ({ handler, prerenderPath, clientBuildDir, basename, api, requestInit })=>{
+    let normalizedPath = `${basename}${prerenderPath}/`.replace(/\/\/+/g, '/').replace(/\/$/g, '');
+    await withBuildRequest(`http://localhost${normalizedPath}`, requestInit, async (request)=>{
+        let response = await handler(request), content = Buffer.from(await response.arrayBuffer());
+        if (200 !== response.status) throw Error(`Prerender (resource): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${normalizedPath}\` path.\n` + content.toString('utf8'));
+        let outputPath = external_pathe_resolve(clientBuildDir, ...normalizedPath.split('/'));
+        await mkdir(dirname(outputPath), {
+            recursive: !0
+        }), await writeFile(outputPath, content), api.logger.info(`Prerender (resource): ${prerenderPath} -> ${relative(process.cwd(), outputPath)}`);
+    });
+}, handleSpaMode = async ({ handler, build, clientBuildDir, basename, api })=>{
+    await withBuildRequest(`http://localhost${basename}`, {
+        headers: {
+            'X-React-Router-SPA-Mode': 'yes'
+        }
+    }, async (request)=>{
+        let response = await handler(request), html = await response.text(), isPrerenderSpaFallback = build.prerender?.includes('/'), filename = isPrerenderSpaFallback ? '__spa-fallback.html' : 'index.html';
+        if (200 !== response.status) {
+            if (isPrerenderSpaFallback) throw Error(`Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename}\` file.\n` + html);
+            throw Error(`SPA Mode: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename}\` file.\n` + html);
+        }
+        if (!html.includes('window.__reactRouterContext =') || !html.includes('window.__reactRouterRouteModules =')) throw Error("SPA Mode: Did you forget to include `<Scripts/>` in your root route? Your pre-rendered HTML cannot hydrate without `<Scripts />`.");
+        let outputPath = external_pathe_resolve(clientBuildDir, filename);
+        await writeFile(outputPath, html);
+        let prettyPath = relative(process.cwd(), outputPath);
+        build.prerender?.length ? api.logger.info(`Prerender (html): SPA Fallback -> ${prettyPath}`) : api.logger.info(`SPA Mode: Generated ${prettyPath}`);
+    });
+}, runPrerenderPaths = async ({ build, requestHandler, clientBuildDir, options })=>{
+    let config, value, { api, basename, future, prerenderConfig, prerenderPaths } = options, buildRoutes = createPrerenderRoutes(build.routes), concurrency = (config = getPrerenderConfigObject(prerenderConfig), 'number' == typeof (value = getPrerenderConcurrencyConfig(config)?.value) && Number.isInteger(value) && value > 0 ? value : 1), pending = new Set(), enqueue = async (path)=>{
+        let data, matches = matchRoutes(buildRoutes, normalizePrerenderMatchPath(path));
+        if (!matches) return;
+        let leafRoute = matches[matches.length - 1]?.route, routeId = leafRoute?.id, manifestRoute = routeId ? build.routes?.[routeId]?.module : null;
+        !manifestRoute || manifestRoute.default || manifestRoute.ErrorBoundary ? (matches.some((match)=>{
+            let matchedRouteId = match.route.id;
+            return !!matchedRouteId && build.assets?.routes?.[matchedRouteId]?.hasLoader;
+        }) && (data = await prerenderData({
+            handler: requestHandler,
+            prerenderPath: path,
+            onlyRoutes: null,
+            clientBuildDir,
+            basename,
+            trailingSlashAwareDataRequests: future.unstable_trailingSlashAwareDataRequests,
+            api
+        })), await prerenderRoute({
+            handler: requestHandler,
+            prerenderPath: path,
+            clientBuildDir,
+            basename,
+            api,
+            requestInit: data ? {
+                headers: {
+                    'X-React-Router-Prerender-Data': encodeURI(data)
+                }
+            } : void 0
+        })) : manifestRoute.loader && routeId ? (await prerenderData({
+            handler: requestHandler,
+            prerenderPath: path,
+            onlyRoutes: [
+                routeId
+            ],
+            clientBuildDir,
+            basename,
+            trailingSlashAwareDataRequests: future.unstable_trailingSlashAwareDataRequests,
+            api
+        }), await prerenderResourceRoute({
+            handler: requestHandler,
+            prerenderPath: path,
+            clientBuildDir,
+            basename,
+            api
+        })) : api.logger.warn(`⚠️ Skipping prerendering for resource route without a loader: ${routeId}`);
+    };
+    for (let path of prerenderPaths){
+        let task = enqueue(path);
+        pending.add(task), task.finally(()=>pending.delete(task)), pending.size >= concurrency && await Promise.race(pending);
+    }
+    await Promise.all(pending);
+}, runReactRouterPrerenderBuild = async (options)=>{
+    if (!options.hasWebEnvironment) return;
+    let { api, buildDirectory, serverBuildFile, ssr, isPrerenderEnabled, prerenderPaths, routes, latestBrowserManifest, latestBrowserManifestModuleExports, clientStats, pluginOptions, appDirectory, assetPrefix, routeChunkOptions, buildManifest, resolvedConfigWithRoutes, buildEnd, basename } = options, { serverBuildDir, serverBuildPath } = await getServerBuildPath({
+        buildDirectory,
+        serverBuildFile
+    }), clientBuildDir = external_pathe_resolve(buildDirectory, 'client');
+    if (!existsSync(serverBuildPath)) return void console.warn(`[${PLUGIN_NAME}] Server build not found at ${serverBuildPath}. Skipping prerendering.`);
+    if (await mkdir(clientBuildDir, {
+        recursive: !0
+    }), !ssr || isPrerenderEnabled) {
+        process.env.IS_RR_BUILD_REQUEST = 'yes';
+        let buildModule = await import(pathToFileURL(serverBuildPath).toString()), build = await resolveServerBuildModule(buildModule, `Server build ${JSON.stringify(serverBuildPath)}`), requestHandler = external_react_router_createRequestHandler(build, 'production');
+        if (isPrerenderEnabled) {
+            if (!ssr) {
+                let generated = latestBrowserManifest ? {
+                    manifest: latestBrowserManifest,
+                    moduleExportsByRouteId: latestBrowserManifestModuleExports
+                } : await generateReactRouterManifestForDev(routes, pluginOptions, clientStats, appDirectory, assetPrefix, routeChunkOptions);
+                (({ routes, manifestRoutes, routeExports, prerenderPaths, api })=>{
+                    let errors = (({ routes, manifestRoutes, routeExports, prerenderPaths })=>{
+                        if (0 === prerenderPaths.length) return [];
+                        let prerenderRoutes = createPrerenderRoutes(routes), prerenderedRoutes = new Set();
+                        for (let path of prerenderPaths){
+                            let matches = matchRoutes(prerenderRoutes, normalizePrerenderMatchPath(path));
+                            if (!matches) throw Error(`Unable to prerender path because it does not match any routes: ${path}`);
+                            matches.forEach((match)=>prerenderedRoutes.add(match.route.id));
+                        }
+                        let errors = [];
+                        for (let [routeId, route] of Object.entries(manifestRoutes)){
+                            let exports = routeExports[routeId] ?? [], invalidApis = [];
+                            if (exports.includes('headers') && invalidApis.push('headers'), exports.includes('action') && invalidApis.push('action'), invalidApis.length > 0 && errors.push(`Prerender: ${invalidApis.length} invalid route export(s) in \`${routeId}\` when pre-rendering with \`ssr:false\`: ${invalidApis.map((api)=>`\`${api}\``).join(', ')}. See https://reactrouter.com/how-to/pre-rendering#invalid-exports for more information.`), !prerenderedRoutes.has(routeId)) {
+                                exports.includes('loader') && errors.push(`Prerender: 1 invalid route export in \`${routeId}\` when pre-rendering with \`ssr:false\`: \`loader\`. See https://reactrouter.com/how-to/pre-rendering#invalid-exports for more information.`);
+                                let parentRoute = route.parentId && manifestRoutes[route.parentId] ? manifestRoutes[route.parentId] : null;
+                                for(; parentRoute;)parentRoute.hasLoader && !parentRoute.hasClientLoader && errors.push(`Prerender: 1 invalid route export in \`${parentRoute.id}\` when pre-rendering with \`ssr:false\`: \`loader\`. See https://reactrouter.com/how-to/pre-rendering#invalid-exports for more information.`), parentRoute = parentRoute.parentId && manifestRoutes[parentRoute.parentId] ? manifestRoutes[parentRoute.parentId] : null;
+                            }
+                        }
+                        return errors;
+                    })({
+                        routes,
+                        manifestRoutes,
+                        routeExports,
+                        prerenderPaths
+                    });
+                    if (errors.length > 0) throw api.logger.error(errors.join('\n')), Error('Invalid route exports found when prerendering with `ssr:false`');
+                })({
+                    routes,
+                    manifestRoutes: generated.manifest.routes,
+                    routeExports: generated.moduleExportsByRouteId,
+                    prerenderPaths,
+                    api
+                });
+            }
+            let routeTree = createPrerenderRoutes(routes);
+            for (let path of prerenderPaths)if (!matchRoutes(routeTree, normalizePrerenderMatchPath(path))) throw Error(`Unable to prerender path because it does not match any routes: ${path}`);
+            prerenderPaths.length > 0 && api.logger.info(`Prerender (html): ${prerenderPaths.length} path(s)...`), await runPrerenderPaths({
+                build,
+                requestHandler,
+                clientBuildDir,
+                options
+            });
+        }
+        ssr || await handleSpaMode({
+            handler: requestHandler,
+            build,
+            clientBuildDir,
+            basename,
+            api
+        });
+    }
+    ssr || (await fs_extra.remove(serverBuildDir), api.logger.info(`[${PLUGIN_NAME}] Removed server build (static deployment)`)), buildEnd && await buildEnd({
+        buildManifest,
+        reactRouterConfig: resolvedConfigWithRoutes,
+        viteConfig: api.getNormalizedConfig()
+    });
+}, DEFAULT_CONFIG = {
     appDirectory: 'app',
     basename: '/',
     buildDirectory: 'build',
     serverBuildFile: 'index.js',
     serverModuleFormat: 'esm',
+    splitRouteModules: !0,
+    subResourceIntegrity: !1,
     ssr: !0,
     future: {
         unstable_optimizeDeps: !1,
@@ -204,6 +574,16 @@ let normalizePath = (value)=>value.replace(/\/\/+/g, '/').replace(/(.+)\/$/, '$1
     allowedActionOrigins: !1,
     routes: {},
     unstable_routeConfig: []
+}, normalizeSubResourceIntegrity = (config)=>{
+    let subResourceIntegrity = config.subResourceIntegrity ?? config.future?.unstable_subResourceIntegrity;
+    return void 0 === subResourceIntegrity ? config : {
+        ...config,
+        subResourceIntegrity,
+        future: {
+            ...config.future ?? {},
+            unstable_subResourceIntegrity: subResourceIntegrity
+        }
+    };
 }, resolveReactRouterConfig = async (reactRouterUserConfig)=>{
     let userAndPresetConfigs = ((...configs)=>configs.reduce((configA, configB)=>{
             let mergeRequired = (key)=>void 0 !== configA[key] && void 0 !== configB[key];
@@ -240,495 +620,337 @@ let normalizePath = (value)=>value.replace(/\/\/+/g, '/').replace(/(.+)\/$/, '$1
         if (!presetConfig) return null;
         let { presets: _presets, ...rest } = presetConfig;
         return rest;
-    }))).filter(Boolean), reactRouterUserConfig), resolvedFuture = {
+    }))).filter(Boolean).map(normalizeSubResourceIntegrity), normalizeSubResourceIntegrity(reactRouterUserConfig)), subResourceIntegrity = userAndPresetConfigs.subResourceIntegrity ?? userAndPresetConfigs.future?.unstable_subResourceIntegrity ?? DEFAULT_CONFIG.subResourceIntegrity, resolvedFuture = {
         ...DEFAULT_CONFIG.future,
-        ...userAndPresetConfigs.future ?? {}
-    }, resolved = {
+        ...userAndPresetConfigs.future ?? {},
+        unstable_subResourceIntegrity: subResourceIntegrity
+    }, splitRouteModules = userAndPresetConfigs.splitRouteModules ?? userAndPresetConfigs.future?.v8_splitRouteModules ?? DEFAULT_CONFIG.splitRouteModules, resolved = {
         ...DEFAULT_CONFIG,
         ...userAndPresetConfigs,
         future: resolvedFuture,
+        splitRouteModules,
+        subResourceIntegrity,
         allowedActionOrigins: userAndPresetConfigs.allowedActionOrigins ?? DEFAULT_CONFIG.allowedActionOrigins,
         routes: DEFAULT_CONFIG.routes,
-        unstable_routeConfig: DEFAULT_CONFIG.unstable_routeConfig,
-        serverBundles: DEFAULT_CONFIG.serverBundles
+        unstable_routeConfig: DEFAULT_CONFIG.unstable_routeConfig
     };
     return resolved.ssr || (resolved = {
         ...resolved,
         serverBundles: void 0
     }), {
         resolved,
-        presets: reactRouterUserConfig.presets ?? []
-    };
-}, routeChunkExportNames = [
-    'clientAction',
-    'clientLoader',
-    'clientMiddleware',
-    'HydrateFallback'
-];
-[
-    ...routeChunkExportNames
-];
-let routeChunkQueryStringPrefix = '?route-chunk=', routeChunkQueryStrings = {
-    main: `${routeChunkQueryStringPrefix}main`,
-    clientAction: `${routeChunkQueryStringPrefix}clientAction`,
-    clientLoader: `${routeChunkQueryStringPrefix}clientLoader`,
-    clientMiddleware: `${routeChunkQueryStringPrefix}clientMiddleware`,
-    HydrateFallback: `${routeChunkQueryStringPrefix}HydrateFallback`
-}, routeChunkEntrySuffix = {
-    clientAction: 'client-action',
-    clientLoader: 'client-loader',
-    clientMiddleware: 'client-middleware',
-    HydrateFallback: 'hydrate-fallback'
-}, invariant = (value, message)=>{
-    if (!value) throw Error(message);
-}, getOrSetFromCache = (cache, key, version, getValue)=>{
-    if (!cache) return getValue();
-    let entry = cache.get(key);
-    if (entry?.version === version) return entry.value;
-    let value = getValue();
-    return cache.set(key, {
-        value,
-        version
-    }), value;
-}, codeToAst = (code, cache, cacheKey)=>structuredClone(getOrSetFromCache(cache, `${cacheKey}::codeToAst`, code, ()=>parse(code, {
-            sourceType: 'module'
-        }))), isNodePathWithNode = (path)=>!(!path || 'object' != typeof path || Array.isArray(path)) && 'node' in path && !!path.node, assertNodePathIsVariableDeclarator = (path)=>{
-    invariant(path && !Array.isArray(path) && isVariableDeclarator(path.node), `Expected a VariableDeclarator path, but got ${Array.isArray(path) ? 'an array' : path?.node?.type}`);
-}, assertNodePathIsPattern = (path)=>{
-    invariant(path && !Array.isArray(path) && isPattern(path.node), `Expected a Pattern path, but got ${Array.isArray(path) ? 'an array' : path?.node?.type}`);
-}, getExportDependencies = (code, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::getExportDependencies`, code, ()=>{
-        let exportDependencies = new Map();
-        function handleExport(exportName, exportPath, identifiersPath = exportPath) {
-            let identifiers = getDependentIdentifiersForPath(identifiersPath), topLevelStatements = new Set([
-                exportPath.node,
-                ...getTopLevelStatementsForPaths(identifiers)
-            ]), topLevelNonModuleStatements = new Set(Array.from(topLevelStatements).filter((statement)=>!isImportDeclaration(statement) && !isExportDeclaration(statement))), importedIdentifierNames = new Set();
-            for (let identifier of identifiers)isIdentifier(identifier.node) && identifier.parentPath?.parentPath?.isImportDeclaration() && importedIdentifierNames.add(identifier.node.name);
-            let exportedVariableDeclarators = new Set();
-            for (let identifier of identifiers){
-                if (identifier.parentPath?.isVariableDeclarator()) {
-                    let parentPath = identifier.parentPath;
-                    if (parentPath.parentPath?.parentPath?.isExportNamedDeclaration()) {
-                        exportedVariableDeclarators.add(parentPath.node);
-                        continue;
-                    }
-                }
-                if (identifier.findParent((path)=>!!(path.isPattern() && path.parentPath?.isVariableDeclarator() && path.parentPath.parentPath?.parentPath?.isExportNamedDeclaration()))) {
-                    let currentPath = identifier;
-                    for(; currentPath;){
-                        if (currentPath.parentPath?.isVariableDeclarator() && 'id' === currentPath.parentKey) {
-                            exportedVariableDeclarators.add(currentPath.parentPath.node);
-                            break;
-                        }
-                        currentPath = currentPath.parentPath;
-                    }
-                }
-            }
-            exportDependencies.set(exportName, {
-                topLevelStatements,
-                topLevelNonModuleStatements,
-                importedIdentifierNames,
-                exportedVariableDeclarators
-            });
-        }
-        return traverse(codeToAst(code, cache, cacheKey), {
-            ExportDeclaration (exportPath) {
-                let { node } = exportPath;
-                if (isExportAllDeclaration(node)) return;
-                if (isExportDefaultDeclaration(node)) return void handleExport('default', exportPath);
-                let { declaration } = node;
-                if (isVariableDeclaration(declaration)) {
-                    let { declarations } = declaration;
-                    for(let i = 0; i < declarations.length; i++){
-                        let declarator = declarations[i];
-                        if (isIdentifier(declarator.id)) {
-                            let declaratorPath = exportPath.get(`declaration.declarations.${i}`);
-                            assertNodePathIsVariableDeclarator(declaratorPath), handleExport(declarator.id.name, exportPath, declaratorPath);
-                            continue;
-                        }
-                        if (isPattern(declarator.id)) {
-                            let exportedPatternPath = exportPath.get(`declaration.declarations.${i}.id`);
-                            for (let identifier of (assertNodePathIsPattern(exportedPatternPath), getIdentifiersForPatternPath(exportedPatternPath)))isIdentifier(identifier.node) && handleExport(identifier.node.name, exportPath, identifier);
-                        }
-                    }
-                    return;
-                }
-                if (isFunctionDeclaration(declaration) || isClassDeclaration(declaration)) {
-                    invariant(declaration.id, 'Expected exported function or class declaration to have a name when not the default export'), handleExport(declaration.id.name, exportPath);
-                    return;
-                }
-                if (isExportNamedDeclaration(node)) {
-                    for (let specifier of node.specifiers)if (isIdentifier(specifier.exported)) {
-                        let name = specifier.exported.name, specifierPath = exportPath.get('specifiers').find((path)=>path.node === specifier);
-                        invariant(specifierPath, `Expected to find specifier path for ${name}`), handleExport(name, exportPath, specifierPath);
-                    }
-                    return;
-                }
-                throw Error('Unknown export node type');
-            }
-        }), exportDependencies;
-    }), getDependentIdentifiersForPath = (path, state)=>{
-    let { visited, identifiers } = state ?? {
-        visited: new Set(),
-        identifiers: new Set()
+        presets: reactRouterUserConfig.presets ?? [],
+        hasConfiguredServerModuleFormat: void 0 !== userAndPresetConfigs.serverModuleFormat
     };
-    if (visited.has(path)) return identifiers;
-    visited.add(path), path.traverse({
-        Identifier (pathInner) {
-            if (identifiers.has(pathInner)) return;
-            identifiers.add(pathInner);
-            let binding = pathInner.scope.getBinding(pathInner.node.name);
-            if (binding) {
-                for (let reference of (getDependentIdentifiersForPath(binding.path, {
-                    visited,
-                    identifiers
-                }), binding.referencePaths))reference.isExportNamedDeclaration() || getDependentIdentifiersForPath(reference, {
-                    visited,
-                    identifiers
-                });
-                for (let constantViolation of binding.constantViolations)getDependentIdentifiersForPath(constantViolation, {
-                    visited,
-                    identifiers
-                });
-            }
-        }
-    });
-    let topLevelStatement = getTopLevelStatementPathForPath(path), withinImportStatement = topLevelStatement.isImportDeclaration(), withinExportStatement = topLevelStatement.isExportDeclaration();
-    if (withinImportStatement || withinExportStatement || getDependentIdentifiersForPath(topLevelStatement, {
-        visited,
-        identifiers
-    }), withinExportStatement && path.isIdentifier() && (isPattern(path.parentPath.node) || isPattern(path.parentPath.parentPath?.node))) {
-        let variableDeclarator = path.findParent((p)=>p.isVariableDeclarator());
-        variableDeclarator && (invariant(variableDeclarator && !Array.isArray(variableDeclarator), `Expected a Path, but got ${Array.isArray(variableDeclarator) ? 'an array' : variableDeclarator}`), getDependentIdentifiersForPath(variableDeclarator, {
-            visited,
-            identifiers
-        }));
+}, BROWSER_MANIFEST_ASSET = 'static/js/virtual/react-router/browser-manifest.js', ABSOLUTE_URL_RE = /^[a-zA-Z][a-zA-Z\d+\-.]*:/, addIntegrity = (sri, assetPrefix, assetName, integrity)=>{
+    'string' == typeof assetName && 'string' == typeof integrity && (sri[ABSOLUTE_URL_RE.test(assetName) || assetName.startsWith('//') || assetName.startsWith('/') ? assetName : combineURLs(assetPrefix, assetName)] = integrity);
+};
+function isSourceMapEnabled(value) {
+    return !0 === value || !1 !== value && null != value && ('string' == typeof value || 'object' == typeof value && !!value.js);
+}
+function getDevtoolFromRspackConfig(config) {
+    if (config && 'function' != typeof config && 'object' == typeof config) return config.devtool;
+}
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return descriptor.get ? descriptor.get.call(receiver) : descriptor.value;
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap), privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw TypeError("attempted to set read only private field");
+        descriptor.value = value;
     }
-    return identifiers;
-}, getTopLevelStatementPathForPath = (path)=>{
-    let ancestry = path.getAncestry(), topLevelStatement = ancestry[ancestry.length - 2];
-    return invariant(topLevelStatement && !Array.isArray(topLevelStatement) && isStatement(topLevelStatement.node), `Expected a Statement path, but got ${Array.isArray(topLevelStatement) ? 'an array' : topLevelStatement?.node?.type}`), topLevelStatement;
-}, getTopLevelStatementsForPaths = (paths)=>{
-    let topLevelStatements = new Set();
-    for (let path of paths){
-        let topLevelStatement = getTopLevelStatementPathForPath(path);
-        topLevelStatements.add(topLevelStatement.node);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet), privateSet.add(obj);
+}
+function _define_property(obj, key, value) {
+    return key in obj ? Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+    }) : obj[key] = value, obj;
+}
+class WorkerStartupError extends Error {
+    constructor(message){
+        super(message), this.name = 'WorkerStartupError';
     }
-    return topLevelStatements;
-}, getIdentifiersForPatternPath = (patternPath, identifiers = new Set())=>(!function walk(currentPath) {
-        if (currentPath.isIdentifier()) return void identifiers.add(currentPath);
-        if (currentPath.isObjectPattern()) {
-            let { properties } = currentPath.node;
-            for(let i = 0; i < properties.length; i++){
-                let property = properties[i];
-                if (isObjectProperty(property)) {
-                    let valuePath = currentPath.get(`properties.${i}.value`);
-                    isNodePathWithNode(valuePath) && walk(valuePath);
-                } else if (isRestElement(property)) {
-                    let argumentPath = currentPath.get(`properties.${i}.argument`);
-                    isNodePathWithNode(argumentPath) && walk(argumentPath);
-                }
-            }
-        } else if (currentPath.isArrayPattern()) {
-            let { elements } = currentPath.node;
-            for(let i = 0; i < elements.length; i++)if (elements[i]) {
-                let elementPath = currentPath.get(`elements.${i}`);
-                isNodePathWithNode(elementPath) && walk(elementPath);
-            }
-        } else if (currentPath.isRestElement()) {
-            let argumentPath = currentPath.get('argument');
-            isNodePathWithNode(argumentPath) && walk(argumentPath);
-        }
-    }(patternPath), identifiers), getExportedName = (exported)=>isIdentifier(exported) ? exported.name : exported.value, setsIntersect = (set1, set2)=>{
-    let smallerSet = set1, largerSet = set2;
-    for (let element of (set1.size > set2.size && (smallerSet = set2, largerSet = set1), smallerSet))if (largerSet.has(element)) return !0;
-    return !1;
-}, hasChunkableExport = (code, exportName, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::hasChunkableExport::${exportName}`, code, ()=>{
-        let exportDependencies = getExportDependencies(code, cache, cacheKey), dependencies = exportDependencies.get(exportName);
-        if (!dependencies) return !1;
-        for (let [currentExportName, currentDependencies] of exportDependencies)if (currentExportName !== exportName && setsIntersect(currentDependencies.topLevelNonModuleStatements, dependencies.topLevelNonModuleStatements)) return !1;
-        if (dependencies.exportedVariableDeclarators.size > 1) return !1;
-        if (dependencies.exportedVariableDeclarators.size > 0) {
-            for (let [currentExportName, currentDependencies] of exportDependencies)if (currentExportName !== exportName && setsIntersect(currentDependencies.exportedVariableDeclarators, dependencies.exportedVariableDeclarators)) return !1;
+}
+var _closed = new WeakMap(), _closePromise = new WeakMap(), _workersDisabled = new WeakMap(), _nextId = new WeakMap(), _nextRouteModuleWorkerIndex = new WeakMap(), _nextSplitRouteAnalysisWorkerIndex = new WeakMap(), _splitRouteAnalysisWorkers = new WeakMap(), _workers = new WeakMap(), _disableWorkers = new WeakSet(), _createWorkerState = new WeakSet(), _runInWorker = new WeakSet(), _createWorkerRequestTask = new WeakSet(), _getWorkerIndex = new WeakSet();
+class ParallelRouteTransformExecutor {
+    async run(task) {
+        if (_class_private_field_get(this, _closed) || 'clientOnlyStub' === task.kind && task.resolveExportAllModule) return executeRouteTransformTask(task, this.options);
+        try {
+            return await _class_private_method_get(this, _runInWorker, runInWorker).call(this, task);
+        } catch (error) {
+            if (error instanceof WorkerStartupError) return executeRouteTransformTask(task, this.options);
+            throw error;
         }
-        return !0;
-    }), getRouteChunkModuleId = (filePath, chunkName)=>`${filePath}${routeChunkQueryStrings[chunkName]}`, normalizeRelativeFilePath = (file, appDirectory)=>{
-    let fullPath = resolve(appDirectory, file);
-    return normalize(relative(appDirectory, fullPath)).split('?')[0];
-}, isRootRouteModuleId = (config, id)=>normalizeRelativeFilePath(id, config.appDirectory) === config.rootRouteFile, detectRouteChunksIfEnabled = async (cache, config, id, code)=>{
-    let hasRouteChunkByExportName, chunkedExports;
-    if (!config.splitRouteModules || isRootRouteModuleId(config, id) || !routeChunkExportNames.some((exportName)=>code.includes(exportName))) return {
-        chunkedExports: [],
-        hasRouteChunks: !1,
-        hasRouteChunkByExportName: {
-            clientAction: !1,
-            clientLoader: !1,
-            clientMiddleware: !1,
-            HydrateFallback: !1
+    }
+    close() {
+        if (_class_private_field_get(this, _closePromise)) return _class_private_field_get(this, _closePromise);
+        _class_private_field_set(this, _closed, !0);
+        let workers = _class_private_field_get(this, _workers);
+        return _class_private_field_set(this, _workers, []), _class_private_field_set(this, _closePromise, Promise.all(workers.map(async (state)=>{
+            for (let pending of state.pending.values())pending.reject(Error('Route transform worker closed.'));
+            state.pending.clear(), await state.worker.terminate();
+        })).then(()=>void 0)), _class_private_field_get(this, _closePromise);
+    }
+    constructor(workerCount, options, balanceRouteModuleTransforms){
+        _class_private_method_init(this, _disableWorkers), _class_private_method_init(this, _createWorkerState), _class_private_method_init(this, _runInWorker), _class_private_method_init(this, _createWorkerRequestTask), _class_private_method_init(this, _getWorkerIndex), _define_property(this, "options", void 0), _define_property(this, "balanceRouteModuleTransforms", void 0), _class_private_field_init(this, _closed, {
+            writable: !0,
+            value: void 0
+        }), _class_private_field_init(this, _closePromise, {
+            writable: !0,
+            value: void 0
+        }), _class_private_field_init(this, _workersDisabled, {
+            writable: !0,
+            value: void 0
+        }), _class_private_field_init(this, _nextId, {
+            writable: !0,
+            value: void 0
+        }), _class_private_field_init(this, _nextRouteModuleWorkerIndex, {
+            writable: !0,
+            value: void 0
+        }), _class_private_field_init(this, _nextSplitRouteAnalysisWorkerIndex, {
+            writable: !0,
+            value: void 0
+        }), _class_private_field_init(this, _splitRouteAnalysisWorkers, {
+            writable: !0,
+            value: void 0
+        }), _class_private_field_init(this, _workers, {
+            writable: !0,
+            value: void 0
+        }), this.options = options, this.balanceRouteModuleTransforms = balanceRouteModuleTransforms, _class_private_field_set(this, _closed, !1), _class_private_field_set(this, _workersDisabled, !1), _class_private_field_set(this, _nextId, 1), _class_private_field_set(this, _nextRouteModuleWorkerIndex, 0), _class_private_field_set(this, _nextSplitRouteAnalysisWorkerIndex, 0), _class_private_field_set(this, _splitRouteAnalysisWorkers, new Map()), _class_private_field_set(this, _workers, []);
+        try {
+            for(let index = 0; index < workerCount; index += 1)_class_private_field_get(this, _workers).push(_class_private_method_get(this, _createWorkerState, createWorkerState).call(this));
+        } catch (error) {
+            for (let state of _class_private_field_get(this, _workers))state.worker.terminate();
+            throw _class_private_field_set(this, _workers, []), error;
         }
+    }
+}
+function disableWorkers(error) {
+    if (_class_private_field_get(this, _workersDisabled) || _class_private_field_get(this, _closed)) return;
+    _class_private_field_set(this, _workersDisabled, !0);
+    let workers = _class_private_field_get(this, _workers);
+    for (let state of (_class_private_field_set(this, _workers, []), workers)){
+        for (let pending of state.pending.values())pending.reject(error);
+        state.pending.clear(), state.worker.terminate();
+    }
+}
+function createWorkerState() {
+    let worker = new Worker(new URL('./parallel-route-transform-worker.js', import.meta.url)), state = {
+        worker,
+        pending: new Map(),
+        sourceCache: new Map()
     };
-    let cacheKey = normalizeRelativeFilePath(id, config.appDirectory);
-    return {
-        hasRouteChunks: (chunkedExports = Object.entries(hasRouteChunkByExportName = Object.fromEntries(routeChunkExportNames.map((exportName)=>[
-                exportName,
-                hasChunkableExport(code, exportName, cache, cacheKey)
-            ]))).filter(([, isChunked])=>isChunked).map(([exportName])=>exportName)).length > 0,
-        hasRouteChunkByExportName,
-        chunkedExports
-    };
-}, getRouteChunkIfEnabled = async (cache, config, id, chunkName, code)=>{
-    if (!config.splitRouteModules) return null;
-    let cacheKey = normalizeRelativeFilePath(id, config.appDirectory);
-    return ('main' === chunkName ? ((code, exportNames, generateOptions = {}, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::omitChunkedExports::${exportNames.join(',')}::${JSON.stringify(generateOptions)}`, code, ()=>{
-            let isOmitted = (exportName)=>exportNames.includes(exportName) && hasChunkableExport(code, exportName, cache, cacheKey), exportDependencies = getExportDependencies(code, cache, cacheKey), allExportNames = Array.from(exportDependencies.keys()), omittedExportNames = allExportNames.filter(isOmitted), retainedExportNames = allExportNames.filter((exportName)=>!isOmitted(exportName)), omittedStatements = new Set(), omittedExportedVariableDeclarators = new Set();
-            for (let omittedExportName of omittedExportNames){
-                let dependencies = exportDependencies.get(omittedExportName);
-                for (let statement of (invariant(dependencies, `Expected dependencies for ${omittedExportName}`), dependencies.topLevelNonModuleStatements))omittedStatements.add(statement);
-                for (let declarator of dependencies.exportedVariableDeclarators)omittedExportedVariableDeclarators.add(declarator);
-            }
-            let ast = codeToAst(code, cache, cacheKey), omittedStatementsArray = Array.from(omittedStatements), omittedExportedVariableDeclaratorsArray = Array.from(omittedExportedVariableDeclarators);
-            if (ast.program.body = ast.program.body.filter((node)=>omittedStatementsArray.every((statement)=>!isNodesEquivalent(node, statement))).map((node)=>isImportDeclaration(node) && 0 !== node.specifiers.length && (node.specifiers = node.specifiers.filter((specifier)=>{
-                    let importedName = specifier.local.name;
-                    for (let retainedExportName of retainedExportNames){
-                        let dependencies = exportDependencies.get(retainedExportName);
-                        if (dependencies?.importedIdentifierNames?.has(importedName)) return !0;
-                    }
-                    for (let omittedExportName of omittedExportNames){
-                        let dependencies = exportDependencies.get(omittedExportName);
-                        if (dependencies?.importedIdentifierNames?.has(importedName)) return !1;
-                    }
-                    return !0;
-                }), 0 === node.specifiers.length) ? null : node).map((node)=>{
-                if (!isExportDeclaration(node) || isExportAllDeclaration(node)) return node;
-                if (isExportDefaultDeclaration(node)) return isOmitted('default') ? null : node;
-                if (isVariableDeclaration(node.declaration)) return (node.declaration.declarations = node.declaration.declarations.filter((declarationNode)=>omittedExportedVariableDeclaratorsArray.every((declarator)=>!isNodesEquivalent(declarationNode, declarator))), 0 === node.declaration.declarations.length) ? null : node;
-                if (isFunctionDeclaration(node.declaration) || isClassDeclaration(node.declaration)) {
-                    let declarationId = node.declaration.id;
-                    return invariant(declarationId, 'Expected exported function or class declaration to have a name when not the default export'), isOmitted(declarationId.name) ? null : node;
+    return worker.on('message', (response)=>{
+        let pending = state.pending.get(response.id);
+        if (pending) if (state.pending.delete(response.id), response.ok) pending.resolve(response.result);
+        else {
+            var error;
+            let result;
+            pending.reject(((result = Error((error = response.error).message)).name = error.name ?? 'Error', error.stack && (result.stack = error.stack), result));
+        }
+    }), worker.on('error', (error)=>{
+        let startupError = new WorkerStartupError(error.message);
+        startupError.stack = error.stack, _class_private_method_get(this, _disableWorkers, disableWorkers).call(this, startupError);
+    }), worker.on('exit', (code)=>{
+        if (_class_private_field_get(this, _closed) || _class_private_field_get(this, _workersDisabled)) return;
+        let startupError = new WorkerStartupError(`Route transform worker exited with code ${code}.`);
+        _class_private_method_get(this, _disableWorkers, disableWorkers).call(this, startupError);
+    }), state;
+}
+function runInWorker(task) {
+    let workerIndex = _class_private_method_get(this, _getWorkerIndex, getWorkerIndex).call(this, task), state = _class_private_field_get(this, _workers)[workerIndex];
+    if (!state) return executeRouteTransformTask(task, this.options);
+    let id = function(receiver, privateMap) {
+        var descriptor = _class_extract_field_descriptor(receiver, privateMap, "update");
+        if (descriptor.set) {
+            if (!descriptor.get) throw TypeError("attempted to read set only private field");
+            return "__destrWrapper" in descriptor || (descriptor.__destrWrapper = {
+                set value (v){
+                    descriptor.set.call(receiver, v);
+                },
+                get value () {
+                    return descriptor.get.call(receiver);
                 }
-                if (isExportNamedDeclaration(node)) return 0 === node.specifiers.length ? node : (node.specifiers = node.specifiers.filter((specifier)=>!isOmitted(getExportedName(specifier.exported))), 0 === node.specifiers.length) ? null : node;
-                throw Error('Unknown node type');
-            }).filter(Boolean), 0 !== ast.program.body.length) return generate(ast, generateOptions).code;
-        }))(code, routeChunkExportNames, {}, cache, cacheKey) : ((code, exportName, generateOptions = {}, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::getChunkedExport::${exportName}::${JSON.stringify(generateOptions)}`, code, ()=>{
-            if (!hasChunkableExport(code, exportName, cache, cacheKey)) return;
-            let dependencies = getExportDependencies(code, cache, cacheKey).get(exportName);
-            invariant(dependencies, 'Expected export to have dependencies');
-            let topLevelStatementsArray = Array.from(dependencies.topLevelStatements), exportedVariableDeclaratorsArray = Array.from(dependencies.exportedVariableDeclarators), ast = codeToAst(code, cache, cacheKey);
-            return ast.program.body = ast.program.body.filter((node)=>topLevelStatementsArray.some((statement)=>isNodesEquivalent(node, statement))).map((node)=>isImportDeclaration(node) ? 0 === dependencies.importedIdentifierNames.size ? null : (node.specifiers = node.specifiers.filter((specifier)=>dependencies.importedIdentifierNames.has(specifier.local.name)), invariant(node.specifiers.length > 0, 'Expected import statement to have used specifiers'), node) : node).map((node)=>{
-                if (!isExportDeclaration(node)) return node;
-                if (isExportAllDeclaration(node)) return null;
-                if (isExportDefaultDeclaration(node)) return 'default' === exportName ? node : null;
-                let { declaration } = node;
-                if (isVariableDeclaration(declaration)) return (declaration.declarations = declaration.declarations.filter((declarationNode)=>exportedVariableDeclaratorsArray.some((declarator)=>isNodesEquivalent(declarationNode, declarator))), 0 === declaration.declarations.length) ? null : node;
-                if (isFunctionDeclaration(node.declaration) || isClassDeclaration(node.declaration)) return node.declaration.id?.name === exportName ? node : null;
-                if (isExportNamedDeclaration(node)) return 0 === node.specifiers.length || (node.specifiers = node.specifiers.filter((specifier)=>getExportedName(specifier.exported) === exportName), 0 === node.specifiers.length) ? null : node;
-                throw Error('Unknown export node type');
-            }).filter(Boolean), generate(ast, generateOptions).code;
-        }))(code, chunkName, {}, cache, cacheKey)) ?? null;
-}, validateRouteChunks = ({ config, id, valid })=>{
-    if (isRootRouteModuleId(config, id)) return;
-    let invalidChunks = Object.entries(valid).filter(([, isValid])=>!isValid).map(([chunkName])=>chunkName);
-    if (0 === invalidChunks.length) return;
-    let plural = invalidChunks.length > 1;
-    throw Error([
-        `Error splitting route module: ${normalizeRelativeFilePath(id, config.appDirectory)}`,
-        invalidChunks.map((name)=>`- ${name}`).join('\n'),
-        `${plural ? 'These exports' : 'This export'} could not be split into ${plural ? 'their own chunks' : 'its own chunk'} because ${plural ? 'they share' : 'it shares'} code with other exports. You should extract any shared code into its own module and then import it within the route module.`
-    ].join('\n\n'));
-}, getRouteChunkEntryName = (routeId, chunkName)=>`${routeId}-${routeChunkEntrySuffix[chunkName]}`;
-(A = ImportType || (ImportType = {}))[A.Static = 1] = "Static", A[A.Dynamic = 2] = "Dynamic", A[A.ImportMeta = 3] = "ImportMeta", A[A.StaticSourcePhase = 4] = "StaticSourcePhase", A[A.DynamicSourcePhase = 5] = "DynamicSourcePhase", A[A.StaticDeferPhase = 6] = "StaticDeferPhase", A[A.DynamicDeferPhase = 7] = "DynamicDeferPhase";
-let lexer_A = 1 === new Uint8Array(new Uint16Array([
-    1
-]).buffer)[0];
-function lexer_parse(E, g = "@") {
-    if (!lexer_C) return lexer_init.then(()=>lexer_parse(E));
-    let I = E.length + 1, w = (lexer_C.__heap_base.value || lexer_C.__heap_base) + 4 * I - lexer_C.memory.buffer.byteLength;
-    w > 0 && lexer_C.memory.grow(Math.ceil(w / 65536));
-    let K = lexer_C.sa(I - 1);
-    if ((lexer_A ? function(A, Q) {
-        let B = A.length, C = 0;
-        for(; C < B;)Q[C] = A.charCodeAt(C++);
-    } : function(A, Q) {
-        let B = A.length, C = 0;
-        for(; C < B;){
-            let B = A.charCodeAt(C);
-            Q[C++] = (255 & B) << 8 | B >>> 8;
+            }), descriptor.__destrWrapper;
         }
-    })(E, new Uint16Array(lexer_C.memory.buffer, K, I)), !lexer_C.parse()) throw Object.assign(Error(`Parse error ${g}:${E.slice(0, lexer_C.e()).split("\n").length}:${lexer_C.e() - E.lastIndexOf("\n", lexer_C.e() - 1)}`), {
-        idx: lexer_C.e()
-    });
-    let o = [], D = [];
-    for(; lexer_C.ri();){
-        let D, A = lexer_C.is(), Q = lexer_C.ie(), B = lexer_C.it(), g = lexer_C.ai(), I = lexer_C.id(), w = lexer_C.ss(), K = lexer_C.se();
-        lexer_C.ip() && (D = k(E.slice(-1 === I ? A - 1 : A, -1 === I ? Q + 1 : Q))), o.push({
-            n: D,
-            t: B,
-            s: A,
-            e: Q,
-            ss: w,
-            se: K,
-            d: I,
-            a: g
+        if (!descriptor.writable) throw TypeError("attempted to set read only private field");
+        return descriptor;
+    }(this, _nextId).value++, sourceCacheKey = task.resourcePath, requestTask = _class_private_method_get(this, _createWorkerRequestTask, createWorkerRequestTask).call(this, state, task, sourceCacheKey);
+    return new Promise((resolve, reject)=>{
+        state.pending.set(id, {
+            resolve,
+            reject
         });
+        try {
+            state.worker.postMessage({
+                id,
+                task: requestTask,
+                sourceCacheKey
+            });
+        } catch (error) {
+            state.pending.delete(id), state.sourceCache.delete(sourceCacheKey), reject(error instanceof Error ? error : Error(String(error)));
+        }
+    });
+}
+function createWorkerRequestTask(state, task, sourceCacheKey) {
+    if (state.sourceCache.get(sourceCacheKey) === task.code) {
+        let { code: _code, ...cachedTask } = task;
+        return cachedTask;
     }
-    for(; lexer_C.re();){
-        let A = lexer_C.es(), Q = lexer_C.ee(), B = lexer_C.els(), g = lexer_C.ele(), I = E.slice(A, Q), w = I[0], K = B < 0 ? void 0 : E.slice(B, g), o = K ? K[0] : "";
-        D.push({
-            s: A,
-            e: Q,
-            ls: B,
-            le: g,
-            n: '"' === w || "'" === w ? k(I) : I,
-            ln: '"' === o || "'" === o ? k(K) : K
-        });
+    return setBoundedCacheEntry(state.sourceCache, sourceCacheKey, task.code, 2048), task;
+}
+function getWorkerIndex(task) {
+    let workerCount = Math.max(1, _class_private_field_get(this, _workers).length);
+    if (this.balanceRouteModuleTransforms && ('routeClientEntry' === task.kind || 'routeChunk' === task.kind || 'splitRouteExports' === task.kind)) {
+        let existingWorkerIndex = _class_private_field_get(this, _splitRouteAnalysisWorkers).get(task.resourcePath);
+        if (void 0 !== existingWorkerIndex) return existingWorkerIndex % workerCount;
+        let workerIndex = _class_private_field_get(this, _nextSplitRouteAnalysisWorkerIndex) % workerCount;
+        return _class_private_field_set(this, _nextSplitRouteAnalysisWorkerIndex, _class_private_field_get(this, _nextSplitRouteAnalysisWorkerIndex) + 1), _class_private_field_get(this, _splitRouteAnalysisWorkers).set(task.resourcePath, workerIndex), workerIndex;
     }
-    function k(A) {
-        try {
-            return (0, eval)(A);
-        } catch (A) {}
+    if (this.balanceRouteModuleTransforms && 'routeModule' === task.kind && !('web' === task.environmentName && !task.ssr && task.isSpaMode)) {
+        let workerIndex = _class_private_field_get(this, _nextRouteModuleWorkerIndex) % workerCount;
+        return _class_private_field_set(this, _nextRouteModuleWorkerIndex, _class_private_field_get(this, _nextRouteModuleWorkerIndex) + 1), workerIndex;
     }
-    return [
-        o,
-        D,
-        !!lexer_C.f(),
-        !!lexer_C.ms()
-    ];
+    return ((value)=>{
+        let hash = 0;
+        for(let index = 0; index < value.length; index += 1)hash = 31 * hash + value.charCodeAt(index) >>> 0;
+        return hash;
+    })(task.resourcePath) % workerCount;
 }
-let lexer_init = WebAssembly.compile((A1 = "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", "u" > typeof Buffer ? Buffer.from(A1, "base64") : Uint8Array.from(atob(A1), (A)=>A.charCodeAt(0)))).then(WebAssembly.instantiate).then(({ exports: A })=>{
-    lexer_C = A;
-}), transformToEsm = async (code, resourcePath)=>(await __rspack_external_esbuild.transform(code, {
-        jsx: 'automatic',
-        format: 'esm',
-        platform: 'neutral',
-        loader: JS_LOADERS[extname(resourcePath)] ?? 'js'
-    })).code, getExportNames = async (code)=>{
-    await lexer_init;
-    let [, exportSpecifiers] = await lexer_parse(code);
-    return Array.from(new Set(exportSpecifiers.map((specifier)=>specifier.n).filter(Boolean)));
-}, getExportNamesAndExportAll = async (code)=>{
-    await lexer_init;
-    let [imports, exportSpecifiers] = await lexer_parse(code), exportNames = new Set();
-    for (let specifier of exportSpecifiers)specifier.n && exportNames.add(specifier.n);
-    let exportAllModules = [];
-    for (let entry of imports){
-        if (!entry.n) continue;
-        let statement = code.slice(entry.ss, entry.se);
-        /^\s*export\s*\*\s*from\s*['"]/.test(statement) && exportAllModules.push(entry.n);
+let defaultWatchDirectoryEntry = (directory, onChange, onError)=>{
+    let watcher = watch(directory, onChange);
+    return watcher.on('error', onError), watcher;
+}, ensureDevRestartMarker = async (restartMarkerPath)=>{
+    await mkdir(dirname(restartMarkerPath), {
+        recursive: !0
+    });
+    try {
+        await access(restartMarkerPath);
+    } catch  {
+        await writeFile(restartMarkerPath, 'react-router-route-watch');
     }
-    return {
-        exportNames: Array.from(exportNames),
-        exportAllModules
-    };
-}, getRouteModuleExports = async (resourcePath)=>{
-    let source = await readFile(resourcePath, 'utf8');
-    return getExportNames(await transformToEsm(source, resourcePath));
-}, DEFAULT_MANIFEST_DIR = 'static/js', getReactRouterManifestPath = ({ version, isBuild, entryModulePath })=>{
-    if (!isBuild) return 'static/js/virtual/react-router/browser-manifest.js';
-    let dir = ((entryModulePath)=>{
-        if (!entryModulePath) return DEFAULT_MANIFEST_DIR;
-        let dir = dirname(entryModulePath);
-        return '.' === dir ? DEFAULT_MANIFEST_DIR : dir;
-    })(entryModulePath);
-    return `${dir}/manifest-${version}.js`;
-}, getRouteEntryName = (route)=>{
-    let extensionIndex = route.file.lastIndexOf('.');
-    return extensionIndex >= 0 ? route.file.slice(0, extensionIndex) : route.file;
-};
-async function getReactRouterManifestForDev(routes, options, clientStats, context, assetPrefix = '/', routeChunkOptions) {
-    let result = {}, splitRouteModules = routeChunkOptions?.splitRouteModules ?? !1, enforceSplitRouteModules = 'enforce' === splitRouteModules, isBuild = routeChunkOptions?.isBuild ?? !1, routeChunkConfig = splitRouteModules && routeChunkOptions?.rootRouteFile ? {
-        splitRouteModules,
-        appDirectory: context,
-        rootRouteFile: routeChunkOptions.rootRouteFile
-    } : null, getAssetsForChunk = (chunkName)=>{
-        let assets = clientStats?.assetsByChunkName?.[chunkName];
-        if (!assets) return [
-            `${DEFAULT_MANIFEST_DIR}/${chunkName}.js`
-        ];
-        let normalizedAssets = Array.isArray(assets) ? assets : [
-            assets
-        ];
-        return normalizedAssets.some((asset)=>asset.endsWith('.js')) ? normalizedAssets : [
-            `${DEFAULT_MANIFEST_DIR}/${chunkName}.js`,
-            ...normalizedAssets
-        ];
-    }, getModulePathForChunk = (chunkName)=>{
-        let jsAssets = getAssetsForChunk(chunkName).filter((asset)=>asset.endsWith('.js'));
-        return jsAssets[0] ? combineURLs(assetPrefix, jsAssets[0]) : void 0;
+}, readRouteDirectories = async (watchDirectory)=>{
+    let directories = new Set(), walkDirectory = async (directory)=>{
+        let entries;
+        try {
+            entries = await readdir(directory, {
+                withFileTypes: !0
+            });
+        } catch  {
+            return;
+        }
+        directories.add(directory), await Promise.all(entries.map(async (entry)=>{
+            let entryPath = external_pathe_resolve(directory, entry.name);
+            entry.isDirectory() && await walkDirectory(entryPath);
+        }));
     };
-    for (let [key, route] of Object.entries(routes)){
-        let routeEntryName = getRouteEntryName(route), assets = getAssetsForChunk(routeEntryName), jsAssets = assets.filter((asset)=>asset.endsWith('.js')) || [], cssAssets = assets.filter((asset)=>asset.endsWith('.css')) || [], routeFilePath = resolve(context, route.file), exports = new Set(), hasRouteChunkByExportName = {
-            clientAction: !1,
-            clientLoader: !1,
-            clientMiddleware: !1,
-            HydrateFallback: !1
+    return await walkDirectory(watchDirectory), directories;
+}, createRouteTopologyWatcher = async ({ watchDirectory, getRouteTopology, initialRouteTopology, restartMarkerPath, onError, onRouteTopologyChange, watchDirectoryEntry: watchDirectoryOverride = defaultWatchDirectoryEntry })=>{
+    let discoveredState, rescanTimer, discoveredDirectories = await readRouteDirectories(watchDirectory);
+    try {
+        discoveredState = {
+            directories: discoveredDirectories,
+            routeTopology: await getRouteTopology()
         };
-        try {
-            let source = await readFile(routeFilePath, 'utf8');
-            !isBuild && 0 === cssAssets.length && /\.(?:css|less|sass|scss)(?:\?[^'"`]+)?['"`]/.test(source) && (cssAssets = [
-                `${DEFAULT_MANIFEST_DIR.replace('/js', '/css')}/${routeEntryName}.css`
-            ]);
-            let code = await transformToEsm(source, routeFilePath);
-            if (exports = new Set(await getExportNames(code)), isBuild && routeChunkConfig) {
-                let { hasRouteChunkByExportName: chunkInfo } = await detectRouteChunksIfEnabled(routeChunkOptions?.cache, routeChunkConfig, routeFilePath, code);
-                hasRouteChunkByExportName = chunkInfo;
-            }
+    } catch (error) {
+        if (!initialRouteTopology) throw error;
+        onError(error), discoveredState = {
+            directories: discoveredDirectories,
+            routeTopology: initialRouteTopology
+        };
+    }
+    let state = {
+        ...discoveredState,
+        routeTopology: initialRouteTopology ?? discoveredState.routeTopology
+    }, closed = !1, rescanQueue = Promise.resolve(), directoryWatchers = new Map(), touchRestartMarker = async ()=>{
+        await mkdir(dirname(restartMarkerPath), {
+            recursive: !0
+        }), await writeFile(restartMarkerPath, String(Date.now()));
+    }, syncDirectoryWatchers = (nextDirectories)=>{
+        for (let [directory, watcher] of directoryWatchers)nextDirectories.has(directory) || (watcher.close(), directoryWatchers.delete(directory));
+        for (let directory of nextDirectories)if (!directoryWatchers.has(directory)) try {
+            let watcher;
+            watcher = watchDirectoryOverride(directory, scheduleRescan, (error)=>{
+                directoryWatchers.get(directory) === watcher && (watcher.close(), directoryWatchers.delete(directory)), onError(error);
+            }), directoryWatchers.set(directory, watcher);
         } catch (error) {
-            console.error(`Failed to analyze route file ${routeFilePath}:`, error);
+            onError(error);
         }
-        let hasClientAction = exports.has('clientAction'), hasClientLoader = exports.has('clientLoader'), hasClientMiddleware = exports.has('clientMiddleware'), hasHydrateFallback = exports.has('HydrateFallback'), hasDefaultExport = exports.has('default');
-        isBuild && enforceSplitRouteModules && routeChunkConfig && validateRouteChunks({
-            config: routeChunkConfig,
-            id: routeFilePath,
-            valid: {
-                clientAction: !hasClientAction || hasRouteChunkByExportName.clientAction,
-                clientLoader: !hasClientLoader || hasRouteChunkByExportName.clientLoader,
-                clientMiddleware: !hasClientMiddleware || hasRouteChunkByExportName.clientMiddleware,
-                HydrateFallback: !hasHydrateFallback || hasRouteChunkByExportName.HydrateFallback
+    }, applyNextState = async (nextState)=>{
+        if (!closed) {
+            if (syncDirectoryWatchers(nextState.directories), !((left, right)=>{
+                if (left.size !== right.size) return !1;
+                for (let value of left)if (!right.has(value)) return !1;
+                return !0;
+            })(state.routeTopology, nextState.routeTopology)) {
+                if (onRouteTopologyChange) {
+                    state = nextState;
+                    try {
+                        Promise.resolve(onRouteTopologyChange()).catch(onError);
+                    } catch (error) {
+                        onError(error);
+                    }
+                    return;
+                }
+                if (await touchRestartMarker(), closed) return;
+                state = nextState;
+                return;
             }
-        }), result[key] = {
-            id: route.id,
-            parentId: route.parentId,
-            path: route.path,
-            index: route.index,
-            caseSensitive: route.caseSensitive,
-            module: combineURLs(assetPrefix, jsAssets[0] || ''),
-            clientActionModule: isBuild && hasRouteChunkByExportName.clientAction ? getModulePathForChunk(getRouteChunkEntryName(route.id, 'clientAction')) : void 0,
-            clientLoaderModule: isBuild && hasRouteChunkByExportName.clientLoader ? getModulePathForChunk(getRouteChunkEntryName(route.id, 'clientLoader')) : void 0,
-            clientMiddlewareModule: isBuild && hasRouteChunkByExportName.clientMiddleware ? getModulePathForChunk(getRouteChunkEntryName(route.id, 'clientMiddleware')) : void 0,
-            hydrateFallbackModule: isBuild && hasRouteChunkByExportName.HydrateFallback ? getModulePathForChunk(getRouteChunkEntryName(route.id, 'HydrateFallback')) : void 0,
-            hasAction: exports.has('action'),
-            hasLoader: exports.has('loader'),
-            hasClientAction,
-            hasClientLoader,
-            hasClientMiddleware,
-            hasDefaultExport,
-            hasErrorBoundary: exports.has('ErrorBoundary'),
-            imports: jsAssets.map((asset)=>combineURLs(assetPrefix, asset)),
-            css: cssAssets.map((asset)=>combineURLs(assetPrefix, asset))
-        };
-    }
-    let entryAssets = getAssetsForChunk('entry.client'), entryJsAssets = entryAssets.filter((asset)=>asset.endsWith('.js')), entryCssAssets = entryAssets.filter((asset)=>asset.endsWith('.css')), fingerprintedValues = {
-        entry: {
-            module: combineURLs(assetPrefix, entryJsAssets[0] || ''),
-            imports: entryJsAssets.map((asset)=>combineURLs(assetPrefix, asset)),
-            css: entryCssAssets.map((asset)=>combineURLs(assetPrefix, asset))
-        },
-        routes: result
-    }, version = isBuild ? createHash('md5').update(JSON.stringify(fingerprintedValues)).digest('hex').slice(0, 8) : String(Math.random()), manifestPath = getReactRouterManifestPath({
-        version,
-        isBuild,
-        entryModulePath: entryJsAssets[0]
-    });
-    return {
-        version,
-        url: combineURLs(assetPrefix, manifestPath),
-        hmr: void 0,
-        entry: fingerprintedValues.entry,
-        sri: void 0,
-        routes: result
+            state = nextState;
+        }
+    }, runRescan = async ()=>{
+        let nextDirectories;
+        if (!closed) try {
+            if (nextDirectories = await readRouteDirectories(watchDirectory), closed) return;
+            let nextState = {
+                directories: nextDirectories,
+                routeTopology: await getRouteTopology()
+            };
+            if (closed) return;
+            await applyNextState(nextState);
+        } catch (error) {
+            nextDirectories && !closed && syncDirectoryWatchers(nextDirectories), onError(error);
+        }
+    }, scheduleRescan = ()=>{
+        rescanTimer && clearTimeout(rescanTimer), rescanTimer = setTimeout(()=>{
+            rescanTimer = void 0, rescanQueue = rescanQueue.then(runRescan, runRescan);
+        }, 100);
     };
-}
-let isPlainObject = (value)=>'object' == typeof value && null !== value, validateEntry = (entry, path, issues)=>isPlainObject(entry) && 'then' in entry && 'catch' in entry ? (issues.push(`${path}\nInvalid type: Expected object but received a promise. Did you forget to await?`), !1) : isPlainObject(entry) ? ('string' != typeof entry.file && issues.push(`${path}.file\nInvalid type: Expected string.`), 'id' in entry && 'root' === entry.id && issues.push(`${path}.id\nA route cannot use the reserved id 'root'.`), 'path' in entry && void 0 !== entry.path && 'string' != typeof entry.path && issues.push(`${path}.path\nInvalid type: Expected string.`), 'index' in entry && void 0 !== entry.index && 'boolean' != typeof entry.index && issues.push(`${path}.index\nInvalid type: Expected boolean.`), 'caseSensitive' in entry && void 0 !== entry.caseSensitive && 'boolean' != typeof entry.caseSensitive && issues.push(`${path}.caseSensitive\nInvalid type: Expected boolean.`), 'children' in entry && void 0 !== entry.children && (Array.isArray(entry.children) ? entry.children.forEach((child, index)=>validateEntry(child, `${path}.children.${index}`, issues)) : issues.push(`${path}.children\nInvalid type: Expected array.`)), 0 === issues.length) : (issues.push(`${path}\nInvalid type: Expected object.`), !1), getRouteBranch = (routes, routeId)=>{
+    try {
+        await applyNextState(discoveredState);
+    } catch (error) {
+        onError(error);
+    }
+    return async ()=>{
+        if (closed) return void await rescanQueue;
+        for (let watcher of (closed = !0, rescanTimer && clearTimeout(rescanTimer), directoryWatchers.values()))watcher.close();
+        for (let watcher of (directoryWatchers.clear(), await rescanQueue, directoryWatchers.values()))watcher.close();
+        directoryWatchers.clear();
+    };
+}, isPlainObject = (value)=>'object' == typeof value && null !== value, validateEntry = (entry, path, issues)=>isPlainObject(entry) && 'then' in entry && 'catch' in entry ? (issues.push(`${path}\nInvalid type: Expected object but received a promise. Did you forget to await?`), !1) : isPlainObject(entry) ? ('string' != typeof entry.file && issues.push(`${path}.file\nInvalid type: Expected string.`), 'id' in entry && 'root' === entry.id && issues.push(`${path}.id\nA route cannot use the reserved id 'root'.`), 'path' in entry && void 0 !== entry.path && 'string' != typeof entry.path && issues.push(`${path}.path\nInvalid type: Expected string.`), 'index' in entry && void 0 !== entry.index && 'boolean' != typeof entry.index && issues.push(`${path}.index\nInvalid type: Expected boolean.`), 'caseSensitive' in entry && void 0 !== entry.caseSensitive && 'boolean' != typeof entry.caseSensitive && issues.push(`${path}.caseSensitive\nInvalid type: Expected boolean.`), 'children' in entry && void 0 !== entry.children && (Array.isArray(entry.children) ? entry.children.forEach((child, index)=>validateEntry(child, `${path}.children.${index}`, issues)) : issues.push(`${path}.children\nInvalid type: Expected array.`)), 0 === issues.length) : (issues.push(`${path}\nInvalid type: Expected object.`), !1), getRouteBranch = (routes, routeId)=>{
     let branch = [], current = routeId;
     for(; current;){
         let route = routes[current];
@@ -742,7 +964,7 @@ let isPlainObject = (value)=>'object' == typeof value && null !== value, validat
         routes
     };
     let rootRelativeRoutes = Object.fromEntries(Object.entries(routes).map(([id, route])=>{
-        let filePath = resolve(appDirectory, route.file);
+        let filePath = external_pathe_resolve(appDirectory, route.file);
         return [
             id,
             {
@@ -750,7 +972,7 @@ let isPlainObject = (value)=>'object' == typeof value && null !== value, validat
                 file: relative(rootDirectory, filePath).replace(/\\/g, '/')
             }
         ];
-    })), serverBuildDirectory = resolve(buildDirectory, 'server'), buildManifest = {
+    })), serverBuildDirectory = external_pathe_resolve(buildDirectory, 'server'), buildManifest = {
         routes: rootRelativeRoutes,
         serverBundles: {},
         routeIdToServerBundleId: {}
@@ -773,7 +995,7 @@ let isPlainObject = (value)=>'object' == typeof value && null !== value, validat
                 return {
                     id: (route = {
                         ...branchRoute,
-                        file: resolve(appDirectory, branchRoute.file)
+                        file: external_pathe_resolve(appDirectory, branchRoute.file)
                     }).id,
                     path: route.path,
                     file: route.file,
@@ -787,13 +1009,10 @@ let isPlainObject = (value)=>'object' == typeof value && null !== value, validat
         } else if (!/^[a-zA-Z0-9-_]+$/.test(serverBundleId)) throw Error('The "serverBundles" function must only return strings containing alphanumeric characters, hyphens and underscores.');
         buildManifest.routeIdToServerBundleId[route.id] = serverBundleId, buildManifest.serverBundles[serverBundleId] ??= {
             id: serverBundleId,
-            file: relative(rootDirectory, resolve(serverBuildDirectory, serverBundleId, serverBuildFile)).replace(/\\/g, '/')
+            file: relative(rootDirectory, external_pathe_resolve(serverBuildDirectory, serverBundleId, serverBuildFile)).replace(/\\/g, '/')
         };
     })), buildManifest;
 };
-function getDevtoolFromRspackConfig(config) {
-    if (config && 'function' != typeof config && 'object' == typeof config) return config.devtool;
-}
 function pluginId(name) {
     return `rsbuild:${name}`;
 }
@@ -809,22 +1028,217 @@ let REACT_ROUTER_EXTERNALS = [
     '@react-router/express',
     '@react-router/node',
     '@react-router/serve'
-], requireFromHere = createRequire(import.meta.url);
+], requireFromHere = createRequire(import.meta.url), roundMs = (value)=>Math.round(10 * value) / 10, VIRTUAL_MODULE_PREFIX = 'virtual/react-router/', isLatestStartedCompilation = (identity, start)=>!identity || start?.status === 'started' && start.identity === identity, hasPendingCompilation = (pair)=>pair.latestWebStart?.status === 'pending' || pair.latestNodeStart?.status === 'pending', snapshotDevChangedFiles = (compiler)=>compiler ? {
+        known: void 0 !== compiler.modifiedFiles || void 0 !== compiler.removedFiles,
+        files: new Set([
+            ...compiler.modifiedFiles ?? [],
+            ...compiler.removedFiles ?? []
+        ])
+    } : {
+        known: !1,
+        files: new Set()
+    }, snapshotDependencies = (compilation)=>({
+        files: new Set([
+            ...compilation.fileDependencies,
+            ...compilation.buildDependencies ?? []
+        ]),
+        contexts: new Set(compilation.contextDependencies),
+        missing: new Set(compilation.missingDependencies)
+    }), isWithinDirectory = (directory, file)=>{
+    let relativePath = external_node_path_relative(directory, file);
+    return '' === relativePath || !relativePath.startsWith('..') && !external_node_path_isAbsolute(relativePath);
+}, getEnvironmentStats = (stats, name)=>(Array.isArray(stats.stats) ? stats.stats : [
+        stats
+    ]).find((child)=>{
+        let compilation = child.compilation;
+        return compilation.name === name || compilation.compiler?.name === name;
+    }), evaluateServerBuild = async (server, entryName)=>resolveServerBuildModule(await server.environments.node.loadBundle(entryName), `Server entry ${JSON.stringify(entryName)}`), evaluateServerBuilds = async (server, entryNames)=>Object.fromEntries(await Promise.all(entryNames.map(async (entryName)=>[
+            entryName,
+            await evaluateServerBuild(server, entryName)
+        ]))), pinBuildToManifest = (entryName, build, manifest)=>{
+    for (let [routeId, manifestRoute] of Object.entries(manifest.routes)){
+        let routeModule = build.routes[routeId]?.module;
+        if (!routeModule) throw Error(`[rsbuild-plugin-react-router] Server build ${JSON.stringify(entryName)} route ${JSON.stringify(routeId)} is missing from the evaluated server build.`);
+        if (!!manifestRoute.hasLoader != ('function' == typeof routeModule.loader)) throw Error(`[rsbuild-plugin-react-router] Server build ${JSON.stringify(entryName)} route ${JSON.stringify(routeId)} loader export does not match its web manifest.`);
+        if (!!manifestRoute.hasAction != ('function' == typeof routeModule.action)) throw Error(`[rsbuild-plugin-react-router] Server build ${JSON.stringify(entryName)} route ${JSON.stringify(routeId)} action export does not match its web manifest.`);
+    }
+    return {
+        ...build,
+        assets: structuredClone(manifest)
+    };
+}, collectManifestCssAssetOwnership = (manifest)=>{
+    let ownership = new Set();
+    for (let asset of manifest.entry?.css ?? [])ownership.add(`entry\0${asset}`);
+    for (let [routeId, route] of Object.entries(manifest.routes ?? {}))for (let asset of route.css ?? [])ownership.add(`route\0${routeId}\0${asset}`);
+    return ownership;
+}, hasRemovedCssAssetOwnership = (previous, next)=>{
+    for (let [entryName, previousManifest] of Object.entries(previous)){
+        let previousOwnership = collectManifestCssAssetOwnership(previousManifest);
+        if (0 === previousOwnership.size) continue;
+        let nextManifest = next[entryName];
+        if (!nextManifest) return !0;
+        let nextOwnership = collectManifestCssAssetOwnership(nextManifest);
+        for (let owner of previousOwnership)if (!nextOwnership.has(owner)) return !0;
+    }
+    return !1;
+}, normalizeManifestForCssOwnershipCheck = (manifest)=>{
+    let cssAssets = ((manifest)=>{
+        let assets = new Set(manifest.entry?.css ?? []);
+        for (let route of Object.values(manifest.routes ?? {}))for (let asset of route.css ?? [])assets.add(asset);
+        return assets;
+    })(manifest), nonCssImports = (imports = [])=>imports.filter((importPath)=>!cssAssets.has(importPath));
+    return {
+        entry: {
+            imports: nonCssImports(manifest.entry?.imports),
+            module: manifest.entry?.module
+        },
+        routes: Object.fromEntries(Object.entries(manifest.routes ?? {}).sort(([left], [right])=>left.localeCompare(right)).map(([routeId, route])=>[
+                routeId,
+                {
+                    caseSensitive: route.caseSensitive,
+                    clientActionModule: route.clientActionModule,
+                    clientLoaderModule: route.clientLoaderModule,
+                    clientMiddlewareModule: route.clientMiddlewareModule,
+                    errorBoundary: route.hasErrorBoundary,
+                    hasAction: route.hasAction,
+                    hasClientAction: route.hasClientAction,
+                    hasClientLoader: route.hasClientLoader,
+                    hasClientMiddleware: route.hasClientMiddleware,
+                    hasDefaultExport: route.hasDefaultExport,
+                    hasLoader: route.hasLoader,
+                    hydrateFallbackModule: route.hydrateFallbackModule,
+                    id: route.id,
+                    imports: nonCssImports(route.imports),
+                    index: route.index,
+                    module: route.module,
+                    parentId: route.parentId,
+                    path: route.path
+                }
+            ]))
+    };
+}, hasSameRouteMetadata = (previous, next)=>previous.caseSensitive === next.caseSensitive && previous.clientActionModule === next.clientActionModule && previous.clientLoaderModule === next.clientLoaderModule && previous.clientMiddlewareModule === next.clientMiddlewareModule && previous.hasErrorBoundary === next.hasErrorBoundary && previous.hasAction === next.hasAction && previous.hasClientAction === next.hasClientAction && previous.hasClientLoader === next.hasClientLoader && previous.hasClientMiddleware === next.hasClientMiddleware && previous.hasDefaultExport === next.hasDefaultExport && previous.hasLoader === next.hasLoader && previous.hydrateFallbackModule === next.hydrateFallbackModule && previous.id === next.id && previous.index === next.index && previous.parentId === next.parentId && previous.path === next.path, createDeferred = ()=>{
+    let resolve, reject, promise = new Promise((resolvePromise, rejectPromise)=>{
+        resolve = resolvePromise, reject = rejectPromise;
+    });
+    return promise.catch(()=>void 0), {
+        promise,
+        resolve,
+        reject
+    };
+}, DEV_RUNTIME_KEY = Symbol.for('rsbuild-plugin-react-router.dev-runtime.v1'), loadReactRouterServerBuild = (server, entryName)=>{
+    let runtime = Reflect.get(server, DEV_RUNTIME_KEY);
+    return runtime ? runtime.load(entryName) : Promise.reject(Error('[rsbuild-plugin-react-router] This Rsbuild development server is not registered with the React Router plugin. Add pluginReactRouter() before calling loadReactRouterServerBuild().'));
+}, config_imports_normalizePath = (filePath)=>external_pathe_resolve(filePath), isNodeModulePath = (filePath)=>filePath.split(/[\\/]/).includes('node_modules'), collectConfigImportWatchPaths = (configPath, moduleCache, previousCacheKeys)=>{
+    let normalizedConfigPath = config_imports_normalizePath(configPath), watchPaths = new Set();
+    for (let [cacheKey, module] of Object.entries(moduleCache)){
+        if (previousCacheKeys.has(cacheKey)) continue;
+        let importPath = config_imports_normalizePath(module?.filename ?? cacheKey);
+        importPath === normalizedConfigPath || isNodeModulePath(importPath) || watchPaths.add(importPath);
+    }
+    return Array.from(watchPaths);
+};
 var src_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-let redirectStatusCodes = new Set([
-    301,
-    302,
-    303,
-    307,
-    308
-]), pluginReactRouter = (options = {})=>({
+let cssUrlAssetExtensions = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)$/, urlAssetResourceQuery = /^(?=.*(?:\?|&)url(?:&|$))(?!.*(?:\?|&)(?:raw|inline)(?:&|$))/, pluginReactRouter = (options = {})=>({
         name: PLUGIN_NAME,
         async setup (api) {
-            let routeDiscovery, clientStats, pluginOptions = {
+            let routeDiscovery, closeRouteTopologyWatcher, clientStats, typegenProcess, pluginOptions = {
                 customServer: !1,
                 serverOutput: 'module',
                 ...options
-            }, nodeExternals = Array.from(new Set([
+            }, logPerformance = !0 === pluginOptions.logPerformance, setupStartMs = logPerformance ? performance.now() : 0, performanceProfiler = (({ enabled, log })=>{
+                let timingsByEnvironment = new Map(), recordDuration = (environment, operation, resource, startMs, endMs)=>{
+                    let timings, timing, duration = endMs - startMs, timing1 = ((timings = timingsByEnvironment.get(environment)) || (timings = new Map(), timingsByEnvironment.set(environment, timings)), (timing = timings.get(operation)) || (timing = {
+                        count: 0,
+                        totalMs: 0,
+                        maxMs: 0,
+                        slowest: [],
+                        intervals: []
+                    }, timings.set(operation, timing)), timing);
+                    timing1.count += 1, timing1.totalMs += duration, timing1.maxMs = Math.max(timing1.maxMs, duration), timing1.intervals.push({
+                        startMs,
+                        endMs
+                    }), ((slowest, entry)=>{
+                        if (5 === slowest.length && entry.durationMs <= slowest[slowest.length - 1].durationMs) return;
+                        let insertIndex = slowest.length;
+                        for(; insertIndex > 0 && entry.durationMs > slowest[insertIndex - 1].durationMs;)insertIndex -= 1;
+                        slowest.splice(insertIndex, 0, entry), slowest.length > 5 && slowest.pop();
+                    })(timing1.slowest, {
+                        durationMs: duration,
+                        resource
+                    });
+                };
+                return {
+                    record (environment, operation, resource, callback) {
+                        if (!enabled) try {
+                            return Promise.resolve(callback());
+                        } catch (error) {
+                            return Promise.reject(error);
+                        }
+                        let resolvedEnvironment = environment ?? 'unknown', start = performance.now();
+                        try {
+                            return callback().then((result)=>{
+                                let end = performance.now();
+                                return recordDuration(resolvedEnvironment, operation, resource, start, end), result;
+                            }, (error)=>{
+                                let end = performance.now();
+                                throw recordDuration(resolvedEnvironment, operation, resource, start, end), error;
+                            });
+                        } catch (error) {
+                            return recordDuration(resolvedEnvironment, operation, resource, start, performance.now()), Promise.reject(error);
+                        }
+                    },
+                    recordSync (environment, operation, resource, callback) {
+                        if (!enabled) return callback();
+                        let start = performance.now();
+                        try {
+                            return callback();
+                        } finally{
+                            recordDuration(environment ?? 'unknown', operation, resource, start, performance.now());
+                        }
+                    },
+                    flush (environment, details = {}) {
+                        if (!enabled) return;
+                        let resolvedEnvironment = environment ?? 'unknown', timings = timingsByEnvironment.get(resolvedEnvironment);
+                        if (!timings || 0 === timings.size) return;
+                        let operations = Object.fromEntries([
+                            ...timings.entries()
+                        ].map(([operation, timing])=>[
+                                operation,
+                                {
+                                    count: timing.count,
+                                    totalMs: roundMs(timing.totalMs),
+                                    wallMs: ((intervals)=>{
+                                        if (0 === intervals.length) return 0;
+                                        let sortedIntervals = [
+                                            ...intervals
+                                        ].sort((a, b)=>a.startMs - b.startMs || a.endMs - b.endMs), mergedStart = sortedIntervals[0].startMs, mergedEnd = sortedIntervals[0].endMs, wallMs = 0;
+                                        for (let interval of sortedIntervals.slice(1)){
+                                            if (interval.startMs <= mergedEnd) {
+                                                mergedEnd = Math.max(mergedEnd, interval.endMs);
+                                                continue;
+                                            }
+                                            wallMs += mergedEnd - mergedStart, mergedStart = interval.startMs, mergedEnd = interval.endMs;
+                                        }
+                                        return roundMs(wallMs += mergedEnd - mergedStart);
+                                    })(timing.intervals),
+                                    maxMs: roundMs(timing.maxMs),
+                                    slowest: timing.slowest.map((entry)=>({
+                                            durationMs: roundMs(entry.durationMs),
+                                            resource: entry.resource
+                                        }))
+                                }
+                            ])), report = {
+                            environment: resolvedEnvironment,
+                            ...details,
+                            operations
+                        };
+                        log(`[react-router:performance] ${JSON.stringify(report)}`), timingsByEnvironment.delete(resolvedEnvironment);
+                    }
+                };
+            })({
+                enabled: logPerformance,
+                log: (message)=>api.logger.info(message)
+            }), nodeExternals = Array.from(new Set([
                 'express',
                 ...function(rootDirectory) {
                     let externals = [];
@@ -891,11 +1305,11 @@ let redirectStatusCodes = new Set([
                         let envTools = normalized.environments?.[clientEnvName]?.tools?.rspack, rootTools = normalized.tools?.rspack;
                         return getDevtoolFromRspackConfig(envTools) ?? getDevtoolFromRspackConfig(rootTools);
                     }(normalized, clientEnvName);
-                    (!0 === sourceMapSetting || !1 !== sourceMapSetting && null != sourceMapSetting && ('string' == typeof sourceMapSetting || 'object' == typeof sourceMapSetting && sourceMapSetting.js) || !0 === devtoolSetting || null != devtoolSetting && !1 !== devtoolSetting && ('string' == typeof devtoolSetting ? devtoolSetting.includes('source-map') : 'object' == typeof devtoolSetting)) && warn("\n  WARNING: Source maps are enabled in production\n  This makes your server code publicly visible in the browser.\n  This is highly discouraged! If you insist, ensure that you are using\n  environment variables for secrets and not hard-coding them in your source code.\n");
+                    (isSourceMapEnabled(sourceMapSetting) || !0 === devtoolSetting || null != devtoolSetting && !1 !== devtoolSetting && ('string' == typeof devtoolSetting ? devtoolSetting.includes('source-map') : 'object' == typeof devtoolSetting)) && warn("\n  WARNING: Source maps are enabled in production\n  This makes your server code publicly visible in the browser.\n  This is highly discouraged! If you insist, ensure that you are using\n  environment variables for secrets and not hard-coding them in your source code.\n");
                 }(api.getNormalizedConfig(), (msg)=>api.logger.warn(msg), 'web');
             }), api.onBeforeStartDevServer(async ()=>{
-                let { execa } = await import("execa");
-                execa('npx', [
+                if (typegenProcess) return;
+                let { execa } = await import("execa"), process1 = execa('npx', [
                     '--yes',
                     'react-router',
                     'typegen',
@@ -904,7 +1318,13 @@ let redirectStatusCodes = new Set([
                     stdio: 'inherit',
                     detached: !1,
                     cleanup: !0
-                }).catch(()=>{});
+                });
+                typegenProcess = process1, process1.catch(()=>{}).finally(()=>{
+                    typegenProcess === process1 && (typegenProcess = void 0);
+                });
+            }), api.onCloseDevServer(async ()=>{
+                let process1 = typegenProcess;
+                typegenProcess = void 0, process1 && (process1.kill('SIGTERM'), await process1.catch(()=>void 0));
             }), api.onBeforeBuild(async ()=>{
                 let { execa } = await import("execa");
                 await execa('npx', [
@@ -915,29 +1335,48 @@ let redirectStatusCodes = new Set([
                     stdio: 'inherit'
                 });
             });
-            let jiti = createJiti(process.cwd()), configPath = findEntryFile(resolve('react-router.config')), configExists = existsSync(configPath), reactRouterUserConfig = {};
+            let configPath = findEntryFile(external_pathe_resolve('react-router.config')), configExists = existsSync(configPath), configWatchPaths = configExists ? configPath : JS_EXTENSIONS.map((extension)=>external_pathe_resolve(`react-router.config${extension}`)), reactRouterUserConfig = {};
             if (configExists) {
-                let displayPath = relative(process.cwd(), configPath);
+                let displayPath = relative(process.cwd(), configPath), configJiti = createJiti(process.cwd(), {
+                    moduleCache: !0
+                }), cacheKeysBeforeImport = new Set(Object.keys(configJiti.cache));
                 try {
-                    let imported = await jiti.import(configPath, {
+                    let imported = await configJiti.import(configPath, {
                         default: !0
-                    });
-                    if (void 0 === imported) throw Error(`${displayPath} must provide a default export`);
+                    }), importedConfigPaths = collectConfigImportWatchPaths(configPath, configJiti.cache, cacheKeysBeforeImport);
+                    if (importedConfigPaths.length > 0 && (configWatchPaths = [
+                        configPath,
+                        ...importedConfigPaths
+                    ]), void 0 === imported) throw Error(`${displayPath} must provide a default export`);
                     if ('object' != typeof imported) throw Error(`${displayPath} must export a config`);
                     reactRouterUserConfig = imported;
                 } catch (error) {
                     throw Error(`Error loading ${displayPath}: ${error}`);
+                } finally{
+                    ((moduleCache, filePaths)=>{
+                        let normalizedFilePaths = new Set(filePaths.map(config_imports_normalizePath));
+                        for (let [cacheKey, module] of Object.entries(moduleCache)){
+                            let cachedPath = config_imports_normalizePath(module?.filename ?? cacheKey);
+                            normalizedFilePaths.has(cachedPath) && delete moduleCache[cacheKey];
+                        }
+                    })(configJiti.cache, [
+                        configPath,
+                        ...collectConfigImportWatchPaths(configPath, configJiti.cache, cacheKeysBeforeImport)
+                    ]);
                 }
             } else console.warn('No react-router.config found, using default configuration.');
-            let { resolved: resolvedConfig, presets: configPresets } = await resolveReactRouterConfig(reactRouterUserConfig), { appDirectory, basename, buildDirectory, future, allowedActionOrigins, routeDiscovery: userRouteDiscovery, ssr, prerender: prerenderConfig, serverBuildFile, serverModuleFormat, serverBundles, buildEnd } = resolvedConfig, hasExplicitServerOutput = Object.prototype.hasOwnProperty.call(options, 'serverOutput'), resolvedServerOutput = hasExplicitServerOutput ? options.serverOutput : 'cjs' === serverModuleFormat ? 'commonjs' : 'module';
-            if (hasExplicitServerOutput && serverModuleFormat && ('commonjs' === options.serverOutput ? 'cjs' : 'esm') !== serverModuleFormat && api.logger.warn(`[${PLUGIN_NAME}] Both \`serverOutput\` and \`serverModuleFormat\` are set. Using \`serverOutput=${options.serverOutput}\` and ignoring \`serverModuleFormat=${serverModuleFormat}\`.`), serverBuildFile && !serverBuildFile.endsWith('.js')) throw Error('The `serverBuildFile` config must end in `.js`.');
+            let jiti = createJiti(process.cwd(), {
+                moduleCache: !1
+            }), { resolved: resolvedConfig, presets: configPresets, hasConfiguredServerModuleFormat } = await resolveReactRouterConfig(reactRouterUserConfig), { appDirectory, basename, buildDirectory, future, allowedActionOrigins, routeDiscovery: userRouteDiscovery, ssr, prerender: prerenderConfig, serverBuildFile, serverModuleFormat, splitRouteModules, buildEnd } = resolvedConfig, hasExplicitServerOutput = Object.prototype.hasOwnProperty.call(options, 'serverOutput'), resolvedServerOutput = pluginOptions.serverOutput;
+            if (hasExplicitServerOutput || (resolvedServerOutput = 'cjs' === serverModuleFormat ? 'commonjs' : 'module'), hasExplicitServerOutput && hasConfiguredServerModuleFormat && serverModuleFormat && ('commonjs' === resolvedServerOutput ? 'cjs' : 'esm') !== serverModuleFormat && api.logger.warn(`[${PLUGIN_NAME}] Both \`serverOutput\` and \`serverModuleFormat\` are set. Using \`serverOutput=${resolvedServerOutput}\` and ignoring \`serverModuleFormat=${serverModuleFormat}\`.`), serverBuildFile && !serverBuildFile.endsWith('.js')) throw Error('The `serverBuildFile` config must end in `.js`.');
             if ('esm' !== serverModuleFormat && 'cjs' !== serverModuleFormat) throw Error('The `serverModuleFormat` config must be "esm" or "cjs".');
-            serverBundles && api.logger.warn(`[${PLUGIN_NAME}] \`serverBundles\` is configured. Rsbuild currently emits a single server bundle, but the build manifest will include the server bundle mapping for compatibility.`);
             let prerenderConfigError = ((prerender)=>{
+                let value;
                 if (!prerender) return null;
-                if (!(isValidPrerenderPathsConfig('object' == typeof prerender && null !== prerender && 'paths' in prerender ? prerender?.paths : prerender) || 'object' == typeof prerender && null !== prerender && 'paths' in prerender && isValidPrerenderPathsConfig(prerender?.paths))) return 'The `prerender`/`prerender.paths` config must be a boolean, an array of string paths, or a function returning a boolean or array of string paths.';
-                let concurrency = 'object' == typeof prerender && null !== prerender && 'unstable_concurrency' in prerender ? prerender?.unstable_concurrency : void 0;
-                return void 0 !== concurrency && (!Number.isInteger(concurrency) || concurrency <= 0) ? 'The `prerender.unstable_concurrency` config must be a positive integer if specified.' : null;
+                let config = getPrerenderConfigObject(prerender);
+                if (!('boolean' == typeof (value = config && 'paths' in config ? config.paths : prerender) || 'function' == typeof value || Array.isArray(value))) return 'The `prerender`/`prerender.paths` config must be a boolean, an array of string paths, or a function returning a boolean or array of string paths.';
+                let concurrency = getPrerenderConcurrencyConfig(config);
+                return concurrency && (!Number.isInteger(concurrency.value) || concurrency.value <= 0) ? `The \`${concurrency.key}\` config must be a positive integer if specified.` : null;
             })(prerenderConfig);
             if (prerenderConfigError) throw Error(prerenderConfigError);
             if (userRouteDiscovery) {
@@ -954,62 +1393,76 @@ let redirectStatusCodes = new Set([
             } : {
                 mode: 'initial'
             };
-            globalThis.__reactRouterAppDirectory = resolve(appDirectory);
-            let routesPath = findEntryFile(resolve(appDirectory, 'routes'));
+            globalThis.__reactRouterAppDirectory = external_pathe_resolve(appDirectory);
+            let routesPath = findEntryFile(external_pathe_resolve(appDirectory, 'routes'));
             if (!existsSync(routesPath)) throw Error(`Route config file not found at "${relative(process.cwd(), routesPath)}".`);
-            let routeConfigExport = await jiti.import(routesPath, {
-                default: !0
-            }), routeConfigValue = await routeConfigExport, validation = (({ routeConfigFile, routeConfig })=>{
-                if (!routeConfig) return {
-                    valid: !1,
-                    message: `Route config must be the default export in "${routeConfigFile}".`
-                };
-                if (!Array.isArray(routeConfig)) return {
-                    valid: !1,
-                    message: `Route config in "${routeConfigFile}" must be an array.`
-                };
-                let issues = [];
-                return (routeConfig.forEach((entry, index)=>validateEntry(entry, `routes.${index}`, issues)), issues.length > 0) ? {
-                    valid: !1,
-                    message: [
-                        `Route config in "${routeConfigFile}" is invalid.`,
-                        issues.join('\n\n')
-                    ].join('\n\n')
-                } : {
-                    valid: !0,
-                    routeConfig: routeConfig
-                };
-            })({
-                routeConfigFile: relative(process.cwd(), routesPath),
-                routeConfig: routeConfigValue
-            });
-            if (!validation.valid) throw Error(validation.message);
-            let routeConfig = validation.routeConfig, entryClientPath = findEntryFile(resolve(appDirectory, 'entry.client')), entryServerPath = findEntryFile(resolve(appDirectory, 'entry.server')), serverAppPath = findEntryFile(resolve(appDirectory, '../server/index')), hasServerApp = existsSync(serverAppPath), templateDir = resolve(src_dirname, 'templates'), templateClientPath = resolve(templateDir, 'entry.client.js'), templateServerPath = resolve(templateDir, 'entry.server.js'), finalEntryClientPath = existsSync(entryClientPath) ? entryClientPath : templateClientPath, finalEntryServerPath = existsSync(entryServerPath) ? entryServerPath : templateServerPath, rootRoutePath = findEntryFile(resolve(appDirectory, 'root')), rootRouteFile = relative(appDirectory, rootRoutePath), routes = {
+            let loadRouteConfig = async ()=>{
+                let routeConfigExport = await jiti.import(routesPath, {
+                    default: !0
+                }), routeConfigValue = await routeConfigExport, validation = (({ routeConfigFile, routeConfig })=>{
+                    if (!routeConfig) return {
+                        valid: !1,
+                        message: `Route config must be the default export in "${routeConfigFile}".`
+                    };
+                    if (!Array.isArray(routeConfig)) return {
+                        valid: !1,
+                        message: `Route config in "${routeConfigFile}" must be an array.`
+                    };
+                    let issues = [];
+                    return (routeConfig.forEach((entry, index)=>validateEntry(entry, `routes.${index}`, issues)), issues.length > 0) ? {
+                        valid: !1,
+                        message: [
+                            `Route config in "${routeConfigFile}" is invalid.`,
+                            issues.join('\n\n')
+                        ].join('\n\n')
+                    } : {
+                        valid: !0,
+                        routeConfig: routeConfig
+                    };
+                })({
+                    routeConfigFile: relative(process.cwd(), routesPath),
+                    routeConfig: routeConfigValue
+                });
+                if (!validation.valid) throw Error(validation.message);
+                return validation.routeConfig;
+            }, routeConfig = await loadRouteConfig(), entryClientPath = findEntryFile(external_pathe_resolve(appDirectory, 'entry.client')), entryServerPath = findEntryFile(external_pathe_resolve(appDirectory, 'entry.server')), serverAppPath = findEntryFile(external_pathe_resolve(appDirectory, '../server/index')), hasServerApp = existsSync(serverAppPath), devServerBuildEntryName = hasServerApp ? 'static/js/react-router-server-build' : 'static/js/app', templateDir = external_pathe_resolve(src_dirname, 'templates'), templateClientPath = external_pathe_resolve(templateDir, 'entry.client.js'), templateServerPath = external_pathe_resolve(templateDir, 'entry.server.js'), finalEntryClientPath = existsSync(entryClientPath) ? entryClientPath : templateClientPath, finalEntryServerPath = existsSync(entryServerPath) ? entryServerPath : templateServerPath, rootRoutePath = findEntryFile(external_pathe_resolve(appDirectory, 'root')), rootRouteFile = relative(appDirectory, rootRoutePath), createRouteTopologySnapshot = (routeFile, routeConfig)=>{
+                let routes;
+                return new Set((Array.isArray(routes = [
+                    [
+                        'root',
+                        {
+                            path: '',
+                            id: 'root',
+                            file: routeFile
+                        }
+                    ],
+                    ...configRoutesToRouteManifestEntries(appDirectory, routeConfig)
+                ]) ? routes : Object.entries(routes)).map(([routeId, route], order)=>JSON.stringify([
+                        order,
+                        routeId,
+                        route.id,
+                        route.parentId ?? null,
+                        route.path ?? null,
+                        route.index ?? null,
+                        route.caseSensitive ?? null,
+                        route.file
+                    ])));
+            }, getWatchedRouteTopology = async ()=>{
+                let latestRouteConfig = await loadRouteConfig();
+                return createRouteTopologySnapshot(relative(appDirectory, findEntryFile(external_pathe_resolve(appDirectory, 'root'))), latestRouteConfig);
+            }, routes = {
                 root: {
                     path: '',
                     id: 'root',
                     file: rootRouteFile
                 },
                 ...function(appDirectory, routes, rootId = 'root') {
-                    let routeManifest = {};
-                    for (let route of routes)!function walk(route, parentId) {
-                        let id = route.id || normalize(route.file.replace(/\.[^/.]+$/, '')), manifestItem = {
-                            id,
-                            parentId,
-                            file: isAbsolute(route.file) ? relative(appDirectory, route.file) : route.file,
-                            path: route.path,
-                            index: route.index,
-                            caseSensitive: route.caseSensitive
-                        };
-                        if (Object.prototype.hasOwnProperty.call(routeManifest, id)) throw Error(`Unable to define routes with duplicate route id: "${id}"`);
-                        if (routeManifest[id] = manifestItem, route.children) for (let child of route.children)walk(child, id);
-                    }(route, rootId);
-                    return routeManifest;
+                    return Object.fromEntries(configRoutesToRouteManifestEntries(appDirectory, routes, rootId));
                 }(appDirectory, routeConfig)
             }, resolvedConfigWithRoutes = {
                 ...resolvedConfig,
-                appDirectory: resolve(appDirectory),
-                buildDirectory: resolve(buildDirectory),
+                appDirectory: external_pathe_resolve(appDirectory),
+                buildDirectory: external_pathe_resolve(buildDirectory),
                 routeDiscovery,
                 prerender: prerenderConfig,
                 routes,
@@ -1019,224 +1472,616 @@ let redirectStatusCodes = new Set([
             for (let preset of configPresets)await preset.reactRouterConfigResolved?.({
                 reactRouterConfig: resolvedConfigForPreset
             });
-            let isBuild = 'build' === api.context.action, splitRouteModules = future?.v8_splitRouteModules ?? !1, enforceSplitRouteModules = 'enforce' === splitRouteModules, routeChunkConfig = {
-                splitRouteModules,
-                appDirectory,
-                rootRouteFile
-            }, routeChunkCache = new Map(), routeChunkOptions = {
+            let isBuild = 'build' === api.context.action, isPrerenderEnabled = void 0 !== prerenderConfig && !1 !== prerenderConfig, isSpaMode = !ssr && !isPrerenderEnabled, routeCount = Object.keys(routes).length, routeChunkCache = new Map(), routeTransformExecutor = (({ parallelRouteTransform, routeChunkCache, splitRouteModules } = {})=>{
+                let options = {
+                    routeChunkCache
+                };
+                if (void 0 === parallelRouteTransform || !1 === parallelRouteTransform) return {
+                    run: (task)=>executeRouteTransformTask(task, options),
+                    close: async ()=>{}
+                };
+                let workerCount = ((parallelRouteTransform)=>{
+                    if (!0 === parallelRouteTransform) return getDefaultConcurrency(void 0);
+                    if (!Number.isInteger(parallelRouteTransform) || parallelRouteTransform < 1) throw Error('[react-router] parallelRouteTransform must be true, false, or a positive integer.');
+                    return parallelRouteTransform;
+                })(parallelRouteTransform);
+                return workerCount < 1 ? {
+                    run: (task)=>executeRouteTransformTask(task, options),
+                    close: async ()=>{}
+                } : new ParallelRouteTransformExecutor(workerCount, options, !!splitRouteModules);
+            })({
+                parallelRouteTransform: pluginOptions.parallelRouteTransform ?? routeCount >= 256,
+                routeChunkCache,
+                splitRouteModules: !!splitRouteModules
+            }), routeChunkOptions = {
                 splitRouteModules,
                 rootRouteFile,
                 isBuild,
                 cache: routeChunkCache
-            }, latestServerManifest = null, latestServerManifestsByBundleId = {}, routeByFilePath = new Map(Object.values(routes).map((route)=>[
-                    resolve(appDirectory, route.file),
+            }, outputClientPath = external_pathe_resolve(buildDirectory, 'client'), assetsBuildDirectory = relative(process.cwd(), outputClientPath), watchDirectory = external_pathe_resolve(appDirectory), routeRestartMarkerPath = external_pathe_resolve(outputClientPath, '.react-router/route-watch'), routeWatchFiles = [
+                {
+                    paths: configWatchPaths,
+                    type: 'reload-server'
+                },
+                ...pluginOptions.onRouteTopologyChange ? [] : [
+                    {
+                        paths: routesPath,
+                        type: 'reload-server'
+                    },
+                    {
+                        paths: routeRestartMarkerPath,
+                        type: 'reload-server'
+                    }
+                ]
+            ];
+            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 = void 0;
+            }), api.onCloseBuild(async ()=>{
+                await routeTransformExecutor.close();
+            }), api.onCloseDevServer(async ()=>{
+                await routeTransformExecutor.close();
+            });
+            let latestBrowserManifest = null, latestBrowserManifestModuleExports = {}, latestServerManifest = null, latestServerManifestsByBundleId = {}, routeByFilePath = new Map(Object.values(routes).map((route)=>[
+                    external_pathe_resolve(appDirectory, route.file),
                     route
-                ])), routeExportsCache = new Map(), getCachedRouteExports = async (filePath)=>{
-                if (routeExportsCache.has(filePath)) return routeExportsCache.get(filePath);
-                let exports = await getRouteModuleExports(filePath);
-                return routeExportsCache.set(filePath, exports), exports;
-            }, webRouteEntries = Object.values(routes).reduce((acc, route)=>{
-                let entryName = route.file.slice(0, route.file.lastIndexOf('.')), routeFilePath = resolve(appDirectory, route.file);
-                if (acc[entryName] = {
-                    import: `${routeFilePath}${BUILD_CLIENT_ROUTE_QUERY_STRING}`
+                ])), manifestChunkNames = new Set([
+                'entry.client'
+            ]), webRouteEntries = Object.values(routes).reduce((acc, route)=>{
+                let entryName = route.file.slice(0, route.file.lastIndexOf('.')), routeFilePath = external_pathe_resolve(appDirectory, route.file);
+                if (manifestChunkNames.add(entryName), acc[entryName] = {
+                    import: `${routeFilePath}${BUILD_CLIENT_ROUTE_QUERY_STRING}`,
+                    html: !1
                 }, isBuild && splitRouteModules && 'root' !== route.id) {
-                    let source = '';
+                    let source;
                     try {
                         source = readFileSync(routeFilePath, 'utf8');
-                    } catch  {
-                        source = '';
+                    } catch (error) {
+                        if ('ENOENT' === error.code) return acc;
+                        throw error;
+                    }
+                    for (let exportName of routeChunkExportNames){
+                        if (!source.includes(exportName)) continue;
+                        let chunkEntryName = getRouteChunkEntryName(route.id, exportName);
+                        manifestChunkNames.add(chunkEntryName), acc[chunkEntryName] = {
+                            import: getRouteChunkModuleId(routeFilePath, exportName),
+                            html: !1
+                        };
                     }
-                    if (source) for (let exportName of routeChunkExportNames)source.includes(exportName) && (acc[getRouteChunkEntryName(route.id, exportName)] = {
-                        import: getRouteChunkModuleId(routeFilePath, exportName)
-                    });
                 }
                 return acc;
-            }, {}), routesByServerBundleId = ((buildManifest)=>{
-                if (!buildManifest || !('routeIdToServerBundleId' in buildManifest)) return {};
-                let routesByServerBundleId = {};
-                for (let [routeId, serverBundleId] of Object.entries(buildManifest.routeIdToServerBundleId))for (let route of (routesByServerBundleId[serverBundleId] ??= {}, getRouteBranch(buildManifest.routes, routeId)))routesByServerBundleId[serverBundleId][route.id] = route;
-                return routesByServerBundleId;
-            })(await getBuildManifest({
+            }, {}), buildManifest = await getBuildManifest({
                 reactRouterConfig: resolvedConfigWithRoutes,
                 routes,
                 rootDirectory: process.cwd()
-            })), outputClientPath = resolve(buildDirectory, 'client'), assetsBuildDirectory = relative(process.cwd(), outputClientPath);
+            }), routesByServerBundleId = ((buildManifest, sourceRoutes)=>{
+                if (!buildManifest || !('routeIdToServerBundleId' in buildManifest)) return {};
+                let routesByServerBundleId = {};
+                for (let [routeId, serverBundleId] of Object.entries(buildManifest.routeIdToServerBundleId))for (let route of (routesByServerBundleId[serverBundleId] ??= {}, getRouteBranch(sourceRoutes, routeId)))routesByServerBundleId[serverBundleId][route.id] = route;
+                return routesByServerBundleId;
+            })(buildManifest, routes), serverBuildPlan = (({ routesByServerBundleId, serverBuildFile, defaultEntryName })=>{
+                let serverBuildFileBase = (serverBuildFile || 'index.js').replace(/\.js$/, ''), serverBundleEntries = Object.entries(routesByServerBundleId).filter(([, bundleRoutes])=>!!(bundleRoutes && Object.keys(bundleRoutes).length > 0)).map(([bundleId])=>({
+                        bundleId,
+                        entryName: `${bundleId}/${serverBuildFileBase}`
+                    })), reservedNodeEntryNames = new Set([
+                    'static/js/app',
+                    'static/js/entry.server',
+                    defaultEntryName
+                ]);
+                for (let { entryName } of serverBundleEntries){
+                    if (reservedNodeEntryNames.has(entryName)) throw Error(`[${PLUGIN_NAME}] Server bundle entry ${JSON.stringify(entryName)} conflicts with a reserved node entry.`);
+                    reservedNodeEntryNames.add(entryName);
+                }
+                return {
+                    defaultEntryName,
+                    entryNames: [
+                        defaultEntryName,
+                        ...serverBundleEntries.map(({ entryName })=>entryName)
+                    ],
+                    serverBundleEntries
+                };
+            })({
+                routesByServerBundleId,
+                serverBuildFile,
+                defaultEntryName: devServerBuildEntryName
+            }), { serverBundleEntries } = serverBuildPlan, devRuntime = (({ api, isBuild, buildPlan })=>{
+                let scheduledCssAssetOwnershipReload, state, nextSessionId, closeObservationByServer, isCurrentBinding, applyCloseOutcome, observeClose, identityByCompilation, webIdentityByNodeCompilation;
+                if (isBuild) return {
+                    captureWeb () {},
+                    createBuildLoader: ()=>()=>Promise.reject(Error(`[${PLUGIN_NAME}] The development server runtime is unavailable during a production build.`))
+                };
+                let lastCssAssetOwnershipReloadAt = 0, reloadAfterCssAssetOwnershipRemoval = !1, sendCssAssetOwnershipReload = ()=>{
+                    let binding = sessions.getActiveBinding();
+                    binding && (lastCssAssetOwnershipReloadAt = Date.now(), binding.server.sockWrite('full-reload', {
+                        path: '*'
+                    }));
+                }, scheduleCssAssetOwnershipReload = ()=>{
+                    scheduledCssAssetOwnershipReload && clearTimeout(scheduledCssAssetOwnershipReload);
+                    let scheduledAt = Date.now();
+                    scheduledCssAssetOwnershipReload = setTimeout(()=>{
+                        scheduledCssAssetOwnershipReload = void 0, lastCssAssetOwnershipReloadAt > scheduledAt || sendCssAssetOwnershipReload();
+                    }, 1000);
+                }, closeBinding = (binding, error)=>{
+                    scheduledCssAssetOwnershipReload && (clearTimeout(scheduledCssAssetOwnershipReload), scheduledCssAssetOwnershipReload = void 0), reloadAfterCssAssetOwnershipRemoval = !1;
+                    let pair = binding.compilers;
+                    pair && (pair.pendingAttempt = void 0, pair.latestCompletedWebIdentity = void 0, pair.latestWebStart = void 0, pair.latestNodeStart = void 0), binding.compilers = void 0, binding.runtime.close(error);
+                    var server = binding.server, runtime = binding.runtime;
+                    Reflect.get(server, DEV_RUNTIME_KEY) === runtime && Reflect.deleteProperty(server, DEV_RUNTIME_KEY);
+                }, sessions = (state = {
+                    status: 'idle'
+                }, nextSessionId = 1, closeObservationByServer = new WeakMap(), isCurrentBinding = (binding)=>('active' === state.status || 'closing' === state.status) && state.binding === binding, applyCloseOutcome = (observation, outcome)=>{
+                    observation.outcome = outcome;
+                    let { binding } = observation;
+                    if (binding) {
+                        if (outcome.ok) isCurrentBinding(binding) && ('active' === state.status && closeBinding(binding), state = {
+                            status: 'idle'
+                        });
+                        else ((binding, cause)=>{
+                            if (!isCurrentBinding(binding)) return;
+                            let error = Error(`[${PLUGIN_NAME}] The previous development server failed to close. Restart the process before retrying because Rsbuild may not have finished tearing down its compiler and watchers.`, {
+                                cause
+                            });
+                            closeBinding(binding, error), state = {
+                                status: 'terminal',
+                                error
+                            };
+                        })(binding, outcome.cause);
+                        observation.binding = void 0;
+                    }
+                }, observeClose = (server)=>{
+                    let existing = closeObservationByServer.get(server);
+                    if (existing) return existing;
+                    let observation = {}, close = server.close.bind(server);
+                    return server.close = ()=>{
+                        let closePromise;
+                        if (observation.promise) return observation.promise;
+                        try {
+                            closePromise = close();
+                        } catch (cause) {
+                            closePromise = Promise.reject(cause);
+                        }
+                        return observation.promise = closePromise, closePromise.then(()=>applyCloseOutcome(observation, {
+                                ok: !0
+                            }), (cause)=>applyCloseOutcome(observation, {
+                                ok: !1,
+                                cause
+                            })), closePromise;
+                    }, closeObservationByServer.set(server, observation), observation;
+                }, {
+                    getState: ()=>state,
+                    getActiveBinding: ()=>'active' === state.status ? state.binding : void 0,
+                    observeClose (server) {
+                        observeClose(server);
+                    },
+                    assertCanStart () {
+                        if ('terminal' === state.status) throw state.error;
+                        if ('active' === state.status) throw Error(`[${PLUGIN_NAME}] A development server is already active. Await its close() before calling createDevServer() again. If startup failed before returning the server, restart the process before retrying.`);
+                        if ('closing' === state.status) throw Error(`[${PLUGIN_NAME}] The previous development server is still closing. Await its close() before calling createDevServer() again.`);
+                    },
+                    createBinding (server, runtime) {
+                        let binding = {
+                            id: nextSessionId++,
+                            server,
+                            runtime
+                        };
+                        return state = {
+                            status: 'active',
+                            binding
+                        }, binding;
+                    },
+                    bindCloseObservation (binding) {
+                        let observation = observeClose(binding.server);
+                        observation.binding = binding, observation.outcome && applyCloseOutcome(observation, observation.outcome);
+                    },
+                    markClosing (binding) {
+                        isCurrentBinding(binding) && (state = {
+                            status: 'closing',
+                            binding
+                        });
+                    },
+                    terminate (binding, error) {
+                        isCurrentBinding(binding) && (closeBinding(binding, error), state = {
+                            status: 'terminal',
+                            error
+                        });
+                    }
+                }), compilationIdentities = (identityByCompilation = new WeakMap(), webIdentityByNodeCompilation = new WeakMap(), {
+                    getCompilationIdentity (compilation) {
+                        let existing = identityByCompilation.get(compilation);
+                        if (existing) return existing;
+                        let identity = Symbol();
+                        return identityByCompilation.set(compilation, identity), identity;
+                    },
+                    getWebIdentityForNodeCompilation: (compilation)=>webIdentityByNodeCompilation.get(compilation),
+                    setWebIdentityForNodeCompilation (compilation, identity) {
+                        webIdentityByNodeCompilation.set(compilation, identity);
+                    }
+                }), { getCompilationIdentity } = compilationIdentities, flushSettledAttempt = (binding, pair)=>{
+                    let pending = pair.pendingAttempt;
+                    !pending || sessions.getActiveBinding()?.id !== binding.id || !pair.settledCompilations.has(pending.webCompilation) || !pair.settledCompilations.has(pending.nodeCompilation) || (pair.pendingAttempt = void 0, isLatestStartedCompilation(pending.identity.web, pair.latestWebStart) && isLatestStartedCompilation(pending.identity.node, pair.latestNodeStart) && binding.runtime.finishAttempt(pending.stats, pending.changes, pending.identity).catch((cause)=>{
+                        sessions.getActiveBinding()?.id === binding.id && binding.runtime.failAttempt(cause instanceof Error ? cause : Error(String(cause)));
+                    }));
+                }, rejectUnsupportedCompiler = (reason)=>{
+                    let message = `[${PLUGIN_NAME}] Could not coordinate React Router development output because ${reason}.`;
+                    api.logger.warn(message);
+                    let binding = sessions.getActiveBinding();
+                    if (!binding) return;
+                    let error = Error(message);
+                    sessions.terminate(binding, error);
+                };
+                return api.modifyRsbuildConfig({
+                    order: 'post',
+                    handler (config) {
+                        let existingSetup = config.server?.setup, setup = existingSetup ? Array.isArray(existingSetup) ? existingSetup : [
+                            existingSetup
+                        ] : [];
+                        return {
+                            ...config,
+                            server: {
+                                ...config.server,
+                                setup: [
+                                    (context)=>{
+                                        'dev' === context.action && sessions.observeClose(context.server);
+                                    },
+                                    ...setup
+                                ]
+                            }
+                        };
+                    }
+                }), api.onBeforeStartDevServer({
+                    order: 'pre',
+                    async handler ({ server }) {
+                        sessions.assertCanStart();
+                        let runtime = (({ server, buildPlan, onEvaluationError, onCssAssetOwnershipChanged = ()=>void 0, onRouteManifestChanged = ()=>void 0, onWarning = ()=>void 0 })=>{
+                            let nextAttemptId = 1, reloadAfterCssRemoval = !1, state = {
+                                kind: 'starting',
+                                attemptId: 0,
+                                readiness: createDeferred()
+                            }, manifestsByCompilation = new WeakMap(), notifyCssAssetOwnershipChanged = (change)=>{
+                                try {
+                                    onCssAssetOwnershipChanged(change);
+                                } catch (cause) {
+                                    let reason = cause instanceof Error ? cause.message : String(cause);
+                                    onWarning(`[rsbuild-plugin-react-router] Failed to notify the browser after CSS asset ownership changed: ${reason}`);
+                                }
+                            }, uniqueEntryNames = new Set(buildPlan.entryNames);
+                            if (uniqueEntryNames.size !== buildPlan.entryNames.length || !uniqueEntryNames.has(buildPlan.defaultEntryName)) throw Error('[rsbuild-plugin-react-router] The development server build plan must contain unique entries and include its default entry.');
+                            let selectBuild = (generation, requestedEntryName)=>{
+                                let entryName = requestedEntryName ?? buildPlan.defaultEntryName, build = generation.buildsByEntryName[entryName];
+                                if (!build) throw Error(`[rsbuild-plugin-react-router] Committed React Router server build ${JSON.stringify(entryName)} was not found.`);
+                                return build;
+                            }, getCurrentAttemptId = ()=>'starting' === state.kind ? state.attemptId : 'ready' === state.kind ? state.pendingAttemptId : null, rejectAttempt = (attemptId, error, report)=>{
+                                if (getCurrentAttemptId() === attemptId) {
+                                    if ('starting' === state.kind) {
+                                        let { readiness } = state;
+                                        state = {
+                                            kind: 'failed',
+                                            attemptId,
+                                            error
+                                        }, readiness.reject(error);
+                                    } else 'ready' === state.kind && (state = {
+                                        ...state,
+                                        pendingAttemptId: null
+                                    });
+                                    report && onEvaluationError(error);
+                                }
+                            };
+                            return {
+                                beginAttempt () {
+                                    if ('closed' === state.kind) return;
+                                    let attemptId = nextAttemptId++;
+                                    state = 'failed' === state.kind ? {
+                                        kind: 'starting',
+                                        attemptId,
+                                        readiness: createDeferred()
+                                    } : 'starting' === state.kind ? {
+                                        ...state,
+                                        attemptId
+                                    } : {
+                                        ...state,
+                                        pendingAttemptId: attemptId
+                                    };
+                                },
+                                captureWeb (compilation, manifestsByEntryName) {
+                                    'closed' !== state.kind && manifestsByCompilation.set(compilation, structuredClone(manifestsByEntryName));
+                                },
+                                async finishAttempt (stats, changes, identity) {
+                                    var previous;
+                                    let previousEntryNames, nextEntryNames, side, attemptId = getCurrentAttemptId();
+                                    if (null === attemptId) return;
+                                    let webStats = getEnvironmentStats(stats, 'web'), nodeStats = getEnvironmentStats(stats, 'node');
+                                    if (!webStats || !nodeStats) return void rejectAttempt(attemptId, Error('[rsbuild-plugin-react-router] Development compilation did not provide both web and node results.'), !0);
+                                    if (webStats.compilation.needAdditionalPass || nodeStats.compilation.needAdditionalPass) return;
+                                    if (webStats.hasErrors() || nodeStats.hasErrors()) return void rejectAttempt(attemptId, Error('[rsbuild-plugin-react-router] The React Router development compilation failed.'), !1);
+                                    let webCompilation = webStats.compilation, nodeCompilation = nodeStats.compilation, webIdentity = identity.web, nodeIdentity = identity.node;
+                                    if (!webIdentity || !nodeIdentity) return void rejectAttempt(attemptId, Error('[rsbuild-plugin-react-router] Development compilation identity was unavailable.'), !0);
+                                    let previous1 = 'ready' === state.kind ? state.committed : void 0, webChanged = !previous1 || previous1.webIdentity !== webIdentity, nodeChanged = !previous1 || previous1.nodeIdentity !== nodeIdentity;
+                                    if (!webChanged && !nodeChanged) return;
+                                    let manifestsByEntryName = webChanged ? manifestsByCompilation.get(webCompilation) : previous1?.web.manifestsByEntryName;
+                                    if (!manifestsByEntryName) return void rejectAttempt(attemptId, Error('[rsbuild-plugin-react-router] The web compilation completed without a matching React Router manifest. Keeping the last-good development build.'), !0);
+                                    let cssAssetsRemoved = !!previous1 && webChanged && hasRemovedCssAssetOwnership(previous1.web.manifestsByEntryName, manifestsByEntryName), cssAssetsAdded = !!previous1 && webChanged && hasRemovedCssAssetOwnership(manifestsByEntryName, previous1.web.manifestsByEntryName), cssOnlyWebManifestChange = (cssAssetsRemoved || cssAssetsAdded) && (previous = previous1.web.manifestsByEntryName, previousEntryNames = Object.keys(previous).sort(), nextEntryNames = Object.keys(manifestsByEntryName).sort(), previousEntryNames.join('\0') === nextEntryNames.join('\0') && previousEntryNames.every((entryName)=>{
+                                        let previousManifest = normalizeManifestForCssOwnershipCheck(previous[entryName]), nextManifest = normalizeManifestForCssOwnershipCheck(manifestsByEntryName[entryName]);
+                                        return JSON.stringify(previousManifest) === JSON.stringify(nextManifest);
+                                    })), routeManifestMetadataChanged = !!previous1 && webChanged && ((previous, next)=>{
+                                        let previousEntryNames = Object.keys(previous);
+                                        if (previousEntryNames.length !== Object.keys(next).length) return !0;
+                                        for (let entryName of previousEntryNames){
+                                            let nextManifest = next[entryName];
+                                            if (!nextManifest) return !0;
+                                            let previousRoutes = previous[entryName].routes ?? {}, nextRoutes = nextManifest.routes ?? {}, previousRouteIds = Object.keys(previousRoutes);
+                                            if (previousRouteIds.length !== Object.keys(nextRoutes).length) return !0;
+                                            for (let routeId of previousRouteIds){
+                                                let previousRoute = previousRoutes[routeId], nextRoute = nextRoutes[routeId];
+                                                if (!nextRoute || !hasSameRouteMetadata(previousRoute, nextRoute)) return !0;
+                                            }
+                                        }
+                                        return !1;
+                                    })(previous1.web.manifestsByEntryName, manifestsByEntryName), reusePreviousNodeBuild = !!previous1 && cssOnlyWebManifestChange;
+                                    if (nodeChanged && identity.nodeWeb !== webIdentity && !reusePreviousNodeBuild) {
+                                        let message = '[rsbuild-plugin-react-router] Discarded web and node results from different compiler cycles and kept the last-good build.';
+                                        if (!previous1) return;
+                                        onWarning(message), rejectAttempt(attemptId, Error(message), !1);
+                                        return;
+                                    }
+                                    let shouldEvaluateNode = nodeChanged && !reusePreviousNodeBuild;
+                                    if (!(previous1 && webChanged !== shouldEvaluateNode && !cssOnlyWebManifestChange && (side = webChanged ? 'web-only' : 'node-only', !((changes, dependencies)=>{
+                                        if (!changes.known || 0 === changes.files.size) return !1;
+                                        for (let file of changes.files){
+                                            if (dependencies.files.has(file) || dependencies.missing.has(file)) return !1;
+                                            for (let directory of dependencies.contexts)if (isWithinDirectory(directory, file)) return !1;
+                                        }
+                                        return !0;
+                                    })(webChanged ? changes.web : changes.node, webChanged ? previous1.nodeDependencies : previous1.web.dependencies) && (onWarning(`[rsbuild-plugin-react-router] Discarded an incomplete ${side} development result and kept the last-good build.`), rejectAttempt(attemptId, Error(`Incomplete ${side} development result.`), !1), 1)))) try {
+                                        let buildsByEntryName = shouldEvaluateNode ? await evaluateServerBuilds(server, buildPlan.entryNames) : previous1.buildsByEntryName;
+                                        if (getCurrentAttemptId() !== attemptId) return;
+                                        let web = webChanged ? {
+                                            manifestsByEntryName,
+                                            dependencies: snapshotDependencies(webCompilation)
+                                        } : previous1.web;
+                                        if (!((attemptId, committed)=>{
+                                            if (getCurrentAttemptId() !== attemptId) return !1;
+                                            if ('starting' === state.kind) {
+                                                let { readiness } = state;
+                                                state = {
+                                                    kind: 'ready',
+                                                    committed,
+                                                    pendingAttemptId: null
+                                                }, readiness.resolve(committed);
+                                            } else 'ready' === state.kind && (state = {
+                                                kind: 'ready',
+                                                committed,
+                                                pendingAttemptId: null
+                                            });
+                                            return !0;
+                                        })(attemptId, {
+                                            buildsByEntryName: ((builds, entryNames, manifestsByEntryName)=>{
+                                                let pinned = {};
+                                                for (let entryName of entryNames){
+                                                    let build = builds[entryName];
+                                                    if (!build) throw Error(`[rsbuild-plugin-react-router] Expected server build ${JSON.stringify(entryName)} was not evaluated.`);
+                                                    let manifest = manifestsByEntryName[entryName];
+                                                    if (!manifest) throw Error(`[rsbuild-plugin-react-router] Server build ${JSON.stringify(entryName)} has no matching web manifest.`);
+                                                    pinned[entryName] = pinBuildToManifest(entryName, build, manifest);
+                                                }
+                                                return pinned;
+                                            })(buildsByEntryName, buildPlan.entryNames, web.manifestsByEntryName),
+                                            webIdentity,
+                                            nodeIdentity: shouldEvaluateNode ? nodeIdentity : previous1.nodeIdentity,
+                                            web,
+                                            nodeDependencies: shouldEvaluateNode ? snapshotDependencies(nodeCompilation) : previous1.nodeDependencies
+                                        })) return;
+                                        cssAssetsRemoved ? (reloadAfterCssRemoval = !cssAssetsAdded, notifyCssAssetOwnershipChanged('removed')) : cssAssetsAdded && (reloadAfterCssRemoval && notifyCssAssetOwnershipChanged('restored'), reloadAfterCssRemoval = !1), routeManifestMetadataChanged && (()=>{
+                                            try {
+                                                onRouteManifestChanged();
+                                            } catch (cause) {
+                                                let reason = cause instanceof Error ? cause.message : String(cause);
+                                                onWarning(`[rsbuild-plugin-react-router] Failed to notify the browser after route manifest metadata changed: ${reason}`);
+                                            }
+                                        })();
+                                    } catch (cause) {
+                                        rejectAttempt(attemptId, cause instanceof Error ? cause : Error(String(cause)), !0);
+                                    }
+                                },
+                                failAttempt (error) {
+                                    let attemptId = getCurrentAttemptId();
+                                    null !== attemptId && rejectAttempt(attemptId, error, !1);
+                                },
+                                load (entryName) {
+                                    if (entryName && !uniqueEntryNames.has(entryName)) return Promise.reject(Error(`[rsbuild-plugin-react-router] React Router server build ${JSON.stringify(entryName)} is not part of this development server build plan.`));
+                                    if ('ready' === state.kind) return Promise.resolve(selectBuild(state.committed, entryName));
+                                    if ('starting' === state.kind) {
+                                        let selected = state.readiness.promise.then((generation)=>selectBuild(generation, entryName));
+                                        return selected.catch(()=>void 0), selected;
+                                    }
+                                    return Promise.reject(state.error);
+                                },
+                                close (error) {
+                                    if ('closed' === state.kind) return;
+                                    let closeError = error ?? Error('[rsbuild-plugin-react-router] The development server closed before a React Router build was ready.');
+                                    'starting' === state.kind && state.readiness.reject(closeError), state = {
+                                        kind: 'closed',
+                                        error: closeError
+                                    };
+                                }
+                            };
+                        })({
+                            server,
+                            buildPlan,
+                            onEvaluationError (error) {
+                                sessions.getActiveBinding()?.runtime === runtime && (api.logger.error(error.message), server.sockWrite('errors', {
+                                    text: [
+                                        error.message
+                                    ],
+                                    html: error.message.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
+                                }));
+                            },
+                            onCssAssetOwnershipChanged (change) {
+                                sessions.getActiveBinding()?.runtime === runtime && (reloadAfterCssAssetOwnershipRemoval = 'removed' === change, sendCssAssetOwnershipReload());
+                            },
+                            onRouteManifestChanged () {
+                                sessions.getActiveBinding()?.runtime === runtime && server.sockWrite('full-reload', {
+                                    path: '*'
+                                });
+                            },
+                            onWarning: (message)=>api.logger.warn(message)
+                        }), binding = sessions.createBinding(server, runtime);
+                        Object.defineProperty(server, DEV_RUNTIME_KEY, {
+                            configurable: !0,
+                            enumerable: !1,
+                            value: runtime
+                        }), sessions.bindCloseObservation(binding);
+                    }
+                }), api.onCloseDevServer({
+                    order: 'pre',
+                    handler () {
+                        let binding = sessions.getActiveBinding();
+                        binding && (closeBinding(binding), sessions.markClosing(binding));
+                    }
+                }), api.onBeforeDevCompile({
+                    order: 'pre',
+                    handler () {
+                        let binding = sessions.getActiveBinding(), pair = binding?.compilers;
+                        !binding || !pair || hasPendingCompilation(pair) || (pair.pendingAttempt = void 0, binding.runtime.beginAttempt());
+                    }
+                }), api.onAfterCreateCompiler(({ compiler })=>{
+                    if (!('compilers' in compiler)) return void rejectUnsupportedCompiler('Rsbuild did not create a multi-compiler');
+                    let web = compiler.compilers.find((item)=>'web' === item.name), node = compiler.compilers.find((item)=>'node' === item.name);
+                    if (!web || !node) return void rejectUnsupportedCompiler('the web or node compiler was missing');
+                    let binding = sessions.getActiveBinding();
+                    if (!binding) return;
+                    let pair = {
+                        web,
+                        node,
+                        settledCompilations: new WeakSet()
+                    };
+                    binding.compilers = pair;
+                    let sessionId = binding.id, runtime = binding.runtime, failCurrentAttempt = (side, error)=>{
+                        sessions.getActiveBinding()?.id === sessionId && ('web' === side ? pair.latestWebStart = void 0 : pair.latestNodeStart = void 0, pair.pendingAttempt = void 0, runtime.failAttempt(error));
+                    }, beginCompilerAttempt = (side)=>{
+                        if (sessions.getActiveBinding()?.id === sessionId && pair[side]?.status !== 'pending') {
+                            let attemptAlreadyPending = hasPendingCompilation(pair);
+                            pair[side] = {
+                                status: 'pending'
+                            }, pair.pendingAttempt = void 0, attemptAlreadyPending || runtime.beginAttempt(), 'latestWebStart' === side && reloadAfterCssAssetOwnershipRemoval && (reloadAfterCssAssetOwnershipRemoval = !1, scheduleCssAssetOwnershipReload());
+                        }
+                    };
+                    web.hooks.invalid.tap(`${PLUGIN_NAME}:dev-web-invalid`, ()=>beginCompilerAttempt('latestWebStart')), node.hooks.invalid.tap(`${PLUGIN_NAME}:dev-node-invalid`, ()=>beginCompilerAttempt('latestNodeStart')), web.hooks.done.tap({
+                        name: `${PLUGIN_NAME}:dev-web-complete`,
+                        stage: -1000
+                    }, (stats)=>{
+                        sessions.getActiveBinding()?.id === sessionId && (pair.latestCompletedWebIdentity = getCompilationIdentity(stats.compilation));
+                    }), web.hooks.thisCompilation.tap(`${PLUGIN_NAME}:dev-web-compilation`, (compilation)=>{
+                        sessions.getActiveBinding()?.id === sessionId && (pair.latestWebStart = {
+                            status: 'started',
+                            identity: getCompilationIdentity(compilation)
+                        }, reloadAfterCssAssetOwnershipRemoval && (reloadAfterCssAssetOwnershipRemoval = !1, scheduleCssAssetOwnershipReload()));
+                    }), node.hooks.thisCompilation.tap(`${PLUGIN_NAME}:dev-node-web-compilation`, (compilation)=>{
+                        sessions.getActiveBinding()?.id === sessionId && (pair.latestNodeStart = {
+                            status: 'started',
+                            identity: getCompilationIdentity(compilation)
+                        }, pair.latestCompletedWebIdentity && compilationIdentities.setWebIdentityForNodeCompilation(compilation, pair.latestCompletedWebIdentity));
+                    });
+                    let settleCompilation = (stats)=>{
+                        sessions.getActiveBinding()?.id === sessionId && (pair.settledCompilations.add(stats.compilation), flushSettledAttempt(binding, pair));
+                    };
+                    web.hooks.afterDone.tap(`${PLUGIN_NAME}:dev-web-settled`, settleCompilation), node.hooks.afterDone.tap(`${PLUGIN_NAME}:dev-node-settled`, settleCompilation), web.hooks.failed.tap(`${PLUGIN_NAME}:dev-web-failed`, (error)=>failCurrentAttempt('web', error)), node.hooks.failed.tap(`${PLUGIN_NAME}:dev-node-failed`, (error)=>failCurrentAttempt('node', error));
+                }), api.onAfterDevCompile(async ({ stats })=>{
+                    let binding = sessions.getActiveBinding(), pair = binding?.compilers;
+                    if (!binding || !pair) return;
+                    let webStats = getEnvironmentStats(stats, 'web'), nodeStats = getEnvironmentStats(stats, 'node');
+                    if (webStats && webStats.compilation.compiler !== pair.web || nodeStats && nodeStats.compilation.compiler !== pair.node) return;
+                    let webIdentity = webStats ? getCompilationIdentity(webStats.compilation) : void 0, nodeIdentity = nodeStats ? getCompilationIdentity(nodeStats.compilation) : void 0;
+                    if (!isLatestStartedCompilation(webIdentity, pair.latestWebStart) || !isLatestStartedCompilation(nodeIdentity, pair.latestNodeStart)) return;
+                    let changes = {
+                        web: snapshotDevChangedFiles(pair.web),
+                        node: snapshotDevChangedFiles(pair.node)
+                    }, identity = {
+                        web: webIdentity,
+                        node: nodeIdentity,
+                        nodeWeb: nodeStats ? compilationIdentities.getWebIdentityForNodeCompilation(nodeStats.compilation) : void 0
+                    };
+                    webStats && nodeStats ? (pair.pendingAttempt = {
+                        stats,
+                        changes,
+                        identity,
+                        webCompilation: webStats.compilation,
+                        nodeCompilation: nodeStats.compilation
+                    }, flushSettledAttempt(binding, pair)) : await binding.runtime.finishAttempt(stats, changes, identity);
+                }), {
+                    captureWeb (compilation, manifestsByEntryName) {
+                        let binding = sessions.getActiveBinding();
+                        binding?.compilers?.web === compilation.compiler && binding.runtime.captureWeb(compilation, manifestsByEntryName);
+                    },
+                    createBuildLoader (entryName) {
+                        let server = sessions.getActiveBinding()?.server;
+                        if (server) return ()=>loadReactRouterServerBuild(server, entryName);
+                        let state = sessions.getState();
+                        if ('terminal' === state.status) {
+                            let { error } = state;
+                            return ()=>Promise.reject(error);
+                        }
+                        return ()=>Promise.reject(Error(`[${PLUGIN_NAME}] The development server runtime is not ready.`));
+                    }
+                };
+            })({
+                api,
+                isBuild,
+                buildPlan: serverBuildPlan
+            });
             api.onAfterEnvironmentCompile(({ stats, environment })=>{
-                if ('web' === environment.name && (clientStats = stats?.toJson()), pluginOptions.federation && ssr) {
-                    let serverBuildDir = resolve(buildDirectory, 'server'), clientBuildDir = resolve(buildDirectory, 'client');
+                if ('web' === environment.name && (clientStats = createReactRouterManifestStats(stats?.compilation, manifestChunkNames)), pluginOptions.federation && ssr) {
+                    let serverBuildDir = external_pathe_resolve(buildDirectory, 'server'), clientBuildDir = external_pathe_resolve(buildDirectory, 'client');
                     if (existsSync(serverBuildDir)) {
-                        let ssrDir = resolve(clientBuildDir, 'static');
+                        let ssrDir = external_pathe_resolve(clientBuildDir, 'static');
                         fs_extra.copySync(serverBuildDir, ssrDir);
                     }
                 }
+                logPerformance && performanceProfiler.flush(environment.name, {
+                    compilerLifecycleMs: roundMs(performance.now() - setupStartMs)
+                });
             });
             let prerenderPaths = await resolvePrerenderPaths(prerenderConfig, ssr, routeConfig, {
                 logWarning: !0,
                 warn: (message)=>api.logger.warn(message)
-            }), isPrerenderEnabled = void 0 !== prerenderConfig && !1 !== prerenderConfig, isSpaMode = !ssr && !isPrerenderEnabled, groupRoutesByParentId = (manifest)=>{
-                let grouped = {};
-                return Object.values(manifest).forEach((route)=>{
-                    if (!route) return;
-                    let parentId = route.parentId || '';
-                    grouped[parentId] || (grouped[parentId] = []), grouped[parentId].push(route);
-                }), grouped;
-            }, createPrerenderRoutes = (manifest, parentId = '', grouped = groupRoutesByParentId(manifest))=>(grouped[parentId] || []).map((route)=>{
-                    let common = {
-                        id: route.id,
-                        path: route.path
-                    };
-                    return route.index ? {
-                        index: !0,
-                        ...common
-                    } : {
-                        ...common,
-                        children: createPrerenderRoutes(manifest, route.id, grouped)
-                    };
-                }), normalizePrerenderMatchPath = (path)=>`/${path}/`.replace(/^\/\/+/, '/'), prerenderData = async (handler, prerenderPath, onlyRoutes, clientBuildDir, requestInit)=>{
-                let dataRequestPath;
-                dataRequestPath = future?.unstable_trailingSlashAwareDataRequests ? prerenderPath.endsWith('/') ? `${prerenderPath}_.data` : `${prerenderPath}.data` : '/' === prerenderPath ? '/_root.data' : `${prerenderPath.replace(/\/$/, '')}.data`;
-                let normalizedPath = `${basename}${dataRequestPath}`.replace(/\/\/+/g, '/'), url = new URL(`http://localhost${normalizedPath}`);
-                onlyRoutes?.length && url.searchParams.set('_routes', onlyRoutes.join(','));
-                let request = new Request(url, requestInit), response = await handler(request), data = await response.text();
-                if (200 !== response.status && 202 !== response.status) throw Error(`Prerender (data): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${prerenderPath}\` path.\n${normalizedPath}`);
-                let outputPath = resolve(clientBuildDir, ...normalizedPath.split('/'));
-                return await mkdir(dirname(outputPath), {
-                    recursive: !0
-                }), await writeFile(outputPath, data), api.logger.info(`Prerender (data): ${prerenderPath} -> ${relative(process.cwd(), outputPath)}`), data;
-            }, prerenderRoute = async (handler, prerenderPath, clientBuildDir, requestInit)=>{
-                let normalizedPath = `${basename}${prerenderPath}/`.replace(/\/\/+/g, '/'), request = new Request(`http://localhost${normalizedPath}`, requestInit), response = await handler(request), html = await response.text();
-                if (redirectStatusCodes.has(response.status)) {
-                    let location = response.headers.get('Location'), delay = 2 * (302 === response.status);
-                    html = `<!doctype html>
-<head>
-<title>Redirecting to: ${location}</title>
-<meta http-equiv="refresh" content="${delay};url=${location}">
-<meta name="robots" content="noindex">
-</head>
-<body>
-\t<a href="${location}">
-    Redirecting from <code>${normalizedPath}</code> to <code>${location}</code>
-  </a>
-</body>
-</html>`;
-                } else if (200 !== response.status) throw Error(`Prerender (html): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${normalizedPath}\` path.\n` + html);
-                let outputPath = resolve(clientBuildDir, ...normalizedPath.split('/'), 'index.html');
-                await mkdir(dirname(outputPath), {
-                    recursive: !0
-                }), await writeFile(outputPath, html), api.logger.info(`Prerender (html): ${prerenderPath} -> ${relative(process.cwd(), outputPath)}`);
-            }, prerenderResourceRoute = async (handler, prerenderPath, clientBuildDir, requestInit)=>{
-                let normalizedPath = `${basename}${prerenderPath}/`.replace(/\/\/+/g, '/').replace(/\/$/g, ''), request = new Request(`http://localhost${normalizedPath}`, requestInit), response = await handler(request), content = Buffer.from(await response.arrayBuffer());
-                if (200 !== response.status) throw Error(`Prerender (resource): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${normalizedPath}\` path.\n` + content.toString('utf8'));
-                let outputPath = resolve(clientBuildDir, ...normalizedPath.split('/'));
-                await mkdir(dirname(outputPath), {
-                    recursive: !0
-                }), await writeFile(outputPath, content), api.logger.info(`Prerender (resource): ${prerenderPath} -> ${relative(process.cwd(), outputPath)}`);
-            }, handleSpaMode = async (handler, build, clientBuildDir)=>{
-                let request = new Request(`http://localhost${basename}`, {
-                    headers: {
-                        'X-React-Router-SPA-Mode': 'yes'
-                    }
-                }), response = await handler(request), html = await response.text(), isPrerenderSpaFallback = build.prerender?.includes('/'), filename = isPrerenderSpaFallback ? '__spa-fallback.html' : 'index.html';
-                if (200 !== response.status) {
-                    if (isPrerenderSpaFallback) throw Error(`Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename}\` file.\n` + html);
-                    throw Error(`SPA Mode: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename}\` file.\n` + html);
-                }
-                if (!html.includes('window.__reactRouterContext =') || !html.includes('window.__reactRouterRouteModules =')) throw Error("SPA Mode: Did you forget to include `<Scripts/>` in your root route? Your pre-rendered HTML cannot hydrate without `<Scripts />`.");
-                let outputPath = resolve(clientBuildDir, filename);
-                await writeFile(outputPath, html);
-                let prettyPath = relative(process.cwd(), outputPath);
-                build.prerender?.length ? api.logger.info(`Prerender (html): SPA Fallback -> ${prettyPath}`) : api.logger.info(`SPA Mode: Generated ${prettyPath}`);
-            }, validateSsrFalsePrerenderExports = async (manifest, prerenderList)=>{
-                if (0 === prerenderList.length) return;
-                let prerenderRoutes = createPrerenderRoutes(routes), prerenderedRoutes = new Set();
-                for (let path of prerenderList){
-                    let matches = matchRoutes(prerenderRoutes, normalizePrerenderMatchPath(path));
-                    if (!matches) throw Error(`Unable to prerender path because it does not match any routes: ${path}`);
-                    matches.forEach((match)=>prerenderedRoutes.add(match.route.id));
-                }
-                let routeExports = {};
-                for (let route of Object.values(routes)){
-                    let filePath = resolve(appDirectory, route.file);
-                    routeExports[route.id] = await getRouteModuleExports(filePath);
-                }
-                let errors = [];
-                for (let [routeId, route] of Object.entries(manifest.routes)){
-                    let exports = routeExports[routeId] ?? [], invalidApis = [];
-                    if (exports.includes('headers') && invalidApis.push('headers'), exports.includes('action') && invalidApis.push('action'), invalidApis.length > 0 && errors.push(`Prerender: ${invalidApis.length} invalid route export(s) in \`${routeId}\` when pre-rendering with \`ssr:false\`: ${invalidApis.map((api)=>`\`${api}\``).join(', ')}. See https://reactrouter.com/how-to/pre-rendering#invalid-exports for more information.`), !prerenderedRoutes.has(routeId)) {
-                        exports.includes('loader') && errors.push(`Prerender: 1 invalid route export in \`${routeId}\` when pre-rendering with \`ssr:false\`: \`loader\`. See https://reactrouter.com/how-to/pre-rendering#invalid-exports for more information.`);
-                        let parentRoute = route.parentId && manifest.routes[route.parentId] ? manifest.routes[route.parentId] : null;
-                        for(; parentRoute && 'root' !== parentRoute.id;)parentRoute.hasLoader && !parentRoute.hasClientLoader && errors.push(`Prerender: 1 invalid route export in \`${parentRoute.id}\` when pre-rendering with \`ssr:false\`: \`loader\`. See https://reactrouter.com/how-to/pre-rendering#invalid-exports for more information.`), parentRoute = parentRoute.parentId && 'root' !== parentRoute.parentId ? manifest.routes[parentRoute.parentId] : null;
-                    }
-                }
-                if (errors.length > 0) throw api.logger.error(errors.join('\n')), Error('Invalid route exports found when prerendering with `ssr:false`');
-            };
+            });
             api.onAfterBuild(async ({ environments })=>{
-                if (!environments.web) return;
-                let serverBuildDir = resolve(buildDirectory, 'server'), defaultServerBuildFile = 'static/js/app.js', configuredServerBuildFile = serverBuildFile || 'index.js', configuredServerBuildPath = resolve(serverBuildDir, configuredServerBuildFile), defaultServerBuildPath = resolve(serverBuildDir, defaultServerBuildFile);
-                configuredServerBuildFile !== defaultServerBuildFile && existsSync(defaultServerBuildPath) && !existsSync(configuredServerBuildPath) && (await mkdir(dirname(configuredServerBuildPath), {
-                    recursive: !0
-                }), await fs_extra.copy(defaultServerBuildPath, configuredServerBuildPath));
-                let serverBuildPath = existsSync(configuredServerBuildPath) ? configuredServerBuildPath : defaultServerBuildPath, clientBuildDir = resolve(buildDirectory, 'client');
-                if (!existsSync(serverBuildPath)) return void console.warn(`[${PLUGIN_NAME}] Server build not found at ${serverBuildPath}. Skipping prerendering.`);
-                if (await mkdir(clientBuildDir, {
-                    recursive: !0
-                }), !ssr || isPrerenderEnabled) {
-                    process.env.IS_RR_BUILD_REQUEST = 'yes';
-                    let normalizedBuild = normalizeBuildModule(await import(pathToFileURL(serverBuildPath).toString())), build = await resolveBuildExports(normalizedBuild), requestHandler = createRequestHandler(build, 'production');
-                    if (isPrerenderEnabled) {
-                        let manifest = await getReactRouterManifestForDev(routes, pluginOptions, clientStats, appDirectory, assetPrefix, routeChunkOptions);
-                        ssr || await validateSsrFalsePrerenderExports(manifest, prerenderPaths);
-                        let routeTree = createPrerenderRoutes(routes);
-                        for (let path of prerenderPaths)if (!matchRoutes(routeTree, normalizePrerenderMatchPath(path))) throw Error(`Unable to prerender path because it does not match any routes: ${path}`);
-                        prerenderPaths.length > 0 && api.logger.info(`Prerender (html): ${prerenderPaths.length} path(s)...`);
-                        let buildRoutes = createPrerenderRoutes(build.routes), concurrency = ((prerender)=>{
-                            if ('object' == typeof prerender && null !== prerender && 'unstable_concurrency' in prerender) {
-                                let value = prerender?.unstable_concurrency;
-                                if ('number' == typeof value && Number.isInteger(value) && value > 0) return value;
-                            }
-                            return 1;
-                        })(prerenderConfig), pending = new Set(), enqueue = async (path)=>{
-                            let matches = matchRoutes(buildRoutes, normalizePrerenderMatchPath(path));
-                            if (!matches) return;
-                            let leafRoute = matches[matches.length - 1]?.route, manifestRoute = leafRoute ? build.routes?.[leafRoute.id]?.module : null;
-                            if (!manifestRoute || manifestRoute.default || manifestRoute.ErrorBoundary) {
-                                let data;
-                                matches.some((match)=>{
-                                    let routeId = match.route.id;
-                                    return !!routeId && build.assets?.routes?.[routeId]?.hasLoader;
-                                }) && (data = await prerenderData(requestHandler, path, null, clientBuildDir)), await prerenderRoute(requestHandler, path, clientBuildDir, data ? {
-                                    headers: {
-                                        'X-React-Router-Prerender-Data': encodeURI(data)
-                                    }
-                                } : void 0);
-                            } else manifestRoute.loader ? (await prerenderData(requestHandler, path, [
-                                leafRoute.id
-                            ], clientBuildDir), await prerenderResourceRoute(requestHandler, path, clientBuildDir)) : api.logger.warn(`⚠️ Skipping prerendering for resource route without a loader: ${leafRoute?.id}`);
-                        };
-                        for (let path of prerenderPaths){
-                            let task = enqueue(path);
-                            pending.add(task), task.finally(()=>pending.delete(task)), pending.size >= concurrency && await Promise.race(pending);
-                        }
-                        await Promise.all(pending);
-                    }
-                    ssr || await handleSpaMode(requestHandler, build, clientBuildDir);
-                }
-                if (ssr || (await fs_extra.remove(serverBuildDir), api.logger.info(`[${PLUGIN_NAME}] Removed server build (static deployment)`)), buildEnd) {
-                    let buildManifest = await getBuildManifest({
-                        reactRouterConfig: resolvedConfigWithRoutes,
-                        routes,
-                        rootDirectory: process.cwd()
-                    });
-                    await buildEnd({
-                        buildManifest,
-                        reactRouterConfig: resolvedConfigWithRoutes,
-                        viteConfig: api.getNormalizedConfig()
-                    });
-                }
+                await runReactRouterPrerenderBuild({
+                    api,
+                    hasWebEnvironment: !!environments.web,
+                    buildDirectory,
+                    serverBuildFile,
+                    ssr,
+                    isPrerenderEnabled,
+                    prerenderConfig,
+                    prerenderPaths,
+                    basename,
+                    future,
+                    routes,
+                    latestBrowserManifest,
+                    latestBrowserManifestModuleExports,
+                    clientStats,
+                    pluginOptions,
+                    appDirectory,
+                    assetPrefix,
+                    routeChunkOptions,
+                    buildManifest,
+                    resolvedConfigWithRoutes,
+                    buildEnd
+                });
             });
-            let allowedActionOriginsForBuild = !1 === allowedActionOrigins ? void 0 : allowedActionOrigins, vmodTempDir = `rspack-virtual-module-${process.pid}-${Math.random().toString(16).slice(2)}`;
+            let allowedActionOriginsForBuild = !1 === allowedActionOrigins ? void 0 : allowedActionOrigins;
             api.modifyRsbuildConfig(async (config, { mergeRsbuildConfig })=>{
-                var publicPath;
+                var existing, publicPath;
                 let bundleVirtualModules, bundleManifestModules, vmodPlugin = (publicPath = assetPrefix = normalizeAssetPrefix(config.output?.assetPrefix), bundleVirtualModules = Object.fromEntries(Object.entries(routesByServerBundleId).map(([bundleId, bundleRoutes])=>[
                         `virtual/react-router/server-build-${bundleId}`,
                         generateServerBuild(bundleRoutes, {
@@ -1256,7 +2101,7 @@ let redirectStatusCodes = new Set([
                     ])), bundleManifestModules = Object.fromEntries(Object.entries(routesByServerBundleId).filter(([, bundleRoutes])=>bundleRoutes && Object.keys(bundleRoutes).length > 0).map(([bundleId])=>[
                         `virtual/react-router/server-manifest-${bundleId}`,
                         'export default {};'
-                    ])), new RspackVirtualModulePlugin({
+                    ])), new rspack.experiments.VirtualModulesPlugin(Object.fromEntries(Object.entries({
                     'virtual/react-router/browser-manifest': 'export default {};',
                     'virtual/react-router/server-manifest': 'export default {};',
                     'virtual/react-router/server-build': generateServerBuild(routes, {
@@ -1274,80 +2119,108 @@ let redirectStatusCodes = new Set([
                     }),
                     ...bundleVirtualModules,
                     ...bundleManifestModules,
-                    'virtual/react-router/with-props': `
-    import { createElement as h } from "react";
-    import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
-
-    export function withComponentProps(Component) {
-      return function Wrapped() {
-        const props = {
-          params: useParams(),
-          loaderData: useLoaderData(),
-          actionData: useActionData(),
-          matches: useMatches(),
-        };
-        return h(Component, props);
-      };
-    }
-
-    export function withHydrateFallbackProps(HydrateFallback) {
-      return function Wrapped() {
-        const props = {
-          params: useParams(),
-        };
-        return h(HydrateFallback, props);
-      };
-    }
-
-    export function withErrorBoundaryProps(ErrorBoundary) {
-      return function Wrapped() {
-        const props = {
-          params: useParams(),
-          loaderData: useLoaderData(),
-          actionData: useActionData(),
-          error: useRouteError(),
-        };
-        return h(ErrorBoundary, props);
-      };
-    }
-  `
-                }, vmodTempDir)), useAsyncNodeChunkLoading = options.federation && 'commonjs' === resolvedServerOutput, nodeChunkLoading = 'module' === resolvedServerOutput ? 'import' : useAsyncNodeChunkLoading ? 'async-node' : 'require', serverBuildFileBase = (serverBuildFile || 'index.js').replace(/\.js$/, ''), nodeEntries = {
-                    ...hasServerApp ? {
-                        'static/js/app': serverAppPath
-                    } : {
-                        'static/js/app': 'virtual/react-router/server-build'
-                    },
-                    'static/js/entry.server': finalEntryServerPath
-                };
-                for (let [bundleId, bundleRoutes] of Object.entries(routesByServerBundleId))bundleRoutes && 0 !== Object.keys(bundleRoutes).length && (nodeEntries[`${bundleId}/${serverBuildFileBase}`] = `virtual/react-router/server-build-${bundleId}`);
+                    'virtual/react-router/with-props': generateWithProps()
+                }).map(([moduleId, contents])=>[
+                        ((moduleId)=>{
+                            if (!moduleId.startsWith(VIRTUAL_MODULE_PREFIX)) throw Error(`Virtual module id must start with ${JSON.stringify(VIRTUAL_MODULE_PREFIX)}: ${moduleId}`);
+                            let relativeId = moduleId.slice(VIRTUAL_MODULE_PREFIX.length), segments = relativeId.split('/');
+                            if (!relativeId || segments.some((segment)=>!segment || '.' === segment || '..' === segment)) throw Error(`Invalid virtual module id: ${moduleId}`);
+                            return `node_modules/${moduleId}.js`;
+                        })(moduleId),
+                        contents
+                    ])))), useAsyncNodeChunkLoading = options.federation && 'commonjs' === resolvedServerOutput, nodeChunkLoading = 'require';
+                'module' === resolvedServerOutput ? nodeChunkLoading = 'import' : useAsyncNodeChunkLoading && (nodeChunkLoading = 'async-node');
+                let nodeEntries = (({ hasServerApp, isBuild, serverAppPath, entryServerPath, defaultEntryName, serverBundleEntries })=>{
+                    let entries = {
+                        'static/js/app': hasServerApp ? serverAppPath : 'virtual/react-router/server-build',
+                        'static/js/entry.server': entryServerPath
+                    };
+                    for (let { bundleId, entryName } of (hasServerApp && !isBuild && (entries[defaultEntryName] = 'virtual/react-router/server-build'), serverBundleEntries))entries[entryName] = `virtual/react-router/server-build-${bundleId}`;
+                    return entries;
+                })({
+                    hasServerApp,
+                    isBuild,
+                    serverAppPath,
+                    entryServerPath: finalEntryServerPath,
+                    defaultEntryName: devServerBuildEntryName,
+                    serverBundleEntries
+                }), guardedLazyCompilation = (({ lazyCompilation, entryClientPath })=>{
+                    let eagerPatterns;
+                    if (void 0 === lazyCompilation || !1 === lazyCompilation) return lazyCompilation;
+                    let options = !0 === lazyCompilation ? {
+                        entries: !0,
+                        imports: !0
+                    } : lazyCompilation, userTest = options.test, isReactRouterHydrationModule = (eagerPatterns = [
+                        entryClientPath.replace(/\\/g, '/'),
+                        'virtual/react-router/browser-manifest',
+                        BUILD_CLIENT_ROUTE_QUERY_STRING,
+                        '?react-router-route'
+                    ], (module)=>[
+                            module.request,
+                            module.userRequest,
+                            module.rawRequest,
+                            module.resource,
+                            module.identifier?.(),
+                            module.nameForCondition?.()
+                        ].filter((value)=>!!value).some((value)=>{
+                            let normalizedValue = value.replace(/\\/g, '/');
+                            return eagerPatterns.some((pattern)=>normalizedValue.includes(pattern));
+                        }));
+                    return {
+                        ...options,
+                        test (module) {
+                            if (isReactRouterHydrationModule(module)) return !1;
+                            if (!userTest) return !0;
+                            if ('function' == typeof userTest) return userTest(module);
+                            let conditionName = module.nameForCondition?.();
+                            return !!conditionName && (userTest.lastIndex = 0, userTest.test(conditionName));
+                        }
+                    };
+                })({
+                    lazyCompilation: void 0 === pluginOptions.lazyCompilation ? config.dev?.lazyCompilation : pluginOptions.lazyCompilation,
+                    entryClientPath: finalEntryClientPath
+                }), shouldCompactFileSizeReport = isBuild && routeCount >= 256 && (config.performance?.printFileSize === void 0 || !0 === config.performance.printFileSize);
                 return mergeRsbuildConfig(config, {
+                    ...shouldCompactFileSizeReport ? {
+                        performance: {
+                            printFileSize: {
+                                total: !0,
+                                detail: !1,
+                                compressed: !1
+                            }
+                        }
+                    } : {},
                     output: {
                         assetPrefix: config.output?.assetPrefix || '/'
                     },
                     dev: {
                         writeToDisk: !0,
+                        ...void 0 === guardedLazyCompilation ? {} : {
+                            lazyCompilation: guardedLazyCompilation
+                        },
+                        watchFiles: (existing = config.dev?.watchFiles, existing ? [
+                            ...Array.isArray(existing) ? existing : [
+                                existing
+                            ],
+                            ...routeWatchFiles
+                        ] : routeWatchFiles),
                         setupMiddlewares: pluginOptions.customServer || !ssr ? [] : [
-                            (middlewares, server)=>{
-                                middlewares.push(async (req, res, next)=>{
+                            (middlewares)=>{
+                                var dependencies;
+                                let listenerPromise;
+                                middlewares.push((dependencies = {
+                                    loadBuild: devRuntime.createBuildLoader()
+                                }, async (req, res, next)=>{
                                     try {
-                                        let tryLoadBundle = async (entryName)=>{
-                                            try {
-                                                return await server.environments.node.loadBundle(entryName);
-                                            } catch (error) {
-                                                if (error instanceof Error && error.message.includes("Can't find entry")) return null;
-                                                throw error;
-                                            }
-                                        }, bundle = await tryLoadBundle('static/js/app') ?? await tryLoadBundle('app');
-                                        if (!bundle || !bundle.routes) throw Error('Server bundle not found or invalid');
-                                        let rr = await import("react-router"), nfs = await import("@remix-run/node-fetch-server");
-                                        if ('function' != typeof rr.createRequestHandler) throw Error('[rsbuild-plugin-react-router] Missing `createRequestHandler` export from `react-router`');
-                                        if ('function' != typeof nfs.createRequestListener) throw Error('[rsbuild-plugin-react-router] Missing `createRequestListener` export from `@remix-run/node-fetch-server`');
-                                        let normalizedBuild = normalizeBuildModule(bundle), build = await resolveBuildExports(normalizedBuild), requestHandler = rr.createRequestHandler(build, 'development'), listener = nfs.createRequestListener((request)=>requestHandler(request));
+                                        let listener = await (listenerPromise ??= (async ()=>{
+                                            let createRequestHandler = dependencies.createRequestHandler ?? (await import("react-router")).createRequestHandler;
+                                            return (dependencies.createRequestListener ?? (await import("@remix-run/node-fetch-server")).createRequestListener)(createRequestHandler(dependencies.loadBuild, 'development'));
+                                        })());
                                         await listener(req, res);
                                     } catch (error) {
-                                        console.error('SSR Error:', error), next(error);
+                                        next(error);
                                     }
-                                });
+                                }));
                             }
                         ]
                     },
@@ -1360,10 +2233,20 @@ let redirectStatusCodes = new Set([
                     },
                     environments: {
                         web: {
+                            ...resolvedConfigWithRoutes.subResourceIntegrity ? {
+                                security: {
+                                    sri: {
+                                        enable: !0
+                                    }
+                                }
+                            } : {},
                             source: {
                                 entry: {
                                     'entry.client': finalEntryClientPath,
-                                    'virtual/react-router/browser-manifest': 'virtual/react-router/browser-manifest',
+                                    'virtual/react-router/browser-manifest': {
+                                        import: 'virtual/react-router/browser-manifest',
+                                        html: !1
+                                    },
                                     ...webRouteEntries
                                 }
                             },
@@ -1378,6 +2261,15 @@ let redirectStatusCodes = new Set([
                             tools: {
                                 rspack: {
                                     name: 'web',
+                                    module: {
+                                        rules: [
+                                            {
+                                                resourceQuery: urlAssetResourceQuery,
+                                                exclude: cssUrlAssetExtensions,
+                                                type: 'asset/resource'
+                                            }
+                                        ]
+                                    },
                                     ...options.federation ? {
                                         output: {
                                             chunkLoading: 'import'
@@ -1395,40 +2287,48 @@ let redirectStatusCodes = new Set([
                                         module: !0
                                     },
                                     optimization: {
+                                        avoidEntryIife: !0,
                                         runtimeChunk: 'single'
                                     }
                                 }
                             }
                         },
-                        ...{
-                            node: {
-                                source: {
-                                    entry: nodeEntries
+                        node: {
+                            source: {
+                                entry: nodeEntries
+                            },
+                            output: {
+                                distPath: {
+                                    root: external_pathe_resolve(buildDirectory, 'server')
                                 },
-                                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'
+                                            }
+                                        ]
                                     },
-                                    target: config.environments?.node?.output?.target || 'node',
-                                    filename: {
-                                        js: '[name].js'
-                                    }
-                                },
-                                tools: {
-                                    rspack: {
-                                        target: options.federation ? 'async-node' : 'node',
-                                        externals: nodeExternals,
-                                        dependencies: [
-                                            'web'
-                                        ],
-                                        externalsType: resolvedServerOutput,
-                                        output: {
-                                            chunkFormat: resolvedServerOutput,
-                                            chunkLoading: nodeChunkLoading,
-                                            workerChunkLoading: nodeChunkLoading,
-                                            wasmLoading: 'fetch',
-                                            module: 'module' === resolvedServerOutput
-                                        }
+                                    externals: nodeExternals,
+                                    dependencies: [
+                                        'web'
+                                    ],
+                                    externalsType: resolvedServerOutput,
+                                    output: {
+                                        chunkFormat: resolvedServerOutput,
+                                        chunkLoading: nodeChunkLoading,
+                                        workerChunkLoading: nodeChunkLoading,
+                                        wasmLoading: 'fetch',
+                                        module: 'module' === resolvedServerOutput
                                     }
                                 }
                             }
@@ -1447,400 +2347,236 @@ let redirectStatusCodes = new Set([
                                         asyncStartup: !0
                                     });
                                 }
-                            })(rspackConfig), 'node' === name && 'module' === resolvedServerOutput) {
-                                let output = rspackConfig.output, library = output?.library, libraryType = library && 'object' == typeof library && !Array.isArray(library) && 'type' in library ? library.type : void 0;
-                                output && 'commonjs2' === libraryType && (rspackConfig.output = {
-                                    ...output,
-                                    library: {
-                                        type: 'module'
-                                    }
-                                });
-                            }
-                            return 'web' === name && rspackConfig.plugins && rspackConfig.plugins.push(function(routes, pluginOptions, appDirectory, assetPrefix = '/', routeChunkOptions, options) {
-                                return {
-                                    apply (compiler) {
-                                        compiler.hooks.emit.tapAsync('ModifyBrowserManifest', async (compilation, callback)=>{
-                                            let sri, stats = compilation.getStats().toJson(), manifest = await getReactRouterManifestForDev(routes, pluginOptions, stats, appDirectory, assetPrefix, routeChunkOptions), virtualManifestPath = 'static/js/virtual/react-router/browser-manifest.js';
-                                            if (compilation.assets[virtualManifestPath]) {
-                                                let newSource = compilation.assets[virtualManifestPath].source().toString().replace(/["'`]PLACEHOLDER["'`]/, jsesc(manifest, {
-                                                    es6: !0
-                                                }));
-                                                compilation.assets[virtualManifestPath] = {
-                                                    source: ()=>newSource,
-                                                    size: ()=>newSource.length,
-                                                    map: ()=>({
-                                                            version: 3,
-                                                            sources: [
-                                                                virtualManifestPath
-                                                            ],
-                                                            names: [],
-                                                            mappings: '',
-                                                            file: virtualManifestPath,
-                                                            sourcesContent: [
-                                                                newSource
-                                                            ]
-                                                        }),
-                                                    sourceAndMap: ()=>({
-                                                            source: newSource,
-                                                            map: {
-                                                                version: 3,
-                                                                sources: [
-                                                                    virtualManifestPath
-                                                                ],
-                                                                names: [],
-                                                                mappings: '',
-                                                                file: virtualManifestPath,
-                                                                sourcesContent: [
-                                                                    newSource
-                                                                ]
-                                                            }
-                                                        }),
-                                                    updateHash: (hash)=>hash.update(newSource),
-                                                    buffer: ()=>Buffer.from(newSource)
-                                                };
-                                            }
-                                            if (routeChunkOptions?.isBuild) {
-                                                let entryAssets = stats?.assetsByChunkName?.['entry.client'], entryJsAssets = entryAssets?.filter((asset)=>asset.endsWith('.js')) || [], manifestPath = getReactRouterManifestPath({
-                                                    version: manifest.version,
-                                                    isBuild: !0,
-                                                    entryModulePath: entryJsAssets[0]
-                                                }), manifestSource = `window.__reactRouterManifest=${jsesc(manifest, {
-                                                    es6: !0
-                                                })};`;
-                                                compilation.assets[manifestPath] = new rspack.sources.RawSource(manifestSource);
-                                            }
-                                            if (routeChunkOptions?.isBuild && options?.future?.unstable_subResourceIntegrity) for (let asset of (sri = {}, 'function' == typeof compilation.getAssets ? compilation.getAssets() : Object.entries(compilation.assets).map(([name, asset])=>({
-                                                    name,
-                                                    source: asset
-                                                })))){
-                                                if (!asset.name.endsWith('.js')) continue;
-                                                let source = asset.source.source().toString(), hash = createHash('sha384').update(source).digest('base64');
-                                                sri[combineURLs(assetPrefix, asset.name)] = `sha384-${hash}`;
-                                            }
-                                            options?.onManifest?.(manifest, sri), callback();
-                                        });
-                                    }
-                                };
-                            }(routes, pluginOptions, appDirectory, assetPrefix, routeChunkOptions, {
-                                future,
-                                onManifest: (manifest, sri)=>{
-                                    let baseServerManifest = {
-                                        ...manifest,
-                                        sri
+                            })(rspackConfig), 'node' === name) {
+                                let output = rspackConfig.output;
+                                if (output) {
+                                    let library = output.library, libraryOptions = library && 'object' == typeof library && !Array.isArray(library) ? library : {};
+                                    rspackConfig.output = {
+                                        ...output,
+                                        library: {
+                                            ...libraryOptions,
+                                            type: 'module' === resolvedServerOutput ? 'module' : 'commonjs2'
+                                        }
                                     };
-                                    for (let [bundleId, bundleRoutes] of (latestServerManifest = baseServerManifest, Object.entries(routesByServerBundleId))){
-                                        if (!bundleRoutes) continue;
-                                        let routeIds = new Set(Object.keys(bundleRoutes)), filteredRoutes = Object.fromEntries(Object.entries(manifest.routes).filter(([routeId])=>routeIds.has(routeId)));
-                                        latestServerManifestsByBundleId[bundleId] = {
-                                            ...baseServerManifest,
-                                            routes: filteredRoutes
-                                        };
-                                    }
-                                }
-                            })), rspackConfig;
-                        }
-                    }
-                })), api.processAssets({
-                stage: 'additional',
-                targets: [
-                    'node'
-                ]
-            }, ({ sources, compilation })=>{
-                let packageJsonPath = 'package.json', source = new sources.RawSource(`{"type": "${resolvedServerOutput}"}`);
-                compilation.getAsset(packageJsonPath) ? compilation.updateAsset(packageJsonPath, source) : compilation.emitAsset(packageJsonPath, source);
-            }), api.transform({
-                test: /virtual\/react-router\/(browser|server)-manifest/
-            }, async (args)=>{
-                if ('web' === args.environment.name) return {
-                    code: 'window.__reactRouterManifest = "PLACEHOLDER";'
-                };
-                let bundleMatch = args.resource.match(/virtual\/react-router\/server-manifest(?:-([^?]+))?/), bundleId = bundleMatch?.[1]?.replace(/\\.js$/, ''), manifest = (isBuild && latestServerManifest ? bundleId && latestServerManifestsByBundleId[bundleId] ? latestServerManifestsByBundleId[bundleId] : latestServerManifest : null) ?? await getReactRouterManifestForDev(routes, pluginOptions, clientStats, appDirectory, assetPrefix, routeChunkOptions);
-                return {
-                    code: `export default ${jsesc(manifest, {
-                        es6: !0
-                    })};`
-                };
-            }), api.transform({
-                resourceQuery: /__react-router-build-client-route/
-            }, async (args)=>{
-                let code = await transformToEsm(args.code, args.resourcePath), exportNames = await getExportNames(code), isServer = args.environment?.name === 'node', chunkedExportSet = new Set(!isServer && isBuild && splitRouteModules ? (await detectRouteChunksIfEnabled(routeChunkCache, routeChunkConfig, args.resourcePath, code)).chunkedExports : []), reexports = exportNames.filter((exp)=>!chunkedExportSet.has(exp) && (CLIENT_ROUTE_EXPORTS.includes(exp) || isServer && SERVER_ONLY_ROUTE_EXPORTS.includes(exp))), target = `${args.resourcePath}?react-router-route`;
-                return {
-                    code: `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`
-                };
-            }), api.transform({
-                resourceQuery: /route-chunk=/
-            }, async (args)=>{
-                if (args.environment?.name !== 'web') return {
-                    code: args.code,
-                    map: null
-                };
-                let preventEmptyChunkSnippet = (reason)=>`Math.random()<0&&console.log(${JSON.stringify(reason)});`;
-                if (!isBuild || !splitRouteModules) return {
-                    code: preventEmptyChunkSnippet('Split route modules disabled'),
-                    map: null
-                };
-                let chunkName = ((id)=>{
-                    if (!id.includes(routeChunkQueryStringPrefix)) return null;
-                    let chunkName = id.split(routeChunkQueryStringPrefix)[1].split('&')[0];
-                    return 'main' === chunkName || routeChunkExportNames.includes(chunkName) ? chunkName : null;
-                })(args.resource);
-                if (!chunkName) throw Error(`Invalid route chunk name in "${args.resource}"`);
-                let transformed = await transformToEsm(args.code, args.resourcePath), chunk = await getRouteChunkIfEnabled(routeChunkCache, routeChunkConfig, args.resourcePath, chunkName, transformed);
-                if (enforceSplitRouteModules && 'main' === chunkName && chunk) {
-                    let exportNames = await getExportNames(chunk);
-                    validateRouteChunks({
-                        config: routeChunkConfig,
-                        id: args.resourcePath,
-                        valid: {
-                            clientAction: !exportNames.includes('clientAction'),
-                            clientLoader: !exportNames.includes('clientLoader'),
-                            clientMiddleware: !exportNames.includes('clientMiddleware'),
-                            HydrateFallback: !exportNames.includes('HydrateFallback')
-                        }
-                    });
-                }
-                return {
-                    code: chunk ?? preventEmptyChunkSnippet(`No ${chunkName} chunk`),
-                    map: null
-                };
-            }), api.transform({
-                test: /\.[cm]?[jt]sx?$/
-            }, async (args)=>{
-                if (args.environment?.name !== 'web' || !isBuild || !splitRouteModules || args.resource.includes(BUILD_CLIENT_ROUTE_QUERY_STRING) || args.resource.includes('?react-router-route') || args.resource.includes('route-chunk=') || !routeByFilePath.get(args.resourcePath)) return {
-                    code: args.code,
-                    map: null
-                };
-                let transformed = await transformToEsm(args.code, args.resourcePath), { hasRouteChunks, chunkedExports } = await detectRouteChunksIfEnabled(routeChunkCache, routeChunkConfig, args.resourcePath, transformed);
-                if (!hasRouteChunks) return {
-                    code: args.code,
-                    map: null
-                };
-                let sourceExports = await getCachedRouteExports(args.resourcePath), chunkedExportSet = new Set(chunkedExports), mainChunkReexports = sourceExports.filter((name)=>!chunkedExportSet.has(name)).join(', '), chunkBasePath = `./${external_pathe_basename(args.resourcePath)}`;
-                return {
-                    code: [
-                        mainChunkReexports ? `export { ${mainChunkReexports} } from "${getRouteChunkModuleId(chunkBasePath, 'main')}";` : null,
-                        ...chunkedExports.map((exportName)=>`export { ${exportName} } from "${getRouteChunkModuleId(chunkBasePath, exportName)}";`)
-                    ].filter(Boolean).join('\n'),
-                    map: null
-                };
-            }), api.transform({
-                test: /[\\/]\.server[\\/]|\.server(\.[cm]?[jt]sx?)?$/
-            }, async (args)=>{
-                if (args.environment?.name !== 'web') return {
-                    code: args.code,
-                    map: null
-                };
-                let relativePath = relative(process.cwd(), args.resourcePath);
-                throw Error(`[${PLUGIN_NAME}] Server-only module referenced by client: ${relativePath}`);
-            }), api.transform({
-                test: /[\\/]\.client[\\/]|\.client(\.[cm]?[jt]sx?)?$/
-            }, async (args)=>{
-                if (args.environment?.name !== 'node') return {
-                    code: args.code,
-                    map: null
-                };
-                let code = await transformToEsm(args.code, args.resourcePath), { exportNames: directExportNames, exportAllModules } = await getExportNamesAndExportAll(code), exportNames = new Set(directExportNames), unresolvedExportAll = new Set(), visitedModules = new Set(), resolveIndexFile = (dirPath)=>{
-                    for (let ext of JS_EXTENSIONS){
-                        let candidate = resolve(dirPath, `index${ext}`);
-                        if (existsSync(candidate)) try {
-                            if (statSync(candidate).isFile()) return candidate;
-                        } catch  {
-                            continue;
-                        }
-                    }
-                    return null;
-                }, resolveExportAllModule = (specifier, importerPath)=>{
-                    if (specifier.startsWith('.') || specifier.startsWith('/')) {
-                        let resolvedPath = ((basePath)=>{
-                            if (existsSync(basePath)) try {
-                                let stats = statSync(basePath);
-                                if (stats.isFile()) return basePath;
-                                if (stats.isDirectory()) return resolveIndexFile(basePath);
-                            } catch  {}
-                            for (let ext of JS_EXTENSIONS){
-                                let candidate = `${basePath}${ext}`;
-                                if (existsSync(candidate)) try {
-                                    if (statSync(candidate).isFile()) return candidate;
-                                } catch  {
-                                    continue;
                                 }
                             }
-                            return resolveIndexFile(basePath);
-                        })(specifier.startsWith('/') ? specifier : resolve(dirname(importerPath), specifier));
-                        if (resolvedPath) return resolvedPath;
-                    }
-                    try {
-                        return createRequire(pathToFileURL(importerPath).href).resolve(specifier);
-                    } catch  {
-                        return null;
-                    }
-                }, collectExportNamesFromModule = async (modulePath)=>{
-                    if (visitedModules.has(modulePath)) return;
-                    visitedModules.add(modulePath);
-                    let source = await readFile(modulePath, 'utf8'), moduleCode = await transformToEsm(source, modulePath), { exportNames: moduleExportNames, exportAllModules: moduleExportAll } = await getExportNamesAndExportAll(moduleCode);
-                    for (let name of moduleExportNames)'default' !== name && exportNames.add(name);
-                    for (let nestedSpecifier of moduleExportAll){
-                        let nestedPath = resolveExportAllModule(nestedSpecifier, modulePath);
-                        if (!nestedPath) {
-                            unresolvedExportAll.add(nestedSpecifier);
-                            continue;
+                            return rspackConfig;
                         }
-                        await collectExportNamesFromModule(nestedPath);
                     }
-                };
-                for (let specifier of exportAllModules){
-                    let resolvedPath = resolveExportAllModule(specifier, args.resourcePath);
-                    if (!resolvedPath) {
-                        unresolvedExportAll.add(specifier);
-                        continue;
+                })), function(api, routes, pluginOptions, appDirectory, assetPrefix = '/', routeChunkOptions, options) {
+                let getAssetPrefix = 'function' == typeof assetPrefix ? assetPrefix : ()=>assetPrefix, manifestChunkNames = options?.manifestChunkNames ?? ((routes, splitRouteModules = !1)=>{
+                    let chunkNames = new Set([
+                        'entry.client'
+                    ]);
+                    for (let route of Object.values(routes))if (chunkNames.add(getRouteEntryName(route)), splitRouteModules && 'root' !== route.id) for (let exportName of routeChunkExportNames)chunkNames.add(getRouteChunkEntryName(route.id, exportName));
+                    return chunkNames;
+                })(routes, routeChunkOptions?.splitRouteModules), finalizeSri = !!(routeChunkOptions?.isBuild && (options?.subResourceIntegrity ?? options?.future?.unstable_subResourceIntegrity)), generatedManifests = finalizeSri ? new WeakMap() : void 0;
+                api.processAssets({
+                    stage: 'additions',
+                    environments: [
+                        'web'
+                    ]
+                }, async ({ assets, sources, compilation })=>{
+                    let currentAssetPrefix = getAssetPrefix(), stats = createReactRouterManifestStats(compilation, manifestChunkNames), { manifest, moduleExportsByRouteId } = await generateReactRouterManifestForDev(routes, pluginOptions, stats, appDirectory, currentAssetPrefix, routeChunkOptions), manifestForBrowser = finalizeSri ? {
+                        ...manifest,
+                        sri: !0
+                    } : manifest, browserManifestAsset = assets[BROWSER_MANIFEST_ASSET];
+                    if (browserManifestAsset) {
+                        let newSource = browserManifestAsset.source().toString().replace(/["'`]PLACEHOLDER["'`]/, jsesc(manifestForBrowser, {
+                            es6: !0
+                        }));
+                        compilation.updateAsset(BROWSER_MANIFEST_ASSET, new sources.RawSource(newSource));
                     }
-                    await collectExportNamesFromModule(resolvedPath);
-                }
-                if (unresolvedExportAll.size > 0) throw Error(`[${PLUGIN_NAME}] Client-only module uses \`export * from\` with unresolvable specifier(s): ${Array.from(unresolvedExportAll).map((spec)=>`\`${spec}\``).join(', ')}. Please explicitly re-export named bindings in \`${relative(process.cwd(), args.resourcePath)}\`.`);
-                return {
-                    code: Array.from(exportNames).map((name)=>'default' === name ? 'export default undefined;' : `export const ${name} = undefined;`).join('\n'),
-                    map: null
-                };
-            }), api.transform({
-                resourceQuery: /\?react-router-route/
-            }, async (args)=>{
-                let code, scopeCrawled;
-                try {
-                    code = await transformToEsm(args.code, args.resourcePath);
-                } catch (error) {
-                    throw console.error(args.resourcePath), error;
-                }
-                if ('web' === args.environment.name && !ssr && isSpaMode) {
-                    let exportNames = await getExportNames(code), isRootRoute = args.resourcePath === rootRoutePath, invalidServerOnly = exportNames.filter((exp)=>(!isRootRoute || 'loader' !== exp) && SERVER_ONLY_ROUTE_EXPORTS.includes(exp));
-                    if (invalidServerOnly.length > 0) {
-                        let list = invalidServerOnly.map((e)=>`\`${e}\``).join(', ');
-                        throw Error(`SPA Mode: ${invalidServerOnly.length} invalid route export(s) in \`${relative(process.cwd(), args.resourcePath)}\`: ${list}. See https://reactrouter.com/how-to/spa for more information.`);
+                    if (routeChunkOptions?.isBuild) {
+                        let entryAssets = stats?.assetsByChunkName?.['entry.client'], entryJsAssets = entryAssets?.filter((asset)=>asset.endsWith('.js')) || [], manifestPath = getReactRouterManifestPath({
+                            version: manifest.version,
+                            isBuild: !0,
+                            entryModulePath: entryJsAssets[0]
+                        }), manifestSource = `window.__reactRouterManifest=${jsesc(manifestForBrowser, {
+                            es6: !0
+                        })};`, source = new sources.RawSource(manifestSource);
+                        compilation.getAsset(manifestPath) ? compilation.updateAsset(manifestPath, source) : compilation.emitAsset(manifestPath, source);
                     }
-                    if (!isRootRoute && exportNames.includes('HydrateFallback')) throw Error(`SPA Mode: Invalid \`HydrateFallback\` export found in \`${relative(process.cwd(), args.resourcePath)}\`. \`HydrateFallback\` is only permitted on the root route in SPA Mode. See https://reactrouter.com/how-to/spa for more information.`);
-                }
-                let defaultExportMatch = code.match(/\n\s{0,}([\w\d_]+)\sas default,?/);
-                defaultExportMatch && 'number' == typeof defaultExportMatch.index && (code = code.slice(0, defaultExportMatch.index) + code.slice(defaultExportMatch.index + defaultExportMatch[0].length) + `\nexport default ${defaultExportMatch[1]};`);
-                let ast = parse(code, {
-                    sourceType: 'module'
+                    generatedManifests ? generatedManifests.set(compilation, {
+                        manifest,
+                        moduleExportsByRouteId,
+                        manifestStats: stats,
+                        assetPrefix: currentAssetPrefix
+                    }) : options?.onManifest?.(manifest, void 0, moduleExportsByRouteId, {
+                        compilation,
+                        manifestStats: stats
+                    });
+                }), generatedManifests && api.processAssets({
+                    stage: 'report',
+                    environments: [
+                        'web'
+                    ]
+                }, ({ compilation })=>{
+                    let generatedManifest = generatedManifests.get(compilation);
+                    if (!generatedManifest) return;
+                    generatedManifests.delete(compilation);
+                    let sri = ((stats, compilation, assetPrefix = '/')=>{
+                        let sri = {};
+                        for (let asset of stats?.assets ?? [])addIntegrity(sri, assetPrefix, asset.name, asset.integrity);
+                        if ('function' == typeof compilation?.getAssets) for (let asset of compilation.getAssets())addIntegrity(sri, assetPrefix, asset.name, asset.info?.integrity);
+                        return Object.keys(sri).length > 0 ? sri : void 0;
+                    })(void 0, compilation, generatedManifest.assetPrefix) ?? !0;
+                    options?.onManifest?.({
+                        ...generatedManifest.manifest,
+                        sri
+                    }, sri, generatedManifest.moduleExportsByRouteId, {
+                        compilation,
+                        manifestStats: generatedManifest.manifestStats
+                    });
                 });
-                if ('web' === args.environment.name) {
-                    var exportsToRemove = [
-                        ...SERVER_ONLY_ROUTE_EXPORTS
-                    ];
-                    let previouslyReferencedIdentifiers = findReferencedIdentifiers(ast), exportsFiltered = !1, markedForRemoval = new Set(), removedExportLocalNames = new Set();
-                    if (traverse(ast, {
-                        ExportDeclaration (path) {
-                            if ('ExportNamedDeclaration' === path.node.type) {
-                                if (path.node.specifiers.length && (path.node.specifiers = path.node.specifiers.filter((specifier)=>!('ExportSpecifier' === specifier.type && 'Identifier' === specifier.exported.type && exportsToRemove.includes(specifier.exported.name)) || (exportsFiltered = !0, specifier.local && 'Identifier' === specifier.local.type && specifier.local.name !== specifier.exported.name && removedExportLocalNames.add(specifier.local.name), !1)), 0 === path.node.specifiers.length && markedForRemoval.add(path)), path.node.declaration?.type === 'VariableDeclaration') {
-                                    let declaration = path.node.declaration;
-                                    declaration.declarations = declaration.declarations.filter((declaration)=>'Identifier' === declaration.id.type && exportsToRemove.includes(declaration.id.name) ? (exportsFiltered = !0, !1) : (('ArrayPattern' === declaration.id.type || 'ObjectPattern' === declaration.id.type) && function validateDestructuredExports(id, exportsToRemove) {
-                                            if ('ArrayPattern' === id.type) {
-                                                for (let element of id.elements)if (element) {
-                                                    if ('Identifier' === element.type && exportsToRemove.includes(element.name)) throw invalidDestructureError(element.name);
-                                                    if ('RestElement' === element.type && 'Identifier' === element.argument.type && exportsToRemove.includes(element.argument.name)) throw invalidDestructureError(element.argument.name);
-                                                    ('ArrayPattern' === element.type || 'ObjectPattern' === element.type) && validateDestructuredExports(element, exportsToRemove);
-                                                }
-                                            }
-                                            if ('ObjectPattern' === id.type) {
-                                                for (let property of id.properties)if (property) {
-                                                    if ('ObjectProperty' === property.type && 'Identifier' === property.key.type) {
-                                                        if ('Identifier' === property.value.type && exportsToRemove.includes(property.value.name)) throw invalidDestructureError(property.value.name);
-                                                        ('ArrayPattern' === property.value.type || 'ObjectPattern' === property.value.type) && validateDestructuredExports(property.value, exportsToRemove);
-                                                    }
-                                                    if ('RestElement' === property.type && 'Identifier' === property.argument.type && exportsToRemove.includes(property.argument.name)) throw invalidDestructureError(property.argument.name);
-                                                }
-                                            }
-                                        }(declaration.id, exportsToRemove), !0)), 0 === declaration.declarations.length && markedForRemoval.add(path);
-                                }
-                                if (path.node.declaration?.type === 'FunctionDeclaration') {
-                                    let id = path.node.declaration.id;
-                                    id && exportsToRemove.includes(id.name) && markedForRemoval.add(path);
-                                }
-                                if (path.node.declaration?.type === 'ClassDeclaration') {
-                                    let id = path.node.declaration.id;
-                                    id && exportsToRemove.includes(id.name) && markedForRemoval.add(path);
-                                }
-                            }
-                            'ExportDefaultDeclaration' === path.node.type && exportsToRemove.includes('default') && (markedForRemoval.add(path), path.node.declaration && ('Identifier' === path.node.declaration.type ? removedExportLocalNames.add(path.node.declaration.name) : ('FunctionDeclaration' === path.node.declaration.type || 'ClassDeclaration' === path.node.declaration.type) && path.node.declaration.id && removedExportLocalNames.add(path.node.declaration.id.name)));
-                        }
-                    }), traverse(ast, {
-                        ExpressionStatement (path) {
-                            if (!path.parentPath.isProgram()) return;
-                            let expr = path.node.expression;
-                            if ('AssignmentExpression' !== expr.type) return;
-                            let left = expr.left;
-                            'MemberExpression' === left.type && 'Identifier' === left.object.type && (exportsToRemove.includes(left.object.name) || removedExportLocalNames.has(left.object.name)) && markedForRemoval.add(path);
+            }(api, routes, pluginOptions, appDirectory, ()=>assetPrefix, routeChunkOptions, {
+                subResourceIntegrity: resolvedConfigWithRoutes.subResourceIntegrity,
+                future,
+                manifestChunkNames,
+                onManifest: (manifest, sri, moduleExportsByRouteId, context)=>{
+                    var compilation;
+                    return compilation = context.compilation, void performanceProfiler.recordSync('web', 'manifest:stage', 'virtual/react-router/browser-manifest', ()=>{
+                        latestBrowserManifest = manifest, latestBrowserManifestModuleExports = moduleExportsByRouteId;
+                        let baseServerManifest = {
+                            ...manifest,
+                            sri: sri
+                        };
+                        latestServerManifest = baseServerManifest;
+                        let manifestsByEntryName = {
+                            [devServerBuildEntryName]: baseServerManifest
+                        };
+                        for (let { bundleId, entryName } of serverBundleEntries){
+                            let bundleRoutes = routesByServerBundleId[bundleId];
+                            if (!bundleRoutes) continue;
+                            let routeIds = new Set(Object.keys(bundleRoutes)), filteredRoutes = Object.fromEntries(Object.entries(manifest.routes).filter(([routeId])=>routeIds.has(routeId))), bundleManifest = {
+                                ...baseServerManifest,
+                                routes: filteredRoutes
+                            };
+                            latestServerManifestsByBundleId[bundleId] = bundleManifest, manifestsByEntryName[entryName] = bundleManifest;
                         }
-                    }), markedForRemoval.size > 0 || exportsFiltered) {
-                        for (let path of markedForRemoval)path.remove();
-                        deadCodeElimination(ast, previouslyReferencedIdentifiers);
-                    }
-                }
-                let hocs = [];
-                function getHocUid(path, hocName) {
-                    let uid = path.scope.generateUidIdentifier(hocName);
-                    return hocs.push([
-                        hocName,
-                        uid
-                    ]), uid;
+                        isBuild || devRuntime.captureWeb(compilation, manifestsByEntryName);
+                    });
                 }
-                return traverse(ast, {
-                    ExportDeclaration (path) {
-                        if (path.isExportDefaultDeclaration()) {
-                            let declaration = path.get('declaration'), expr = declaration.isExpression() ? declaration.node : declaration.isFunctionDeclaration() ? toFunctionExpression(declaration.node) : void 0;
-                            if (expr) {
-                                let uid = getHocUid(path, 'withComponentProps');
-                                declaration.replaceWith(callExpression(uid, [
-                                    expr
-                                ]));
-                            }
-                            return;
-                        }
-                        if (path.isExportNamedDeclaration()) {
-                            let decl = path.get('declaration');
-                            if (decl.isVariableDeclaration()) return void decl.get('declarations').forEach((varDeclarator)=>{
-                                let id = varDeclarator.get('id'), init = varDeclarator.get('init'), expr = init.node;
-                                if (!expr || !id.isIdentifier()) return;
-                                let { name } = id.node;
-                                if (!isNamedComponentExport(name)) return;
-                                let uid = getHocUid(path, `with${name}Props`);
-                                init.replaceWith(callExpression(uid, [
-                                    expr
-                                ]));
-                            });
-                            if (decl.isFunctionDeclaration()) {
-                                let { id } = decl.node;
-                                if (!id) return;
-                                let { name } = id;
-                                if (!isNamedComponentExport(name)) return;
-                                let uid = getHocUid(path, `with${name}Props`);
-                                decl.replaceWith(variableDeclaration('const', [
-                                    types_variableDeclarator(types_identifier(name), callExpression(uid, [
-                                        toFunctionExpression(decl.node)
-                                    ]))
-                                ]));
-                            }
-                        }
-                    }
-                }), hocs.length > 0 && ast.program.body.unshift(importDeclaration(hocs.map(([name, identifier])=>importSpecifier(identifier, types_identifier(name))), stringLiteral('virtual/react-router/with-props'))), 'web' === args.environment.name && (scopeCrawled = !1, traverse(ast, {
-                    Program (path) {
-                        scopeCrawled || (path.scope.crawl(), scopeCrawled = !0);
+            }), (({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath })=>{
+                let transformRouteModule = async (args)=>performanceProfiler.record(args.environment?.name, 'route:module', args.resource, async ()=>routeTransformExecutor.run({
+                            kind: 'routeModule',
+                            code: args.code,
+                            resource: args.resource,
+                            resourcePath: args.resourcePath,
+                            environmentName: args.environment.name,
+                            sourceMaps: isSourceMapEnabled(args.environment.config.output.sourceMap),
+                            ssr,
+                            isBuild,
+                            isSpaMode,
+                            rootRoutePath
+                        }));
+                api.processAssets({
+                    stage: 'additional',
+                    targets: [
+                        'node'
+                    ]
+                }, ({ sources, compilation })=>{
+                    let packageJsonPath = 'package.json', source = new sources.RawSource(`{"type": "${resolvedServerOutput}"}`);
+                    compilation.getAsset(packageJsonPath) ? compilation.updateAsset(packageJsonPath, source) : compilation.emitAsset(packageJsonPath, source);
+                }), api.transform({
+                    test: /virtual\/react-router\/(browser|server)-manifest/
+                }, async (args)=>performanceProfiler.record(args.environment?.name, 'manifest:transform', args.resource, async ()=>{
+                        if ('web' === args.environment.name) return {
+                            code: 'window.__reactRouterManifest = "PLACEHOLDER";'
+                        };
+                        let bundleMatch = args.resource.match(/virtual\/react-router\/server-manifest(?:-([^?]+))?/), bundleId = bundleMatch?.[1]?.replace(/\.js$/, ''), latestServerManifest = getLatestServerManifest(), manifest = (latestServerManifest ? (bundleId && getLatestServerManifestByBundleId(bundleId)) ?? latestServerManifest : null) ?? await getReactRouterManifestForDev(routes, pluginOptions, getClientStats(), appDirectory, getAssetPrefix(), routeChunkOptions);
+                        return {
+                            code: `export default ${jsesc(manifest, {
+                                es6: !0
+                            })};`
+                        };
+                    })), api.transform({
+                    resourceQuery: /__react-router-build-client-route/
+                }, async (args)=>performanceProfiler.record(args.environment?.name, 'route:client-entry', args.resource, async ()=>routeTransformExecutor.run({
+                            kind: 'routeClientEntry',
+                            code: args.code,
+                            resourcePath: args.resourcePath,
+                            environmentName: args.environment?.name,
+                            isBuild,
+                            routeChunkConfig
+                        }))), api.transform({
+                    resourceQuery: /route-chunk=/,
+                    environments: [
+                        'web'
+                    ]
+                }, async (args)=>performanceProfiler.record(args.environment?.name, 'route:chunk', args.resource, async ()=>routeTransformExecutor.run({
+                            kind: 'routeChunk',
+                            code: args.code,
+                            resource: args.resource,
+                            resourcePath: args.resourcePath,
+                            isBuild,
+                            routeChunkConfig
+                        }))), isBuild && splitRouteModules && api.transform({
+                    test: (path)=>routeByFilePath.has(path),
+                    resourceQuery: {
+                        not: /__react-router-build-client-route|react-router-route|route-chunk=/
                     },
-                    ImportDeclaration (path) {
-                        if (0 !== path.node.specifiers.length) {
-                            for (let specifierPath of path.get('specifiers')){
-                                let local = specifierPath.node.local, binding = local ? path.scope.getBinding(local.name) : null;
-                                binding && binding.referenced || specifierPath.remove();
-                            }
-                            0 === path.node.specifiers.length && path.remove();
-                        }
-                    }
-                })), generate(ast, {
-                    sourceMaps: !0,
-                    filename: args.resource,
-                    sourceFileName: args.resourcePath
-                });
+                    environments: [
+                        'web'
+                    ]
+                }, async (args)=>performanceProfiler.record(args.environment?.name, 'route:split-exports', args.resource, async ()=>routeTransformExecutor.run({
+                            kind: 'splitRouteExports',
+                            code: args.code,
+                            resourcePath: args.resourcePath,
+                            routeChunkConfig
+                        }))), api.transform({
+                    test: /[\\/]\.server[\\/]|\.server(\.[cm]?[jt]sx?)?$/,
+                    environments: [
+                        'web'
+                    ]
+                }, async (args)=>performanceProfiler.record(args.environment?.name, 'module:server-only-guard', args.resource, async ()=>{
+                        let relativePath = relative(process.cwd(), args.resourcePath);
+                        throw Error(`[${PLUGIN_NAME}] Server-only module referenced by client: ${relativePath}`);
+                    })), api.transform({
+                    test: /[\\/]\.client[\\/]|\.client(\.[cm]?[jt]sx?)?$/,
+                    environments: [
+                        'node'
+                    ]
+                }, async (args)=>performanceProfiler.record(args.environment?.name, 'module:client-only-stub', args.resource, async ()=>routeTransformExecutor.run({
+                            kind: 'clientOnlyStub',
+                            code: args.code,
+                            resourcePath: args.resourcePath,
+                            resolveExportAllModule: 'function' == typeof args.resolve ? createBundlerRouteExportResolver(args.resolve) : void 0
+                        }))), api.transform({
+                    resourceQuery: /\?react-router-route/,
+                    order: 'post'
+                }, transformRouteModule), api.transform({
+                    test: (path)=>routeByFilePath.has(path),
+                    resourceQuery: {
+                        not: /__react-router-build-client-route|react-router-route|route-chunk=/
+                    },
+                    order: 'post'
+                }, transformRouteModule);
+            })({
+                api,
+                resolvedServerOutput,
+                performanceProfiler,
+                getLatestServerManifest: ()=>latestServerManifest,
+                getLatestServerManifestByBundleId: (bundleId)=>latestServerManifestsByBundleId[bundleId],
+                routes,
+                pluginOptions,
+                getClientStats: ()=>clientStats,
+                appDirectory,
+                getAssetPrefix: ()=>assetPrefix,
+                routeChunkOptions,
+                routeTransformExecutor,
+                routeByFilePath,
+                routeChunkConfig: {
+                    splitRouteModules,
+                    appDirectory,
+                    rootRouteFile
+                },
+                isBuild,
+                splitRouteModules: !!splitRouteModules,
+                ssr,
+                isSpaMode,
+                rootRoutePath
             });
         }
     });
-export { pluginReactRouter };
+export { loadReactRouterServerBuild, pluginReactRouter, resolveReactRouterServerBuild };