rsbuild-plugin-react-router 0.4.1 → 0.6.0

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

@@ -0,0 +1,15 @@
+export type RscRouteComponentExport = {
+    readonly routeProperty: 'Component' | 'Layout' | 'ErrorBoundary' | 'HydrateFallback';
+    readonly clientExport: 'default' | 'Layout' | 'ErrorBoundary' | 'HydrateFallback';
+    readonly serverExport: 'ServerComponent' | 'ServerLayout' | 'ServerErrorBoundary' | 'ServerHydrateFallback';
+};
+export type RscClientComponentExport = RscRouteComponentExport['clientExport'];
+export type RscServerComponentExport = RscRouteComponentExport['serverExport'];
+export declare const RSC_ROUTE_COMPONENT_EXPORTS: readonly RscRouteComponentExport[];
+export declare const RSC_MUTUALLY_EXCLUSIVE_ROUTE_EXPORTS: readonly (readonly [
+    RscClientComponentExport,
+    RscServerComponentExport
+])[];
+export declare const RSC_CLIENT_COMPONENT_EXPORTS: readonly RscClientComponentExport[];
+export declare const RSC_SERVER_COMPONENT_EXPORTS: readonly RscServerComponentExport[];
+export declare const describeRscRouteExportConflict: (clientExport: string, serverExport: string) => string;

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

@@ -0,0 +1,43 @@
+"use strict";
+const __rslib_import_meta_url__ = "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+var __webpack_require__ = {};
+__webpack_require__.d = (exports1, getters, values)=>{
+    var define = (defs, kind)=>{
+        for(var key in defs)__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key) && Object.defineProperty(exports1, key, {
+            enumerable: !0,
+            [kind]: defs[key]
+        });
+    };
+    define(getters, "get"), define(values, "value");
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports1)=>{
+    "u" > typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports1, '__esModule', {
+        value: !0
+    });
+};
+var __webpack_exports__ = {};
+function rscRouteTransformLoader(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);
+}
+for(var __rspack_i in __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
+    default: ()=>rscRouteTransformLoader
+}), exports.default = __webpack_exports__.default, __webpack_exports__)-1 === [
+    "default"
+].indexOf(__rspack_i) && (exports[__rspack_i] = __webpack_exports__[__rspack_i]);
+Object.defineProperty(exports, '__esModule', {
+    value: !0
+});

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

@@ -0,0 +1,30 @@
+type LoaderCallback = (error: Error | null, code?: string | Buffer, map?: unknown) => void;
+type TransformArgs = {
+    code: string;
+    resource: string;
+    resourcePath: string;
+    resourceQuery?: string;
+    environment: {
+        name: string;
+    };
+};
+type TransformResult = {
+    code: string;
+    map?: unknown;
+};
+type ReactRouterRscTransform = (args: TransformArgs) => Promise<TransformResult>;
+type LoaderCompiler = {
+    __reactRouterRscRouteTransform?: ReactRouterRscTransform;
+};
+type RscRouteTransformLoaderContext = {
+    _compiler?: LoaderCompiler;
+    async(): LoaderCallback;
+    getOptions(): {
+        environmentName: string;
+    };
+    resource: string;
+    resourcePath: string;
+    resourceQuery?: string;
+};
+export default function rscRouteTransformLoader(this: RscRouteTransformLoaderContext, source: string | Buffer, map: unknown): void;
+export {};

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.
      *
@@ -49,11 +63,10 @@ export type PluginOptions = {
      */
     logPerformance?: boolean;
     /**
-     * Run route transforms in a worker-thread pool.
-     * Pass `true` to force the default worker count, a positive integer to set
-     * the worker count, or `false` to disable.
-     * @default Automatically enabled for 256+ resolved routes. The automatic
-     * pool uses available CPU cores minus 2.
+     * Run route module transforms with Rspack's parallel loader workers.
+     * Pass `true` to use Rspack's default worker count, a positive integer to set
+     * the maximum worker count, or `false` to disable.
+     * @default false
      */
     parallelRouteTransform?: boolean | number;
     /**
@@ -64,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;