rsbuild-plugin-react-router 0.4.1 → 0.6.0

package/dist/lazy-compilation-prewarm.d.ts

@@ -1,15 +1,17 @@
 import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import type { ReactRouterManifestForDev } from './manifest.js';
-type LazyCompilationPrewarmConfig = {
+import { type PluginEffectRuntime } from './effect-runtime.js';
+export type LazyCompilationPrewarmConfig = {
     entry: boolean;
     routeLimit: number;
     delayMs: number;
 };
-type LazyCompilationPrewarmController = {
+export type LazyCompilationPrewarmController = {
     setServerOrigin(origin: string): void;
     setManifest(manifest: ReactRouterManifestForDev | null): void;
     schedule(): void;
-    cancelEffect(): Effect.Effect<void, Error, never>;
+    cancelEffect(): Effect.Effect<void>;
 };
 export type RspackLazyCompilationTriggerClient = {
     extractModuleKeys(source: string): string[];
@@ -18,8 +20,9 @@ export type RspackLazyCompilationTriggerClient = {
 export declare const normalizeLazyCompilationPrewarmOptions: (options: boolean | undefined) => LazyCompilationPrewarmConfig | null;
 export declare const collectLazyCompilationPrewarmAssets: (manifest: ReactRouterManifestForDev, config: LazyCompilationPrewarmConfig) => string[];
 export declare const createRspackLazyCompilationTriggerClient: (triggerPrefix?: string) => RspackLazyCompilationTriggerClient;
-export declare const createLazyCompilationPrewarmController: ({ config, onError, }: {
+export declare const createLazyCompilationPrewarmController: ({ runtime, config, onError, }: {
+    runtime: PluginEffectRuntime;
     config: LazyCompilationPrewarmConfig;
     onError: (error: Error) => void;
 }) => LazyCompilationPrewarmController;
-export {};
+export declare const acquireLazyCompilationPrewarm: (options: Parameters<typeof createLazyCompilationPrewarmController>[0]) => Effect.Effect<LazyCompilationPrewarmController, never, Scope.Scope>;

package/dist/manifest.d.ts

@@ -1,5 +1,6 @@
 import type { Route, PluginOptions, RouteManifestItem } from './types.js';
 import { type RouteChunkCache } from './route-chunks.js';
+import { type RouteModuleAnalysis } from './export-utils.js';
 /**
  * Structural equivalent of `RouteConfigEntry` from `@react-router/dev/routes`,
  * inlined so the public declaration files do not reference a devDependency
@@ -15,12 +16,20 @@ export interface RouteConfigEntry {
 }
 export declare function configRoutesToRouteManifest(appDirectory: string, routes: RouteConfigEntry[], rootId?: string): Record<string, Route>;
 export declare function configRoutesToRouteManifestEntries(appDirectory: string, routes: RouteConfigEntry[], rootId?: string): Array<[string, Route]>;
-type RouteChunkManifestOptions = {
+export type RouteChunkManifestOptions = {
     splitRouteModules?: boolean | 'enforce';
     rootRouteFile?: string;
     isBuild?: boolean;
     cache?: RouteChunkCache;
 };
+export type RouteModuleAnalysisProvider = (routeFilePath: string, route: Route) => Promise<RouteModuleAnalysis | undefined>;
+export type ReactRouterManifestOptions = RouteChunkManifestOptions & {
+    routeModuleAnalysis?: RouteModuleAnalysisProvider;
+};
+export declare const createReactRouterManifestOptions: ({ routeChunks, routeModuleAnalysis, }: {
+    routeChunks?: RouteChunkManifestOptions;
+    routeModuleAnalysis?: RouteModuleAnalysisProvider;
+}) => ReactRouterManifestOptions | undefined;
 export type ReactRouterManifestForDev = {
     version: string;
     url: string;
@@ -45,8 +54,11 @@ type ReactRouterManifestStatsChunk = {
 type ReactRouterManifestStatsEntrypoint = {
     getFiles?: () => Iterable<string>;
 };
-type ReactRouterManifestStatsLookup<T> = Iterable<[string, T]> & {
-    get?: (name: string) => T | undefined;
+type ReactRouterManifestStatsLookup<T> = Iterable<[
+    string,
+    T | null | undefined
+]> & {
+    get?: (name: string) => T | null | undefined;
 };
 type ReactRouterManifestStatsCompilation = {
     namedChunks: ReactRouterManifestStatsLookup<ReactRouterManifestStatsChunk>;
@@ -64,6 +76,6 @@ export declare const getReactRouterManifestPath: ({ version, isBuild, entryModul
     entryModulePath?: string;
 }) => string;
 export declare const getReactRouterManifestChunkNames: (routes: Record<string, Route>, splitRouteModules?: boolean | "enforce") => Set<string>;
-export declare function generateReactRouterManifestForDev(routes: Record<string, Route>, options: PluginOptions, clientStats: ReactRouterManifestStats | undefined, context: string, assetPrefix?: string, routeChunkOptions?: RouteChunkManifestOptions): Promise<ReactRouterManifestGenerationResult>;
+export declare function generateReactRouterManifestForDev(routes: Record<string, Route>, _options: PluginOptions, clientStats: ReactRouterManifestStats | undefined, context: string, assetPrefix?: string, manifestOptions?: ReactRouterManifestOptions): Promise<ReactRouterManifestGenerationResult>;
 export declare function getReactRouterManifestForDev(...args: Parameters<typeof generateReactRouterManifestForDev>): Promise<ReactRouterManifestForDev>;
 export {};

package/dist/mode-plan.d.ts

@@ -0,0 +1,82 @@
+import type { RsbuildConfig, RsbuildEntryDescription, RsbuildPluginAPI, Rspack } from '@rsbuild/core';
+import type { RouteConfigEntry } from '@react-router/dev/routes';
+import type { Config, ResolvedReactRouterConfig } from './react-router-config.js';
+import type { RouteChunkCache, RouteChunkConfig } from './route-chunks.js';
+import type { DevHmrPlanOptions } from './dev-hmr.js';
+import type { Route } from './types.js';
+import { type ClassicBuildArtifacts } from './classic-mode.js';
+type CommonModePlan = {
+    routeChunkConfig: RouteChunkConfig;
+    manifestChunkNames: Set<string>;
+    webEntries: Record<string, string | RsbuildEntryDescription>;
+    nodeEntries: Record<string, string | RsbuildEntryDescription>;
+    createVirtualModules(publicPath: string, jsDistPath: string): Record<string, string>;
+    createResolveConfig(rootPath: string): Rspack.Configuration['resolve'];
+    server: RsbuildConfig['server'] | undefined;
+    webExternalsType: 'module' | undefined;
+    webOutput: NonNullable<Rspack.Configuration['output']>;
+    webOptimization: NonNullable<Rspack.Configuration['optimization']>;
+    nodeExternals: string[] | undefined;
+    nodeDependencies: {
+        dependencies?: string[];
+    };
+};
+export type ClassicModePlan = CommonModePlan & {
+    kind: 'classic';
+    artifacts: ClassicBuildArtifacts;
+    routeChunkOptions: {
+        splitRouteModules: Config['splitRouteModules'];
+        rootRouteFile: string;
+        isBuild: boolean;
+        cache: RouteChunkCache;
+    };
+};
+export type RscModePlan = CommonModePlan & {
+    kind: 'rsc';
+    prerenderPaths: string[];
+};
+export type ReactRouterModePlan = ClassicModePlan | RscModePlan;
+type ModePlanContext = {
+    allowedActionOriginsForBuild: string[] | undefined;
+    api: RsbuildPluginAPI;
+    appDirectory: string;
+    basename: string;
+    customServer: boolean;
+    splitRouteModules: Config['splitRouteModules'];
+    isBuild: boolean;
+    isSpaMode: boolean;
+    prerenderConfig: Config['prerender'];
+    routeConfig: RouteConfigEntry[];
+    routeDiscovery: Config['routeDiscovery'];
+    routes: Record<string, Route>;
+    rootRouteFile: string;
+    ssr: boolean;
+};
+type CreateClassicModePlanOptions = ModePlanContext & {
+    assetsBuildDirectory: string;
+    devHmr?: DevHmrPlanOptions;
+    defaultEntryName: string;
+    entryServerPath: string;
+    finalEntryClientPath: string;
+    future: Config['future'];
+    hasServerApp: boolean;
+    reactRouterConfig: ResolvedReactRouterConfig;
+    routeChunkCache: RouteChunkCache;
+    serverAppPath: string;
+    shouldDependOnWebCompiler: boolean;
+};
+type CreateRscModePlanOptions = ModePlanContext & {
+    buildDirectory: string;
+    finalEntryRscClientPath: string;
+    finalEntryRscPath: string;
+    outputClientPath: string;
+    pluginName: string;
+    serverBuildFile: string | undefined;
+};
+type CreateReactRouterModePlanOptions = ({
+    isRscMode: true;
+} & CreateRscModePlanOptions) | ({
+    isRscMode: false;
+} & CreateClassicModePlanOptions);
+export declare const createReactRouterModePlan: (options: CreateReactRouterModePlanOptions) => Promise<ReactRouterModePlan>;
+export {};

package/dist/modify-browser-manifest.d.ts

@@ -1,6 +1,6 @@
 import type { Route, PluginOptions } from './types.js';
 import type { RsbuildPluginAPI, Rspack } from '@rsbuild/core';
-import { createReactRouterManifestStats, generateReactRouterManifestForDev, getReactRouterManifestForDev } from './manifest.js';
+import { createReactRouterManifestStats, type ReactRouterManifestForDev as ReactRouterManifest, type RouteChunkManifestOptions, type RouteManifestModuleExports, type RouteModuleAnalysisProvider } from './manifest.js';
 type StatsAssetWithIntegrity = {
     name?: string;
     integrity?: unknown;
@@ -10,6 +10,9 @@ type StatsWithIntegrity = {
 };
 type CompilationAssetWithIntegrity = {
     name: string;
+    source?: {
+        source(): string | Buffer;
+    };
     info?: {
         integrity?: unknown;
     };
@@ -18,12 +21,13 @@ type CompilationWithIntegrityAssets = {
     getAssets?: () => readonly CompilationAssetWithIntegrity[];
 } | Pick<Rspack.Compilation, 'getAssets'>;
 type ModifyBrowserManifestOptions = {
+    subResourceIntegrity?: boolean;
     future?: {
         unstable_subResourceIntegrity?: boolean;
     };
-    subResourceIntegrity?: boolean;
     manifestChunkNames?: ReadonlySet<string>;
-    onManifest?: (manifest: Awaited<ReturnType<typeof getReactRouterManifestForDev>>, sri: Record<string, string> | true | undefined, moduleExportsByRouteId: Awaited<ReturnType<typeof generateReactRouterManifestForDev>>['moduleExportsByRouteId'], context: {
+    routeModuleAnalysis?: RouteModuleAnalysisProvider;
+    onManifest?: (manifest: ReactRouterManifest, sri: Record<string, string> | true | undefined, moduleExportsByRouteId: RouteManifestModuleExports, context: {
         compilation: Rspack.Compilation;
         manifestStats: ReturnType<typeof createReactRouterManifestStats>;
     }) => void;
@@ -31,5 +35,5 @@ type ModifyBrowserManifestOptions = {
 type ProcessAssetsApi = Pick<RsbuildPluginAPI, 'processAssets'>;
 type AssetPrefixInput = string | (() => string);
 export declare const collectSubresourceIntegrity: (stats: StatsWithIntegrity | undefined, compilation: CompilationWithIntegrityAssets | undefined, assetPrefix?: string) => Record<string, string> | undefined;
-export declare function registerModifyBrowserManifestAssets(api: ProcessAssetsApi, routes: Record<string, Route>, pluginOptions: PluginOptions, appDirectory: string, assetPrefix?: AssetPrefixInput, routeChunkOptions?: Parameters<typeof getReactRouterManifestForDev>[5], options?: ModifyBrowserManifestOptions): void;
+export declare function registerModifyBrowserManifestAssets(api: ProcessAssetsApi, routes: Record<string, Route>, pluginOptions: PluginOptions, appDirectory: string, assetPrefix?: AssetPrefixInput, routeChunkOptions?: RouteChunkManifestOptions, options?: ModifyBrowserManifestOptions): void;
 export {};

package/dist/performance.d.ts

@@ -12,12 +12,15 @@ export declare const roundMs: (value: number) => number;
 export type ReactRouterPerformanceReport = {
     environment: string;
     compilerLifecycleMs?: number;
+    partial?: boolean;
+    workerId?: string;
     operations: Record<string, OperationTiming>;
 };
+export declare const formatReactRouterPerformanceReport: (report: ReactRouterPerformanceReport) => string;
 export type ReactRouterPerformanceProfiler = {
     record<T>(environment: string | undefined, operation: string, resource: string, callback: () => Promise<T>): Promise<T>;
     recordSync<T>(environment: string | undefined, operation: string, resource: string, callback: () => T): T;
-    flush(environment: string | undefined, details?: Pick<ReactRouterPerformanceReport, 'compilerLifecycleMs'>): void;
+    flush(environment: string | undefined, details?: Pick<ReactRouterPerformanceReport, 'compilerLifecycleMs' | 'partial' | 'workerId'>): void;
 };
 export declare const createReactRouterPerformanceProfiler: ({ enabled, log, }: {
     enabled: boolean;

package/dist/plugin-utils.d.ts

@@ -1,6 +1,32 @@
+export declare const resolveAppPackagePath: (specifier: string) => string | undefined;
+export declare const parseVersionMajorMinor: (version: string | undefined) => {
+    major: number;
+    minor: number;
+} | undefined;
+export declare const getPackageVersion: (packageName: string, resolvePackagePath?: (specifier: string) => string | undefined) => string | undefined;
+export declare const escapeHtml: (value: string) => string;
 export declare function combineURLs(baseURL: string, relativeURL: string): string;
 export declare function normalizeAssetPrefix(assetPrefix?: string): string;
-export declare function stripFileExtension(file: string): string;
+/**
+ * Resolve the asset prefix Rsbuild applies to emitted asset URLs for the given
+ * mode. In development the effective prefix is `dev.assetPrefix` (which Rsbuild
+ * defaults from `server.base`, falling back to `output.assetPrefix`); in a
+ * production build it is `output.assetPrefix`. Both fields are already resolved
+ * on the normalized config, so this mirrors Rsbuild's own precedence rather than
+ * re-deriving it from `server.base`.
+ *
+ * `dev.assetPrefix` may be a boolean on the raw config (`false` disables it);
+ * boolean/`'auto'`/empty values normalize to the root prefix `'/'`.
+ */
+export declare function resolveEffectiveAssetPrefix(config: {
+    dev?: {
+        assetPrefix?: unknown;
+    };
+    output?: {
+        assetPrefix?: unknown;
+    };
+    isBuild: boolean;
+}): string;
 export declare function createRouteId(file: string): string;
 export declare function findEntryFile(basePath: string): string;
 export declare function generateWithProps(): string;

package/dist/prerender-build.d.ts

@@ -1,10 +1,9 @@
 import * as Effect from 'effect/Effect';
 import type { RsbuildPluginAPI } from '@rsbuild/core';
 import { getBuildManifest } from './build-manifest.js';
-import { getReactRouterManifestForDev, type ReactRouterManifestStats, type RouteManifestModuleExports } from './manifest.js';
+import { type ReactRouterManifestForDev as ReactRouterManifest, type ReactRouterManifestStats, type RouteChunkManifestOptions, type RouteModuleAnalysisProvider, type RouteManifestModuleExports } from './manifest.js';
 import type { Config, ResolvedReactRouterConfig } from './react-router-config.js';
 import type { PluginOptions, Route } from './types.js';
-type ReactRouterManifest = Awaited<ReturnType<typeof getReactRouterManifestForDev>>;
 type PrerenderBuildApi = Pick<RsbuildPluginAPI, 'logger' | 'getNormalizedConfig'>;
 type RunReactRouterPrerenderBuildOptions = {
     api: PrerenderBuildApi;
@@ -24,13 +23,14 @@ type RunReactRouterPrerenderBuildOptions = {
     pluginOptions: PluginOptions;
     appDirectory: string;
     assetPrefix: string;
-    routeChunkOptions: Parameters<typeof getReactRouterManifestForDev>[5];
+    routeChunkOptions: RouteChunkManifestOptions | undefined;
+    routeModuleAnalysis?: RouteModuleAnalysisProvider;
     buildManifest: Awaited<ReturnType<typeof getBuildManifest>>;
-    resolvedConfigWithRoutes: ResolvedReactRouterConfig;
+    buildEndReactRouterConfig: ResolvedReactRouterConfig;
     buildEnd: Config['buildEnd'];
 };
 export declare const createBuildRequestEffect: <T>(input: string | URL, init: RequestInit | undefined, handle: (request: Request) => Promise<T>) => Effect.Effect<T, Error, never>;
 export declare const withBuildRequest: <T>(input: string | URL, init: RequestInit | undefined, handle: (request: Request) => Promise<T>) => Promise<T>;
-export declare const createBoundedPrerenderTasksEffect: (prerenderPaths: string[], concurrency: number, renderPath: (path: string) => Effect.Effect<void, Error, never>) => Effect.Effect<void, Error, never>;
+export declare const createBoundedPrerenderTasksEffect: <T>(prerenderPaths: T[], concurrency: number, renderPath: (path: T) => Effect.Effect<void, Error, never>) => Effect.Effect<void, Error, never>;
 export declare const runReactRouterPrerenderBuild: (options: RunReactRouterPrerenderBuildOptions) => Promise<void>;
 export {};

package/dist/prerender.d.ts

@@ -1,13 +1,9 @@
 import type { Config } from './react-router-config.js';
+import type { PrerenderConfigObject } from './types.js';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
 import { matchRoutes } from 'react-router';
 type ReactRouterPrerenderConfig = Config['prerender'];
 type MatchRouteObject = Parameters<typeof matchRoutes>[0] extends Array<infer R> ? R : never;
-type PrerenderConfigObject = Extract<NonNullable<ReactRouterPrerenderConfig>, {
-    paths: unknown;
-}> & {
-    unstable_concurrency?: number;
-};
 type PrerenderConfig = ReactRouterPrerenderConfig | PrerenderConfigObject;
 type PrerenderResolveOptions = {
     logWarning?: boolean;

package/dist/react-router-config.d.ts

@@ -2,17 +2,19 @@ import type { BuildManifest as ReactRouterBuildManifest, Config as ReactRouterCo
 import type { NormalizedConfig } from '@rsbuild/core';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
 import * as Effect from 'effect/Effect';
+import type { PrerenderConfigObject, PrerenderPathsConfig } from './types.js';
 export type BuildEndHook = {
     bivarianceHack(args: {
         buildManifest: ReactRouterBuildManifest | undefined;
         reactRouterConfig: ResolvedReactRouterConfig;
-        viteConfig: NormalizedConfig;
+        rsbuildConfig: NormalizedConfig;
     }): void | Promise<void>;
 }['bivarianceHack'];
 type SplitRouteModulesConfig = boolean | 'enforce';
-export type Config = Omit<ReactRouterConfig, 'buildEnd' | 'future' | 'splitRouteModules' | 'subResourceIntegrity'> & {
+export type Config = Omit<ReactRouterConfig, 'buildEnd' | 'future' | 'prerender' | 'splitRouteModules' | 'subResourceIntegrity'> & {
     buildEnd?: BuildEndHook;
     future?: Partial<FutureConfig>;
+    prerender?: PrerenderConfig;
     splitRouteModules?: SplitRouteModulesConfig;
     subResourceIntegrity?: boolean;
 };
@@ -24,6 +26,7 @@ type FutureConfig = {
     v8_splitRouteModules: boolean | 'enforce';
     v8_viteEnvironmentApi: boolean;
 };
+type PrerenderConfig = PrerenderPathsConfig | PrerenderConfigObject | undefined;
 type RouteManifestEntry = {
     id: string;
     parentId?: string;
@@ -35,9 +38,15 @@ type RouteManifestEntry = {
 type RouteManifest = Record<string, RouteManifestEntry>;
 type ResolveReactRouterConfigResult = {
     resolved: ResolvedReactRouterConfig;
+    userAndPresetConfig: Config;
     presets: NonNullable<Config['presets']>;
     hasConfiguredServerModuleFormat: boolean;
 };
+export declare const getDefaultTrailingSlashAwareDataRequests: (reactRouterVersion?: string | undefined) => boolean;
+export declare const resolveRouteDiscoveryConfig: ({ ssr, userRouteDiscovery, }: {
+    ssr: boolean;
+    userRouteDiscovery: Config["routeDiscovery"];
+}) => Config["routeDiscovery"];
 export type ResolvedReactRouterConfig = Readonly<{
     appDirectory: string;
     basename: string;
@@ -57,5 +66,4 @@ export type ResolvedReactRouterConfig = Readonly<{
     unstable_routeConfig: RouteConfigEntry[];
 }>;
 export declare const resolveReactRouterConfigEffect: (reactRouterUserConfig: Config) => Effect.Effect<ResolveReactRouterConfigResult, Error, never>;
-export declare const resolveReactRouterConfig: (reactRouterUserConfig: Config) => Promise<ResolveReactRouterConfigResult>;
 export {};

package/dist/route-artifacts.d.ts

@@ -27,10 +27,12 @@ type RouteChunkArtifact = {
     map: null;
 };
 export declare const HMR_PATCHABLE_ROUTE_FLAGS: readonly ["hasAction", "hasClientAction", "hasClientLoader", "hasClientMiddleware", "hasErrorBoundary", "hasLoader"];
-export declare const buildRouteHmrFlags: (exportNames: readonly string[]) => number;
-export declare const buildRouteClientEntryCode: ({ exportNames, chunkedExports, isServer, resourcePath, routeId, devHmr, }: {
+type RouteHmrMetadata = Record<(typeof HMR_PATCHABLE_ROUTE_FLAGS)[number], boolean>;
+export declare const buildRouteHmrMetadata: (exportNames: readonly string[]) => RouteHmrMetadata;
+export declare const buildRouteClientEntryCode: ({ exportNames, chunkedExports, sharedChunkedExports, isServer, resourcePath, routeId, devHmr, }: {
     exportNames: readonly string[];
     chunkedExports: readonly string[];
+    sharedChunkedExports?: readonly string[];
     isServer: boolean;
     resourcePath: string;
     routeId?: string;

package/dist/route-chunks.d.ts

@@ -1,5 +1,5 @@
 export type RouteChunkExportName = 'clientAction' | 'clientLoader' | 'clientMiddleware' | 'HydrateFallback';
-export type RouteChunkName = 'main' | RouteChunkExportName;
+export type RouteChunkName = 'main' | RouteChunkExportName | (string & {});
 export type RouteChunkConfig = {
     splitRouteModules?: boolean | 'enforce';
     appDirectory: string;
@@ -15,6 +15,7 @@ export type RouteChunkInfo = {
     hasRouteChunks: boolean;
     hasRouteChunkByExportName: Record<RouteChunkExportName, boolean>;
     chunkedExports: RouteChunkExportName[];
+    sharedChunkedExports: string[];
 };
 export declare const routeChunkExportNames: RouteChunkExportName[];
 export declare const routeChunkNames: RouteChunkName[];

package/dist/route-component-transform.d.ts

@@ -1,5 +1,3 @@
 import type { ParseResult } from 'yuku-parser';
 import { type AnyNode } from './route-ast.js';
-export declare function toFunctionExpression(decl: AnyNode): AnyNode;
-export declare function toClassExpression(decl: AnyNode): AnyNode;
 export declare const transformRoute: (ast: ParseResult | AnyNode) => void;

package/dist/route-export-pruning.d.ts

@@ -2,5 +2,8 @@ import { type ParseResult } from 'yuku-parser';
 import { type AnyNode } from './route-ast.js';
 export declare function validateDestructuredExports(id: AnyNode, exportsToRemove: readonly string[]): void;
 export declare function invalidDestructureError(name: string): Error;
-export declare const removeExports: (ast: ParseResult | AnyNode, exportsToRemove: readonly string[], exportsToRemoveSet?: ReadonlySet<string>) => boolean;
+export declare const collectReferencedNames: (node: AnyNode) => Set<string>;
+export declare const removeExports: (ast: ParseResult | AnyNode, exportsToRemove: readonly string[], exportsToRemoveSet?: ReadonlySet<string>, options?: {
+    pruneDeadDeclarations?: boolean;
+}) => boolean;
 export declare const removeUnusedImports: (ast: ParseResult | AnyNode) => void;

package/dist/route-imports.d.ts

@@ -0,0 +1,18 @@
+import type { Rspack } from '@rsbuild/core';
+import type { Route } from './types.js';
+type QuerylessRouteImportPlugin = {
+    name: string;
+    apply(compiler: Rspack.Compiler): void;
+};
+export declare const resolveQuerylessRouteImportRequest: ({ compilerName, context, issuer, rsc, request, routeByFilePath, }: {
+    compilerName?: string;
+    context?: string;
+    issuer?: string;
+    rsc?: boolean;
+    request?: string;
+    routeByFilePath: ReadonlyMap<string, Route>;
+}) => string | undefined;
+export declare const createQuerylessRouteImportPlugin: (routeByFilePath: ReadonlyMap<string, Route>, options?: {
+    rsc?: boolean;
+}) => QuerylessRouteImportPlugin;
+export {};

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

@@ -0,0 +1,14 @@
+import type { LoaderDefinition } from '@rspack/core';
+export type RouteModuleTransformLoaderOptions = {
+    environmentName: string;
+    performanceScopeId: string;
+    logPerformance: boolean;
+    ssr: boolean;
+    isBuild: boolean;
+    isSpaMode: boolean;
+    rootRoutePath: string | null;
+    devHmr: boolean;
+};
+export declare const flushRouteModuleTransformLoaderPerformance: () => void;
+declare const routeModuleTransformLoader: LoaderDefinition<RouteModuleTransformLoaderOptions>;
+export default routeModuleTransformLoader;

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

@@ -0,0 +1,44 @@
+let performanceFlushTimer;
+import { threadId } from "node:worker_threads";
+import remapping from "@jridgewell/remapping";
+import { createReactRouterPerformanceProfiler, executeRouteTransformTask } from "./511.js";
+let performanceWorkerId = `process-${process.pid}:thread-${threadId}`, performanceProfilersByScope = new Map(), flushRouteModuleTransformLoaderPerformance = ()=>{
+    for (let profilers of (performanceFlushTimer && (clearTimeout(performanceFlushTimer), performanceFlushTimer = void 0), performanceProfilersByScope.values()))for (let [environment, profiler] of profilers)profiler.flush('unknown' === environment ? void 0 : environment, {
+        partial: !0,
+        workerId: performanceWorkerId
+    });
+    performanceProfilersByScope.clear();
+};
+process.once('beforeExit', flushRouteModuleTransformLoaderPerformance);
+let route_module_transform_loader_routeModuleTransformLoader = async function(source, inputSourceMap) {
+    let callback = this.async(), options = this.getOptions(), transform = ()=>executeRouteTransformTask({
+            kind: 'routeModule',
+            code: String(source),
+            resource: this.resource,
+            resourcePath: this.resourcePath,
+            environmentName: options.environmentName,
+            sourceMaps: !!this.sourceMap,
+            ssr: options.ssr,
+            isBuild: options.isBuild,
+            isSpaMode: options.isSpaMode,
+            rootRoutePath: options.rootRoutePath,
+            devHmr: options.devHmr
+        });
+    try {
+        var scopeId, environment;
+        let profilers, environmentKey, profiler, generatedMap, result = options.logPerformance ? await (scopeId = options.performanceScopeId, environment = options.environmentName, !(profilers = performanceProfilersByScope.get(scopeId)) && (profilers = new Map(), performanceProfilersByScope.set(scopeId, profilers)), environmentKey = environment ?? 'unknown', !(profiler = profilers.get(environmentKey)) && (profiler = createReactRouterPerformanceProfiler({
+            enabled: !0,
+            log: (message)=>console.info(message)
+        }), profilers.set(environmentKey, profiler)), profiler).record(options.environmentName, 'route:module', this.resource, transform) : await transform(), outputSourceMap = result.map && inputSourceMap ? (generatedMap = result.map, JSON.parse(remapping([
+            generatedMap,
+            inputSourceMap
+        ], ()=>null).toString())) : result.map;
+        callback(null, result.code, outputSourceMap ?? void 0);
+    } catch (error) {
+        callback(error instanceof Error ? error : Error(String(error)));
+    } finally{
+        options.logPerformance && (performanceFlushTimer && clearTimeout(performanceFlushTimer), performanceFlushTimer = setTimeout(flushRouteModuleTransformLoaderPerformance, 50));
+    }
+};
+export default route_module_transform_loader_routeModuleTransformLoader;
+export { flushRouteModuleTransformLoaderPerformance };

package/dist/route-module-transform-rules.d.ts

@@ -0,0 +1,14 @@
+import type { Rspack } from '@rsbuild/core';
+import type { PluginOptions, Route } from './types.js';
+export declare const shouldUseRouteModuleTransformLoader: (parallelRouteTransform: PluginOptions["parallelRouteTransform"]) => boolean;
+export declare const registerRouteModuleTransformRules: (rspackConfig: Rspack.Configuration, { environmentName, ssr, isBuild, isSpaMode, rootRoutePath, devHmr, logPerformance, routeByFilePath, parallelRouteTransform, }: {
+    environmentName: string;
+    ssr: boolean;
+    isBuild: boolean;
+    isSpaMode: boolean;
+    rootRoutePath: string | null;
+    devHmr: boolean;
+    logPerformance: boolean;
+    routeByFilePath: Map<string, Route>;
+    parallelRouteTransform: PluginOptions["parallelRouteTransform"];
+}) => void;

package/dist/route-transform-tasks.d.ts

@@ -46,5 +46,11 @@ export type RouteTransformTask = RouteClientEntryTransformTask | RouteChunkTrans
 export type RouteTransformTaskOptions = {
     routeChunkCache?: RouteChunkCache;
 };
+export type RouteTransformRunner = (task: RouteTransformTask) => Promise<RouteTransformResult>;
+export declare const validateSpaModeRouteExports: ({ exportNames, resourcePath, rootRoutePath, }: {
+    exportNames: readonly string[];
+    resourcePath: string;
+    rootRoutePath: string | null;
+}) => void;
 export declare const executeRouteTransformTask: (task: RouteTransformTask, options?: RouteTransformTaskOptions) => Promise<RouteTransformResult>;
 export {};

package/dist/route-watch.d.ts

@@ -1,5 +1,8 @@
 import { type FSWatcher } from 'node:fs';
 import type { RsbuildConfig } from '@rsbuild/core';
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
+import { type PluginEffectRuntime } from './effect-runtime.js';
 import type { Route } from './types.js';
 type RouteManifestSnapshotEntry = Pick<Route, 'caseSensitive' | 'file' | 'id' | 'index' | 'parentId' | 'path'>;
 type RouteManifestSnapshotEntryPair = readonly [
@@ -11,11 +14,8 @@ type WatchFilesConfig = NonNullable<NonNullable<RsbuildConfig['dev']>['watchFile
 export type WatchFileConfig = Exclude<WatchFilesConfig, readonly unknown[]> | Extract<WatchFilesConfig, readonly unknown[]>[number];
 type DirectoryWatcher = Pick<FSWatcher, 'close'>;
 type WatchDirectoryEntry = (directory: string, onChange: () => void, onError: (error: unknown) => void) => DirectoryWatcher;
-export declare const mergeWatchFiles: (existing: WatchFilesConfig | undefined, additions: WatchFileConfig[]) => WatchFilesConfig;
-export declare const getRouteRestartMarkerPath: (outputClientPath: string) => string;
-export declare const createRouteManifestSnapshot: (routes: RouteManifestSnapshotEntries) => Set<string>;
-export declare const ensureDevRestartMarker: (restartMarkerPath: string) => Promise<void>;
-export declare const createRouteTopologyWatcher: ({ watchDirectory, getRouteTopology, initialRouteTopology, restartMarkerPath, onError, onRouteTopologyChange, watchDirectoryEntry: watchDirectoryOverride, }: {
+export type CreateRouteTopologyWatcherOptions = {
+    runtime: PluginEffectRuntime;
     watchDirectory: string;
     getRouteTopology: () => Promise<Set<string>>;
     initialRouteTopology?: Set<string>;
@@ -23,5 +23,10 @@ export declare const createRouteTopologyWatcher: ({ watchDirectory, getRouteTopo
     onError: (error: unknown) => void;
     onRouteTopologyChange?: () => void | Promise<void>;
     watchDirectoryEntry?: WatchDirectoryEntry;
-}) => Promise<() => Promise<void>>;
+};
+export declare const mergeWatchFiles: (existing: WatchFilesConfig | undefined, additions: WatchFileConfig[]) => WatchFilesConfig;
+export declare const getRouteRestartMarkerPath: (appDirectory: string) => string;
+export declare const createRouteManifestSnapshot: (routes: RouteManifestSnapshotEntries) => Set<string>;
+export declare const ensureDevRestartMarker: (restartMarkerPath: string) => Promise<void>;
+export declare const acquireRouteTopologyWatcher: (options: CreateRouteTopologyWatcherOptions) => Effect.Effect<() => Effect.Effect<void, Error>, Error, Scope.Scope>;
 export {};

package/dist/rsc-dev-server.d.ts

@@ -0,0 +1,26 @@
+import type { RsbuildConfig } from '@rsbuild/core';
+type RscDevServerSetup = NonNullable<NonNullable<RsbuildConfig['server']>['setup']>;
+type RscDevServerSetupOptions = {
+    entryName: string;
+    pluginName: string;
+};
+/**
+ * Decides whether a dev-server request should skip the RSC request handler
+ * and fall through to the rest of the middleware chain.
+ *
+ * Only Rsbuild-internal endpoints (`/__rsbuild_*`, e.g. HMR web socket
+ * fallbacks) are bypassed. Everything else — any method, any pathname,
+ * with or without a file extension — is handled by the RSC server build,
+ * matching production where the RSC server handles every request.
+ *
+ * Static assets need no bypass here: the RSC middleware is registered via
+ * the callback returned from `server.setup`, which Rsbuild invokes only
+ * after its built-in middlewares (compiled assets, public dir) are
+ * registered. A request that reaches this middleware was already declined
+ * by static asset serving.
+ */
+export declare const shouldBypassRscDevRequest: (request: {
+    url?: string;
+}) => boolean;
+export declare function createReactRouterRscDevServerSetup({ entryName, pluginName, }: RscDevServerSetupOptions): RscDevServerSetup;
+export {};

package/dist/rsc-prerender.d.ts

@@ -0,0 +1,54 @@
+import type { RsbuildPluginAPI } from '@rsbuild/core';
+import type { Config } from './react-router-config.js';
+/**
+ * RSC-mode prerendering.
+ *
+ * Mirrors React Router's upstream RSC behavior, feeding the shared
+ * `prerender` plugin with one request per prerender path (plus
+ * `/__spa-fallback.html` when `ssr: false`) and post-processes each HTML
+ * response into two artifacts in the client build directory:
+ *
+ * - `<path>/index.html` — the prerendered document
+ * - `<path>.rsc` (`_.rsc` for `/`) — the RSC payload reassembled from the
+ *   inline `__FLIGHT_DATA` scripts, served for client-side navigations
+ *
+ * Instead of an HTTP round-trip through a preview server, the RSC server
+ * bundle's default-exported `fetch` handler is invoked in-process, matching
+ * how classic mode prerenders through `createRequestHandler`.
+ */
+export declare const SPA_FALLBACK_REQUEST_PATH: string;
+type RscPrerenderBuildApi = Pick<RsbuildPluginAPI, 'logger'>;
+type RscPrerenderRequest = {
+    requestPath: string;
+    artifactPath: string;
+};
+type RunReactRouterRscPrerenderBuildOptions = {
+    api: RscPrerenderBuildApi;
+    hasWebEnvironment: boolean;
+    buildDirectory: string;
+    serverBuildFile?: string;
+    ssr: boolean;
+    prerenderConfig: Config['prerender'];
+    prerenderPaths: string[];
+    basename: string;
+};
+export declare const normalizeRscPrerenderBasename: (basename: string) => string;
+/**
+ * The request paths to prerender: the resolved prerender paths joined with
+ * the basename, plus the SPA fallback document when `ssr: false`.
+ */
+export declare const getRscPrerenderRequests: ({ prerenderPaths, ssr, basename, }: {
+    prerenderPaths: string[];
+    ssr: boolean;
+    basename: string;
+}) => RscPrerenderRequest[];
+/**
+ * Reassembles the RSC payload from the inline flight data scripts that
+ * `react-router`'s HTML stream injects into server-rendered documents.
+ * Returns `null` when the document carries no flight data.
+ */
+export declare const extractRscFlightData: (html: string) => string | null;
+export declare const getRscHtmlFilePath: (pathname: string) => string;
+export declare const getRscPayloadFilePath: (pathname: string) => string;
+export declare const runReactRouterRscPrerenderBuild: (options: RunReactRouterRscPrerenderBuildOptions) => Promise<void>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { Route } from './types.js';
+export declare const createRscRouteConfig: ({ appDirectory, routes, }: {
+    appDirectory: string;
+    routes: Record<string, Route>;
+}) => string;
+export declare const createRscInternalClientModule: () => string;