rsbuild-plugin-react-router 0.5.0 → 0.6.0

package/dist/rsc-route-transform-loader.js

@@ -0,0 +1,16 @@
+export default function(source, map) {
+    let callback = this.async(), transform = this._compiler?.__reactRouterRscRouteTransform;
+    transform ? transform({
+        code: source.toString(),
+        resource: this.resource,
+        resourcePath: this.resourcePath,
+        resourceQuery: this.resourceQuery,
+        environment: {
+            name: this.getOptions().environmentName
+        }
+    }).then((result)=>{
+        callback(null, result.code, result.map ?? map);
+    }).catch((error)=>{
+        callback(error instanceof Error ? error : Error(String(error)));
+    }) : callback(null, source, map);
+};

package/dist/rsc-route-transform-registration.d.ts

@@ -0,0 +1,12 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { RouteChunkCache, RouteChunkConfig } from './route-chunks.js';
+import type { Route } from './types.js';
+import type { ReactRouterPerformanceProfiler } from './performance.js';
+export declare const registerReactRouterRscRouteTransforms: ({ api, isBuild, performanceProfiler, routeByFilePath, routeChunkCache, routeChunkConfig, }: {
+    api: Parameters<RsbuildPlugin["setup"]>[0];
+    isBuild: boolean;
+    performanceProfiler: Pick<ReactRouterPerformanceProfiler, "record">;
+    routeByFilePath: Map<string, Route>;
+    routeChunkCache: RouteChunkCache;
+    routeChunkConfig: RouteChunkConfig;
+}) => void;

package/dist/rsc-route-transforms.d.ts

@@ -0,0 +1,21 @@
+import { generate } from './yuku.js';
+import { type RouteChunkCache, type RouteChunkConfig } from './route-chunks.js';
+import type { Route } from './types.js';
+type RscRouteTransformOptions = {
+    code: string;
+    resourcePath: string;
+    resourceQuery?: string;
+    isRootRoute: boolean;
+    routeId: string;
+    routeByFilePath?: ReadonlyMap<string, Route>;
+    routeChunkCache: RouteChunkCache;
+    routeChunkConfig: RouteChunkConfig;
+    isServerEnvironment: boolean;
+    isDev: boolean;
+};
+type RscRouteTransformResult = {
+    code: string;
+    map: null | ReturnType<typeof generate>['map'];
+};
+export declare const transformRscRouteModule: (options: RscRouteTransformOptions) => Promise<RscRouteTransformResult>;
+export {};

package/dist/rsc-support.d.ts

@@ -0,0 +1,23 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Config } from './react-router-config.js';
+import type { PluginOptions } from './types.js';
+type RscPluginOptions = Exclude<NonNullable<PluginOptions['rsc']>, boolean>;
+type RscUnsupportedConfig = Pick<Config, 'buildEnd' | 'future' | 'presets' | 'serverBundles' | 'subResourceIntegrity'>;
+export declare const assertReactRouterRscConfigSupport: ({ pluginName, userConfig, }: {
+    pluginName: string;
+    userConfig: RscUnsupportedConfig;
+}) => void;
+export declare const assertReactRouterRscSupport: ({ pluginName, resolvePackagePath, }: {
+    pluginName: string;
+    resolvePackagePath: (specifier: string) => string | undefined;
+}) => void;
+export declare const setupReactRouterRscPlugin: ({ api, entryRscPath, entrySsrPath, pluginName, rsc, }: {
+    api: Parameters<RsbuildPlugin["setup"]>[0];
+    entryRscPath: string;
+    entrySsrPath: string;
+    pluginName: string;
+    rsc: RscPluginOptions;
+}) => Promise<void>;
+export { createReactRouterRscDevServerSetup } from './rsc-dev-server.js';
+export { registerReactRouterRscRouteTransforms } from './rsc-route-transform-registration.js';
+export { createReactRouterRscResolveAliases, createReactRouterRscVirtualModules, } from './rsc-virtual-modules.js';

package/dist/rsc-virtual-modules.d.ts

@@ -0,0 +1,19 @@
+import type { Config } from './react-router-config.js';
+import type { Route } from './types.js';
+type RscVirtualModulesOptions = {
+    allowedActionOrigins: string[] | undefined;
+    appDirectory: string;
+    basename: string;
+    buildDirectory: string;
+    isBuild: boolean;
+    /** Resolved web `output.distPath.js` segment, e.g. `static/js`. */
+    jsDistPath: string;
+    outputClientPath: string;
+    publicPath: string;
+    routeDiscovery: Config['routeDiscovery'];
+    routes: Record<string, Route>;
+    ssr: boolean;
+};
+export declare const createReactRouterRscResolveAliases: (rootPath: string) => Record<string, string>;
+export declare const createReactRouterRscVirtualModules: ({ allowedActionOrigins, appDirectory, basename, buildDirectory, isBuild, jsDistPath, outputClientPath, publicPath, routeDiscovery, routes, ssr, }: RscVirtualModulesOptions) => Record<string, string>;
+export {};

package/dist/server-build-plan.d.ts

@@ -12,11 +12,12 @@ export declare const createReactRouterServerBuildPlan: ({ routesByServerBundleId
     serverBuildFile: string | undefined;
     defaultEntryName: string;
 }) => ReactRouterServerBuildPlan;
-export declare const createReactRouterNodeEntries: ({ hasServerApp, isBuild, serverAppPath, entryServerPath, defaultEntryName, serverBundleEntries, }: {
+export declare const createReactRouterNodeEntries: ({ hasServerApp, isBuild, serverAppPath, entryServerPath, serverBuildFile, defaultEntryName, serverBundleEntries, }: {
     hasServerApp: boolean;
     isBuild: boolean;
     serverAppPath: string;
     entryServerPath: string;
+    serverBuildFile: string | undefined;
     defaultEntryName: string;
     serverBundleEntries: readonly ReactRouterServerBundleEntry[];
 }) => Record<string, string>;

package/dist/server-build-resolution.d.ts

@@ -1,3 +1,2 @@
-import * as Effect from 'effect/Effect';
 import type { ServerBuild } from 'react-router';
-export declare function resolveServerBuildModuleEffect(buildModule: unknown, source: string): Effect.Effect<ServerBuild, Error, never>;
+export declare function resolveServerBuildModule(buildModule: unknown, source: string): Promise<ServerBuild>;

package/dist/server-utils.d.ts

@@ -1,4 +1,5 @@
 import type { ServerBuild } from 'react-router';
+import { resolveServerBuildModule } from './server-build-resolution.js';
 import type { Route } from './types.js';
 /**
  * Generates the server build template string.
@@ -13,6 +14,7 @@ interface ServerBuildOptions {
     basename: string;
     appDirectory: string;
     ssr: boolean;
+    isSpaMode: boolean;
     future?: unknown;
     allowedActionOrigins?: string[];
     prerender?: string[];
@@ -31,9 +33,6 @@ interface ServerBuildOptions {
  * @param options Build options
  * @returns The generated module content as a string
  */
-declare function generateServerBuild(routes: Record<string, Route>, options: ServerBuildOptions & {
-    federation?: boolean;
-}): string;
-export declare function resolveServerBuildModule(buildModule: unknown, source: string): Promise<ServerBuild>;
+export declare function generateServerBuild(routes: Record<string, Route>, options: ServerBuildOptions): string;
+export { resolveServerBuildModule };
 export declare function resolveReactRouterServerBuild(buildModule: unknown): Promise<ServerBuild>;
-export { generateServerBuild };

package/dist/ssr-asset-relocation.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Relocation of server-only static assets to the client build.
+ *
+ * In React Router framework mode a route's server-only code (a loader or a
+ * `.server` module) can import an asset — for example
+ * `import txtUrl from "./file.txt?url"` or a `.css?url` file. The imported URL
+ * is returned to the client (e.g. as loader data) and fetched from the client
+ * build directory at runtime, so the asset file must exist under
+ * `build/client` even though only the node/server compilation referenced it.
+ *
+ * Rspack emits these assets into the server output (`build/server/static/...`)
+ * and never into the client output. This module mirrors upstream React
+ * Router's Vite plugin, which internally enables `ssrEmitAssets` and then, in
+ * the SSR `writeBundle` hook, moves server-emitted static assets into the
+ * client assets directory and strips them from the server build
+ * (`react-router-dev/vite/plugin.ts`). Here the equivalent runs inside the
+ * node compilation's `processAssets` hook: static assets are written into the
+ * client output at the same public path and deleted from the server
+ * compilation so the server build never ships duplicate static files.
+ */
+/**
+ * The subset of an Rspack asset info that identifies static assets emitted by
+ * asset modules (`asset/resource`) and the CSS pipeline.
+ */
+export interface RelocatableAssetInfo {
+    /**
+     * Set by Rspack for assets produced from a source module (asset modules and
+     * extracted CSS). JavaScript chunks and generated files such as
+     * `package.json` do not carry a `sourceFilename`.
+     */
+    sourceFilename?: string;
+    /**
+     * Set for JavaScript chunk assets. Static assets never set this, so it is
+     * used to keep code-split JS in the server build.
+     */
+    javascriptModule?: boolean;
+}
+/**
+ * The minimal compilation surface needed to collect and relocate assets. Kept
+ * narrow so the logic can be unit-tested without a real Rspack compilation.
+ */
+export interface RelocatableAssetCompilation {
+    assets: Record<string, unknown>;
+    getAsset(name: string): {
+        name: string;
+        source: {
+            buffer(): Buffer;
+        };
+        info: RelocatableAssetInfo;
+    } | undefined | void;
+    deleteAsset(name: string): void;
+}
+export interface CollectedServerAsset {
+    /** The public path of the asset, relative to the compilation output root. */
+    name: string;
+    source: {
+        buffer(): Buffer;
+    };
+}
+/**
+ * Determine whether an emitted asset is a static asset that must live in the
+ * client build. Static assets (asset modules and CSS) carry a `sourceFilename`
+ * and are not JavaScript chunks. Code-split JavaScript is intentionally
+ * excluded so it remains in the server build.
+ */
+export declare const isRelocatableServerAsset: (info: RelocatableAssetInfo | undefined) => boolean;
+/**
+ * Collect the server-only static assets from a node compilation. Returns them
+ * in stable (sorted) order so callers and tests see deterministic output.
+ */
+export declare const collectRelocatableServerAssets: (compilation: RelocatableAssetCompilation) => CollectedServerAsset[];
+export interface RelocateServerAssetsResult {
+    /** Assets written into the client output because they were missing or stale. */
+    written: string[];
+    /**
+     * Assets that already existed in the client output. They are still removed
+     * from the server build but not rewritten.
+     */
+    skipped: string[];
+}
+export declare const relocateServerAssetsToClient: ({ compilation, outputClientPath, relocatedDestinations, existsSyncFn, mkdirFn, readFileFn, renameFn, rmFn, writeFileFn, }: {
+    compilation: RelocatableAssetCompilation;
+    outputClientPath: string;
+    /**
+     * Destination content digests already handled by a previous compilation
+     * (dev rebuilds, serverBundles). Stable dev filenames can carry changed
+     * bytes, so the cache is keyed by path and digest rather than path alone.
+     */
+    relocatedDestinations?: Map<string, string>;
+    existsSyncFn?: (path: string) => boolean;
+    mkdirFn?: (dir: string) => Promise<unknown>;
+    readFileFn?: (path: string) => Promise<Buffer>;
+    renameFn?: (oldPath: string, newPath: string) => Promise<void>;
+    rmFn?: (path: string, options: {
+        force: true;
+    }) => Promise<void>;
+    writeFileFn?: (path: string, data: Buffer) => Promise<void>;
+}) => Promise<RelocateServerAssetsResult>;

package/dist/templates/entry.rsc.client.d.ts

@@ -0,0 +1 @@
+import 'virtual/react-router/unstable_rsc/inject-hmr-runtime';

package/dist/templates/entry.rsc.client.js

@@ -0,0 +1,61 @@
+import "virtual/react-router/unstable_rsc/inject-hmr-runtime";
+import { hydrateRoot } from "react-dom/client";
+import { unstable_RSCHydratedRouter, unstable_createCallServer, unstable_getRSCStream } from "react-router/dom";
+import { createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "react-server-dom-rspack/client.browser";
+import * as __rspack_external_react from "react";
+let hydrationWindow = window, InitialRscDataLoadGuard = ({ active, children })=>(__rspack_external_react.useEffect(()=>{
+        let frame;
+        if (!active) return;
+        let clearGuardOnceDataLoadStarts = ()=>{
+            let router = hydrationWindow.__reactRouterDataRouter;
+            if (router && (router.state.initialized || 'idle' !== router.state.navigation.state)) {
+                hydrationWindow.__reactRouterHdrActive = !1;
+                return;
+            }
+            frame = requestAnimationFrame(clearGuardOnceDataLoadStarts);
+        };
+        return frame = requestAnimationFrame(clearGuardOnceDataLoadStarts), ()=>cancelAnimationFrame(frame);
+    }, [
+        active
+    ]), children);
+setServerCallback(unstable_createCallServer({
+    createFromReadableStream: createFromReadableStream,
+    createTemporaryReferenceSet: createTemporaryReferenceSet,
+    encodeReply: encodeReply
+}));
+let hydrate = ()=>{
+    createFromReadableStream(unstable_getRSCStream()).then((payload)=>{
+        (0, __rspack_external_react.startTransition)(async ()=>{
+            let formState = 'render' === payload.type ? await payload.formState : void 0, needsInitialDataLoadGuard = 'render' === payload.type && payload.matches.some((match)=>null != match.clientLoader && !match.hasLoader && null != match.hydrateFallbackElement);
+            needsInitialDataLoadGuard && (hydrationWindow.__reactRouterHdrActive = !0), hydrateRoot(document, __rspack_external_react.createElement(__rspack_external_react.StrictMode, null, __rspack_external_react.createElement(InitialRscDataLoadGuard, {
+                active: needsInitialDataLoadGuard
+            }, __rspack_external_react.createElement(unstable_RSCHydratedRouter, {
+                createFromReadableStream: createFromReadableStream,
+                payload
+            }))), {
+                formState
+            });
+        });
+    }, (error)=>{
+        setTimeout(()=>{
+            throw error;
+        });
+    });
+};
+'loading' === document.readyState ? document.addEventListener('DOMContentLoaded', hydrate, {
+    once: !0
+}) : hydrate();
+let hot = import.meta.webpackHot;
+hot?.on('rsc:update', (data)=>{
+    requestAnimationFrame(()=>{
+        let router = window.__reactRouterDataRouter;
+        if (data?.revalidate) return void router?.revalidate();
+        if (router?.navigate) {
+            let basename = router.basename || '/', pathname = window.location.pathname;
+            '/' !== basename && pathname.startsWith(basename) && '/' !== (pathname = pathname.slice(basename.length) || '/')[0] && (pathname = '/' + pathname), router.navigate(pathname + window.location.search + window.location.hash, {
+                replace: !0,
+                preventScrollReset: !0
+            });
+        }
+    });
+});

package/dist/templates/entry.rsc.d.ts

@@ -0,0 +1,9 @@
+import { RouterContextProvider } from 'react-router';
+import unstable_reactRouterServeConfig from 'virtual/react-router/unstable_rsc/react-router-serve-config';
+export { unstable_reactRouterServeConfig };
+type RscRequestHandler = {
+    fetch(request: Request, requestContext?: RouterContextProvider): Promise<Response>;
+};
+export declare function fetchServer(request: Request, requestContext?: RouterContextProvider): Promise<Response>;
+declare const handler: RscRequestHandler;
+export default handler;

package/dist/templates/entry.rsc.js

@@ -0,0 +1,38 @@
+import { createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, loadServerAction, renderToReadableStream } from "react-server-dom-rspack/server.node";
+import { RouterContextProvider, unstable_matchRSCServerRequest } from "react-router";
+import routes from "virtual/react-router/unstable_rsc/routes";
+import route_discovery from "virtual/react-router/unstable_rsc/route-discovery";
+import basename from "virtual/react-router/unstable_rsc/basename";
+import allowed_action_origins from "virtual/react-router/unstable_rsc/allowed-action-origins";
+import client_version from "virtual/react-router/unstable_rsc/client-version";
+import server_manifest from "virtual/react-router/unstable_rsc/server-manifest";
+import bootstrap_scripts from "virtual/react-router/unstable_rsc/bootstrap-scripts";
+import { generateHTML } from "./entry.rsc.ssr.js";
+function fetchServer(request, requestContext) {
+    return unstable_matchRSCServerRequest({
+        allowedActionOrigins: allowed_action_origins,
+        basename: basename,
+        clientVersion: client_version,
+        createTemporaryReferenceSet: createTemporaryReferenceSet,
+        decodeAction: (body)=>decodeAction(body, server_manifest()),
+        decodeFormState: async (actionResult, body)=>await decodeFormState(actionResult, body, server_manifest()) ?? void 0,
+        decodeReply: decodeReply,
+        loadServerAction: (id)=>Promise.resolve(loadServerAction(id)),
+        request,
+        requestContext,
+        routes: routes,
+        routeDiscovery: route_discovery,
+        generateResponse: (match, options)=>new Response(renderToReadableStream(match.payload, options), {
+                status: match.statusCode,
+                headers: match.headers
+            })
+    });
+}
+import.meta.webpackHot?.accept();
+export { default as unstable_reactRouterServeConfig } from "virtual/react-router/unstable_rsc/react-router-serve-config";
+export default {
+    fetch: async (request, requestContext)=>(!requestContext || requestContext instanceof RouterContextProvider || (requestContext = void 0), generateHTML(request, await fetchServer(request, requestContext), {
+            bootstrapScripts: bootstrap_scripts
+        }))
+};
+export { fetchServer };

package/dist/templates/entry.rsc.ssr.d.ts

@@ -0,0 +1,4 @@
+export declare function generateHTML(request: Request, serverResponse: Response, options?: {
+    bootstrapScripts?: string[];
+    bootstrapModules?: string[];
+}): Promise<Response>;

package/dist/templates/entry.rsc.ssr.js

@@ -0,0 +1,24 @@
+import { renderToReadableStream } from "react-dom/server";
+import { unstable_RSCStaticRouter, unstable_routeRSCServerRequest } from "react-router";
+import { createFromReadableStream } from "react-server-dom-rspack/client.node";
+import * as __rspack_external_react from "react";
+async function generateHTML(request, serverResponse, options = {}) {
+    return unstable_routeRSCServerRequest({
+        request,
+        serverResponse,
+        createFromReadableStream: createFromReadableStream,
+        async renderHTML (getPayload, renderOptions) {
+            let payloadPromise = getPayload();
+            return payloadPromise.formState ??= payloadPromise.then((payload)=>'render' === payload.type ? payload.formState : void 0), renderToReadableStream(__rspack_external_react.createElement(unstable_RSCStaticRouter, {
+                getPayload: getPayload
+            }), {
+                ...renderOptions,
+                bootstrapModules: options.bootstrapModules,
+                bootstrapScripts: options.bootstrapScripts,
+                formState: await payloadPromise.formState,
+                signal: request.signal
+            });
+        }
+    });
+}
+export { generateHTML };

package/dist/typegen.d.ts

@@ -1,4 +1,5 @@
 import type { RsbuildPluginAPI } from '@rsbuild/core';
+import { type PluginEffectRuntime } from './effect-runtime.js';
 type Execa = typeof import('execa').execa;
 type LoadExeca = () => Promise<Execa>;
 export type ReactRouterTypegenRunner = {
@@ -7,9 +8,10 @@ export type ReactRouterTypegenRunner = {
     runBuild(): Promise<void>;
 };
 export declare const createReactRouterTypegenRunner: (loadExeca?: LoadExeca, appDirectory?: string) => ReactRouterTypegenRunner;
-export declare const registerReactRouterTypegen: (api: RsbuildPluginAPI, { runner, devWatchDelayMs, appDirectory, }?: {
+export declare const registerReactRouterTypegen: (api: RsbuildPluginAPI, { runtime, runner, devWatchDelayMs, appDirectory, }: {
+    runtime: PluginEffectRuntime;
     runner?: ReactRouterTypegenRunner;
     devWatchDelayMs?: number;
     appDirectory?: string;
-}) => void;
+}) => Promise<void>;
 export {};

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { RsbuildConfig } from '@rsbuild/core';
+import type { RsbuildConfig, Rspack } from '@rsbuild/core';
 export type Route = {
     id: string;
     parentId?: string;
@@ -25,6 +25,20 @@ export type PluginOptions = {
      * Federation mode configuration
      */
     federation?: boolean;
+    /**
+     * Enable experimental React Router RSC framework mode.
+     * This composes `rsbuild-plugin-rsc` with React Router's Rsbuild
+     * environments. Environment names are managed by this plugin.
+     * Requires `react-router >=7.18.0 || >=8.0.0`, `rsbuild-plugin-rsc`,
+     * and `react-server-dom-rspack`.
+     * @default false
+     */
+    rsc?: boolean | {
+        layers?: {
+            rsc?: Rspack.RuleSetCondition;
+            ssr?: Rspack.RuleSetCondition;
+        };
+    };
     /**
      * Rsbuild dev-only lazy compilation behavior.
      *
@@ -63,6 +77,21 @@ export type PluginOptions = {
      */
     onRouteTopologyChange?: () => void | Promise<void>;
 };
+export type ReactRouterRSCPluginOptions = Omit<PluginOptions, 'rsc'> & {
+    /**
+     * Optional overrides forwarded to `rsbuild-plugin-rsc`.
+     * Environment names are managed by this plugin.
+     */
+    rsc?: Exclude<NonNullable<PluginOptions['rsc']>, boolean>;
+};
+export type PrerenderPathsConfig = boolean | string[] | ((args: {
+    getStaticPaths: () => string[];
+}) => boolean | string[] | Promise<boolean | string[]>);
+export type PrerenderConfigObject = {
+    paths: PrerenderPathsConfig;
+    concurrency?: number;
+    unstable_concurrency?: number;
+};
 export type RouteManifestItem = Omit<Route, 'file' | 'children'> & {
     module: string;
     clientActionModule?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsbuild-plugin-react-router",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "React Router plugin for Rsbuild",
   "repository": {
     "type": "git",
@@ -37,6 +37,18 @@
       "types": "./dist/templates/entry.server.d.ts",
       "import": "./dist/templates/entry.server.js",
       "require": "./dist/templates/entry.server.cjs"
+    },
+    "./templates/entry.rsc": {
+      "types": "./dist/templates/entry.rsc.d.ts",
+      "import": "./dist/templates/entry.rsc.js"
+    },
+    "./templates/entry.rsc.client": {
+      "types": "./dist/templates/entry.rsc.client.d.ts",
+      "import": "./dist/templates/entry.rsc.client.js"
+    },
+    "./templates/entry.rsc.ssr": {
+      "types": "./dist/templates/entry.rsc.ssr.d.ts",
+      "import": "./dist/templates/entry.rsc.ssr.js"
     }
   },
   "main": "./dist/index.cjs",
@@ -50,8 +62,8 @@
   },
   "dependencies": {
     "@jridgewell/remapping": "^2.3.5",
-    "@react-router/node": "^7.13.0",
-    "@remix-run/node-fetch-server": "^0.13.0",
+    "@react-router/node": "^7.13.0 || ^8.0.0",
+    "@remix-run/node-fetch-server": "^0.13.3",
     "@rspack/plugin-react-refresh": "^2.0.2",
     "execa": "^9.6.1",
     "fs-extra": "11.3.3",
@@ -68,40 +80,76 @@
     "@changesets/cli": "^2.29.8",
     "@codspeed/vitest-plugin": "^5.7.1",
     "@jridgewell/trace-mapping": "^0.3.31",
+    "@playwright/test": "^1.61.1",
     "@react-router/dev": "^8.0.1",
-    "@rsbuild/core": "2.1.5",
+    "@react-router/express": "^8.0.1",
+    "@react-router/fs-routes": "^8.0.1",
+    "@react-router/remix-routes-option-adapter": "^8.0.1",
+    "@react-router/serve": "^8.0.1",
+    "@rsbuild/core": "2.2.0",
+    "@rsbuild/plugin-less": "1.6.4",
+    "@rsbuild/plugin-mdx": "^1.1.3",
     "@rsbuild/plugin-react": "2.1.0",
+    "@rsbuild/plugin-sass": "1.5.3",
+    "@rsbuild/plugin-svgr": "2.0.4",
+    "@rsbuild/plugin-tailwindcss": "2.0.3",
     "@rslib/core": "^0.23.2",
-    "@rspack/core": "2.1.3",
-    "@rstest/core": "^0.11.0",
-    "@rstest/coverage-istanbul": "^0.11.0",
+    "@rspack/core": "2.2.0",
+    "@rstest/core": "^0.11.4",
+    "@rstest/coverage-istanbul": "^0.11.4",
     "@swc/helpers": "^0.5.23",
     "@types/fs-extra": "11.0.4",
     "@types/jsesc": "^3.0.3",
     "@types/node": "^25.0.10",
     "@types/react": "^19.2.10",
     "@types/react-dom": "^19.2.3",
-    "effect": "^3.21.4",
+    "@types/webpack-env": "^1.18.8",
+    "@vanilla-extract/css": "^1.20.1",
+    "cheerio": "^1.2.0",
+    "cross-spawn": "^7.0.6",
+    "dedent": "^1.7.2",
+    "effect": "^3.22.0",
     "es-module-lexer": "1.7.0",
+    "express": "^4.22.2",
+    "fast-glob": "^3.3.3",
+    "get-port": "7.1.0",
     "kill-port": "^2.0.1",
     "pkg-pr-new": "^0.0.75",
     "playwright": "^1.61.1",
     "prettier": "3.8.1",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "react-router": "^7.13.0",
-    "react-router-dom": "^7.13.0",
+    "react-router": "^7.18.0",
+    "react-router-dom": "^7.18.0",
+    "react-server-dom-rspack": "0.1.0",
+    "rsbuild-plugin-rsc": "^0.1.1",
+    "semver": "^7.8.5",
+    "shelljs": "^0.10.0",
+    "strip-ansi": "^7.2.0",
+    "strip-indent": "^4.1.1",
+    "tailwindcss": "4.3.2",
+    "type-fest": "^5.7.0",
     "typescript": "^5.9.3",
     "vitest": "^4.1.10",
+    "wait-on": "^9.0.10",
     "@rsbuild/config": "1.0.1"
   },
   "peerDependencies": {
     "@react-router/dev": "^7.13.0 || ^8.0.0",
-    "@rsbuild/core": "^2.0.0"
+    "@rsbuild/core": "^2.2.0",
+    "react-router": "^7.13.0 || ^8.0.0",
+    "react-server-dom-rspack": "0.1.0",
+    "rsbuild-plugin-rsc": "^0.1.1"
   },
   "peerDependenciesMeta": {
     "@react-router/dev": {
       "optional": true
+    },
+    "react-server-dom-rspack": {
+      "optional": true
+    },
+    "rsbuild-plugin-rsc": {
+      "optional": true
     }
   },
   "publishConfig": {
@@ -113,15 +161,22 @@
     "build": "rslib build",
     "bench": "pnpm build && node benchmarks/run.mts",
     "bench:smoke": "pnpm build && node benchmarks/run.mts --iterations 1 --warmup 0",
-    "bench:codspeed": "pnpm build && vitest bench --run --config vitest.benchmark.config.mts",
-    "e2e": "pnpm build && pnpm test:package-interop && pnpm --filter './examples/{default-template,spa-mode,prerender,custom-node-server,cloudflare,client-only}' test:e2e",
+    "bench:codspeed": "pnpm build && vitest bench --run --config vitest.benchmark.config.mts -t build-256-ssr",
+    "e2e": "pnpm build && pnpm e2e:no-build",
+    "e2e:no-build": "pnpm test:package-interop && pnpm --filter './examples/{default-template,spa-mode,prerender,custom-node-server,cloudflare,client-only,react-router-8,rsc-mode}' test:e2e",
     "dev": "rslib build --watch",
-    "test": "rstest run",
+    "test": "pnpm typecheck && rstest run",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.tests.json && pnpm --filter integration typecheck && pnpm --filter integration-rsbuild-template typecheck && pnpm --filter integration-rsc-framework typecheck && pnpm --filter integration-rsc-preview typecheck",
     "test:watch": "rstest watch",
     "test:coverage": "rstest run --coverage",
     "test:core": "rstest run -c ./rstest.config.ts",
     "test:core:watch": "rstest watch -c ./rstest.config.ts",
     "test:package-interop": "node scripts/test-package-interop.mts",
+    "test:react-router-framework": "pnpm build && playwright test --config tests/react-router-framework/integration/playwright.config.ts",
+    "test:react-router-framework:failfast": "pnpm build && pnpm test:react-router-framework:failfast:no-build",
+    "test:react-router-framework:failfast:no-build": "RR_FRAMEWORK_MAX_WORKERS=2 playwright test --config tests/react-router-framework/integration/playwright.config.ts tests/react-router-framework/integration/hmr-hdr-test.ts --workers=2 --max-failures=1 --retries=0 --reporter=line && RR_FRAMEWORK_MAX_WORKERS=2 playwright test --config tests/react-router-framework/integration/playwright.config.ts tests/react-router-framework/integration/hmr-hdr-rsc-test.ts --workers=2 --max-failures=1 --retries=0 --reporter=line && RR_FRAMEWORK_MAX_WORKERS=4 playwright test --config tests/react-router-framework/integration/playwright.config.ts --grep-invert 'HMR & HDR' --workers=4 --max-failures=1 --retries=0 --reporter=line",
+    "test:react-router-framework:smoke": "pnpm build && playwright test --config tests/react-router-framework/integration/playwright.config.ts use-route-test.ts loader-test.ts",
+    "check:react-router-framework-upstream": "node scripts/check-react-router-framework-upstream.mjs",
     "format": "prettier --write \"src/**/*.{js,jsx,ts,tsx}\"",
     "format:check": "prettier --check \"src/**/*.{js,jsx,ts,tsx}\"",
     "changeset": "changeset",