rsbuild-plugin-react-router 0.3.0 → 0.3.1

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
@@ -235,6 +234,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 +352,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 +364,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
@@ -632,6 +647,22 @@ 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.
+
 ## 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: 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
+    }), 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: '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);
@@ -748,7 +764,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
             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)};`;
         })({
-            exportNames: routeChunkInfo?.exportNames ?? await getExportNames(code),
+            exportNames: routeChunkInfo?.exportNames ?? await getExportNames(code, resourcePath),
             chunkedExports: routeChunkInfo?.chunkedExports ?? [],
             isServer,
             resourcePath
@@ -773,11 +789,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 {

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/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;

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

@@ -8,6 +8,11 @@ export type ReactRouterDevBuildPlan = {
 };
 export type ReactRouterDevManifestSet = Readonly<Record<string, ReactRouterDevManifest>>;
 export type ReactRouterServerBuilds = Readonly<Record<string, ServerBuild>>;
+export type PairedDevStats = {
+    web: Rspack.Stats;
+    node: Rspack.Stats;
+};
+export type DevRuntimeStats = Rspack.Stats | Rspack.MultiStats | PairedDevStats;
 export type DependencySnapshot = {
     files: ReadonlySet<string>;
     contexts: ReadonlySet<string>;
@@ -22,10 +27,12 @@ export type DevGraphChanges = {
     node: DevChangedFiles;
 };
 export type DevCompilationIdentity = symbol;
+export type DevCompileAttemptIdentity = symbol;
 export type DevGraphIdentity = {
     web: DevCompilationIdentity | undefined;
     node: DevCompilationIdentity | undefined;
     nodeWeb: DevCompilationIdentity | undefined;
+    attempt: DevCompileAttemptIdentity | undefined;
 };
 export type WebArtifact = {
     manifestsByEntryName: ReactRouterDevManifestSet;
@@ -34,6 +41,7 @@ export type WebArtifact = {
 export declare const snapshotDevChangedFiles: (compiler: Pick<Rspack.Compiler, "modifiedFiles" | "removedFiles"> | undefined) => DevChangedFiles;
 export declare const snapshotDependencies: (compilation: Rspack.Compilation) => DependencySnapshot;
 export declare const isSafeOneSidedChange: (changes: DevChangedFiles, dependencies: DependencySnapshot) => boolean;
-export declare const getEnvironmentStats: (stats: Rspack.Stats | Rspack.MultiStats, name: "web" | "node") => Rspack.Stats | undefined;
+export declare const isPairedDevStats: (stats: DevRuntimeStats) => stats is PairedDevStats;
+export declare const getEnvironmentStats: (stats: DevRuntimeStats, name: "web" | "node") => Rspack.Stats | undefined;
 export declare const evaluateServerBuilds: (server: RsbuildDevServer, entryNames: readonly string[]) => Promise<ReactRouterServerBuilds>;
 export declare const pinServerBuildsToManifests: (builds: ReactRouterServerBuilds, entryNames: readonly string[], manifestsByEntryName: ReactRouterDevManifestSet) => ReactRouterServerBuilds;

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

@@ -1,16 +1,19 @@
 import type { Rspack } from '@rsbuild/core';
-import type { DevCompilationIdentity, DevGraphChanges, DevGraphIdentity } from './dev-runtime-artifacts.js';
+import type { DevCompileAttemptIdentity, DevCompilationIdentity, DevRuntimeStats, DevGraphChanges, DevGraphIdentity } from './dev-runtime-artifacts.js';
 export type DevCompilerPair = {
     web: Rspack.Compiler;
     node: Rspack.Compiler;
     settledCompilations: WeakSet<Rspack.Compilation>;
     pendingAttempt?: PendingDevCompilation;
+    currentAttemptIdentity?: DevCompileAttemptIdentity;
     latestCompletedWebIdentity?: DevCompilationIdentity;
+    latestCompletedWebStats?: Rspack.Stats;
+    latestCompletedNodeStats?: Rspack.Stats;
     latestWebStart?: CompilationStart;
     latestNodeStart?: CompilationStart;
 };
 export type PendingDevCompilation = {
-    stats: Rspack.Stats | Rspack.MultiStats;
+    stats: DevRuntimeStats;
     changes: DevGraphChanges;
     identity: DevGraphIdentity;
     webCompilation: Rspack.Compilation;
@@ -22,11 +25,23 @@ export type CompilationStart = {
     status: 'started';
     identity: DevCompilationIdentity;
 };
+type CompilerPairStartSide = 'latestWebStart' | 'latestNodeStart';
+export declare const createDevCompilerPair: ({ web, node, }: {
+    web: Rspack.Compiler;
+    node: Rspack.Compiler;
+}) => DevCompilerPair;
+export declare const resetDevCompilerPair: (pair: DevCompilerPair) => void;
 export declare const isLatestStartedCompilation: (identity: DevCompilationIdentity | undefined, start: CompilationStart | undefined) => boolean;
 export declare const hasPendingCompilation: (pair: DevCompilerPair) => boolean;
+export declare const beginDevCompilerAttempt: (pair: DevCompilerPair) => void;
+export declare const markDevCompilerPending: (pair: DevCompilerPair, side: CompilerPairStartSide) => boolean;
+export declare const clearDevCompilerStart: (pair: DevCompilerPair, side: CompilerPairStartSide) => void;
 export type CompilationIdentityTracker = {
     getCompilationIdentity(compilation: Rspack.Compilation): DevCompilationIdentity;
     getWebIdentityForNodeCompilation(compilation: Rspack.Compilation): DevCompilationIdentity | undefined;
+    getAttemptIdentityForCompilation(compilation: Rspack.Compilation): DevCompileAttemptIdentity | undefined;
+    setAttemptIdentityForCompilation(compilation: Rspack.Compilation, identity: DevCompileAttemptIdentity): void;
     setWebIdentityForNodeCompilation(compilation: Rspack.Compilation, identity: DevCompilationIdentity): void;
 };
 export declare const createCompilationIdentityTracker: () => CompilationIdentityTracker;
+export {};

package/dist/dev-server.d.ts

@@ -1,5 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { RsbuildConfig } from '@rsbuild/core';
 import type { ServerBuild } from 'react-router';
+export type ServerSetup = Exclude<NonNullable<NonNullable<RsbuildConfig['server']>['setup']>, unknown[]>;
 export type DevServerMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => Promise<void>;
 type RequestHandler = (request: Request) => Response | Promise<Response>;
 type BuildProvider = () => Promise<ServerBuild>;
@@ -9,4 +11,7 @@ export type DevServerMiddlewareDependencies = {
     createRequestListener?: (handler: RequestHandler) => (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
 };
 export declare const createDevServerMiddleware: (dependencies: DevServerMiddlewareDependencies) => DevServerMiddleware;
+export declare const createReactRouterDevServerSetup: ({ loadBuild, }: {
+    loadBuild: BuildProvider;
+}) => ServerSetup;
 export {};

package/dist/effect-runtime.d.ts

@@ -0,0 +1,18 @@
+import * as Effect from 'effect/Effect';
+export declare const DEV_BACKGROUND_STARTUP_DELAY_MS = 3000;
+export declare const normalizeEffectError: (cause: unknown) => Error;
+export declare const runPluginEffect: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>;
+export declare const tryPluginSync: <A>(evaluate: () => A) => Effect.Effect<A, Error, never>;
+export declare const tryPluginPromise: <A>(evaluate: () => PromiseLike<A> | A) => Effect.Effect<A, Error, never>;
+type DelayedPluginTask = {
+    schedule(): void;
+    reschedule(): void;
+    cancelEffect(): Effect.Effect<void, Error, never>;
+    cancel(): Promise<void>;
+};
+export declare const createDelayedPluginTask: ({ delayMs, run, onError, }: {
+    delayMs: number;
+    run: () => Effect.Effect<void, Error, never>;
+    onError: (error: Error) => void;
+}) => DelayedPluginTask;
+export {};

package/dist/export-utils.d.ts

@@ -9,7 +9,7 @@ type RouteModuleAnalysis = {
     readonly exportAllModules: readonly string[];
 };
 export declare const collectProgramExportNames: (program: ProgramNode) => string[];
-export declare const getExportNames: (code: string) => Promise<readonly string[]>;
-export declare const getExportNamesAndExportAll: (code: string) => Promise<ExportInfo>;
+export declare const getExportNames: (code: string, resourcePath?: string) => Promise<readonly string[]>;
+export declare const getExportNamesAndExportAll: (code: string, resourcePath?: string) => Promise<ExportInfo>;
 export declare const getRouteModuleAnalysis: (resourcePath: string) => Promise<RouteModuleAnalysis>;
 export {};