rsbuild-plugin-react-router 0.1.1 → 0.3.0

package/dist/lazy-compilation.d.ts

@@ -0,0 +1,5 @@
+import type { PluginOptions } from './types.js';
+export declare const guardReactRouterLazyCompilation: ({ lazyCompilation, entryClientPath, }: {
+    lazyCompilation: PluginOptions["lazyCompilation"] | undefined;
+    entryClientPath: string;
+}) => PluginOptions["lazyCompilation"] | undefined;

package/dist/manifest.d.ts

@@ -1,20 +1,15 @@
 import type { Route, PluginOptions, RouteManifestItem } from './types.js';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
-import type { Rspack } from '@rsbuild/core';
 import { type RouteChunkCache } from './route-chunks.js';
 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 = {
     splitRouteModules?: boolean | 'enforce';
     rootRouteFile?: string;
     isBuild?: boolean;
     cache?: RouteChunkCache;
 };
-export declare const getReactRouterManifestPath: ({ version, isBuild, entryModulePath, }: {
-    version: string;
-    isBuild: boolean;
-    entryModulePath?: string;
-}) => string;
-export declare function getReactRouterManifestForDev(routes: Record<string, Route>, options: PluginOptions, clientStats: Rspack.StatsCompilation | undefined, context: string, assetPrefix?: string, routeChunkOptions?: RouteChunkManifestOptions): Promise<{
+export type ReactRouterManifestForDev = {
     version: string;
     url: string;
     hmr?: {
@@ -25,7 +20,35 @@ export declare function getReactRouterManifestForDev(routes: Record<string, Rout
         imports: string[];
         css: string[];
     };
-    sri?: Record<string, string>;
+    sri?: Record<string, string> | true;
     routes: Record<string, RouteManifestItem>;
-}>;
+};
+export type ReactRouterManifestStats = {
+    assetsByChunkName?: Record<string, string[]>;
+    entrypointFilesByName?: Record<string, string[]>;
+};
+type ReactRouterManifestStatsChunk = {
+    files?: Iterable<string>;
+};
+type ReactRouterManifestStatsEntrypoint = {
+    getFiles?: () => Iterable<string>;
+};
+type ReactRouterManifestStatsCompilation = {
+    namedChunks: Iterable<[string, ReactRouterManifestStatsChunk]>;
+    entrypoints?: Iterable<[string, ReactRouterManifestStatsEntrypoint]>;
+};
+export declare const createReactRouterManifestStats: (compilation: ReactRouterManifestStatsCompilation | undefined, chunkNames?: ReadonlySet<string>) => ReactRouterManifestStats | undefined;
+export type RouteManifestModuleExports = Record<string, readonly string[]>;
+export type ReactRouterManifestGenerationResult = {
+    manifest: ReactRouterManifestForDev;
+    moduleExportsByRouteId: RouteManifestModuleExports;
+};
+export declare const getReactRouterManifestPath: ({ version, isBuild, entryModulePath, }: {
+    version: string;
+    isBuild: boolean;
+    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 getReactRouterManifestForDev(...args: Parameters<typeof generateReactRouterManifestForDev>): Promise<ReactRouterManifestForDev>;
 export {};

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

@@ -1,18 +1,35 @@
 import type { Route, PluginOptions } from './types.js';
-import type { Rspack } from '@rsbuild/core';
-import { getReactRouterManifestForDev } from './manifest.js';
-/**
- * Creates a Webpack/Rspack plugin that modifies the browser manifest
- * @param routes - The routes configuration
- * @param pluginOptions - The plugin options
- * @param appDirectory - The application directory
- * @returns A webpack/rspack plugin
- */
-export declare function createModifyBrowserManifestPlugin(routes: Record<string, Route>, pluginOptions: PluginOptions, appDirectory: string, assetPrefix?: string, routeChunkOptions?: Parameters<typeof getReactRouterManifestForDev>[5], options?: {
+import type { RsbuildPluginAPI, Rspack } from '@rsbuild/core';
+import { createReactRouterManifestStats, generateReactRouterManifestForDev, getReactRouterManifestForDev } from './manifest.js';
+type StatsAssetWithIntegrity = {
+    name?: string;
+    integrity?: unknown;
+};
+type StatsWithIntegrity = {
+    assets?: StatsAssetWithIntegrity[];
+};
+type CompilationAssetWithIntegrity = {
+    name: string;
+    info?: {
+        integrity?: unknown;
+    };
+};
+type CompilationWithIntegrityAssets = {
+    getAssets?: () => readonly CompilationAssetWithIntegrity[];
+} | Pick<Rspack.Compilation, 'getAssets'>;
+type ModifyBrowserManifestOptions = {
     future?: {
         unstable_subResourceIntegrity?: boolean;
     };
-    onManifest?: (manifest: Awaited<ReturnType<typeof getReactRouterManifestForDev>>, sri: Record<string, string> | undefined) => void;
-}): {
-    apply(compiler: Rspack.Compiler): void;
+    subResourceIntegrity?: boolean;
+    manifestChunkNames?: ReadonlySet<string>;
+    onManifest?: (manifest: Awaited<ReturnType<typeof getReactRouterManifestForDev>>, sri: Record<string, string> | true | undefined, moduleExportsByRouteId: Awaited<ReturnType<typeof generateReactRouterManifestForDev>>['moduleExportsByRouteId'], context: {
+        compilation: Rspack.Compilation;
+        manifestStats: ReturnType<typeof createReactRouterManifestStats>;
+    }) => void;
 };
+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 {};

package/dist/parallel-route-transform-protocol.d.ts

@@ -0,0 +1,25 @@
+import type { RouteTransformResult, RouteTransformTask } from './route-transform-tasks.js';
+type WithoutRequiredSource<Task> = Task extends RouteTransformTask ? Omit<Task, 'code'> & {
+    code?: string;
+} : never;
+export type CachedRouteTransformTask = WithoutRequiredSource<RouteTransformTask>;
+export type WorkerRequest = {
+    id: number;
+    task: RouteTransformTask | CachedRouteTransformTask;
+    sourceCacheKey?: string;
+};
+export type WorkerErrorPayload = {
+    name?: string;
+    message: string;
+    stack?: string;
+};
+export type WorkerResponse = {
+    id: number;
+    ok: true;
+    result: RouteTransformResult;
+} | {
+    id: number;
+    ok: false;
+    error: WorkerErrorPayload;
+};
+export {};

package/dist/parallel-route-transform-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/parallel-route-transform-worker.js

@@ -0,0 +1,38 @@
+import { parentPort } from "node:worker_threads";
+import { setBoundedCacheEntry, executeRouteTransformTask } from "./451.js";
+if (!parentPort) throw Error('parallel route transform worker requires parentPort');
+let sourceCache = new Map();
+parentPort.on('message', async ({ id, task, sourceCacheKey })=>{
+    try {
+        let hydratedTask = (({ task, sourceCacheKey })=>{
+            if (!sourceCacheKey) return task;
+            if ('string' == typeof task.code) return setBoundedCacheEntry(sourceCache, sourceCacheKey, task.code, 2048), task;
+            let code = sourceCache.get(sourceCacheKey);
+            if (void 0 === code) throw Error(`Missing cached route transform source for ${sourceCacheKey}.`);
+            return {
+                ...task,
+                code
+            };
+        })({
+            task,
+            sourceCacheKey
+        }), result = await executeRouteTransformTask(hydratedTask);
+        parentPort?.postMessage({
+            id,
+            ok: !0,
+            result
+        });
+    } catch (error) {
+        parentPort?.postMessage({
+            id,
+            ok: !1,
+            error: error instanceof Error ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack
+            } : {
+                message: String(error)
+            }
+        });
+    }
+});

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

@@ -0,0 +1,14 @@
+import { type RouteTransformResult, type RouteTransformTask, type RouteTransformTaskOptions } from './route-transform-tasks.js';
+import type { PluginOptions } from './types.js';
+export type ParallelRouteTransformConfig = NonNullable<PluginOptions['parallelRouteTransform']> extends infer Config ? Exclude<Config, false> : never;
+export type RouteTransformExecutorOptions = RouteTransformTaskOptions & {
+    parallelRouteTransform?: PluginOptions['parallelRouteTransform'];
+    splitRouteModules?: boolean;
+};
+export type RouteTransformExecutor = {
+    run: (task: RouteTransformTask) => Promise<RouteTransformResult>;
+    close: () => Promise<void>;
+};
+export declare const getDefaultWorkerCount: (cpuCount?: number) => number;
+export declare const shouldParallelizeRouteTransforms: (routeCount: number) => boolean;
+export declare const createRouteTransformExecutor: ({ parallelRouteTransform, routeChunkCache, splitRouteModules, }?: RouteTransformExecutorOptions) => RouteTransformExecutor;

package/dist/performance.d.ts

@@ -0,0 +1,26 @@
+type OperationTiming = {
+    count: number;
+    totalMs: number;
+    wallMs: number;
+    maxMs: number;
+    slowest: Array<{
+        durationMs: number;
+        resource: string;
+    }>;
+};
+export declare const roundMs: (value: number) => number;
+export type ReactRouterPerformanceReport = {
+    environment: string;
+    compilerLifecycleMs?: number;
+    operations: Record<string, OperationTiming>;
+};
+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;
+};
+export declare const createReactRouterPerformanceProfiler: ({ enabled, log, }: {
+    enabled: boolean;
+    log: (message: string) => void;
+}) => ReactRouterPerformanceProfiler;
+export {};

package/dist/plugin-utils.d.ts

@@ -1,18 +1,8 @@
-import type { Babel, ParseResult } from './babel.js';
-export declare function validateDestructuredExports(id: Babel.ArrayPattern | Babel.ObjectPattern, exportsToRemove: string[]): void;
-export declare function invalidDestructureError(name: string): Error;
-export declare function toFunctionExpression(decl: Babel.FunctionDeclaration): any;
 export declare function combineURLs(baseURL: string, relativeURL: string): string;
 export declare function normalizeAssetPrefix(assetPrefix?: string): string;
 export declare function stripFileExtension(file: string): string;
 export declare function createRouteId(file: string): string;
-/**
- * Find a file with any of the supported JavaScript extensions
- * @param basePath - The base path without extension
- * @returns The file path with extension if found, or a default path
- */
 export declare function findEntryFile(basePath: string): string;
 export declare function generateWithProps(): string;
-export declare const removeExports: (ast: ParseResult<Babel.File>, exportsToRemove: string[]) => void;
-export declare const removeUnusedImports: (ast: ParseResult<Babel.File>) => void;
-export declare const transformRoute: (ast: ParseResult<Babel.File>) => void;
+export { invalidDestructureError, removeExports, removeUnusedImports, validateDestructuredExports, } from './route-export-pruning.js';
+export { transformRoute } from './route-component-transform.js';

package/dist/prerender-build.d.ts

@@ -0,0 +1,32 @@
+import type { RsbuildPluginAPI } from '@rsbuild/core';
+import { getBuildManifest } from './build-manifest.js';
+import { getReactRouterManifestForDev, type ReactRouterManifestStats, 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;
+    hasWebEnvironment: boolean;
+    buildDirectory: string;
+    serverBuildFile?: string;
+    ssr: boolean;
+    isPrerenderEnabled: boolean;
+    prerenderConfig: Config['prerender'];
+    prerenderPaths: string[];
+    basename: string;
+    future: ResolvedReactRouterConfig['future'];
+    routes: Record<string, Route>;
+    latestBrowserManifest: ReactRouterManifest | null;
+    latestBrowserManifestModuleExports: RouteManifestModuleExports;
+    clientStats: ReactRouterManifestStats | undefined;
+    pluginOptions: PluginOptions;
+    appDirectory: string;
+    assetPrefix: string;
+    routeChunkOptions: Parameters<typeof getReactRouterManifestForDev>[5];
+    buildManifest: Awaited<ReturnType<typeof getBuildManifest>>;
+    resolvedConfigWithRoutes: ResolvedReactRouterConfig;
+    buildEnd: Config['buildEnd'];
+};
+export declare const runReactRouterPrerenderBuild: (options: RunReactRouterPrerenderBuildOptions) => Promise<void>;
+export {};

package/dist/prerender.d.ts

@@ -1,6 +1,14 @@
 import type { Config } from './react-router-config.js';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
-type PrerenderConfig = Config['prerender'];
+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;
     warn?: (message: string) => void;
@@ -9,8 +17,26 @@ type StaticPrerenderPaths = {
     paths: string[];
     paramRoutes: string[];
 };
+type SsrFalsePrerenderRoute = {
+    id: string;
+    parentId?: string;
+    path?: string;
+    index?: boolean;
+    hasLoader?: boolean;
+    hasClientLoader?: boolean;
+};
+type SsrFalsePrerenderExportOptions = {
+    routes: Record<string, SsrFalsePrerenderRoute>;
+    manifestRoutes: Record<string, SsrFalsePrerenderRoute>;
+    routeExports: Record<string, readonly string[] | undefined>;
+    prerenderPaths: string[];
+};
+export declare const createPrerenderRoutes: (manifest: Record<string, any>, parentId?: string, grouped?: Record<string, any[]>) => MatchRouteObject[];
+export declare const normalizePrerenderMatchPath: (path: string) => string;
+export declare const withBuildRequest: <T>(input: string | URL, init: RequestInit | undefined, handle: (request: Request) => Promise<T>) => Promise<T>;
+export declare const getSsrFalsePrerenderExportErrors: ({ routes, manifestRoutes, routeExports, prerenderPaths, }: SsrFalsePrerenderExportOptions) => string[];
 export declare const getStaticPrerenderPaths: (routes: RouteConfigEntry[]) => StaticPrerenderPaths;
 export declare const resolvePrerenderPaths: (prerender: PrerenderConfig, ssr: boolean, routes: RouteConfigEntry[], options?: PrerenderResolveOptions) => Promise<string[]>;
-export declare const getPrerenderConcurrency: (prerender: PrerenderConfig) => number;
+export declare const getPrerenderConcurrency: (prerender: PrerenderConfig, _cpuCount?: number) => number;
 export declare const validatePrerenderConfig: (prerender: PrerenderConfig) => string | null;
 export {};

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

@@ -8,8 +8,12 @@ export type BuildEndHook = {
         viteConfig: NormalizedConfig;
     }): void | Promise<void>;
 }['bivarianceHack'];
-export type Config = Omit<ReactRouterConfig, 'buildEnd'> & {
+type SplitRouteModulesConfig = boolean | 'enforce';
+export type Config = Omit<ReactRouterConfig, 'buildEnd' | 'future' | 'splitRouteModules' | 'subResourceIntegrity'> & {
     buildEnd?: BuildEndHook;
+    future?: Partial<FutureConfig>;
+    splitRouteModules?: SplitRouteModulesConfig;
+    subResourceIntegrity?: boolean;
 };
 type FutureConfig = {
     unstable_optimizeDeps: boolean;
@@ -40,6 +44,8 @@ export type ResolvedReactRouterConfig = Readonly<{
     serverBuildFile: NonNullable<ReactRouterConfig['serverBuildFile']>;
     serverBundles?: Config['serverBundles'];
     serverModuleFormat: NonNullable<ReactRouterConfig['serverModuleFormat']>;
+    splitRouteModules: SplitRouteModulesConfig;
+    subResourceIntegrity: boolean;
     ssr: NonNullable<ReactRouterConfig['ssr']>;
     allowedActionOrigins: string[] | false;
     unstable_routeConfig: RouteConfigEntry[];
@@ -47,5 +53,6 @@ export type ResolvedReactRouterConfig = Readonly<{
 export declare const resolveReactRouterConfig: (reactRouterUserConfig: Config) => Promise<{
     resolved: ResolvedReactRouterConfig;
     presets: NonNullable<Config["presets"]>;
+    hasConfiguredServerModuleFormat: boolean;
 }>;
 export {};

package/dist/route-artifacts.d.ts

@@ -0,0 +1,33 @@
+import { type RouteChunkCache, type RouteChunkConfig } from './route-chunks.js';
+export type RouteClientEntryArtifactOptions = {
+    code: string;
+    resourcePath: string;
+    environmentName?: string;
+    isBuild: boolean;
+    routeChunkCache?: RouteChunkCache;
+    routeChunkConfig: RouteChunkConfig;
+};
+type RouteClientEntryArtifact = {
+    code: string;
+};
+export type RouteChunkArtifactOptions = {
+    code: string;
+    resource: string;
+    resourcePath: string;
+    isBuild: boolean;
+    routeChunkCache?: RouteChunkCache;
+    routeChunkConfig: RouteChunkConfig;
+};
+type RouteChunkArtifact = {
+    code: string;
+    map: null;
+};
+export declare const buildRouteClientEntryCode: ({ exportNames, chunkedExports, isServer, resourcePath, }: {
+    exportNames: readonly string[];
+    chunkedExports: readonly string[];
+    isServer: boolean;
+    resourcePath: string;
+}) => string;
+export declare const createRouteClientEntryArtifact: ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig, }: RouteClientEntryArtifactOptions) => Promise<RouteClientEntryArtifact>;
+export declare const createRouteChunkArtifact: ({ code, resource, resourcePath, isBuild, routeChunkCache, routeChunkConfig, }: RouteChunkArtifactOptions) => Promise<RouteChunkArtifact>;
+export {};

package/dist/route-ast.d.ts

@@ -0,0 +1,21 @@
+import type { ParseResult } from 'yuku-parser';
+export type AnyNode = Record<string, any>;
+export type ProgramNode = AnyNode & {
+    body: AnyNode[];
+};
+export declare const getProgram: (ast: ParseResult | AnyNode) => ProgramNode;
+export declare const getPatternIdentifierNames: (pattern: AnyNode | null | undefined, names?: Set<string>) => Set<string>;
+export declare const getIdentifierNamesFromPattern: (pattern: AnyNode | null | undefined) => string[];
+export declare const patternIncludesName: (pattern: AnyNode | null | undefined, name: string) => boolean;
+export declare const getExportedName: (node: AnyNode | null | undefined) => string | null;
+export declare const identifier: (name: string) => AnyNode;
+export declare const literal: (value: string) => AnyNode;
+export declare const callExpression: (callee: AnyNode, args: AnyNode[]) => AnyNode;
+export declare const importDeclaration: (specifiers: Array<{
+    local: string;
+    imported: string;
+}>, source: string) => AnyNode;
+export declare const exportSpecifier: (local: string, exported: string) => AnyNode;
+export declare const exportNamedDeclaration: (specifiers: AnyNode[]) => AnyNode;
+export declare const variableDeclaration: (name: string, init: AnyNode) => AnyNode;
+export declare const removeFromArray: <T>(array: T[], value: T) => void;

package/dist/route-chunks.d.ts

@@ -5,23 +5,30 @@ export type RouteChunkConfig = {
     appDirectory: string;
     rootRouteFile: string;
 };
-export type RouteChunkCacheEntry<T> = {
+type RouteChunkCacheEntry<T> = {
     value: T;
     version: string;
 };
 export type RouteChunkCache = Map<string, RouteChunkCacheEntry<unknown>>;
 export type RouteChunkInfo = {
+    exportNames: string[];
     hasRouteChunks: boolean;
     hasRouteChunkByExportName: Record<RouteChunkExportName, boolean>;
     chunkedExports: RouteChunkExportName[];
 };
 export declare const routeChunkExportNames: RouteChunkExportName[];
 export declare const routeChunkNames: RouteChunkName[];
+export declare const mightContainRouteChunkExportName: (source: string) => boolean;
+export declare const emptyRouteChunkSnippet: () => string;
 export declare const detectRouteChunks: (code: string, cache: RouteChunkCache | undefined, cacheKey: string) => RouteChunkInfo;
 export declare const getRouteChunkCode: (code: string, chunkName: RouteChunkName, cache: RouteChunkCache | undefined, cacheKey: string) => string | undefined;
 export declare const getRouteChunkModuleId: (filePath: string, chunkName: RouteChunkName) => string;
 export declare const isRouteChunkModuleId: (id: string) => boolean;
 export declare const getRouteChunkNameFromModuleId: (id: string) => RouteChunkName | null;
+export declare const shouldAnalyzeRouteChunks: (config: RouteChunkConfig, id: string, code: string) => boolean;
+export declare const createEmptyRouteChunkByExportName: () => Record<RouteChunkExportName, boolean>;
+export declare const buildEnforceChunkValidity: (exportNames: readonly string[]) => Record<RouteChunkExportName, boolean>;
+export declare const buildManifestChunkValidity: (exportNames: ReadonlySet<string>, hasRouteChunkByExportName: Readonly<Record<RouteChunkExportName, boolean>>) => Record<RouteChunkExportName, boolean>;
 export declare const detectRouteChunksIfEnabled: (cache: RouteChunkCache | undefined, config: RouteChunkConfig, id: string, code: string) => Promise<RouteChunkInfo>;
 export declare const getRouteChunkIfEnabled: (cache: RouteChunkCache | undefined, config: RouteChunkConfig, id: string, chunkName: RouteChunkName, code: string) => Promise<string | null>;
 export declare const validateRouteChunks: (args: {
@@ -30,3 +37,4 @@ export declare const validateRouteChunks: (args: {
     valid: Record<RouteChunkExportName, boolean>;
 }) => void;
 export declare const getRouteChunkEntryName: (routeId: string, chunkName: RouteChunkExportName) => string;
+export {};

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,6 @@
+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 removeUnusedImports: (ast: ParseResult | AnyNode) => void;

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

@@ -0,0 +1,5 @@
+export type RouteExportResolver = (specifier: string, importerPath: string) => Promise<string | null> | string | null;
+export type RouteModuleResolveCallback = (error: Error | null, resolved?: string | false) => void;
+export type RouteModuleResolver = (context: string, specifier: string, callback: RouteModuleResolveCallback) => void;
+export declare const createBundlerRouteExportResolver: (resolveModule: RouteModuleResolver) => RouteExportResolver;
+export declare const collectClientOnlyStubExportNames: (code: string, resourcePath: string, resolveModule?: RouteExportResolver) => Promise<Set<string>>;

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

@@ -0,0 +1,47 @@
+import { generate } from './yuku.js';
+import { type RouteExportResolver } from './route-export-resolution.js';
+import { type RouteChunkCache, type RouteChunkConfig } from './route-chunks.js';
+export type RouteTransformResult = {
+    code: string;
+    map?: ReturnType<typeof generate>['map'];
+};
+type BaseRouteTransformTask = {
+    code: string;
+    resourcePath: string;
+};
+export type RouteClientEntryTransformTask = BaseRouteTransformTask & {
+    kind: 'routeClientEntry';
+    environmentName?: string;
+    isBuild: boolean;
+    routeChunkConfig: RouteChunkConfig;
+};
+export type RouteChunkTransformTask = BaseRouteTransformTask & {
+    kind: 'routeChunk';
+    resource: string;
+    isBuild: boolean;
+    routeChunkConfig: RouteChunkConfig;
+};
+export type SplitRouteExportsTransformTask = BaseRouteTransformTask & {
+    kind: 'splitRouteExports';
+    routeChunkConfig: RouteChunkConfig;
+};
+export type ClientOnlyStubTransformTask = BaseRouteTransformTask & {
+    kind: 'clientOnlyStub';
+    resolveExportAllModule?: RouteExportResolver;
+};
+export type RouteModuleTransformTask = BaseRouteTransformTask & {
+    kind: 'routeModule';
+    resource: string;
+    environmentName: string;
+    sourceMaps: boolean;
+    ssr: boolean;
+    isBuild: boolean;
+    isSpaMode: boolean;
+    rootRoutePath: string | null;
+};
+export type RouteTransformTask = RouteClientEntryTransformTask | RouteChunkTransformTask | SplitRouteExportsTransformTask | ClientOnlyStubTransformTask | RouteModuleTransformTask;
+export type RouteTransformTaskOptions = {
+    routeChunkCache?: RouteChunkCache;
+};
+export declare const executeRouteTransformTask: (task: RouteTransformTask, options?: RouteTransformTaskOptions) => Promise<RouteTransformResult>;
+export {};

package/dist/route-watch.d.ts

@@ -0,0 +1,27 @@
+import { type FSWatcher } from 'node:fs';
+import type { RsbuildConfig } from '@rsbuild/core';
+import type { Route } from './types.js';
+type RouteManifestSnapshotEntry = Pick<Route, 'caseSensitive' | 'file' | 'id' | 'index' | 'parentId' | 'path'>;
+type RouteManifestSnapshotEntryPair = readonly [
+    string,
+    RouteManifestSnapshotEntry
+];
+type RouteManifestSnapshotEntries = Record<string, RouteManifestSnapshotEntry> | ReadonlyArray<RouteManifestSnapshotEntryPair>;
+type WatchFilesConfig = NonNullable<NonNullable<RsbuildConfig['dev']>['watchFiles']>;
+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, }: {
+    watchDirectory: string;
+    getRouteTopology: () => Promise<Set<string>>;
+    initialRouteTopology?: Set<string>;
+    restartMarkerPath: string;
+    onError: (error: unknown) => void;
+    onRouteTopologyChange?: () => void | Promise<void>;
+    watchDirectoryEntry?: WatchDirectoryEntry;
+}) => Promise<() => Promise<void>>;
+export {};

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

@@ -0,0 +1,22 @@
+import type { ReactRouterDevBuildPlan } from './dev-runtime-artifacts.js';
+import type { Route } from './types.js';
+export type ReactRouterServerBundleEntry = {
+    bundleId: string;
+    entryName: string;
+};
+export type ReactRouterServerBuildPlan = ReactRouterDevBuildPlan & {
+    serverBundleEntries: ReactRouterServerBundleEntry[];
+};
+export declare const createReactRouterServerBuildPlan: ({ routesByServerBundleId, serverBuildFile, defaultEntryName, }: {
+    routesByServerBundleId: Record<string, Record<string, Route>>;
+    serverBuildFile: string | undefined;
+    defaultEntryName: string;
+}) => ReactRouterServerBuildPlan;
+export declare const createReactRouterNodeEntries: ({ hasServerApp, isBuild, serverAppPath, entryServerPath, defaultEntryName, serverBundleEntries, }: {
+    hasServerApp: boolean;
+    isBuild: boolean;
+    serverAppPath: string;
+    entryServerPath: string;
+    defaultEntryName: string;
+    serverBundleEntries: readonly ReactRouterServerBundleEntry[];
+}) => Record<string, string>;

package/dist/server-utils.d.ts

@@ -1,3 +1,4 @@
+import type { ServerBuild } from 'react-router';
 import type { Route } from './types.js';
 /**
  * Generates the server build template string.
@@ -33,6 +34,6 @@ interface ServerBuildOptions {
 declare function generateServerBuild(routes: Record<string, Route>, options: ServerBuildOptions & {
     federation?: boolean;
 }): string;
-export declare const normalizeBuildModule: <T extends Record<string, any>>(build: T) => T;
-export declare const resolveBuildExports: <T extends Record<string, any>>(build: T) => Promise<T>;
+export declare function resolveServerBuildModule(buildModule: unknown, source: string): Promise<ServerBuild>;
+export declare function resolveReactRouterServerBuild(buildModule: unknown): Promise<ServerBuild>;
 export { generateServerBuild };

package/dist/templates/entry.client.js

@@ -1,6 +1,6 @@
 import { hydrateRoot } from "react-dom/client";
 import { HydratedRouter } from "react-router/dom";
-import { startTransition, createElement, StrictMode } from "../946.js";
-startTransition(()=>{
-    hydrateRoot(document, createElement(StrictMode, null, createElement(HydratedRouter, null)));
+import * as __rspack_external_react from "react";
+__rspack_external_react.startTransition(()=>{
+    hydrateRoot(document, __rspack_external_react.createElement(__rspack_external_react.StrictMode, null, __rspack_external_react.createElement(HydratedRouter, null)));
 });