rsbuild-plugin-react-router 0.3.0 → 0.4.0

package/README.md

@@ -70,24 +70,23 @@ plugin only needs options for Rsbuild-specific behavior.
 ```ts
 pluginReactRouter({
   customServer: false,
-  serverOutput: 'module',
-  lazyCompilation: undefined,
+  lazyCompilation: true,
+  unstableLazyCompilationPrewarm: false,
   logPerformance: false,
-  parallelRouteTransform: undefined,
-  onRouteTopologyChange: undefined,
   federation: false,
 });
 ```
 
-| Option                   | Default     | Description                                                                                                                                                                                                                      |
-| ------------------------ | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `customServer`           | `false`     | Disables the built-in development SSR middleware. Enable this when an app owns the server with `createDevServer()` or an adapter.                                                                                                |
-| `serverOutput`           | `'module'`  | 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`        | `undefined` | 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. |
-| `logPerformance`         | `false`     | Logs structured React Router plugin timing information through the Rsbuild logger.                                                                                                                                               |
-| `parallelRouteTransform` | `undefined` | Controls worker-thread route transforms. `undefined` auto-enables workers for 256+ routes, `true` forces the default worker count, a positive integer sets the worker count, and `false` keeps transforms inline.                |
-| `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.                                                                                                                                                                 |
+| Option                           | Default     | Description                                                                                                                                                                                                                                                                                                                                          |
+| -------------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `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 Rspack 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 through the Rsbuild logger.                                                                                                                                                                                                                                                                   |
+| `parallelRouteTransform`         | `undefined` | Controls worker-thread route transforms. `undefined` auto-enables workers for 256+ routes, `true` forces the default worker count (in dev this is 0 on machines with 4 or fewer cores, where workers cost more than they save; production builds always use workers), a positive integer sets the worker count, and `false` keeps transforms inline. |
+| `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.                                                                                                                                                                                                                                                                                     |
 
 When `federation` is enabled, configure the Module Federation plugin with
 `experiments.asyncStartup: true`. The dev server resolves async server build
@@ -99,7 +98,7 @@ async exports before passing the build to React Router's request handler.
 Put React Router framework settings in `react-router.config.*`:
 
 ```ts
-import type { Config } from '@react-router/dev/config';
+import type { ReactRouterRsbuildConfig } from 'rsbuild-plugin-react-router';
 
 export default {
   ssr: true,
@@ -108,9 +107,15 @@ export default {
   basename: '/',
   splitRouteModules: true,
   subResourceIntegrity: false,
-} satisfies Config;
+} satisfies ReactRouterRsbuildConfig;
 ```
 
+Use `ReactRouterRsbuildConfig` for Rsbuild projects so plugin-supported
+configuration such as `splitRouteModules` stays typed. The underlying route
+and config types come from `@react-router/dev`, which framework-mode apps
+already install for `routes.ts` helpers and typegen; it is declared as an
+optional peer dependency.
+
 Commonly used options:
 
 | Option                 | Default      | Notes                                                                                                                     |
@@ -179,7 +184,7 @@ For static sites with multiple pages, you can prerender specific routes at build
 
 ```ts
 // react-router.config.ts
-import type { Config } from '@react-router/dev/config';
+import type { ReactRouterRsbuildConfig } from 'rsbuild-plugin-react-router';
 
 export default {
   ssr: false,
@@ -191,7 +196,7 @@ export default {
     '/docs/advanced',
     '/projects',
   ],
-} satisfies Config;
+} satisfies ReactRouterRsbuildConfig;
 ```
 
 When `prerender` is specified:
@@ -210,7 +215,7 @@ export default {
   ssr: false,
   prerender: ({ getStaticPaths }) =>
     getStaticPaths().filter(path => path !== '/admin'),
-} satisfies Config;
+} satisfies ReactRouterRsbuildConfig;
 ```
 
 Prerendering defaults to one path at a time, matching React Router. Use
@@ -224,7 +229,7 @@ export default {
     paths: ['/', '/about'],
     concurrency: 4,
   },
-} satisfies Config;
+} satisfies ReactRouterRsbuildConfig;
 ```
 
 For builds with 256+ routes, detailed file-size reporting is compacted to totals
@@ -235,6 +240,20 @@ Route transform source maps are generated in development only. If you enable
 Rsbuild source maps for faster local debugging, prefer a cheap JS map:
 `output.sourceMap: { js: 'cheap-module-source-map', css: false }`.
 
+Lazy compilation prewarming is disabled by default. When enabled alongside
+`lazyCompilation`, the plugin fetches emitted browser entry and route JS assets,
+extracts activation keys from Rspack's generated lazy-compilation client calls,
+and POSTs those keys to Rspack's configured lazy trigger endpoint after dev
+compiles. It does not request application routes or run route loaders. Because
+the key extraction depends on Rspack's generated client code shape, opt in with
+`unstableLazyCompilationPrewarm: true`.
+
+Subresource Integrity is disabled by default. Enable it with
+`subResourceIntegrity: true` in `react-router.config.*` when the deployed app
+should emit integrity metadata for browser scripts. The legacy
+`future.unstable_subResourceIntegrity` flag is still accepted and is normalized
+to the stable option.
+
 ### Route Configuration
 
 Routes can be defined in `app/routes.ts` using the helper functions from `@react-router/dev/routes`:
@@ -339,6 +358,11 @@ export default defineConfig(() => {
     plugins: [
       pluginReactRouter({
         customServer: true,
+        onRouteTopologyChange() {
+          console.warn('Route topology changed; restart the dev server.');
+          process.exitCode = 75;
+          setTimeout(() => process.exit(75), 0);
+        },
       }),
       pluginReact(),
     ],
@@ -346,17 +370,14 @@ export default defineConfig(() => {
 });
 ```
 
-If the server is created programmatically with `createDevServer()`, pass
-`onRouteTopologyChange` and use it to recreate that server. Rsbuild's
-`reload-server` watcher is owned by the CLI and is not installed by the
-programmatic API. The callback is a notification and is not awaited, so it can
-safely start a serialized replacement task. Always `await` the active server's
-`close()` before calling `createDevServer()` again; the plugin rejects overlapping
-or out-of-order replacement instead of closing one server from inside another
-server's startup hooks. If startup fails before returning a server, or if
-`close()` rejects, restart the process before retrying unless you can externally
-prove and force complete teardown; a fresh Rsbuild instance alone is not
-sufficient. Do not launch concurrent `createDevServer()` calls.
+Rsbuild's `reload-server` watcher is owned by the CLI and is not installed by
+the programmatic `createDevServer()` API. The sample below therefore treats
+route topology changes as a full process restart: do not call `startServer()`
+again inside the same process or mount a second dev server on the same Express
+app. If you implement in-process replacement instead, route requests through
+replaceable middleware and request-handler delegates, always `await` the active
+server's `close()` before calling `createDevServer()` again, and do not launch
+concurrent replacements.
 
 Create one server entry point (`server.js`) and let it own the React Router
 request handler in both development and production. Only the build provider
@@ -569,14 +590,14 @@ export default {
 ```json
 {
   "dependencies": {
-    "@react-router/node": "^7.1.3",
-    "@react-router/serve": "^7.1.3",
-    "react-router": "^7.1.3"
+    "@react-router/node": "^7.13.0",
+    "@react-router/serve": "^7.13.0",
+    "react-router": "^7.13.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20241112.0",
-    "@react-router/cloudflare": "^7.1.3",
-    "@react-router/dev": "^7.1.3",
+    "@react-router/cloudflare": "^7.13.0",
+    "@react-router/dev": "^7.13.0",
     "wrangler": "^3.106.0"
   }
 }
@@ -632,6 +653,38 @@ The plugin automatically:
 - Handles route-based code splitting
 - Manages client and server builds
 
+### Benchmarking
+
+`pnpm bench:large` runs this repository's generated stress fixture for quick
+regression checks. `pnpm bench:synthetic-app` runs the embedded complex Rsbuild
+app under `benchmarks/synthetic-web-bundler-benchmark`, which adds heavier
+loader and transform contention for benchmark coverage closer to a large
+real-world application.
+
+```bash
+pnpm bench:large
+pnpm bench:synthetic-app -- --profile all --runs 2
+```
+
+The PR benchmark workflow reports production build, dev route-load, HMR/update,
+and embedded synthetic app timings in the same benchmark comment. It measures
+the PR and its base on the same runner instead of reusing cached timing data,
+counterbalances which side runs first, and excludes one warmup iteration. Small
+fixtures use five measured iterations; expensive large fixtures use three.
+
+Every raw median delta remains visible. The comment also reports each side's
+relative median absolute deviation (rMAD), a conservative noise band, and a
+signal label:
+
+- `regression` or `improvement` means the median delta exceeds the observed
+  run-to-run noise band.
+- `inconclusive` means the raw delta is not clearly separated from that noise.
+- `insufficient data` means either side has fewer than three finite samples.
+
+The labels are triage aids, not pass/fail gates. Use the uploaded diagnostics
+and raw per-run samples to investigate important changes, and rerun an
+inconclusive comparison before treating it as a performance result.
+
 ## React Router Framework Mode
 
 React Router "Framework Mode" wraps Data Mode using a Vite plugin. This Rsbuild

package/dist/451.js

@@ -4,6 +4,7 @@ import { langFromPath, parse, walk as external_yuku_parser_walk } from "yuku-par
 import { Analyzer } from "yuku-analyzer";
 import { print } from "yuku-codegen";
 import { readFile, stat } from "node:fs/promises";
+import { rspack } from "@rsbuild/core";
 import { createRequire } from "node:module";
 let PLUGIN_NAME = 'rsbuild:react-router', JS_EXTENSIONS = [
     '.tsx',
@@ -557,16 +558,30 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         oldestEntry.done || cache.delete(oldestEntry.value);
     }
     cache.set(key, value);
-}, exportInfoCache = new Map(), routeModuleAnalysisCache = new Map(), cachePromiseOnReject = (promise, invalidate)=>promise.catch((error)=>{
-        throw invalidate(), error;
-    }), parseProgram = (code, resourcePath)=>{
-    let result = parse(code, {
+}, exportInfoCache = new Map(), routeModuleAnalysisCache = new Map(), getParseErrors = (result)=>result.diagnostics.filter((diagnostic)=>'error' === diagnostic.severity), getParseErrorMessage = (errors)=>errors.map((error)=>error.message).join('\n'), parseProgram = (code, resourcePath)=>{
+    let sourcePath = resourcePath ? resourcePath.replace(/[?#].*$/, '') : void 0, lang = sourcePath ? langFromPath(sourcePath) : 'tsx', result = parse(code, {
+        sourceType: 'module',
+        lang
+    }), errors = getParseErrors(result);
+    if (0 === errors.length) return result.program ?? result;
+    if (!sourcePath || 'ts' !== lang && 'tsx' !== lang) throw Error(getParseErrorMessage(errors));
+    let normalizedResult = parse(rspack.experiments.swc.transformSync(code, {
+        filename: sourcePath,
+        jsc: {
+            parser: {
+                syntax: "typescript",
+                tsx: 'tsx' === lang
+            }
+        }
+    }).code, {
         sourceType: 'module',
-        lang: resourcePath ? langFromPath(resourcePath) : 'tsx'
-    }), errors = result.diagnostics.filter((diagnostic)=>'error' === diagnostic.severity);
-    if (errors.length > 0) throw Error(errors.map((error)=>error.message).join('\n'));
-    return result.program ?? result;
-}, isTypeOnlyExport = (node)=>'type' === node.exportKind || 'TSExportAssignment' === node.type || node.declaration?.declare === !0 || 'ExportDefaultDeclaration' === node.type && node.declaration?.type === 'TSInterfaceDeclaration', collectProgramExportNames = (program)=>{
+        lang: 'js'
+    }), normalizedErrors = getParseErrors(normalizedResult);
+    if (normalizedErrors.length > 0) throw Error(getParseErrorMessage(normalizedErrors));
+    return normalizedResult.program ?? normalizedResult;
+}, cachePromiseOnReject = (promise, invalidate)=>promise.catch((error)=>{
+        throw invalidate(), error;
+    }), isTypeOnlyExport = (node)=>'type' === node.exportKind || 'TSExportAssignment' === node.type || node.declaration?.declare === !0 || 'ExportDefaultDeclaration' === node.type && node.declaration?.type === 'TSInterfaceDeclaration', collectProgramExportNames = (program)=>{
     let exportNames = new Set();
     for (let statement of program.body ?? []){
         if (isTypeOnlyExport(statement)) continue;
@@ -601,17 +616,18 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         'string' == typeof source && modules.push(source);
     }
     return modules;
-}, getExportNames = async (code)=>(await getExportNamesAndExportAll(code)).exportNames, getExportNamesAndExportAll = async (code)=>{
-    let trackedExportInfo, cached = exportInfoCache.get(code);
+}, getExportNames = async (code, resourcePath)=>(await getExportNamesAndExportAll(code, resourcePath)).exportNames, getExportNamesAndExportAll = async (code, resourcePath)=>{
+    var code1, resourcePath1;
+    let lang, trackedExportInfo, cacheKey = (code1 = code, lang = (resourcePath1 = resourcePath) ? langFromPath(resourcePath1.replace(/[?#].*$/, '')) : 'inline', `${lang}\0${code1}`), cached = exportInfoCache.get(cacheKey);
     return cached || (trackedExportInfo = cachePromiseOnReject((async ()=>{
-        let program = parseProgram(code);
+        let program = parseProgram(code, resourcePath);
         return {
             exportNames: collectProgramExportNames(program),
             exportAllModules: collectExportAllModules(program)
         };
     })(), ()=>{
-        exportInfoCache.get(code) === trackedExportInfo && exportInfoCache.delete(code);
-    }), setBoundedCacheEntry(exportInfoCache, code, trackedExportInfo, 2048), trackedExportInfo);
+        exportInfoCache.get(cacheKey) === trackedExportInfo && exportInfoCache.delete(cacheKey);
+    }), setBoundedCacheEntry(exportInfoCache, cacheKey, trackedExportInfo, 2048), trackedExportInfo);
 }, getRouteModuleAnalysis = async (resourcePath)=>{
     let trackedAnalysis, stats = await stat(resourcePath), cached = routeModuleAnalysisCache.get(resourcePath);
     return cached?.mtimeMs === stats.mtimeMs && cached.size === stats.size ? cached.analysis : (trackedAnalysis = cachePromiseOnReject((async ()=>{
@@ -712,12 +728,12 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
     } catch  {
         return null;
     }
-}, createBundlerRouteExportResolver = (resolveModule)=>(specifier, importerPath)=>new Promise((resolveResolvedPath)=>{
+}, createBundlerRouteExportResolver = (resolveModule)=>(specifier, importerPath)=>new Promise((resolvePromise)=>{
             resolveModule(dirname(importerPath), specifier, (error, resolved)=>{
-                resolveResolvedPath(error || !resolved ? null : resolved);
+                resolvePromise(error || !resolved ? null : resolved);
             });
         }), collectClientOnlyStubExportNames = async (code, resourcePath, resolveModule = resolveExportAllModule)=>{
-    let { exportNames: directExportNames, exportAllModules } = await getExportNamesAndExportAll(code), exportNames = new Set(directExportNames), unresolvedExportAll = new Set(), visitedModules = new Set(), collectExportNamesFromModule = async (modulePath)=>{
+    let { exportNames: directExportNames, exportAllModules } = await getExportNamesAndExportAll(code, resourcePath), exportNames = new Set(directExportNames), unresolvedExportAll = new Set(), visitedModules = new Set(), collectExportNamesFromModule = async (modulePath)=>{
         if (visitedModules.has(modulePath)) return;
         visitedModules.add(modulePath);
         let { exports: moduleExportNames, exportAllModules: moduleExportAll } = await getRouteModuleAnalysis(modulePath);
@@ -741,17 +757,67 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
     }
     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(), resourcePath)}\`.`);
     return exportNames;
-}, createRouteClientEntryArtifact = async ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig })=>{
+}, HMR_PATCHABLE_ROUTE_FLAGS = [
+    'hasAction',
+    'hasClientAction',
+    'hasClientLoader',
+    'hasClientMiddleware',
+    'hasErrorBoundary',
+    'hasLoader'
+], HMR_FLAG_EXPORT_NAME = {
+    hasAction: SERVER_EXPORTS.action,
+    hasClientAction: CLIENT_EXPORTS.clientAction,
+    hasClientLoader: CLIENT_EXPORTS.clientLoader,
+    hasClientMiddleware: CLIENT_EXPORTS.clientMiddleware,
+    hasErrorBoundary: CLIENT_EXPORTS.ErrorBoundary,
+    hasLoader: SERVER_EXPORTS.loader
+}, createRouteClientEntryArtifact = async ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig, routeId, devHmr })=>{
     let isServer = 'node' === environmentName, routeChunkInfo = !isServer && isBuild && shouldAnalyzeRouteChunks(routeChunkConfig, resourcePath, code) ? await detectRouteChunksIfEnabled(routeChunkCache, routeChunkConfig, resourcePath, code) : null;
     return {
-        code: (({ exportNames, chunkedExports, isServer, resourcePath })=>{
-            let chunkedExportSet = chunkedExports.length > 0 ? new Set(chunkedExports) : void 0, reexports = exportNames.filter((exp)=>!chunkedExportSet?.has(exp) && (CLIENT_ROUTE_EXPORTS_SET.has(exp) || isServer && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp))).sort(), target = `${resourcePath}?react-router-route`;
-            return `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`;
+        code: (({ exportNames, chunkedExports, isServer, resourcePath, routeId, devHmr })=>{
+            let exports, flags, chunkedExportSet = chunkedExports.length > 0 ? new Set(chunkedExports) : void 0, reexports = exportNames.filter((exp)=>!chunkedExportSet?.has(exp) && (CLIENT_ROUTE_EXPORTS_SET.has(exp) || isServer && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp))).sort(), target = `${resourcePath}?react-router-route`, reexportCode = `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`;
+            return !devHmr || isServer || void 0 === routeId ? reexportCode : reexportCode + (({ routeId, target, acceptTarget, flags })=>{
+                let targetJson = JSON.stringify(target), acceptTargetJson = JSON.stringify(acceptTarget);
+                return `
+import * as __rrm from ${targetJson};
+import {
+  registerReactRouterRouteExports as __rrr,
+  scheduleReactRouterRouteUpdate as __rru,
+} from "virtual/react-router/hmr-runtime";
+
+const __rrid = ${JSON.stringify(routeId)};
+const __rrf = ${flags};
+const __rrg = () => __rrm;
+const __rru0 = () => {
+  __rrr(__rrid, __rrm);
+  __rru(__rrid, __rrf, __rrg);
+};
+
+__rrr(__rrid, __rrm);
+
+if (import.meta.webpackHot) {
+  const __rrh = import.meta.webpackHot;
+  __rrh.accept(${acceptTargetJson}, __rru0);
+  __rrh.accept();
+  __rrh.dispose(data => { data.__rr = true; });
+  if (__rrh.data && __rrh.data.__rr) __rru0();
+}
+`;
+            })({
+                routeId,
+                target,
+                acceptTarget: `./${basename(resourcePath)}?react-router-route`,
+                flags: (exports = new Set(exportNames), flags = 0, HMR_PATCHABLE_ROUTE_FLAGS.forEach((flag, index)=>{
+                    exports.has(HMR_FLAG_EXPORT_NAME[flag]) && (flags |= 1 << index);
+                }), flags)
+            });
         })({
-            exportNames: routeChunkInfo?.exportNames ?? await getExportNames(code),
+            exportNames: routeChunkInfo?.exportNames ?? await getExportNames(code, resourcePath),
             chunkedExports: routeChunkInfo?.chunkedExports ?? [],
             isServer,
-            resourcePath
+            resourcePath,
+            routeId,
+            devHmr: devHmr && !isBuild
         })
     };
 }, createRouteChunkArtifact = async ({ code, resource, resourcePath, isBuild, routeChunkCache, routeChunkConfig })=>{
@@ -773,11 +839,11 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
     };
     let chunk = await getRouteChunkIfEnabled(routeChunkCache, routeChunkConfig, resourcePath, chunkName, code);
     if ('enforce' === splitRouteModules && 'main' === chunkName && chunk) {
-        let exportNameSet;
+        let exportNameSet, exportNames = await getExportNames(chunk, resourcePath);
         validateRouteChunks({
             config: routeChunkConfig,
             id: resourcePath,
-            valid: (exportNameSet = new Set(await getExportNames(chunk)), createRouteChunkExportMap((exportName)=>!exportNameSet.has(exportName)))
+            valid: (exportNameSet = new Set(exportNames), createRouteChunkExportMap((exportName)=>!exportNameSet.has(exportName)))
         });
     }
     return {
@@ -801,7 +867,50 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
 }, createClientOnlyStub = async (task)=>({
         code: Array.from(await collectClientOnlyStubExportNames(task.code, task.resourcePath, task.resolveExportAllModule)).map((name)=>'default' === name ? 'export default undefined;' : `export const ${name} = undefined;`).join('\n'),
         map: null
-    }), transformRouteModule = async (task)=>{
+    }), callResolvesToComponent = (node)=>{
+    let args = node.arguments ?? [];
+    if (0 === args.length) return !1;
+    let callee = node.callee;
+    if (!callee || 'Import' === callee.type) return !1;
+    if ('Identifier' === callee.type) {
+        let calleeName = callee.name ?? '';
+        if (calleeName.startsWith('require') || calleeName.startsWith('import')) return !1;
+    } else if ('MemberExpression' !== callee.type) return !1;
+    var node1 = args[0];
+    switch(node1?.type){
+        case 'FunctionExpression':
+            return !0;
+        case 'ArrowFunctionExpression':
+            return node1.body?.type !== 'ArrowFunctionExpression';
+        case 'Identifier':
+            let name;
+            return !!node1.name && (name = node1.name, /^[A-Z]/.test(name));
+        case 'CallExpression':
+            return callResolvesToComponent(node1);
+        default:
+            return !1;
+    }
+}, collectDeclaredComponentNames = (declaration, names)=>{
+    let name, name1;
+    if ('FunctionDeclaration' === declaration.type && declaration.id?.name && (name = declaration.id.name, /^[A-Z]/.test(name))) return void names.add(declaration.id.name);
+    if ('VariableDeclaration' !== declaration.type) return;
+    let declarators = declaration.declarations ?? [];
+    if (1 !== declarators.length) return;
+    let [declarator] = declarators;
+    declarator?.id?.type === 'Identifier' && declarator.id.name && (name1 = declarator.id.name, /^[A-Z]/.test(name1)) && declarator.init && ((init)=>{
+        switch(init.type){
+            case 'FunctionExpression':
+            case 'TaggedTemplateExpression':
+                return !0;
+            case 'ArrowFunctionExpression':
+                return init.body?.type !== 'ArrowFunctionExpression';
+            case 'CallExpression':
+                return callResolvesToComponent(init);
+            default:
+                return !1;
+        }
+    })(declarator.init) && names.add(declarator.id.name);
+}, transformRouteModule = async (task)=>{
     let code = task.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 = ((code, options = {})=>{
@@ -924,7 +1033,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
             return !(!declaration || currentlyLive.has(declaration)) && (previouslyLive.has(declaration) || declarationReferencesName(declaration, removedExportReferencedNames, declarationGraph, removedReferenceCache));
         }, program.body = program.body.filter((statement)=>'VariableDeclaration' === statement.type ? (statement.declarations = (statement.declarations ?? []).filter((declarator)=>!isRemovableDeadDeclaration(declarator)), statement.declarations.length > 0) : !isRemovableDeadDeclaration(statement))), exportsChanged;
     })(ast, SERVER_ONLY_ROUTE_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS_SET);
-    return ((ast)=>{
+    ((ast)=>{
         let program = ast.program ?? ast, usedNames = new Set(), hocs = [], componentWrapperDeclarations = [];
         function getUid(name) {
             let uid = `_${name}`, index = 2;
@@ -1028,7 +1137,8 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         for (let statement of [
             ...program.body
         ])'ImportDeclaration' === statement.type && 0 !== (statement.specifiers ?? []).length && (statement.specifiers = (statement.specifiers ?? []).filter((specifier)=>'type' !== specifier.importKind && (!specifier.local?.name || referenced.has(specifier.local.name))), 0 === statement.specifiers.length && removeFromArray(program.body, statement));
-    })(ast), ((ast, options = {})=>{
+    })(ast);
+    let result = ((ast, options = {})=>{
         let result = 'program' in ast ? ast : {
             program: ast,
             lineStarts: []
@@ -1056,6 +1166,28 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         filename: task.resource,
         sourceFileName: task.resourcePath
     });
+    if (task.devHmr && 'web' === task.environmentName && !task.isBuild) {
+        let registrations, unregisteredComponents = ((program)=>{
+            let declared = new Set(), registered = new Set();
+            for (let statement of program.body ?? []){
+                if ('ExportNamedDeclaration' === statement.type && statement.declaration) {
+                    collectDeclaredComponentNames(statement.declaration, declared);
+                    continue;
+                }
+                if ('ExpressionStatement' === statement.type && statement.expression?.type === 'CallExpression' && statement.expression.callee?.type === 'Identifier' && '$RefreshReg$' === statement.expression.callee.name) {
+                    let nameArgument = statement.expression.arguments?.[1];
+                    'string' == typeof nameArgument?.value && registered.add(nameArgument.value);
+                    continue;
+                }
+                collectDeclaredComponentNames(statement, declared);
+            }
+            return [
+                ...declared
+            ].filter((name)=>!registered.has(name));
+        })(ast.program ?? ast);
+        unregisteredComponents.length > 0 && (result.code += (registrations = unregisteredComponents.map((name)=>`  if (typeof ${name} === 'function' || (typeof ${name} === 'object' && ${name} !== null)) $RefreshReg$(${name}, ${JSON.stringify(name)});`).join('\n'), `\nif (typeof $RefreshReg$ === 'function') {\n${registrations}\n}\n`));
+    }
+    return result;
 }, executeRouteTransformTask = async (task, options)=>{
     switch(task.kind){
         case 'routeClientEntry':
@@ -1065,7 +1197,9 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
                 environmentName: task.environmentName,
                 isBuild: task.isBuild,
                 routeChunkCache: getRouteChunkCache(options),
-                routeChunkConfig: task.routeChunkConfig
+                routeChunkConfig: task.routeChunkConfig,
+                routeId: task.routeId,
+                devHmr: task.devHmr
             });
         case 'routeChunk':
             return createRouteChunkArtifact({
@@ -1084,4 +1218,4 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
             return transformRouteModule(task);
     }
 };
-export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, JS_EXTENSIONS, PLUGIN_NAME, SERVER_EXPORTS, buildManifestChunkValidity, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createRouteId, detectRouteChunksIfEnabled, executeRouteTransformTask, findEntryFile, generateWithProps, getRouteChunkEntryName, getRouteChunkModuleId, getRouteModuleAnalysis, normalizeAssetPrefix, routeChunkExportNames, setBoundedCacheEntry, validateRouteChunks };
+export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, HMR_PATCHABLE_ROUTE_FLAGS, JS_EXTENSIONS, PLUGIN_NAME, SERVER_EXPORTS, buildManifestChunkValidity, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createRouteId, detectRouteChunksIfEnabled, executeRouteTransformTask, findEntryFile, generateWithProps, getRouteChunkEntryName, getRouteChunkModuleId, getRouteModuleAnalysis, normalizeAssetPrefix, routeChunkExportNames, setBoundedCacheEntry, validateRouteChunks };

package/dist/build-manifest.d.ts

@@ -1,3 +1,4 @@
+import * as Effect from 'effect/Effect';
 import type { Config } from './react-router-config.js';
 import type { Route } from './types.js';
 type BuildManifest = {
@@ -10,10 +11,12 @@ type BuildManifest = {
     }>;
     routeIdToServerBundleId: Record<string, string>;
 };
-export declare const getBuildManifest: ({ reactRouterConfig, routes, rootDirectory, }: {
-    reactRouterConfig: Required<Pick<Config, "appDirectory" | "buildDirectory" | "serverBuildFile" | "future">> & Pick<Config, "serverBundles">;
+type GetBuildManifestOptions = {
+    reactRouterConfig: Required<Pick<Config, 'appDirectory' | 'buildDirectory' | 'serverBuildFile' | 'future'>> & Pick<Config, 'serverBundles'>;
     routes: Record<string, Route>;
     rootDirectory: string;
-}) => Promise<BuildManifest | undefined>;
+};
+export declare const getBuildManifestEffect: ({ reactRouterConfig, routes, rootDirectory, }: GetBuildManifestOptions) => Effect.Effect<BuildManifest | undefined, Error, never>;
+export declare const getBuildManifest: (options: GetBuildManifestOptions) => Promise<BuildManifest | undefined>;
 export declare const getRoutesByServerBundleId: (buildManifest: BuildManifest | undefined, sourceRoutes: Record<string, Route>) => Record<string, Record<string, Route>>;
 export {};

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

@@ -25,6 +25,7 @@ type RegisterBuildOutputTransformsOptions = {
     ssr: boolean;
     isSpaMode: boolean;
     rootRoutePath: string;
+    isDevHmrEnabled?: () => boolean;
 };
-export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath, }: RegisterBuildOutputTransformsOptions) => void;
+export declare const registerBuildOutputTransforms: ({ api, resolvedServerOutput, performanceProfiler, getLatestServerManifest, getLatestServerManifestByBundleId, routes, pluginOptions, getClientStats, appDirectory, getAssetPrefix, routeChunkOptions, routeTransformExecutor, routeByFilePath, routeChunkConfig, isBuild, splitRouteModules, ssr, isSpaMode, rootRoutePath, isDevHmrEnabled, }: RegisterBuildOutputTransformsOptions) => void;
 export {};

package/dist/concurrency.d.ts

@@ -1,2 +1,3 @@
+export declare const getAvailableCpuCount: () => number;
 export declare const getDefaultConcurrency: (cpuCount?: number) => number;
-export declare const mapWithConcurrency: <Item, Result>(items: readonly Item[], concurrency: number, worker: (item: Item, index: number) => Promise<Result>) => Promise<Result[]>;
+export declare const getCappedPluginConcurrency: (cap?: number) => number;

package/dist/config-imports.d.ts

@@ -1,3 +1,10 @@
 import type { ModuleCache } from 'jiti';
+import { createJiti } from 'jiti';
+type ConfigImporter = Pick<ReturnType<typeof createJiti>, 'import'>;
 export declare const collectConfigImportWatchPaths: (configPath: string, moduleCache: ModuleCache, previousCacheKeys: ReadonlySet<string>) => string[];
 export declare const clearConfigImportCache: (moduleCache: ModuleCache, filePaths: readonly string[]) => void;
+export declare const importConfigWithWatchPaths: <T>(configPath: string, load?: (importer: ConfigImporter) => PromiseLike<T> | T) => Promise<{
+    value: Awaited<T>;
+    watchPaths: string | string[];
+}>;
+export {};

package/dist/dev-background-resources.d.ts

@@ -0,0 +1,38 @@
+import type { RsbuildPluginAPI } from '@rsbuild/core';
+import type { RouteConfigEntry } from '@react-router/dev/routes';
+import { type ReactRouterManifestForDev } from './manifest.js';
+import type { RouteTransformExecutor } from './parallel-route-transforms.js';
+import { type WatchFileConfig } from './route-watch.js';
+import type { PluginOptions } from './types.js';
+type RegisterReactRouterDevBackgroundResourcesOptions = {
+    api: RsbuildPluginAPI;
+    isBuild: boolean;
+    lazyCompilationPrewarm: PluginOptions['unstableLazyCompilationPrewarm'];
+    routeTransformExecutor: RouteTransformExecutor;
+    routeRestartMarkerPath: string;
+    watchDirectory: string;
+    getRouteTopology: () => Promise<Set<string>>;
+    initialRouteTopology: Set<string>;
+    onRouteTopologyChange: PluginOptions['onRouteTopologyChange'];
+};
+type ReactRouterDevBackgroundResources = {
+    setManifest(manifest: ReactRouterManifestForDev): void;
+};
+export declare const createReactRouterRouteTopology: ({ appDirectory, rootRouteFile, routeConfig, loadRouteConfig, getRootRoutePath, }: {
+    appDirectory: string;
+    rootRouteFile: string;
+    routeConfig: RouteConfigEntry[];
+    loadRouteConfig: () => Promise<RouteConfigEntry[]>;
+    getRootRoutePath: () => string;
+}) => {
+    initialRouteTopology: Set<string>;
+    getRouteTopology: () => Promise<Set<string>>;
+};
+export declare const createReactRouterRouteWatchFiles: ({ configWatchPaths, routeConfigWatchPaths, routeRestartMarkerPath, onRouteTopologyChange, }: {
+    configWatchPaths: string | string[];
+    routeConfigWatchPaths: string | string[];
+    routeRestartMarkerPath: string;
+    onRouteTopologyChange: PluginOptions["onRouteTopologyChange"];
+}) => WatchFileConfig[];
+export declare const registerReactRouterDevBackgroundResources: ({ api, isBuild, lazyCompilationPrewarm, routeTransformExecutor, routeRestartMarkerPath, watchDirectory, getRouteTopology, initialRouteTopology, onRouteTopologyChange, }: RegisterReactRouterDevBackgroundResourcesOptions) => ReactRouterDevBackgroundResources;
+export {};

package/dist/dev-generation.d.ts

@@ -1,12 +1,12 @@
 import type { RsbuildDevServer, Rspack } from '@rsbuild/core';
 import type { ServerBuild } from 'react-router';
-import { type DevGraphChanges, type DevGraphIdentity, type ReactRouterDevBuildPlan, type ReactRouterDevManifestSet } from './dev-runtime-artifacts.js';
+import { type DevGraphChanges, type DevGraphIdentity, type DevRuntimeStats, type ReactRouterDevBuildPlan, type ReactRouterDevManifestSet } from './dev-runtime-artifacts.js';
 export { snapshotDevChangedFiles } from './dev-runtime-artifacts.js';
 export type { DevChangedFiles, DevGraphChanges, DevGraphIdentity, ReactRouterDevBuildPlan, ReactRouterDevManifest, ReactRouterDevManifestSet, } from './dev-runtime-artifacts.js';
 export type ReactRouterDevRuntime = {
     beginAttempt: () => void;
     captureWeb: (compilation: Rspack.Compilation, manifestsByEntryName: ReactRouterDevManifestSet) => void;
-    finishAttempt: (stats: Rspack.Stats | Rspack.MultiStats, changes: DevGraphChanges, identity: DevGraphIdentity) => Promise<void>;
+    finishAttempt: (stats: DevRuntimeStats, changes: DevGraphChanges, identity: DevGraphIdentity) => Promise<'committed' | 'ignored' | 'retry-node'>;
     failAttempt: (error: Error) => void;
     load: (entryName?: string) => Promise<ServerBuild>;
     close: (error?: Error) => void;