rsbuild-plugin-react-router 0.7.2 → 0.8.0

package/README.md

@@ -76,6 +76,16 @@ rsbuild.config.ts
 
 ## Configuration
 
+This plugin requires Rsbuild 2.2.8 or newer. Development hot data revalidation
+uses its custom-event connection API and no longer writes an HDR revision file.
+
+For server-only changes, `rsbuild build --environment node` can reuse the
+finalized browser manifest from a previous full build in the same project.
+Keep the browser output and build cache. Run a full build after changing routes
+or browser assets, or adding or removing a route's `loader` or `action` export.
+Node-only builds check the compiled exports against the cached manifest. If the
+manifest is missing or incompatible, the build fails and asks for a full build.
+
 React Router application settings live in `react-router.config.*`. The Rsbuild
 plugin only needs options for Rsbuild-specific behavior.
 
@@ -83,6 +93,7 @@ plugin only needs options for Rsbuild-specific behavior.
 
 ```ts
 pluginReactRouter({
+  typegen: true,
   customServer: false,
   lazyCompilation: true,
   unstableLazyCompilationPrewarm: false,
@@ -93,12 +104,13 @@ pluginReactRouter({
 
 | Option                           | Default     | Description                                                                                                                                                                                                                      |
 | -------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `typegen`                        | `true`      | Generates React Router route types during development and builds. Set to `false` when type generation is managed separately.                                                                                                     |
 | `customServer`                   | `false`     | Disables the built-in development SSR middleware. Enable this when an app owns the server with `createDevServer()` or an adapter.                                                                                                |
 | `serverOutput`                   | Derived     | Emitted Rsbuild server format: `'module'` or `'commonjs'`. When omitted, React Router's `serverModuleFormat` selects the format (`'esm'` -> `'module'`, `'cjs'` -> `'commonjs'`); setting `serverOutput` overrides it.           |
 | `lazyCompilation`                | `true`      | Optional Rsbuild dev lazy-compilation config. When enabled here or through `dev.lazyCompilation`, React Router hydration-critical modules stay eager so the browser manifest and route modules are not replaced by lazy proxies. |
 | `unstableLazyCompilationPrewarm` | `false`     | Experimental prewarm for emitted lazy-compilation proxy modules after dev compiles. Enable with `true` when route JS proxy startup should happen shortly after compiler readiness.                                               |
 | `logPerformance`                 | `false`     | Logs structured React Router plugin timing information.                                                                                                                                                                          |
-| `parallelRouteTransform`         | `undefined` | Controls worker-thread route transforms. `undefined` and `false` keep transforms inline, `true` uses an automatic worker count, and a positive integer sets the maximum worker count.                                             |
+| `parallelRouteTransform`         | `undefined` | Controls worker-thread route transforms. `undefined` and `false` keep transforms inline, `true` uses an automatic worker count, and a positive integer sets the maximum worker count.                                            |
 | `onRouteTopologyChange`          | `undefined` | Notification for programmatic/custom dev servers. Recreate the Rsbuild server when route files are added, removed, or moved. The callback is not awaited.                                                                        |
 | `federation`                     | `false`     | Enables the plugin's experimental Module Federation integration.                                                                                                                                                                 |
 
@@ -185,7 +197,7 @@ React Router's SPA Mode still requires a build-time server render of the root ro
 When `ssr: false`:
 
 - The plugin builds both `web` and `node` internally.
-- It generates `build/client/index.html` by running the server build once (requesting `basename` with the `X-React-Router-SPA-Mode: yes` header).
+- It generates `build/client/index.html` by running the server build once (requesting `basename` with the `X-React-Router-SPA-Mode: yes` header). The server bundle is evaluated in a worker thread that is terminated afterwards, with `process.env.IS_RR_BUILD_REQUEST === 'yes'` set, so module-scope side effects in your root route's import graph run at build time but cannot keep `rsbuild build` alive. The same applies to prerendering.
 - It removes `build/server` after generating `index.html`, so the output is deployable as static assets.
 
 **Important:** In SPA mode, use `clientLoader` instead of `loader` for data loading since there's no server at runtime.

package/dist/468.js

@@ -0,0 +1,48 @@
+let PLUGIN_NAME = 'rsbuild:react-router', DEFAULT_JS_DIST_PATH = 'static/js', JS_EXTENSIONS = [
+    '.tsx',
+    '.ts',
+    '.jsx',
+    '.js',
+    '.mjs',
+    '.mts'
+], BUILD_CLIENT_ROUTE_QUERY_STRING = '?__react-router-build-client-route', SERVER_ONLY_ROUTE_EXPORTS = [
+    'loader',
+    'action',
+    'middleware',
+    'headers'
+], SERVER_ONLY_ROUTE_EXPORTS_SET = new Set(SERVER_ONLY_ROUTE_EXPORTS), CLIENT_NON_COMPONENT_EXPORTS = [
+    'clientAction',
+    'clientLoader',
+    'clientMiddleware',
+    'handle',
+    'meta',
+    'links',
+    'shouldRevalidate'
+], CLIENT_ROUTE_EXPORTS_SET = new Set([
+    ...CLIENT_NON_COMPONENT_EXPORTS,
+    'default',
+    'ErrorBoundary',
+    'HydrateFallback',
+    'Layout'
+]), NAMED_COMPONENT_EXPORTS_SET = new Set([
+    'HydrateFallback',
+    'ErrorBoundary'
+]), SERVER_EXPORTS = {
+    loader: 'loader',
+    action: 'action',
+    middleware: 'middleware',
+    headers: 'headers'
+}, CLIENT_EXPORTS = {
+    clientAction: 'clientAction',
+    clientLoader: 'clientLoader',
+    clientMiddleware: 'clientMiddleware',
+    default: 'default',
+    ErrorBoundary: 'ErrorBoundary',
+    handle: 'handle',
+    HydrateFallback: 'HydrateFallback',
+    Layout: 'Layout',
+    links: 'links',
+    meta: 'meta',
+    shouldRevalidate: 'shouldRevalidate'
+}, SPA_FALLBACK_HTML_FILE = '__spa-fallback.html', BROWSER_MANIFEST_ENTRY_NAME = 'virtual/react-router/browser-manifest';
+export { BROWSER_MANIFEST_ENTRY_NAME, BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, CLIENT_NON_COMPONENT_EXPORTS, CLIENT_ROUTE_EXPORTS_SET, DEFAULT_JS_DIST_PATH, JS_EXTENSIONS, NAMED_COMPONENT_EXPORTS_SET, PLUGIN_NAME, SERVER_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS_SET, SPA_FALLBACK_HTML_FILE };

package/dist/511.js

@@ -2,57 +2,12 @@ import { basename, dirname, normalize, relative, resolve } from "pathe";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { langFromPath, parse, walk as external_yuku_parser_walk } from "yuku-parser";
-import { Analyzer } from "yuku-analyzer";
+import { Analyzer, SymbolFlags } from "yuku-analyzer";
 import { print } from "yuku-codegen";
 import { readFile, stat } from "node:fs/promises";
 import { rspack } from "@rsbuild/core";
-let PLUGIN_NAME = 'rsbuild:react-router', DEFAULT_JS_DIST_PATH = 'static/js', JS_EXTENSIONS = [
-    '.tsx',
-    '.ts',
-    '.jsx',
-    '.js',
-    '.mjs',
-    '.mts'
-], BUILD_CLIENT_ROUTE_QUERY_STRING = '?__react-router-build-client-route', SERVER_ONLY_ROUTE_EXPORTS = [
-    'loader',
-    'action',
-    'middleware',
-    'headers'
-], SERVER_ONLY_ROUTE_EXPORTS_SET = new Set(SERVER_ONLY_ROUTE_EXPORTS), CLIENT_NON_COMPONENT_EXPORTS = [
-    'clientAction',
-    'clientLoader',
-    'clientMiddleware',
-    'handle',
-    'meta',
-    'links',
-    'shouldRevalidate'
-], CLIENT_ROUTE_EXPORTS_SET = new Set([
-    ...CLIENT_NON_COMPONENT_EXPORTS,
-    'default',
-    'ErrorBoundary',
-    'HydrateFallback',
-    'Layout'
-]), NAMED_COMPONENT_EXPORTS_SET = new Set([
-    'HydrateFallback',
-    'ErrorBoundary'
-]), SERVER_EXPORTS = {
-    loader: 'loader',
-    action: 'action',
-    middleware: 'middleware',
-    headers: 'headers'
-}, CLIENT_EXPORTS = {
-    clientAction: 'clientAction',
-    clientLoader: 'clientLoader',
-    clientMiddleware: 'clientMiddleware',
-    default: 'default',
-    ErrorBoundary: 'ErrorBoundary',
-    handle: 'handle',
-    HydrateFallback: 'HydrateFallback',
-    Layout: 'Layout',
-    links: 'links',
-    meta: 'meta',
-    shouldRevalidate: 'shouldRevalidate'
-}, SPA_FALLBACK_HTML_FILE = '__spa-fallback.html', getProgram = (ast)=>ast.program ?? ast, getPatternIdentifierNames = (pattern, names = new Set())=>{
+import { SERVER_ONLY_ROUTE_EXPORTS, SERVER_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS_SET, JS_EXTENSIONS, CLIENT_EXPORTS, PLUGIN_NAME, NAMED_COMPONENT_EXPORTS_SET, CLIENT_ROUTE_EXPORTS_SET } from "./468.js";
+let getProgram = (ast)=>ast.program ?? ast, getPatternIdentifierNames = (pattern, names = new Set())=>{
     if (!pattern) return names;
     if ('Identifier' === pattern.type) return names.add(pattern.name), names;
     if ('RestElement' === pattern.type) return getPatternIdentifierNames(pattern.argument, names);
@@ -345,9 +300,9 @@ let PLUGIN_NAME = 'rsbuild:react-router', DEFAULT_JS_DIST_PATH = 'static/js', JS
         if (declaration && declarationIncludesName(declaration, name)) return !0;
     }
     return !1;
-}, requireFromApp = createRequire(resolve(process.cwd(), 'package.json')), resolveAppPackagePath = (specifier)=>{
+}, requireFromApp = createRequire(resolve(process.cwd(), 'package.json')), resolveAppPackagePath = (specifier, rootPath)=>{
     try {
-        return requireFromApp.resolve(specifier);
+        return (rootPath ? createRequire(resolve(rootPath, 'package.json')) : requireFromApp).resolve(specifier);
     } catch  {
         return;
     }
@@ -453,12 +408,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
             module,
             program: module.ast
         };
-    }), isTopLevelExportedVariableDeclarator = (module, node)=>{
-    let declaration = module.parentOf(node);
-    if (declaration?.type !== 'VariableDeclaration') return !1;
-    let statement = module.parentOf(declaration);
-    return statement?.type === 'ExportNamedDeclaration';
-}, route_chunks_getExportedName = (exported)=>'Identifier' === exported.type ? exported.name : String(exported.value), setsIntersect = (set1, set2)=>{
+    }), route_chunks_getExportedName = (exported)=>'Identifier' === exported.type ? exported.name : String(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;
@@ -467,7 +417,13 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
     let resolved = normalize(resolve('/', dirname(importer), source));
     return /(?:^|\/)entry\.client(?:\.[cm]?[jt]sx?)?$/.test(resolved);
 }, getExportDependencies = (code, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::getExportDependencies`, code, ()=>{
-        let { module } = analyzeCode(code, cache, cacheKey), exportDependencies = new Map(), topLevelStatementCache = new Map(), variableDeclaratorCache = new Map(), getCachedTopLevelStatementForNode = (node)=>{
+        let { module } = analyzeCode(code, cache, cacheKey), namedExports = module.exports.filter((exp)=>null !== exp.name && !exp.typeOnly && !exp.isStar && !exp.isExportEquals), hasDecorators = !1;
+        external_yuku_parser_walk(module.ast, {
+            Decorator (_node, context) {
+                hasDecorators = !0, context.stop();
+            }
+        });
+        let exportDependencies = new Map(), topLevelStatementCache = new Map(), exportedVariableDeclaratorCache = new Map(), getCachedTopLevelStatementForNode = (node)=>{
             let cached = topLevelStatementCache.get(node);
             if (cached) return cached;
             let statement = ((module, node)=>{
@@ -476,17 +432,34 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
                 return invariant(parent?.type === 'Program', 'Expected node to be within Program'), current;
             })(module, node);
             return topLevelStatementCache.set(node, statement), statement;
-        }, getCachedVariableDeclaratorForNode = (node)=>{
-            if (variableDeclaratorCache.has(node)) return variableDeclaratorCache.get(node) ?? null;
+        }, nonShareableExportedSymbols = new Set();
+        for (let { local } of namedExports){
+            if (!local?.has(SymbolFlags.ValueSpace | SymbolFlags.ValueImport)) continue;
+            let isImport = local.declarations.every((declaration)=>'ImportDeclaration' === getCachedTopLevelStatementForNode(declaration).type), hasSetup = isImport && local.references.some((reference)=>{
+                let statement = getCachedTopLevelStatementForNode(reference.node);
+                return 'value' === reference.kind && 'ImportDeclaration' !== statement.type && !statement.type.startsWith('Export');
+            });
+            (!isImport || hasSetup) && nonShareableExportedSymbols.add(local);
+        }
+        let isRuntimeRelevantReference = (reference)=>hasDecorators || 'value' === reference.kind || ((reference)=>{
+                let node = reference.node, parent = module.parentOf(node);
+                for(; parent?.type === 'TSQualifiedName';)node = parent, parent = module.parentOf(node);
+                return parent?.type === 'TSImportEqualsDeclaration' && parent.moduleReference === node && 'type' !== parent.importKind;
+            })(reference), getCachedExportedVariableDeclaratorForNode = (node)=>{
+            if (exportedVariableDeclaratorCache.has(node)) return exportedVariableDeclaratorCache.get(node) ?? null;
             let declarator = ((module, node)=>{
                 let current = node;
-                for(; current;){
-                    if ('VariableDeclarator' === current.type) return current;
-                    current = module.parentOf(current);
+                for(;;){
+                    let parent = module.parentOf(current);
+                    if (!parent || 'Program' === parent.type) return null;
+                    if ('VariableDeclarator' === current.type && 'VariableDeclaration' === parent.type) {
+                        let exported = module.parentOf(parent);
+                        if (exported?.type === 'ExportNamedDeclaration' && module.parentOf(exported)?.type === 'Program') return current;
+                    }
+                    current = parent;
                 }
-                return null;
             })(module, node);
-            return variableDeclaratorCache.set(node, declarator), declarator;
+            return exportedVariableDeclaratorCache.set(node, declarator), declarator;
         }, addCachedTopLevelStatement = (dependencies, node)=>{
             let statement = getCachedTopLevelStatementForNode(node);
             return dependencies.topLevelStatements.add(statement), 'ImportDeclaration' === statement.type || statement.type.startsWith('Export') || dependencies.topLevelNonModuleStatements.add(statement), statement;
@@ -496,46 +469,47 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
                 topLevelNonModuleStatements: new Set(),
                 importedIdentifierNames: new Set(),
                 importSources: new Set(),
-                exportedVariableDeclarators: new Set()
-            }, visitedSymbols = new Set(), scannedNodes = new Set(), scanNode = (node)=>{
+                exportedVariableDeclarators: new Set(),
+                exportedLocalSymbols: new Set()
+            }, visitedSymbols = new Set(), scannedNodes = new Set(), visitIdentifier = (node)=>{
+                let reference = module.referenceOf(node);
+                if (reference) {
+                    reference.symbol && isRuntimeRelevantReference(reference) && visitSymbol(reference.symbol);
+                    return;
+                }
+                let symbol = module.symbolOf(node);
+                symbol?.scope === module.rootScope && symbol.has(SymbolFlags.ValueSpace | SymbolFlags.ValueImport) && dependencies.topLevelNonModuleStatements.has(getCachedTopLevelStatementForNode(node)) && visitSymbol(symbol);
+            }, scanNode = (node)=>{
                 scannedNodes.has(node) || (scannedNodes.add(node), external_yuku_parser_walk(node, {
-                    Identifier (node) {
-                        let reference = module.referenceOf(node);
-                        reference?.symbol && visitSymbol(reference.symbol);
-                    }
+                    Identifier: visitIdentifier,
+                    JSXIdentifier: visitIdentifier
                 }));
             }, visitSymbol = (symbol)=>{
                 if (!visitedSymbols.has(symbol) && (visitedSymbols.add(symbol), 0 !== symbol.declarations.length)) {
-                    for (let declaration of symbol.declarations){
+                    for (let declaration of (nonShareableExportedSymbols.has(symbol) && dependencies.exportedLocalSymbols.add(symbol), symbol.declarations)){
                         let statement = addCachedTopLevelStatement(dependencies, declaration);
-                        if ('ImportDeclaration' === statement.type) {
-                            dependencies.importedIdentifierNames.add(symbol.name), 'string' == typeof statement.source?.value && dependencies.importSources.add(statement.source.value);
-                            return;
-                        }
-                        let declarator = getCachedVariableDeclaratorForNode(declaration);
-                        declarator && isTopLevelExportedVariableDeclarator(module, declarator) && dependencies.exportedVariableDeclarators.add(declarator), scanNode(declarator ?? statement);
+                        if ('ImportDeclaration' === statement.type && (dependencies.importedIdentifierNames.add(symbol.name), 'string' == typeof statement.source?.value && dependencies.importSources.add(statement.source.value), symbol !== localSymbol)) return;
+                        let declarator = getCachedExportedVariableDeclaratorForNode(declaration);
+                        declarator && dependencies.exportedVariableDeclarators.add(declarator), scanNode(declarator ?? statement);
                     }
                     for (let reference of symbol.references){
+                        if (!isRuntimeRelevantReference(reference)) continue;
                         let statement = addCachedTopLevelStatement(dependencies, reference.node);
-                        scanNode(getCachedVariableDeclaratorForNode(reference.node) ?? statement);
+                        scanNode(getCachedExportedVariableDeclaratorForNode(reference.node) ?? statement);
                     }
                 }
             };
             addCachedTopLevelStatement(dependencies, exportNode), localSymbol ? visitSymbol(localSymbol) : scanNode(getCachedTopLevelStatementForNode(exportNode)), exportDependencies.set(exportName, dependencies);
         };
-        for (let exp of module.exports)exp.typeOnly || exp.isStar || exp.isExportEquals || handleExport(exp.name, exp.node, exp.local ?? null);
+        for (let exp of namedExports)handleExport(exp.name, exp.node, exp.local ?? null);
         return exportDependencies;
     }), isExportChunkable = (exportName, exportDependencies, importer)=>{
     let dependencies = exportDependencies.get(exportName);
-    if (!dependencies || 'clientLoader' === exportName && hasHydrateAssignment(dependencies) || 'clientLoader' === exportName && ((dependencies, importer)=>{
+    if (!dependencies || dependencies.exportedVariableDeclarators.size > 1 || 'clientLoader' === exportName && hasHydrateAssignment(dependencies) || 'clientLoader' === exportName && ((dependencies, importer)=>{
         for (let source of dependencies.importSources)if (isEntryClientImport(source, importer)) return !0;
         return !1;
     })(dependencies, importer)) 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;
-    }
+    for (let [currentExportName, currentDependencies] of exportDependencies)if (currentExportName !== exportName && (setsIntersect(currentDependencies.topLevelNonModuleStatements, dependencies.topLevelNonModuleStatements) || setsIntersect(currentDependencies.exportedVariableDeclarators, dependencies.exportedVariableDeclarators) || setsIntersect(currentDependencies.exportedLocalSymbols, dependencies.exportedLocalSymbols))) return !1;
     return !0;
 }, hasHydrateAssignment = (dependencies)=>Array.from(dependencies.topLevelNonModuleStatements).some((statement)=>{
         let expression = statement.expression, left = expression?.left;
@@ -1355,4 +1329,4 @@ if (import.meta.webpackHot) {
         }
     };
 };
-export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, CLIENT_NON_COMPONENT_EXPORTS, DEFAULT_JS_DIST_PATH, HMR_PATCHABLE_ROUTE_FLAGS, JS_EXTENSIONS, PLUGIN_NAME, SERVER_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS, SPA_FALLBACK_HTML_FILE, analyzeRouteModuleCode, buildManifestChunkValidity, collectReferencedNames, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createReactRouterPerformanceProfiler, createRouteId, detectRouteChunks, detectRouteChunksIfEnabled, escapeHtml, executeRouteTransformTask, findEntryFile, generate, generateWithProps, getExportNames, getExportedName, getPackageVersion, getPatternIdentifierNames, getProgram, getRouteChunkEntryName, getRouteChunkModuleId, getRouteChunkNameFromModuleId, getRouteEntryBaseName, getRouteModuleAnalysis, normalizeAssetPrefix, parseVersionMajorMinor, removeExports, removeUnusedImports, resolveAppPackagePath, resolveEffectiveAssetPrefix, roundMs, routeChunkExportNames, validateRouteChunks, validateSpaModeRouteExports, yuku_parse };
+export { HMR_PATCHABLE_ROUTE_FLAGS, analyzeRouteModuleCode, buildManifestChunkValidity, collectReferencedNames, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createReactRouterPerformanceProfiler, createRouteId, detectRouteChunks, detectRouteChunksIfEnabled, escapeHtml, executeRouteTransformTask, findEntryFile, generate, generateWithProps, getExportNames, getExportedName, getPackageVersion, getPatternIdentifierNames, getProgram, getRouteChunkEntryName, getRouteChunkModuleId, getRouteChunkNameFromModuleId, getRouteEntryBaseName, getRouteModuleAnalysis, normalizeAssetPrefix, parseVersionMajorMinor, removeExports, removeUnusedImports, resolveAppPackagePath, resolveEffectiveAssetPrefix, roundMs, routeChunkExportNames, validateRouteChunks, validateSpaModeRouteExports, yuku_parse };

package/dist/819.js

@@ -0,0 +1,64 @@
+let RESOLVABLE_BUILD_EXPORTS = new Set([
+    'allowedActionOrigins',
+    'assets',
+    'assetsBuildDirectory',
+    'basename',
+    'entry',
+    'future',
+    'isSpaMode',
+    'prerender',
+    'publicPath',
+    'routeDiscovery',
+    'routes',
+    'ssr'
+]);
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function isPromiseLike(value) {
+    return isRecord(value) && 'function' == typeof value.then;
+}
+async function resolveBuildExports(build) {
+    let resolved = {
+        ...build
+    };
+    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;
+}
+async function resolveServerBuildCandidate(candidate) {
+    var value;
+    if (!isRecord(candidate)) return;
+    let resolved = await resolveBuildExports(candidate);
+    return isRecord(resolved) && isRecord(resolved.entry) && isRecord(resolved.entry.module) && 'function' == typeof resolved.entry.module.default && isRecord(resolved.routes) && isRecord(resolved.assets) && 'string' == typeof resolved.assetsBuildDirectory && (void 0 === resolved.basename || 'string' == typeof resolved.basename) && isRecord(resolved.future) && 'boolean' == typeof resolved.isSpaMode && Array.isArray(resolved.prerender) && 'string' == typeof resolved.publicPath && (void 0 === (value = resolved.routeDiscovery) || isRecord(value) && ('initial' === value.mode || 'lazy' === value.mode && (void 0 === value.manifestPath || 'string' == typeof value.manifestPath))) && 'boolean' == typeof resolved.ssr ? resolved : void 0;
+}
+async function resolveServerBuildModule(buildModule, source) {
+    try {
+        let moduleValue = isPromiseLike(buildModule) ? await buildModule : buildModule, candidates = [
+            ()=>moduleValue
+        ];
+        for (let getCandidate of (isRecord(moduleValue) && ('default' in moduleValue && candidates.push(()=>moduleValue.default), 'module.exports' in moduleValue && candidates.push(()=>moduleValue['module.exports'])), candidates)){
+            let candidate = await getCandidate(), serverBuild = await resolveServerBuildCandidate(candidate);
+            if (serverBuild) return serverBuild;
+        }
+        throw Error(`[rsbuild-plugin-react-router] ${source} did not contain a valid React Router ServerBuild.`);
+    } catch (cause) {
+        throw cause instanceof Error ? cause : Error(String(cause));
+    }
+}
+let headerEntries = (headers)=>{
+    let entries = [];
+    return headers.forEach((value, key)=>entries.push([
+            key,
+            value
+        ])), entries;
+};
+export { headerEntries, resolveServerBuildModule };

package/dist/build-output-transforms.d.ts

@@ -31,6 +31,8 @@ type RegisterBuildOutputTransformsOptions = {
     resolvedServerOutput: 'module' | 'commonjs';
     performanceProfiler: ReactRouterPerformanceProfiler;
     getLatestServerManifest: () => ReactRouterManifest | null;
+    /** File holding the captured manifests; a dependency of the server-manifest module. */
+    serverManifestStampPath: string;
     getLatestServerManifestByBundleId: (bundleId: string) => ReactRouterManifest | undefined;
     routes: Record<string, Route>;
     pluginOptions: PluginOptions;
@@ -52,5 +54,5 @@ type RegisterBuildOutputTransformsOptions = {
     isDevHmrEnabled?: () => boolean;
     onRouteModuleAnalysis?: (resourcePath: string, analysis: RouteModuleAnalysis) => void;
 };
-export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeModuleAnalysis, routeTransformRunner, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, useRouteModuleTransformApi, ssr, isSpaMode, rootRoutePath, outputClientPath, isDevHmrEnabled, onRouteModuleAnalysis, }: RegisterBuildOutputTransformsOptions) => void;
+export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, serverManifestStampPath, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeModuleAnalysis, routeTransformRunner, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, useRouteModuleTransformApi, ssr, isSpaMode, rootRoutePath, outputClientPath, isDevHmrEnabled, onRouteModuleAnalysis, }: RegisterBuildOutputTransformsOptions) => void;
 export {};

package/dist/constants.d.ts

@@ -39,3 +39,4 @@ export declare const CLIENT_EXPORTS: {
     readonly shouldRevalidate: "shouldRevalidate";
 };
 export declare const SPA_FALLBACK_HTML_FILE = "__spa-fallback.html";
+export declare const BROWSER_MANIFEST_ENTRY_NAME = "virtual/react-router/browser-manifest";

package/dist/dev-hdr-channel.d.ts

@@ -0,0 +1,9 @@
+import type { RsbuildDevServer } from '@rsbuild/core';
+export declare const DEV_HDR_UPDATE_EVENT = "react-router:hdr-update";
+export declare const createDevHdrChannel: ({ hot, isEnabled, }: {
+    hot: RsbuildDevServer["environments"][string]["hot"];
+    isEnabled: () => boolean;
+}) => {
+    publish(): void;
+    close(): void;
+};

package/dist/dev-hmr.d.ts

@@ -4,7 +4,6 @@ export declare const DEV_MANIFEST_UPDATE_EVENT = "react-router:manifest-update";
 export type DevHmrPlanOptions = {
     isEnabled: () => boolean;
     runtimeModule: string;
-    onNodeRebuildCommitted: () => void;
 };
 export declare const isRspackSwcReactRefreshEnabled: (rspackConfig: Rspack.Configuration) => boolean;
 /**
@@ -16,25 +15,6 @@ export declare const isRspackSwcReactRefreshEnabled: (rspackConfig: Rspack.Confi
  * dev HMR falls back to full reloads.
  */
 export declare const resolveReactRefreshRuntimePath: (rootPath: string) => string | undefined;
-/**
- * The HDR revision module is a real file (not a virtual module) because it
- * must wake the web compiler through the regular file watcher: the browser
- * HMR runtime imports it, so bumping the revision produces a web hot update
- * whenever server code changes, which the client answers by revalidating
- * React Router loader data.
- */
-export declare const getDevHdrRevisionFilePath: (rootPath: string) => string;
-export type DevHdrRevisionSignal = {
-    filePath: string;
-    /** Writes the initial revision module so the first compile can resolve it. */
-    ensure: () => void;
-    /** Increments the revision, signaling hot data revalidation to the client. */
-    bump: () => void;
-};
-export declare const createDevHdrRevisionSignal: ({ filePath, onError, }: {
-    filePath: string;
-    onError?: (error: Error) => void;
-}) => DevHdrRevisionSignal;
 /**
  * Browser-side HMR runtime shared by all route client entries in development.
  *
@@ -45,7 +25,6 @@ export declare const createDevHdrRevisionSignal: ({ filePath, onError, }: {
  * recreating the client routes with revalidation opt-out, revalidating loader
  * data, and finally performing a React refresh.
  */
-export declare const generateDevHmrRuntimeModule: ({ reactRefreshRuntimePath, hdrRevisionFilePath, }: {
+export declare const generateDevHmrRuntimeModule: ({ reactRefreshRuntimePath, }: {
     reactRefreshRuntimePath: string;
-    hdrRevisionFilePath: string;
 }) => string;

package/dist/dev-runtime-controller.d.ts

@@ -14,11 +14,6 @@ type CreateControllerOptions = {
      * flags) in place, so metadata-only changes no longer need a full reload.
      */
     clientPatchesRouteMetadata?: boolean | (() => boolean);
-    /**
-     * Invoked after a development attempt commits a re-evaluated node build for
-     * changed server files. Used to signal hot data revalidation to the client.
-     */
-    onNodeRebuildCommitted?: () => void;
 };
-export declare const createReactRouterDevRuntimeController: ({ api, isBuild, buildPlan, clientPatchesRouteMetadata, onNodeRebuildCommitted, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
+export declare const createReactRouterDevRuntimeController: ({ api, isBuild, buildPlan, clientPatchesRouteMetadata, }: CreateControllerOptions) => ReactRouterDevRuntimeController;
 export {};

package/dist/dev-server.d.ts

@@ -6,12 +6,14 @@ export type DevServerMiddleware = (req: IncomingMessage, res: ServerResponse, ne
 type RequestHandler = (request: Request) => Response | Promise<Response>;
 type BuildProvider = () => Promise<ServerBuild>;
 export type DevServerMiddlewareDependencies = {
+    rootPath: string;
     loadBuild: BuildProvider;
     createRequestHandler?: (build: BuildProvider, mode: 'development') => RequestHandler;
     createRequestListener?: (handler: RequestHandler) => (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
 };
 export declare const createDevServerMiddleware: (dependencies: DevServerMiddlewareDependencies) => DevServerMiddleware;
-export declare const createReactRouterDevServerSetup: ({ loadBuild, }: {
+export declare const createReactRouterDevServerSetup: ({ loadBuild, rootPath, }: {
     loadBuild: BuildProvider;
+    rootPath: string;
 }) => ServerSetup;
 export {};