rsbuild-plugin-react-router 0.0.4 → 0.1.0

package/dist/index.js

@@ -1,333 +1,988 @@
-import { fileURLToPath as __webpack_fileURLToPath__ } from "node:url";
-import { dirname as __webpack_dirname__ } from "node:path";
-import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
-import * as __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__ from "fs-extra";
-import * as __WEBPACK_EXTERNAL_MODULE_esbuild__ from "esbuild";
-import * as __WEBPACK_EXTERNAL_MODULE_jiti__ from "jiti";
-import * as __WEBPACK_EXTERNAL_MODULE_jsesc__ from "jsesc";
-import * as __WEBPACK_EXTERNAL_MODULE_pathe__ from "pathe";
-import * as __WEBPACK_EXTERNAL_MODULE_rspack_plugin_virtual_module_609978fd__ from "rspack-plugin-virtual-module";
-import * as __WEBPACK_EXTERNAL_MODULE__babel_parser_31177a12__ from "@babel/parser";
-import * as __WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__ from "@babel/types";
-import * as __WEBPACK_EXTERNAL_MODULE__react_router_node_fff52f02__ from "@react-router/node";
-import * as __WEBPACK_EXTERNAL_MODULE_babel_dead_code_elimination_8901ce62__ from "babel-dead-code-elimination";
-var __webpack_modules__ = {
-    "@babel/generator": function(module) {
-        module.exports = require("@babel/generator");
-    },
-    "@babel/traverse": function(module) {
-        module.exports = require("@babel/traverse");
-    }
-}, __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
-}
-let traverse = __webpack_require__("@babel/traverse").default, generate = __webpack_require__("@babel/generator").default, JS_EXTENSIONS = [
+let lexer_C;
+import { fileURLToPath as __rspack_fileURLToPath, pathToFileURL } from "node:url";
+import { dirname as __rspack_dirname, sep } from "node:path";
+import * as __rspack_external__babel_types_69e65b52 from "@babel/types";
+import { __webpack_require__ } from "./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 fs_extra from "fs-extra";
+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 { deadCodeElimination, findReferencedIdentifiers } from "babel-dead-code-elimination";
+import { createHash } from "node:crypto";
+import { transform } from "esbuild";
+import { rspack } from "@rsbuild/core";
+import { createRequestHandler, matchRoutes } from "./906.js";
+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'
+    '.mjs',
+    '.mts'
 ], JS_LOADERS = {
     '.ts': 'ts',
     '.tsx': 'tsx',
     '.js': 'js',
-    '.jsx': 'jsx'
-}, SERVER_ONLY_ROUTE_EXPORTS = [
+    '.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'
-], SERVER_EXPORTS = {
-    loader: 'loader',
-    action: 'action'
-}, CLIENT_EXPORTS = {
-    clientAction: 'clientAction',
-    clientLoader: 'clientLoader',
-    ErrorBoundary: 'ErrorBoundary'
-}, createDevServerMiddleware = (server)=>async (req, res, next)=>{
-        try {
-            let bundle = await server.environments.node.loadBundle('app');
-            if (!bundle || !bundle.routes) throw Error('Server bundle not found or invalid');
-            let listener = (0, __WEBPACK_EXTERNAL_MODULE__react_router_node_fff52f02__.createRequestListener)({
-                build: bundle
-            });
-            await listener(req, res);
-        } catch (error) {
-            console.error('SSR Error:', error), next(error);
-        }
+];
+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`)};`;
+    }).join('\n')}
+        
+    export { default as assets } from ${JSON.stringify(manifestId)};
+    export const assetsBuildDirectory = ${JSON.stringify(options.assetsBuildDirectory)};
+    export const basename = ${JSON.stringify(options.basename)};
+    export const future = ${JSON.stringify(options.future ?? {})};
+    export const isSpaMode = ${!options.ssr};
+    export const ssr = ${options.ssr};
+    export const routeDiscovery = ${JSON.stringify(options.routeDiscovery)};
+    export const prerender = ${JSON.stringify(options.prerender ?? [])};
+    export const publicPath = ${JSON.stringify(options.publicPath ?? '/')};
+    export const entry = { module: entryServer };
+    export const allowedActionOrigins = ${JSON.stringify(options.allowedActionOrigins)};
+    export var routes = {};
+    ${Object.keys(routes).map((key, index)=>{
+        let route = routes[key];
+        return `routes[${JSON.stringify(key)}] = {
+          id: ${JSON.stringify(route.id)},
+          parentId: ${JSON.stringify(route.parentId)},
+          path: ${JSON.stringify(route.path)},
+          index: ${JSON.stringify(route.index)},
+          caseSensitive: ${JSON.stringify(route.caseSensitive)},
+          module: route${index}
+        };`;
+    }).join('\n    ')}
+  `;
+}
+let RESOLVABLE_BUILD_EXPORTS = new Set([
+    'allowedActionOrigins',
+    'assets',
+    'assetsBuildDirectory',
+    'basename',
+    'entry',
+    'future',
+    'isSpaMode',
+    'prerender',
+    'publicPath',
+    '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)=>{
+    let resolved = {
+        ...build
     };
+    for (let key of Object.keys(build)){
+        if (!RESOLVABLE_BUILD_EXPORTS.has(key)) continue;
+        let value = build[key];
+        if ('function' == typeof value && 0 === value.length) {
+            let result = value();
+            resolved[key] = isPromiseLike(result) ? await result : result;
+            continue;
+        }
+        isPromiseLike(value) && (resolved[key] = await value);
+    }
+    return resolved;
+};
 function invalidDestructureError(name) {
     return Error(`Cannot remove destructured export "${name}"`);
 }
 function toFunctionExpression(decl) {
-    return __WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
+    return __rspack_external__babel_types_69e65b52.functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
 }
 function combineURLs(baseURL, relativeURL) {
     return relativeURL ? `${baseURL.replace(/\/+$/, '')}/${relativeURL.replace(/^\/+/, '')}` : baseURL;
 }
+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 ((0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(filePath)) return filePath;
+        if (existsSync(filePath)) return filePath;
     }
     return `${basePath}.tsx`;
 }
-let removeExports = (ast, exportsToRemove)=>{
-    let previouslyReferencedIdentifiers = (0, __WEBPACK_EXTERNAL_MODULE_babel_dead_code_elimination_8901ce62__.findReferencedIdentifiers)(ast), exportsFiltered = !1, markedForRemoval = new Set();
-    if (traverse(ast, {
-        ExportDeclaration (path) {
-            if ('ExportNamedDeclaration' === path.node.type) {
-                var _path_node_declaration, _path_node_declaration1, _path_node_declaration2;
-                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, !1)), 0 === path.node.specifiers.length && markedForRemoval.add(path)), (null === (_path_node_declaration = path.node.declaration) || void 0 === _path_node_declaration ? void 0 : _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);
+function isNamedComponentExport(name) {
+    return NAMED_COMPONENT_EXPORTS.includes(name);
+}
+let normalizePath = (value)=>value.replace(/\/\/+/g, '/').replace(/(.+)\/$/, '$1'), 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 = [
+        '/'
+    ], paramRoutes = [], (recurse = (entries, prefix = '', hasDynamicParent = !1)=>{
+        for (let route of entries){
+            let routePath = route.path ?? '', hasDynamicSegment = routePath.split('/').filter(Boolean).some((segment)=>segment.startsWith(':') || '*' === segment) || '*' === routePath, nextHasDynamic = hasDynamicParent || hasDynamicSegment;
+            if (routePath) {
+                let fullPath = normalizePath([
+                    prefix,
+                    routePath
+                ].join('/'));
+                nextHasDynamic ? paramRoutes.push(fullPath) : paths.push(fullPath);
+            }
+            if (route.children) {
+                let newPrefix = routePath ? normalizePath([
+                    prefix,
+                    routePath
+                ].join('/')) : prefix;
+                recurse(route.children, newPrefix, nextHasDynamic);
+            }
+        }
+    })(routes), {
+        paths: paths.map(normalizePath),
+        paramRoutes: paramRoutes.map(normalizePath)
+    });
+    if (!0 === pathsConfig) return options.logWarning && !ssr && paramRoutes1.length > 0 && (options.warn ?? ((message)=>{
+        console.warn(message);
+    }))([
+        'Warning: Paths with dynamic/splat params cannot be prerendered when using `prerender: true`.',
+        'You may want to use the `prerender()` API to prerender the following paths:',
+        ...paramRoutes1.map((path)=>`  - ${path}`)
+    ].join('\n')), paths1;
+    if ('function' == typeof pathsConfig) {
+        let resolved = await pathsConfig({
+            getStaticPaths: ()=>paths1
+        });
+        return !0 === resolved ? paths1 : !1 === resolved || null == resolved ? [] : resolved;
+    }
+    return pathsConfig ?? [];
+}, isValidPrerenderPathsConfig = (value)=>'boolean' == typeof value || 'function' == typeof value || Array.isArray(value), DEFAULT_CONFIG = {
+    appDirectory: 'app',
+    basename: '/',
+    buildDirectory: 'build',
+    serverBuildFile: 'index.js',
+    serverModuleFormat: 'esm',
+    ssr: !0,
+    future: {
+        unstable_optimizeDeps: !1,
+        unstable_subResourceIntegrity: !1,
+        unstable_trailingSlashAwareDataRequests: !1,
+        v8_middleware: !1,
+        v8_splitRouteModules: !1,
+        v8_viteEnvironmentApi: !1
+    },
+    routeDiscovery: void 0,
+    prerender: void 0,
+    serverBundles: void 0,
+    buildEnd: void 0,
+    allowedActionOrigins: !1,
+    routes: {},
+    unstable_routeConfig: []
+}, resolveReactRouterConfig = async (reactRouterUserConfig)=>{
+    let userAndPresetConfigs = ((...configs)=>configs.reduce((configA, configB)=>{
+            let mergeRequired = (key)=>void 0 !== configA[key] && void 0 !== configB[key];
+            return {
+                ...configA,
+                ...configB,
+                ...mergeRequired('buildEnd') ? {
+                    buildEnd: async (...args)=>{
+                        await Promise.all([
+                            configA.buildEnd?.(...args),
+                            configB.buildEnd?.(...args)
+                        ]);
+                    }
+                } : {},
+                ...mergeRequired('future') ? {
+                    future: {
+                        ...configA.future,
+                        ...configB.future
+                    }
+                } : {},
+                ...mergeRequired('presets') ? {
+                    presets: [
+                        ...configA.presets ?? [],
+                        ...configB.presets ?? []
+                    ]
+                } : {}
+            };
+        }, {}))(...(await Promise.all((reactRouterUserConfig.presets ?? []).map(async (preset)=>{
+        if (!preset.name) throw Error('React Router presets must have a `name` property defined.');
+        if (!preset.reactRouterConfig) return null;
+        let { buildEnd: _buildEnd, ...reactRouterUserConfigForPreset } = reactRouterUserConfig, presetConfig = await preset.reactRouterConfig({
+            reactRouterUserConfig: reactRouterUserConfigForPreset
+        });
+        if (!presetConfig) return null;
+        let { presets: _presets, ...rest } = presetConfig;
+        return rest;
+    }))).filter(Boolean), reactRouterUserConfig), resolvedFuture = {
+        ...DEFAULT_CONFIG.future,
+        ...userAndPresetConfigs.future ?? {}
+    }, resolved = {
+        ...DEFAULT_CONFIG,
+        ...userAndPresetConfigs,
+        future: resolvedFuture,
+        allowedActionOrigins: userAndPresetConfigs.allowedActionOrigins ?? DEFAULT_CONFIG.allowedActionOrigins,
+        routes: DEFAULT_CONFIG.routes,
+        unstable_routeConfig: DEFAULT_CONFIG.unstable_routeConfig,
+        serverBundles: DEFAULT_CONFIG.serverBundles
+    };
+    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) && __rspack_external__babel_types_69e65b52.isVariableDeclarator(path.node), `Expected a VariableDeclarator path, but got ${Array.isArray(path) ? 'an array' : path?.node?.type}`);
+}, assertNodePathIsPattern = (path)=>{
+    invariant(path && !Array.isArray(path) && __rspack_external__babel_types_69e65b52.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)=>!__rspack_external__babel_types_69e65b52.isImportDeclaration(statement) && !__rspack_external__babel_types_69e65b52.isExportDeclaration(statement))), importedIdentifierNames = new Set();
+            for (let identifier of identifiers)__rspack_external__babel_types_69e65b52.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 ((null === (_path_node_declaration1 = path.node.declaration) || void 0 === _path_node_declaration1 ? void 0 : _path_node_declaration1.type) === 'FunctionDeclaration') {
-                    let id = path.node.declaration.id;
-                    id && exportsToRemove.includes(id.name) && markedForRemoval.add(path);
+                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;
+                    }
                 }
-                if ((null === (_path_node_declaration2 = path.node.declaration) || void 0 === _path_node_declaration2 ? void 0 : _path_node_declaration2.type) === 'ClassDeclaration') {
-                    let id = path.node.declaration.id;
-                    id && exportsToRemove.includes(id.name) && markedForRemoval.add(path);
+            }
+            exportDependencies.set(exportName, {
+                topLevelStatements,
+                topLevelNonModuleStatements,
+                importedIdentifierNames,
+                exportedVariableDeclarators
+            });
+        }
+        return traverse(codeToAst(code, cache, cacheKey), {
+            ExportDeclaration (exportPath) {
+                let { node } = exportPath;
+                if (__rspack_external__babel_types_69e65b52.isExportAllDeclaration(node)) return;
+                if (__rspack_external__babel_types_69e65b52.isExportDefaultDeclaration(node)) return void handleExport('default', exportPath);
+                let { declaration } = node;
+                if (__rspack_external__babel_types_69e65b52.isVariableDeclaration(declaration)) {
+                    let { declarations } = declaration;
+                    for(let i = 0; i < declarations.length; i++){
+                        let declarator = declarations[i];
+                        if (__rspack_external__babel_types_69e65b52.isIdentifier(declarator.id)) {
+                            let declaratorPath = exportPath.get(`declaration.declarations.${i}`);
+                            assertNodePathIsVariableDeclarator(declaratorPath), handleExport(declarator.id.name, exportPath, declaratorPath);
+                            continue;
+                        }
+                        if (__rspack_external__babel_types_69e65b52.isPattern(declarator.id)) {
+                            let exportedPatternPath = exportPath.get(`declaration.declarations.${i}.id`);
+                            for (let identifier of (assertNodePathIsPattern(exportedPatternPath), getIdentifiersForPatternPath(exportedPatternPath)))__rspack_external__babel_types_69e65b52.isIdentifier(identifier.node) && handleExport(identifier.node.name, exportPath, identifier);
+                        }
+                    }
+                    return;
+                }
+                if (__rspack_external__babel_types_69e65b52.isFunctionDeclaration(declaration) || __rspack_external__babel_types_69e65b52.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 (__rspack_external__babel_types_69e65b52.isExportNamedDeclaration(node)) {
+                    for (let specifier of node.specifiers)if (__rspack_external__babel_types_69e65b52.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()
+    };
+    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
+                });
             }
-            'ExportDefaultDeclaration' === path.node.type && exportsToRemove.includes('default') && markedForRemoval.add(path);
         }
-    }), markedForRemoval.size > 0 || exportsFiltered) {
-        for (let path of markedForRemoval)path.remove();
-        (0, __WEBPACK_EXTERNAL_MODULE_babel_dead_code_elimination_8901ce62__.deadCodeElimination)(ast, previouslyReferencedIdentifiers);
+    });
+    let topLevelStatement = getTopLevelStatementPathForPath(path), withinImportStatement = topLevelStatement.isImportDeclaration(), withinExportStatement = topLevelStatement.isExportDeclaration();
+    if (withinImportStatement || withinExportStatement || getDependentIdentifiersForPath(topLevelStatement, {
+        visited,
+        identifiers
+    }), withinExportStatement && path.isIdentifier() && (__rspack_external__babel_types_69e65b52.isPattern(path.parentPath.node) || __rspack_external__babel_types_69e65b52.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
+        }));
     }
-}, transformRoute = (ast)=>{
-    let hocs = [];
-    function getHocUid(path, hocName) {
-        let uid = path.scope.generateUidIdentifier(hocName);
-        return hocs.push([
-            hocName,
-            uid
-        ]), uid;
+    return identifiers;
+}, getTopLevelStatementPathForPath = (path)=>{
+    let ancestry = path.getAncestry(), topLevelStatement = ancestry[ancestry.length - 2];
+    return invariant(topLevelStatement && !Array.isArray(topLevelStatement) && __rspack_external__babel_types_69e65b52.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);
     }
-    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(__WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.callExpression(uid, [
-                        expr
-                    ]));
+    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 (__rspack_external__babel_types_69e65b52.isObjectProperty(property)) {
+                    let valuePath = currentPath.get(`properties.${i}.value`);
+                    isNodePathWithNode(valuePath) && walk(valuePath);
+                } else if (__rspack_external__babel_types_69e65b52.isRestElement(property)) {
+                    let argumentPath = currentPath.get(`properties.${i}.argument`);
+                    isNodePathWithNode(argumentPath) && walk(argumentPath);
                 }
-                return;
             }
-            if (path.isExportNamedDeclaration()) {
-                let decl = path.get('declaration');
-                if (decl.isVariableDeclaration()) {
-                    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(__WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.callExpression(uid, [
-                            expr
-                        ]));
-                    });
-                    return;
-                }
-                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(__WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.variableDeclaration('const', [
-                        __WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.variableDeclarator(__WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.identifier(name), __WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.callExpression(uid, [
-                            toFunctionExpression(decl.node)
-                        ]))
-                    ]));
-                }
+        } 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);
         }
-    }), hocs.length > 0 && ast.program.body.unshift(__WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.importDeclaration(hocs.map(([name, identifier])=>__WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.importSpecifier(identifier, __WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.identifier(name))), __WEBPACK_EXTERNAL_MODULE__babel_types_69e65b52__.stringLiteral('virtual/react-router/with-props')));
-};
-function isNamedComponentExport(name) {
-    return NAMED_COMPONENT_EXPORTS.includes(name);
+    }(patternPath), identifiers), getExportedName = (exported)=>__rspack_external__babel_types_69e65b52.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;
+        }
+        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
+        }
+    };
+    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)=>!__rspack_external__babel_types_69e65b52.isNodesEquivalent(node, statement))).map((node)=>__rspack_external__babel_types_69e65b52.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 (!__rspack_external__babel_types_69e65b52.isExportDeclaration(node) || __rspack_external__babel_types_69e65b52.isExportAllDeclaration(node)) return node;
+                if (__rspack_external__babel_types_69e65b52.isExportDefaultDeclaration(node)) return isOmitted('default') ? null : node;
+                if (__rspack_external__babel_types_69e65b52.isVariableDeclaration(node.declaration)) return (node.declaration.declarations = node.declaration.declarations.filter((declarationNode)=>omittedExportedVariableDeclaratorsArray.every((declarator)=>!__rspack_external__babel_types_69e65b52.isNodesEquivalent(declarationNode, declarator))), 0 === node.declaration.declarations.length) ? null : node;
+                if (__rspack_external__babel_types_69e65b52.isFunctionDeclaration(node.declaration) || __rspack_external__babel_types_69e65b52.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;
+                }
+                if (__rspack_external__babel_types_69e65b52.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)=>__rspack_external__babel_types_69e65b52.isNodesEquivalent(node, statement))).map((node)=>__rspack_external__babel_types_69e65b52.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 (!__rspack_external__babel_types_69e65b52.isExportDeclaration(node)) return node;
+                if (__rspack_external__babel_types_69e65b52.isExportAllDeclaration(node)) return null;
+                if (__rspack_external__babel_types_69e65b52.isExportDefaultDeclaration(node)) return 'default' === exportName ? node : null;
+                let { declaration } = node;
+                if (__rspack_external__babel_types_69e65b52.isVariableDeclaration(declaration)) return (declaration.declarations = declaration.declarations.filter((declarationNode)=>exportedVariableDeclaratorsArray.some((declarator)=>__rspack_external__babel_types_69e65b52.isNodesEquivalent(declarationNode, declarator))), 0 === declaration.declarations.length) ? null : node;
+                if (__rspack_external__babel_types_69e65b52.isFunctionDeclaration(node.declaration) || __rspack_external__babel_types_69e65b52.isClassDeclaration(node.declaration)) return node.declaration.id?.name === exportName ? node : null;
+                if (__rspack_external__babel_types_69e65b52.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;
+        }
+    })(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
+        });
+    }
+    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
+        });
+    }
+    function k(A) {
+        try {
+            return (0, eval)(A);
+        } catch (A) {}
+    }
+    return [
+        o,
+        D,
+        !!lexer_C.f(),
+        !!lexer_C.ms()
+    ];
 }
-async function getReactRouterManifestForDev(routes, options, clientStats, context) {
-    var _clientStats_assetsByChunkName, _clientStats_assetsByChunkName1;
-    let result = {};
+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 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);
+    }
+    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`;
+};
+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];
+        return assets ? Array.isArray(assets) ? assets : [
+            assets
+        ] : [];
+    }, getModulePathForChunk = (chunkName)=>{
+        let jsAssets = getAssetsForChunk(chunkName).filter((asset)=>asset.endsWith('.js'));
+        return jsAssets[0] ? combineURLs(assetPrefix, jsAssets[0]) : void 0;
+    };
     for (let [key, route] of Object.entries(routes)){
-        let assets = null == clientStats ? void 0 : null === (_clientStats_assetsByChunkName1 = clientStats.assetsByChunkName) || void 0 === _clientStats_assetsByChunkName1 ? void 0 : _clientStats_assetsByChunkName1[route.id], jsAssets = (null == assets ? void 0 : assets.filter((asset)=>asset.endsWith('.js'))) || [], cssAssets = (null == assets ? void 0 : assets.filter((asset)=>asset.endsWith('.css'))) || [], routeFilePath = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(context, route.file), exports = new Set();
+        let assets = getAssetsForChunk(route.id), 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
+        };
         try {
-            let buildResult = await __WEBPACK_EXTERNAL_MODULE_esbuild__.build({
-                entryPoints: [
-                    routeFilePath
-                ],
-                bundle: !1,
-                write: !1,
-                metafile: !0,
-                jsx: 'automatic',
-                format: 'esm',
-                platform: 'neutral',
-                loader: JS_LOADERS
-            }), entryPoint = Object.values(buildResult.metafile.outputs)[0];
-            (null == entryPoint ? void 0 : entryPoint.exports) && (exports = new Set(entryPoint.exports));
+            let source = await readFile(routeFilePath, 'utf8'), 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) {
             console.error(`Failed to analyze route file ${routeFilePath}:`, error);
         }
-        result[key] = {
+        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
+            }
+        }), result[key] = {
             id: route.id,
             parentId: route.parentId,
             path: route.path,
             index: route.index,
             caseSensitive: route.caseSensitive,
-            module: combineURLs('/', jsAssets[0] || ''),
-            hasAction: exports.has(SERVER_EXPORTS.action),
-            hasLoader: exports.has(SERVER_EXPORTS.loader),
-            hasClientAction: exports.has(CLIENT_EXPORTS.clientAction),
-            hasClientLoader: exports.has(CLIENT_EXPORTS.clientLoader),
-            hasErrorBoundary: exports.has(CLIENT_EXPORTS.ErrorBoundary),
-            imports: jsAssets.map((asset)=>combineURLs('/', asset)),
-            css: cssAssets.map((asset)=>combineURLs('/', asset))
+            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 = null == clientStats ? void 0 : null === (_clientStats_assetsByChunkName = clientStats.assetsByChunkName) || void 0 === _clientStats_assetsByChunkName ? void 0 : _clientStats_assetsByChunkName['entry.client'], entryJsAssets = (null == entryAssets ? void 0 : entryAssets.filter((asset)=>asset.endsWith('.js'))) || [], entryCssAssets = (null == entryAssets ? void 0 : entryAssets.filter((asset)=>asset.endsWith('.css'))) || [];
-    return {
-        version: String(Math.random()),
-        url: '/static/js/virtual/react-router/browser-manifest.js',
+    let entryAssets = clientStats?.assetsByChunkName?.['entry.client'], entryJsAssets = entryAssets?.filter((asset)=>asset.endsWith('.js')) || [], entryCssAssets = entryAssets?.filter((asset)=>asset.endsWith('.css')) || [], fingerprintedValues = {
         entry: {
-            module: combineURLs('/', entryJsAssets[0] || ''),
-            imports: entryJsAssets.map((asset)=>combineURLs('/', asset)),
-            css: entryCssAssets.map((asset)=>combineURLs('/', asset))
+            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
     };
 }
-async function transformRouteFederation(args) {
-    var _args_environment;
-    let code = args.code, 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 = (0, __WEBPACK_EXTERNAL_MODULE__babel_parser_31177a12__.parse)(code, {
-        sourceType: 'module',
-        plugins: [
-            "typescript",
-            'jsx'
-        ]
-    });
-    args.environment && 'web' === args.environment.name && removeExports(ast, [
-        ...SERVER_ONLY_ROUTE_EXPORTS
-    ]), transformRoute(ast);
-    let transformedCode = generate(ast, {
-        sourceMaps: !0,
-        filename: args.resource,
-        sourceFileName: args.resourcePath,
-        retainLines: !0,
-        compact: !1,
-        concise: !1
-    }).code, output = (await __WEBPACK_EXTERNAL_MODULE_esbuild__.build({
-        bundle: !1,
-        write: !1,
-        metafile: !0,
-        jsx: 'automatic',
-        format: 'esm',
-        platform: 'neutral',
-        loader: {
-            '.ts': 'ts',
-            '.tsx': 'tsx'
-        },
-        stdin: {
-            contents: transformedCode,
-            resolveDir: args.context || void 0,
-            sourcefile: args.resourcePath
-        }
-    })).metafile.outputs['stdin.js'];
-    return (null === (_args_environment = args.environment) || void 0 === _args_environment ? void 0 : _args_environment.name) === 'node' ? `
-    let cache;
-    const loadRoute = async (exportName)=>{
-      if(cache !== undefined) {
-       return cache[exportName];
-      }
-     let exp = await import('${args.resourcePath}?react-router-route');
-     cache = exp;
-     return exp[exportName]
+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)=>{
+    let branch = [], current = routeId;
+    for(; current;){
+        let route = routes[current];
+        if (!route) throw Error(`Missing route for ${current}`);
+        branch.push(route), current = route.parentId || '';
     }
-    
-    ${output.exports.map((exp)=>'default' === exp ? "export default (...args) => loadRoute(\"default\").then(fn => typeof fn === 'function' ? fn(...args) : fn);" : `export const ${exp} = (...args) => loadRoute(${JSON.stringify(exp)}).then(fn => typeof fn === 'function' ? fn(...args) : fn);`).join('\n')}
-    ` : `const moduleProxy = await import('${args.resourcePath}?react-router-route');
-${output.exports.includes('default') ? `const { default: defaultExport, ${output.exports.filter((exp)=>'default' !== exp).join(', ')} } = moduleProxy;` : `const { ${output.exports.join(', ')} } = moduleProxy;`}
-export { ${output.exports.map((exp)=>'default' === exp ? 'defaultExport as default' : exp).join(', ')} };
-`;
+    return branch.reverse();
+}, getBuildManifest = async ({ reactRouterConfig, routes, rootDirectory })=>{
+    let { serverBundles, appDirectory, buildDirectory, serverBuildFile, future } = reactRouterConfig;
+    if (!serverBundles) return {
+        routes
+    };
+    let rootRelativeRoutes = Object.fromEntries(Object.entries(routes).map(([id, route])=>{
+        let filePath = resolve(appDirectory, route.file);
+        return [
+            id,
+            {
+                ...route,
+                file: relative(rootDirectory, filePath).replace(/\\/g, '/')
+            }
+        ];
+    })), serverBuildDirectory = resolve(buildDirectory, 'server'), buildManifest = {
+        routes: rootRelativeRoutes,
+        serverBundles: {},
+        routeIdToServerBundleId: {}
+    };
+    return await Promise.all(((routes)=>{
+        let nonAddressableIds = new Set();
+        for(let id in routes){
+            let route = routes[id];
+            if (route.index) {
+                if (!route.parentId) continue;
+                nonAddressableIds.add(route.parentId);
+            }
+            'string' == typeof route.path || route.index || nonAddressableIds.add(id);
+        }
+        return Object.values(routes).filter((route)=>!nonAddressableIds.has(route.id));
+    })(routes).map(async (route)=>{
+        let branch = getRouteBranch(routes, route.id), serverBundleId = await serverBundles({
+            branch: branch.map((branchRoute)=>{
+                let route;
+                return {
+                    id: (route = {
+                        ...branchRoute,
+                        file: resolve(appDirectory, branchRoute.file)
+                    }).id,
+                    path: route.path,
+                    file: route.file,
+                    index: route.index
+                };
+            })
+        });
+        if ('string' != typeof serverBundleId) throw Error('The "serverBundles" function must return a string');
+        if (future?.v8_viteEnvironmentApi) {
+            if (!/^[a-zA-Z0-9_]+$/.test(serverBundleId)) throw Error('The "serverBundles" function must only return strings containing alphanumeric characters and underscores.');
+        } 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, '/')
+        };
+    })), buildManifest;
+};
+function getDevtoolFromRspackConfig(config) {
+    if (config && 'function' != typeof config && 'object' == typeof config) return config.devtool;
+}
+function pluginId(name) {
+    return `rsbuild:${name}`;
+}
+function indexOfPlugin(plugins, names) {
+    return plugins.findIndex((p)=>!!p?.name && names.includes(p.name));
 }
-var src_rslib_entry_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
-let pluginReactRouter = (options = {})=>({
-        name: 'rsbuild:react-router',
+let REACT_ROUTER_EXTERNALS = [
+    'react-router',
+    'react-router-dom',
+    '@react-router/architect',
+    '@react-router/cloudflare',
+    '@react-router/dev',
+    '@react-router/express',
+    '@react-router/node',
+    '@react-router/serve'
+], requireFromHere = createRequire(import.meta.url);
+var src_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+let redirectStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]), pluginReactRouter = (options = {})=>({
+        name: PLUGIN_NAME,
         async setup (api) {
-            var options1;
-            let clientStats;
-            let pluginOptions = {
+            let routeDiscovery, clientStats, pluginOptions = {
                 customServer: !1,
                 serverOutput: 'module',
                 ...options
-            };
-            'commonjs' === pluginOptions.serverOutput && api.processAssets({
-                stage: 'additional',
-                targets: [
-                    'node'
-                ]
-            }, async ({ compilation })=>{
-                let { RawSource } = compilation.compiler.webpack.sources, packageJsonPath = 'package.json', source = new RawSource(JSON.stringify({
-                    type: 'commonjs'
-                }));
-                compilation.getAsset(packageJsonPath) ? compilation.updateAsset(packageJsonPath, source) : compilation.emitAsset(packageJsonPath, source);
+            }, nodeExternals = Array.from(new Set([
+                'express',
+                ...function(rootDirectory) {
+                    let externals = [];
+                    for (let name of REACT_ROUTER_EXTERNALS){
+                        let resolved = function(name, rootDirectory) {
+                            try {
+                                return requireFromHere.resolve(`${name}/package.json`, {
+                                    paths: [
+                                        rootDirectory
+                                    ]
+                                });
+                            } catch  {
+                                return null;
+                            }
+                        }(name, rootDirectory);
+                        resolved && ((function(pathname) {
+                            try {
+                                return realpathSync(pathname);
+                            } catch  {
+                                return pathname;
+                            }
+                        })(resolved).split(sep).includes('node_modules') || externals.push(name));
+                    }
+                    return externals;
+                }(process.cwd())
+            ])), assetPrefix = '/';
+            api.modifyRsbuildConfig({
+                order: 'pre',
+                handler (config) {
+                    let plugins, issues, rrIndex, mdxIndex, hasReact;
+                    for (let issue of (plugins = function flattenPlugins(input) {
+                        if (!Array.isArray(input)) return [];
+                        let out = [];
+                        for (let item of input)if (item) {
+                            if (Array.isArray(item)) {
+                                out.push(...flattenPlugins(item));
+                                continue;
+                            }
+                            'function' != typeof item?.then && 'object' == typeof item && out.push(item);
+                        }
+                        return out;
+                    }(config.plugins), issues = [], rrIndex = indexOfPlugin(plugins, [
+                        'rsbuild:react-router'
+                    ]), mdxIndex = indexOfPlugin(plugins, [
+                        pluginId('mdx')
+                    ]), rrIndex >= 0 && mdxIndex >= 0 && mdxIndex > rrIndex && issues.push({
+                        kind: 'error',
+                        message: 'The "rsbuild:mdx" plugin should be placed before the React Router plugin in your Rsbuild config. This ensures route modules authored in MDX are compiled before React Router inspects route exports.'
+                    }), hasReact = plugins.some((p)=>p?.name === pluginId('react')), rrIndex >= 0 && !hasReact && issues.push({
+                        kind: 'warn',
+                        message: 'React Router plugin detected without "rsbuild:react". If you are using JSX/TSX route modules, add "@rsbuild/plugin-react" to your plugins list.'
+                    }), issues)){
+                        if ('error' === issue.kind) throw Error(issue.message);
+                        api.logger.warn(issue.message);
+                    }
+                    return assetPrefix = normalizeAssetPrefix(config.output?.assetPrefix), config;
+                }
+            }), api.onBeforeBuild(()=>{
+                !function(normalized, warn, clientEnvName = 'web') {
+                    if ('production' !== normalized.mode && 'production' !== process.env.NODE_ENV) return;
+                    let sourceMapSetting = function(normalized, clientEnvName = 'web') {
+                        return normalized.environments?.[clientEnvName]?.output?.sourceMap ?? normalized.output?.sourceMap;
+                    }(normalized, clientEnvName), devtoolSetting = function(normalized, clientEnvName = 'web') {
+                        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");
+                }(api.getNormalizedConfig(), (msg)=>api.logger.warn(msg), 'web');
             }), api.onBeforeStartDevServer(async ()=>{
-                let { $ } = await import("execa");
-                $`npx --yes react-router typegen --watch`;
+                let { execa } = await import("execa");
+                execa('npx', [
+                    '--yes',
+                    'react-router',
+                    'typegen',
+                    '--watch'
+                ], {
+                    stdio: 'inherit',
+                    detached: !1,
+                    cleanup: !0
+                }).catch(()=>{});
             }), api.onBeforeBuild(async ()=>{
-                let { $ } = await import("execa");
-                $`npx --yes react-router typegen`;
+                let { execa } = await import("execa");
+                await execa('npx', [
+                    '--yes',
+                    'react-router',
+                    'typegen'
+                ], {
+                    stdio: 'inherit'
+                });
             });
-            let jiti = (0, __WEBPACK_EXTERNAL_MODULE_jiti__.createJiti)(process.cwd()), { appDirectory = 'app', basename = '/', buildDirectory = 'build', ssr = !0 } = await jiti.import('./react-router.config.ts', {
-                default: !0
-            }).catch(()=>(console.error('No react-router.config.ts found, using default configuration.'), {})), routesPath = findEntryFile((0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(appDirectory, 'routes')), routeConfig = await jiti.import(routesPath, {
+            let jiti = createJiti(process.cwd()), configPath = findEntryFile(resolve('react-router.config')), configExists = existsSync(configPath), reactRouterUserConfig = {};
+            if (configExists) {
+                let displayPath = relative(process.cwd(), configPath);
+                try {
+                    let imported = await jiti.import(configPath, {
+                        default: !0
+                    });
+                    if (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}`);
+                }
+            } 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`.');
+            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)=>{
+                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;
+            })(prerenderConfig);
+            if (prerenderConfigError) throw Error(prerenderConfigError);
+            if (userRouteDiscovery) {
+                if ('initial' === userRouteDiscovery.mode) routeDiscovery = userRouteDiscovery;
+                else if ('lazy' === userRouteDiscovery.mode) {
+                    if (!ssr) throw Error('The `routeDiscovery.mode` config cannot be set to "lazy" when setting `ssr:false`');
+                    let manifestPath = userRouteDiscovery.manifestPath;
+                    if (manifestPath && !manifestPath.startsWith('/')) throw Error('The `routeDiscovery.manifestPath` config must be a root-relative pathname beginning with a slash (i.e., "/__manifest")');
+                    routeDiscovery = userRouteDiscovery;
+                }
+            } else routeDiscovery = ssr ? {
+                mode: 'lazy',
+                manifestPath: '/__manifest'
+            } : {
+                mode: 'initial'
+            };
+            globalThis.__reactRouterAppDirectory = resolve(appDirectory);
+            let routesPath = findEntryFile(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
-            }).catch((error)=>(console.error('Failed to load routes file:', error), console.error('No routes file found in app directory.'), [])), entryClientPath = findEntryFile((0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(appDirectory, 'entry.client')), entryServerPath = findEntryFile((0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(appDirectory, 'entry.server')), serverAppPath = findEntryFile((0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(appDirectory, '../server/index')), hasServerApp = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(serverAppPath), templateDir = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(src_rslib_entry_dirname, 'templates'), templateClientPath = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(templateDir, 'entry.client.js'), templateServerPath = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(templateDir, 'entry.server.js'), finalEntryClientPath = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(entryClientPath) ? entryClientPath : templateClientPath, finalEntryServerPath = (0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(entryServerPath) ? entryServerPath : templateServerPath, routes = {
+            }), 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 = {
                 root: {
                     path: '',
                     id: 'root',
-                    file: (0, __WEBPACK_EXTERNAL_MODULE_pathe__.relative)(appDirectory, (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(appDirectory, 'root.tsx'))
+                    file: rootRouteFile
                 },
                 ...function(appDirectory, routes, rootId = 'root') {
                     let routeManifest = {};
                     for (let route of routes)!function walk(route, parentId) {
-                        var file;
-                        let id = route.id || (file = route.file, (0, __WEBPACK_EXTERNAL_MODULE_pathe__.normalize)(file.replace(/\.[^/.]+$/, ''))), manifestItem = {
+                        let id = route.id || normalize(route.file.replace(/\.[^/.]+$/, '')), manifestItem = {
                             id,
                             parentId,
-                            file: (0, __WEBPACK_EXTERNAL_MODULE_pathe__.isAbsolute)(route.file) ? (0, __WEBPACK_EXTERNAL_MODULE_pathe__.relative)(appDirectory, route.file) : route.file,
+                            file: isAbsolute(route.file) ? relative(appDirectory, route.file) : route.file,
                             path: route.path,
                             index: route.index,
                             caseSensitive: route.caseSensitive
@@ -337,136 +992,271 @@ let pluginReactRouter = (options = {})=>({
                     }(route, rootId);
                     return routeManifest;
                 }(appDirectory, routeConfig)
-            }, outputClientPath = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(buildDirectory, 'client'), assetsBuildDirectory = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.relative)(process.cwd(), outputClientPath);
+            }, resolvedConfigWithRoutes = {
+                ...resolvedConfig,
+                appDirectory: resolve(appDirectory),
+                buildDirectory: resolve(buildDirectory),
+                routeDiscovery,
+                prerender: prerenderConfig,
+                routes,
+                unstable_routeConfig: routeConfig,
+                allowedActionOrigins: allowedActionOrigins ?? !1
+            }, { buildEnd: _buildEnd, ...resolvedConfigForPreset } = resolvedConfigWithRoutes;
+            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 = {
+                splitRouteModules,
+                rootRouteFile,
+                isBuild,
+                cache: routeChunkCache
+            }, latestServerManifest = null, latestServerManifestsByBundleId = {}, routeByFilePath = new Map(Object.values(routes).map((route)=>[
+                    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}`
+                }, isBuild && splitRouteModules && 'root' !== route.id) {
+                    let source = '';
+                    try {
+                        source = readFileSync(routeFilePath, 'utf8');
+                    } catch  {
+                        source = '';
+                    }
+                    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({
+                reactRouterConfig: resolvedConfigWithRoutes,
+                routes,
+                rootDirectory: process.cwd()
+            })), outputClientPath = resolve(buildDirectory, 'client'), assetsBuildDirectory = relative(process.cwd(), outputClientPath);
             api.onAfterEnvironmentCompile(({ stats, environment })=>{
-                if ('web' === environment.name && (clientStats = null == stats ? void 0 : stats.toJson()), pluginOptions.federation && ssr) {
-                    let serverBuildDir = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(buildDirectory, 'server'), clientBuildDir = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(buildDirectory, 'client');
-                    if ((0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(serverBuildDir)) {
-                        let ssrDir = (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(clientBuildDir, 'static');
-                        (0, __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__.copySync)(serverBuildDir, ssrDir);
+                if ('web' === environment.name && (clientStats = stats?.toJson()), pluginOptions.federation && ssr) {
+                    let serverBuildDir = resolve(buildDirectory, 'server'), clientBuildDir = resolve(buildDirectory, 'client');
+                    if (existsSync(serverBuildDir)) {
+                        let ssrDir = resolve(clientBuildDir, 'static');
+                        fs_extra.copySync(serverBuildDir, ssrDir);
+                    }
+                }
+            });
+            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()
+                    });
                 }
             });
-            let vmodPlugin = new __WEBPACK_EXTERNAL_MODULE_rspack_plugin_virtual_module_609978fd__.RspackVirtualModulePlugin({
+            let allowedActionOriginsForBuild = !1 === allowedActionOrigins ? void 0 : allowedActionOrigins, bundleVirtualModules = Object.fromEntries(Object.entries(routesByServerBundleId).map(([bundleId, bundleRoutes])=>[
+                    `virtual/react-router/server-build-${bundleId}`,
+                    generateServerBuild(bundleRoutes, {
+                        entryServerPath: finalEntryServerPath,
+                        assetsBuildDirectory,
+                        basename,
+                        appDirectory,
+                        ssr,
+                        federation: options.federation,
+                        future,
+                        allowedActionOrigins: allowedActionOriginsForBuild,
+                        prerender: prerenderPaths,
+                        routeDiscovery,
+                        publicPath: assetPrefix,
+                        serverManifestId: `virtual/react-router/server-manifest-${bundleId}`
+                    })
+                ])), bundleManifestModules = Object.fromEntries(Object.entries(routesByServerBundleId).filter(([, bundleRoutes])=>bundleRoutes && Object.keys(bundleRoutes).length > 0).map(([bundleId])=>[
+                    `virtual/react-router/server-manifest-${bundleId}`,
+                    'export default {};'
+                ])), vmodTempDir = `rspack-virtual-module-${process.pid}-${Math.random().toString(16).slice(2)}`, vmodPlugin = new RspackVirtualModulePlugin({
                 'virtual/react-router/browser-manifest': 'export default {};',
                 'virtual/react-router/server-manifest': 'export default {};',
-                'virtual/react-router/server-build': (options1 = {
+                'virtual/react-router/server-build': generateServerBuild(routes, {
                     entryServerPath: finalEntryServerPath,
                     assetsBuildDirectory,
                     basename,
                     appDirectory,
                     ssr,
-                    federation: options.federation
-                }).federation ? `
-    // Create a module cache to store the dynamically imported module
-    let entryServerModule = null;
-    
-    // Function to ensure the module is loaded
-    const ensureEntryServerLoaded = async () => {
-      if (!entryServerModule) {
-        entryServerModule = await import(${JSON.stringify(options1.entryServerPath)});
-      }
-      return entryServerModule;
-    };
-
-    // Helper function to create async handlers
-    const createAsyncHandler = (exportName) => {
-      return async (...args) => {
-        const module = await ensureEntryServerLoaded();
-        const handler = module[exportName];
-        return typeof handler === 'function' ? handler(...args) : handler;
-      };
-    };
-
-    // Helper function to create sync handlers
-    const createSyncHandler = (exportName) => {
-      return (...args) => {
-        if (!entryServerModule) {
-          throw new Error('Entry server module not loaded yet. Call an async method first or await ensureEntryServerLoaded()');
-        }
-        
-        const handler = entryServerModule[exportName];
-        return typeof handler === 'function' ? handler(...args) : handler;
-      };
-    };
-
-    // Create a proxy for the entryServer exports
-    const entryServer = new Proxy({}, {
-      get: (target, prop) => {
-      
-        if (entryServerModule) {
-          return entryServerModule[prop];
-        }
-        
-        if (prop === 'handleDataRequest' || prop === 'handleRequest' || prop === 'default') {
-          return createAsyncHandler(prop);
-        }
-        
-      }
-    });
-
-    // Preload the entry server module
-    ensureEntryServerLoaded().catch(console.error);
-    
-    ${Object.keys(routes).map((key, index)=>{
-                    let route = routes[key];
-                    return `import * as route${index} from ${JSON.stringify(`${(0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(options1.appDirectory, route.file)}?react-router-route`)};`;
-                }).join('\n')}
-    
-    export { default as assets } from "virtual/react-router/server-manifest";
-    export const assetsBuildDirectory = ${JSON.stringify(options1.assetsBuildDirectory)};
-    export const basename = ${JSON.stringify(options1.basename)};
-    export const future = ${JSON.stringify({})};
-    export const isSpaMode = ${!options1.ssr};
-    export const ssr = ${options1.ssr};
-    export const publicPath = "/";
-    export const prerender = [];
-    export const entry = { module: entryServer };
-    export const routes = {
-      ${Object.keys(routes).map((key, index)=>{
-                    let route = routes[key];
-                    return `${JSON.stringify(key)}: {
-            id: ${JSON.stringify(route.id)},
-            parentId: ${JSON.stringify(route.parentId)},
-            path: ${JSON.stringify(route.path)},
-            index: ${JSON.stringify(route.index)},
-            caseSensitive: ${JSON.stringify(route.caseSensitive)},
-            module: route${index}
-          }
-            `;
-                }).join(',\n  ')}
-    };
-  ` : `
-    import * as entryServer from ${JSON.stringify(options1.entryServerPath)};
-    ${Object.keys(routes).map((key, index)=>{
-                    let route = routes[key];
-                    return `import * as route${index} from ${JSON.stringify(`${(0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(options1.appDirectory, route.file)}?react-router-route`)};`;
-                }).join('\n')}
-        
-    export { default as assets } from "virtual/react-router/server-manifest";
-    export const assetsBuildDirectory = ${JSON.stringify(options1.assetsBuildDirectory)};
-    export const basename = ${JSON.stringify(options1.basename)};
-    export const future = ${JSON.stringify({})};
-    export const isSpaMode = ${!options1.ssr};
-    export const ssr = ${options1.ssr};
-    export const prerender = [];
-    export const publicPath = "/";
-    export const entry = { module: entryServer };
-    export const routes = {
-      ${Object.keys(routes).map((key, index)=>{
-                    let route = routes[key];
-                    return `${JSON.stringify(key)}: {
-            id: ${JSON.stringify(route.id)},
-            parentId: ${JSON.stringify(route.parentId)},
-            path: ${JSON.stringify(route.path)},
-            index: ${JSON.stringify(route.index)},
-            caseSensitive: ${JSON.stringify(route.caseSensitive)},
-            module: route${index}
-          }
-            `;
-                }).join(',\n  ')}
-    };
-  `,
+                    federation: options.federation,
+                    future,
+                    allowedActionOrigins: allowedActionOriginsForBuild,
+                    prerender: prerenderPaths,
+                    routeDiscovery,
+                    publicPath: assetPrefix
+                }),
+                ...bundleVirtualModules,
+                ...bundleManifestModules,
                 'virtual/react-router/with-props': `
     import { createElement as h } from "react";
     import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
@@ -504,20 +1294,47 @@ let pluginReactRouter = (options = {})=>({
       };
     }
   `
-            });
+            }, vmodTempDir);
             api.modifyRsbuildConfig(async (config, { mergeRsbuildConfig })=>{
-                var _config_output, _config_environments_node_output, _config_environments_node, _config_environments;
+                assetPrefix = normalizeAssetPrefix(config.output?.assetPrefix);
+                let 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}`);
                 return mergeRsbuildConfig(config, {
                     output: {
-                        assetPrefix: (null === (_config_output = config.output) || void 0 === _config_output ? void 0 : _config_output.assetPrefix) || '/'
+                        assetPrefix: config.output?.assetPrefix || '/'
                     },
                     dev: {
                         writeToDisk: !0,
                         hmr: !1,
                         liveReload: !0,
-                        setupMiddlewares: pluginOptions.customServer ? [] : [
+                        setupMiddlewares: pluginOptions.customServer || !ssr ? [] : [
                             (middlewares, server)=>{
-                                middlewares.push(createDevServerMiddleware(server));
+                                middlewares.push(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 { createRequestListener } = await import("@react-router/node"), normalizedBuild = normalizeBuildModule(bundle), build = await resolveBuildExports(normalizedBuild), listener = createRequestListener({
+                                            build
+                                        });
+                                        await listener(req, res);
+                                    } catch (error) {
+                                        console.error('SSR Error:', error), next(error);
+                                    }
+                                });
                             }
                         ]
                     },
@@ -532,11 +1349,9 @@ let pluginReactRouter = (options = {})=>({
                         web: {
                             source: {
                                 entry: {
-                                    'entry.client': finalEntryClientPath + (options.federation ? '?react-router-route-federation' : ''),
+                                    'entry.client': finalEntryClientPath,
                                     'virtual/react-router/browser-manifest': 'virtual/react-router/browser-manifest',
-                                    ...Object.values(routes).reduce((acc, route)=>(acc[route.file.slice(0, route.file.lastIndexOf('.'))] = {
-                                            import: `${(0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(appDirectory, route.file)}?${options.federation ? 'react-router-route-federation' : 'react-router-route'}`
-                                        }, acc), {})
+                                    ...webRouteEntries
                                 }
                             },
                             output: {
@@ -554,6 +1369,11 @@ let pluginReactRouter = (options = {})=>({
                                         topLevelAwait: !0,
                                         outputModule: !0
                                     },
+                                    ...options.federation ? {
+                                        output: {
+                                            chunkLoading: 'import'
+                                        }
+                                    } : {},
                                     externalsType: 'module',
                                     output: {
                                         chunkFormat: 'module',
@@ -571,113 +1391,159 @@ let pluginReactRouter = (options = {})=>({
                                 }
                             }
                         },
-                        node: {
-                            source: {
-                                entry: {
-                                    ...hasServerApp ? {
-                                        app: serverAppPath + (options.federation ? '?react-router-route-federation' : '')
-                                    } : {
-                                        app: 'virtual/react-router/server-build' + (options.federation ? '?react-router-route-federation' : '')
-                                    },
-                                    'entry.server': finalEntryServerPath + (options.federation ? '?react-router-route-federation' : '')
-                                }
-                            },
-                            output: {
-                                distPath: {
-                                    root: (0, __WEBPACK_EXTERNAL_MODULE_pathe__.resolve)(buildDirectory, 'server')
+                        ...{
+                            node: {
+                                source: {
+                                    entry: nodeEntries
                                 },
-                                target: (null === (_config_environments = config.environments) || void 0 === _config_environments ? void 0 : null === (_config_environments_node = _config_environments.node) || void 0 === _config_environments_node ? void 0 : null === (_config_environments_node_output = _config_environments_node.output) || void 0 === _config_environments_node_output ? void 0 : _config_environments_node_output.target) || 'node',
-                                filename: {
-                                    js: 'static/js/[name].js'
-                                }
-                            },
-                            tools: {
-                                rspack: {
-                                    target: options.federation ? 'async-node' : 'node',
-                                    externals: [
-                                        'express'
-                                    ],
-                                    dependencies: [
-                                        'web'
-                                    ],
-                                    experiments: {
-                                        outputModule: 'module' === pluginOptions.serverOutput
+                                output: {
+                                    distPath: {
+                                        root: resolve(buildDirectory, 'server')
                                     },
-                                    externalsType: pluginOptions.serverOutput,
-                                    output: {
-                                        chunkFormat: pluginOptions.serverOutput,
-                                        chunkLoading: 'module' === pluginOptions.serverOutput ? 'import' : options.federation ? 'async-node' : 'require',
-                                        workerChunkLoading: 'module' === pluginOptions.serverOutput ? 'import' : 'require',
-                                        wasmLoading: 'fetch',
-                                        library: {
-                                            type: pluginOptions.serverOutput
+                                    target: config.environments?.node?.output?.target || 'node',
+                                    filename: {
+                                        js: '[name].js'
+                                    }
+                                },
+                                tools: {
+                                    rspack: {
+                                        target: options.federation ? 'async-node' : 'node',
+                                        externals: nodeExternals,
+                                        dependencies: [
+                                            'web'
+                                        ],
+                                        experiments: {
+                                            outputModule: 'module' === resolvedServerOutput,
+                                            ...options.federation ? {
+                                                asyncStartup: !0
+                                            } : {}
                                         },
-                                        module: 'module' === pluginOptions.serverOutput
+                                        externalsType: resolvedServerOutput,
+                                        output: {
+                                            chunkFormat: resolvedServerOutput,
+                                            chunkLoading: nodeChunkLoading,
+                                            workerChunkLoading: nodeChunkLoading,
+                                            wasmLoading: 'fetch',
+                                            module: 'module' === resolvedServerOutput
+                                        }
                                     }
                                 }
                             }
                         }
                     }
                 });
-            }), api.modifyEnvironmentConfig(async (config, { name, mergeEnvironmentConfig })=>'web' === name ? mergeEnvironmentConfig(config, {
+            }), api.modifyEnvironmentConfig(async (config, { name, mergeEnvironmentConfig })=>'web' !== name && 'node' !== name ? config : mergeEnvironmentConfig(config, {
                     tools: {
                         rspack: (rspackConfig)=>{
-                            if (rspackConfig.plugins) rspackConfig.plugins.push({
-                                apply (compiler) {
-                                    compiler.hooks.emit.tapAsync('ModifyBrowserManifest', async (compilation, callback)=>{
-                                        let manifest = await getReactRouterManifestForDev(routes, pluginOptions, compilation.getStats().toJson(), appDirectory), manifestPath = 'static/js/virtual/react-router/browser-manifest.js';
-                                        if (compilation.assets[manifestPath]) {
-                                            let newSource = compilation.assets[manifestPath].source().toString().replace(/["'`]PLACEHOLDER["'`]/, (0, __WEBPACK_EXTERNAL_MODULE_jsesc__.default)(manifest, {
-                                                es6: !0
-                                            }));
-                                            compilation.assets[manifestPath] = {
-                                                source: ()=>newSource,
-                                                size: ()=>newSource.length,
-                                                map: ()=>({
-                                                        version: 3,
-                                                        sources: [
-                                                            manifestPath
-                                                        ],
-                                                        names: [],
-                                                        mappings: '',
-                                                        file: manifestPath,
-                                                        sourcesContent: [
-                                                            newSource
-                                                        ]
-                                                    }),
-                                                sourceAndMap: ()=>({
-                                                        source: newSource,
-                                                        map: {
+                            if (pluginOptions.federation && ((rspackConfig)=>{
+                                if (rspackConfig?.plugins?.length) for (let plugin of rspackConfig.plugins){
+                                    if (!plugin || 'object' != typeof plugin || 'ModuleFederationPlugin' !== plugin.name) continue;
+                                    let pluginOptions = plugin._options ?? plugin.options;
+                                    pluginOptions && (pluginOptions.experiments = {
+                                        ...pluginOptions.experiments,
+                                        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: [
-                                                                manifestPath
+                                                                virtualManifestPath
                                                             ],
                                                             names: [],
                                                             mappings: '',
-                                                            file: manifestPath,
+                                                            file: virtualManifestPath,
                                                             sourcesContent: [
                                                                 newSource
                                                             ]
-                                                        }
-                                                    }),
-                                                updateHash: (hash)=>hash.update(newSource),
-                                                buffer: ()=>Buffer.from(newSource)
-                                            };
-                                        }
-                                        callback();
-                                    });
+                                                        }),
+                                                    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
+                                    };
+                                    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
+                                        };
+                                    }
                                 }
-                            });
-                            return rspackConfig;
+                            })), rspackConfig;
                         }
                     }
-                }) : config), api.processAssets({
+                })), api.processAssets({
                 stage: 'additional',
                 targets: [
                     'node'
                 ]
             }, ({ sources, compilation })=>{
-                let packageJsonPath = 'package.json', source = new sources.RawSource(`{"type": "${pluginOptions.serverOutput}"}`);
+                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/
@@ -685,36 +1551,288 @@ let pluginReactRouter = (options = {})=>({
                 if ('web' === args.environment.name) return {
                     code: 'window.__reactRouterManifest = "PLACEHOLDER";'
                 };
-                let manifest = await getReactRouterManifestForDev(routes, pluginOptions, clientStats, appDirectory);
+                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 ${(0, __WEBPACK_EXTERNAL_MODULE_jsesc__.default)(manifest, {
+                    code: `export default ${jsesc(manifest, {
                         es6: !0
                     })};`
                 };
             }), api.transform({
-                resourceQuery: /\?react-router-route-federation/
-            }, async (args)=>await transformRouteFederation(args)), 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;
+                        }
+                        await collectExportNamesFromModule(nestedPath);
+                    }
+                };
+                for (let specifier of exportAllModules){
+                    let resolvedPath = resolveExportAllModule(specifier, args.resourcePath);
+                    if (!resolvedPath) {
+                        unresolvedExportAll.add(specifier);
+                        continue;
+                    }
+                    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;
+                let code, scopeCrawled;
                 try {
-                    code = (await __WEBPACK_EXTERNAL_MODULE_esbuild__.transform(args.code, {
-                        jsx: 'automatic',
-                        format: 'esm',
-                        platform: 'neutral',
-                        loader: args.resourcePath.endsWith('x') ? 'tsx' : 'ts'
-                    })).code;
+                    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 (!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 = (0, __WEBPACK_EXTERNAL_MODULE__babel_parser_31177a12__.parse)(code, {
+                let ast = parse(code, {
                     sourceType: 'module'
                 });
-                return 'web' === args.environment.name && removeExports(ast, [
-                    ...SERVER_ONLY_ROUTE_EXPORTS
-                ]), transformRoute(ast), generate(ast, {
+                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);
+                        }
+                    }), 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;
+                }
+                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(__rspack_external__babel_types_69e65b52.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(__rspack_external__babel_types_69e65b52.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(__rspack_external__babel_types_69e65b52.variableDeclaration('const', [
+                                    __rspack_external__babel_types_69e65b52.variableDeclarator(__rspack_external__babel_types_69e65b52.identifier(name), __rspack_external__babel_types_69e65b52.callExpression(uid, [
+                                        toFunctionExpression(decl.node)
+                                    ]))
+                                ]));
+                            }
+                        }
+                    }
+                }), hocs.length > 0 && ast.program.body.unshift(__rspack_external__babel_types_69e65b52.importDeclaration(hocs.map(([name, identifier])=>__rspack_external__babel_types_69e65b52.importSpecifier(identifier, __rspack_external__babel_types_69e65b52.identifier(name))), __rspack_external__babel_types_69e65b52.stringLiteral('virtual/react-router/with-props'))), 'web' === args.environment.name && (scopeCrawled = !1, traverse(ast, {
+                    Program (path) {
+                        scopeCrawled || (path.scope.crawl(), scopeCrawled = !0);
+                    },
+                    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