rsbuild-plugin-react-router 0.7.2 → 0.8.0

package/src/route-chunks.ts

@@ -1,10 +1,13 @@
 import {
   Analyzer,
+  SymbolFlags,
+  type Export as YukuExport,
   type Module,
+  type Reference as YukuReference,
   type Symbol as YukuSymbol,
 } from 'yuku-analyzer';
 import { print } from 'yuku-codegen';
-import { walk } from 'yuku-parser';
+import { walk, type Node } from 'yuku-parser';
 import { dirname, normalize, relative, resolve } from 'pathe';
 import { SERVER_ONLY_ROUTE_EXPORTS_SET } from './constants.js';
 import { createRouteId } from './plugin-utils.js';
@@ -146,6 +149,7 @@ type ExportDependencies = {
   importedIdentifierNames: Set<string>;
   importSources: Set<string>;
   exportedVariableDeclarators: Set<AnyNode>;
+  exportedLocalSymbols: Set<YukuSymbol>;
 };
 
 const getTopLevelStatementForNode = (
@@ -162,30 +166,30 @@ const getTopLevelStatementForNode = (
   return current;
 };
 
-const getVariableDeclaratorForNode = (
+const getExportedVariableDeclaratorForNode = (
   module: Module,
   node: AnyNode
 ): AnyNode | null => {
-  let current: AnyNode | null = node;
-  while (current) {
-    if (current.type === 'VariableDeclarator') {
-      return current;
+  let current = node as Node;
+  while (true) {
+    const parent = module.parentOf(current);
+    if (!parent || parent.type === 'Program') {
+      return null;
     }
-    current = module.parentOf(current as never) as AnyNode | null;
-  }
-  return null;
-};
-
-const isTopLevelExportedVariableDeclarator = (
-  module: Module,
-  node: AnyNode
-): boolean => {
-  const declaration = module.parentOf(node as never) as AnyNode | null;
-  if (declaration?.type !== 'VariableDeclaration') {
-    return false;
+    if (
+      current.type === 'VariableDeclarator' &&
+      parent.type === 'VariableDeclaration'
+    ) {
+      const exported = module.parentOf(parent);
+      if (
+        exported?.type === 'ExportNamedDeclaration' &&
+        module.parentOf(exported)?.type === 'Program'
+      ) {
+        return current;
+      }
+    }
+    current = parent;
   }
-  const statement = module.parentOf(declaration as never) as AnyNode | null;
-  return statement?.type === 'ExportNamedDeclaration';
 };
 
 const getExportedName = (exported: AnyNode): string => {
@@ -241,9 +245,29 @@ const getExportDependencies = (
     code,
     () => {
       const { module } = analyzeCode(code, cache, cacheKey);
+      const namedExports = module.exports.filter(
+        (exp): exp is YukuExport & { name: string } =>
+          exp.name !== null &&
+          !exp.typeOnly &&
+          !exp.isStar &&
+          !exp.isExportEquals
+      );
+      // Removing type declarations can change legacy decorator metadata and
+      // name hygiene. Preserve the original dependency graph for decorated
+      // modules because the downstream compiler options are not known here.
+      let hasDecorators = false;
+      walk(module.ast, {
+        Decorator(_node, context) {
+          hasDecorators = true;
+          context.stop();
+        },
+      });
       const exportDependencies = new Map<string, ExportDependencies>();
       const topLevelStatementCache = new Map<AnyNode, AnyNode>();
-      const variableDeclaratorCache = new Map<AnyNode, AnyNode | null>();
+      const exportedVariableDeclaratorCache = new Map<
+        AnyNode,
+        AnyNode | null
+      >();
       const getCachedTopLevelStatementForNode = (node: AnyNode): AnyNode => {
         const cached = topLevelStatementCache.get(node);
         if (cached) {
@@ -254,14 +278,67 @@ const getExportDependencies = (
         return statement;
       };
 
-      const getCachedVariableDeclaratorForNode = (
+      // Ordinary imports can be repeated in multiple chunks. Exported local
+      // bindings must keep a single owner, including functions and classes.
+      const nonShareableExportedSymbols = new Set<YukuSymbol>();
+      for (const { local } of namedExports) {
+        if (!local?.has(SymbolFlags.ValueSpace | SymbolFlags.ValueImport)) {
+          continue;
+        }
+        const isImport = local.declarations.every(
+          declaration =>
+            getCachedTopLevelStatementForNode(declaration).type ===
+            'ImportDeclaration'
+        );
+        // Setup belongs to the imported value too. If another export consumes
+        // that value, moving its setup into a separate chunk changes behavior.
+        const hasSetup =
+          isImport &&
+          local.references.some(reference => {
+            const statement = getCachedTopLevelStatementForNode(reference.node);
+            return (
+              reference.kind === 'value' &&
+              statement.type !== 'ImportDeclaration' &&
+              !statement.type.startsWith('Export')
+            );
+          });
+        if (isImport && !hasSetup) continue;
+        nonShareableExportedSymbols.add(local);
+      }
+
+      const isValueImportEqualsReference = (
+        reference: YukuReference
+      ): boolean => {
+        let node: Node = reference.node;
+        let parent = module.parentOf(node);
+        while (parent?.type === 'TSQualifiedName') {
+          node = parent;
+          parent = module.parentOf(node);
+        }
+        // Yuku also marks the runtime RHS of `import x = Namespace.value`
+        // as a type reference.
+        return (
+          parent?.type === 'TSImportEqualsDeclaration' &&
+          parent.moduleReference === node &&
+          parent.importKind !== 'type'
+        );
+      };
+
+      const isRuntimeRelevantReference = (reference: YukuReference): boolean =>
+        hasDecorators ||
+        reference.kind === 'value' ||
+        isValueImportEqualsReference(reference);
+
+      const getCachedExportedVariableDeclaratorForNode = (
         node: AnyNode
       ): AnyNode | null => {
-        if (variableDeclaratorCache.has(node)) {
-          return variableDeclaratorCache.get(node) ?? null;
+        if (exportedVariableDeclaratorCache.has(node)) {
+          return exportedVariableDeclaratorCache.get(node) ?? null;
         }
-        const declarator = getVariableDeclaratorForNode(module, node);
-        variableDeclaratorCache.set(node, declarator);
+        // Only direct exported declarators can be emitted independently.
+        // Every other top-level statement is moved as a whole.
+        const declarator = getExportedVariableDeclaratorForNode(module, node);
+        exportedVariableDeclaratorCache.set(node, declarator);
         return declarator;
       };
 
@@ -291,22 +368,41 @@ const getExportDependencies = (
           importedIdentifierNames: new Set(),
           importSources: new Set(),
           exportedVariableDeclarators: new Set(),
+          exportedLocalSymbols: new Set(),
         };
         const visitedSymbols = new Set<YukuSymbol>();
         const scannedNodes = new Set<AnyNode>();
 
+        const visitIdentifier = (node: YukuReference['node']) => {
+          const reference = module.referenceOf(node);
+          if (reference) {
+            if (reference.symbol && isRuntimeRelevantReference(reference)) {
+              visitSymbol(reference.symbol);
+            }
+            return;
+          }
+          const symbol = module.symbolOf(node);
+          if (
+            symbol?.scope === module.rootScope &&
+            symbol.has(SymbolFlags.ValueSpace | SymbolFlags.ValueImport) &&
+            dependencies.topLevelNonModuleStatements.has(
+              getCachedTopLevelStatementForNode(node)
+            )
+          ) {
+            // Moving a statement also moves the bindings it declares. Follow
+            // their consumers so no references remain in another chunk.
+            visitSymbol(symbol);
+          }
+        };
+
         const scanNode = (node: AnyNode) => {
           if (scannedNodes.has(node)) {
             return;
           }
           scannedNodes.add(node);
           walk(node as any, {
-            Identifier(node: AnyNode) {
-              const reference = module.referenceOf(node as never);
-              if (reference?.symbol) {
-                visitSymbol(reference.symbol);
-              }
-            },
+            Identifier: visitIdentifier,
+            JSXIdentifier: visitIdentifier,
           });
         };
 
@@ -318,6 +414,9 @@ const getExportDependencies = (
           if (symbol.declarations.length === 0) {
             return;
           }
+          if (nonShareableExportedSymbols.has(symbol)) {
+            dependencies.exportedLocalSymbols.add(symbol);
+          }
 
           for (const declaration of symbol.declarations as AnyNode[]) {
             const statement = addCachedTopLevelStatement(
@@ -329,24 +428,27 @@ const getExportDependencies = (
               if (typeof statement.source?.value === 'string') {
                 dependencies.importSources.add(statement.source.value);
               }
-              return;
+              // Ordinary imports are shareable; a directly exported import
+              // also owns setup statements such as `load.hydrate = true`.
+              if (symbol !== localSymbol) return;
             }
-            const declarator = getCachedVariableDeclaratorForNode(declaration);
-            if (
-              declarator &&
-              isTopLevelExportedVariableDeclarator(module, declarator)
-            ) {
+            const declarator =
+              getCachedExportedVariableDeclaratorForNode(declaration);
+            if (declarator) {
               dependencies.exportedVariableDeclarators.add(declarator);
             }
             scanNode(declarator ?? statement);
           }
 
-          for (const reference of symbol.references as any[]) {
+          for (const reference of symbol.references) {
+            if (!isRuntimeRelevantReference(reference)) {
+              continue;
+            }
             const statement = addCachedTopLevelStatement(
               dependencies,
               reference.node
             );
-            const declarator = getCachedVariableDeclaratorForNode(
+            const declarator = getCachedExportedVariableDeclaratorForNode(
               reference.node
             );
             scanNode(declarator ?? statement);
@@ -365,10 +467,7 @@ const getExportDependencies = (
         exportDependencies.set(exportName, dependencies);
       };
 
-      for (const exp of module.exports as any[]) {
-        if (exp.typeOnly || exp.isStar || exp.isExportEquals) {
-          continue;
-        }
+      for (const exp of namedExports) {
         handleExport(exp.name, exp.node as AnyNode, exp.local ?? null);
       }
 
@@ -383,7 +482,7 @@ const isExportChunkable = (
   importer: string
 ) => {
   const dependencies = exportDependencies.get(exportName);
-  if (!dependencies) {
+  if (!dependencies || dependencies.exportedVariableDeclarators.size > 1) {
     return false;
   }
   if (exportName === 'clientLoader' && hasHydrateAssignment(dependencies)) {
@@ -403,29 +502,19 @@ const isExportChunkable = (
       setsIntersect(
         currentDependencies.topLevelNonModuleStatements,
         dependencies.topLevelNonModuleStatements
+      ) ||
+      setsIntersect(
+        currentDependencies.exportedVariableDeclarators,
+        dependencies.exportedVariableDeclarators
+      ) ||
+      setsIntersect(
+        currentDependencies.exportedLocalSymbols,
+        dependencies.exportedLocalSymbols
       )
     ) {
       return false;
     }
   }
-  if (dependencies.exportedVariableDeclarators.size > 1) {
-    return false;
-  }
-  if (dependencies.exportedVariableDeclarators.size > 0) {
-    for (const [currentExportName, currentDependencies] of exportDependencies) {
-      if (currentExportName === exportName) {
-        continue;
-      }
-      if (
-        setsIntersect(
-          currentDependencies.exportedVariableDeclarators,
-          dependencies.exportedVariableDeclarators
-        )
-      ) {
-        return false;
-      }
-    }
-  }
   return true;
 };
 

package/src/rsc-prerender.ts

@@ -1,10 +1,10 @@
 import { existsSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { pathToFileURL } from 'node:url';
 import type { RsbuildPluginAPI } from '@rsbuild/core';
 import { dirname, relative, resolve } from 'pathe';
 import * as Effect from 'effect/Effect';
 import { PLUGIN_NAME, SPA_FALLBACK_HTML_FILE } from './constants.js';
+import { startServerBuildWorker } from './server-build-worker-client.js';
 import {
   createBuildRequestEffect,
   createBoundedPrerenderTasksEffect,
@@ -27,8 +27,9 @@ import { runPluginEffect } from './effect-runtime.js';
  *   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`.
+ * bundle's default-exported `fetch` handler is invoked directly (in the
+ * server build worker), matching how classic mode prerenders through
+ * `createRequestHandler`.
  */
 
 export const SPA_FALLBACK_REQUEST_PATH: string = `/${SPA_FALLBACK_HTML_FILE}`;
@@ -145,29 +146,6 @@ const createRedirectHtml = ({
 </html>`;
 };
 
-const resolveRscRequestHandler = (
-  buildModule: unknown,
-  serverBuildPath: string
-): RscRequestHandler => {
-  const moduleRecord = buildModule as
-    | { default?: { fetch?: unknown; default?: { fetch?: unknown } } }
-    | undefined;
-  const handler =
-    typeof moduleRecord?.default?.fetch === 'function'
-      ? moduleRecord.default.fetch
-      : typeof moduleRecord?.default?.default?.fetch === 'function'
-        ? moduleRecord.default.default.fetch
-        : null;
-  if (!handler) {
-    throw new Error(
-      `[${PLUGIN_NAME}] RSC server build ${JSON.stringify(
-        serverBuildPath
-      )} must default-export an object with a fetch function.`
-    );
-  }
-  return handler as RscRequestHandler;
-};
-
 const writePrerenderedFile = async ({
   api,
   clientBuildDir,
@@ -330,11 +308,9 @@ export const runReactRouterRscPrerenderBuild = async (
   const clientBuildDir = resolve(buildDirectory, 'client');
   await mkdir(clientBuildDir, { recursive: true });
 
-  const previousBuildRequestFlag = process.env.IS_RR_BUILD_REQUEST;
-  process.env.IS_RR_BUILD_REQUEST = 'yes';
+  const worker = await startServerBuildWorker({ serverBuildPath, mode: 'rsc' });
   try {
-    const buildModule = await import(pathToFileURL(serverBuildPath).toString());
-    const handler = resolveRscRequestHandler(buildModule, serverBuildPath);
+    const handler: RscRequestHandler = worker.handler;
 
     api.logger.info(`Prerender: ${prerenderRequests.length} path(s)...`);
 
@@ -353,10 +329,6 @@ export const runReactRouterRscPrerenderBuild = async (
       )
     );
   } finally {
-    if (previousBuildRequestFlag === undefined) {
-      delete process.env.IS_RR_BUILD_REQUEST;
-    } else {
-      process.env.IS_RR_BUILD_REQUEST = previousBuildRequestFlag;
-    }
+    await worker.close();
   }
 };

package/src/server-build-resolution.ts

@@ -1,7 +1,6 @@
 // Internal module: exposes ServerBuild resolution used by dev-runtime code.
 // External callers go through the Promise wrappers in server-utils.ts.
 import type { ServerBuild } from 'react-router';
-import { normalizeEffectError } from './effect-runtime.js';
 
 const RESOLVABLE_BUILD_EXPORTS = new Set([
   'allowedActionOrigins',
@@ -116,6 +115,6 @@ export async function resolveServerBuildModule(
       `[rsbuild-plugin-react-router] ${source} did not contain a valid React Router ServerBuild.`
     );
   } catch (cause) {
-    throw normalizeEffectError(cause);
+    throw cause instanceof Error ? cause : new Error(String(cause));
   }
 }

package/src/server-build-worker-client.ts

@@ -0,0 +1,221 @@
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { normalizeEffectError } from './effect-runtime.js';
+import {
+  headerEntries,
+  type ServerBuildDescription,
+  type ServerBuildWorkerData,
+  type ServerBuildWorkerRequest,
+  type ServerBuildWorkerResponse,
+} from './server-build-worker-protocol.js';
+
+const defaultWorkerPath = fileURLToPath(
+  new URL('./server-build-worker.js', import.meta.url)
+);
+
+export type ServerBuildWorker = {
+  /** Plain-data view of the classic server build (routes, assets, prerender). */
+  description: ServerBuildDescription | undefined;
+  /** Runs the request against the server build in the worker. */
+  handler(request: Request): Promise<Response>;
+  /** Terminates the worker, and with it any handle the server graph opened. */
+  close(): Promise<void>;
+};
+
+type Reply = Exclude<ServerBuildWorkerResponse, { type: 'ready' | 'closed' }>;
+
+type Pending = {
+  resolve: (reply: Reply) => void;
+  reject: (error: Error) => void;
+};
+
+const replyError = (reply: Extract<Reply, { ok: false }>): Error => {
+  const error = new Error(reply.error.message);
+  error.name = reply.error.name ?? error.name;
+  if (reply.error.stack) {
+    error.stack = reply.error.stack;
+  }
+  return error;
+};
+
+/**
+ * Evaluate a built server bundle in a worker thread and proxy requests to it.
+ * Build-time rendering used to `import()` the bundle into the build process;
+ * a module-scope handle in the app's server graph then kept `rsbuild build`
+ * alive forever (#135). The worker is terminated by `close()`.
+ *
+ * The worker's `exit` is its final event, so any exit (including one between
+ * requests, e.g. the app calling `process.exit`) is terminal: outstanding and
+ * later requests reject instead of waiting for a reply that cannot come.
+ */
+export const startServerBuildWorker = async (
+  data: ServerBuildWorkerData,
+  // Tests run from `src/` and point this at the built worker.
+  workerPath: string = defaultWorkerPath
+): Promise<ServerBuildWorker> => {
+  const worker = new Worker(workerPath, { workerData: data });
+  const pending = new Map<number, Pending>();
+  const active = new Map<number, (error: Error) => void>();
+  let nextId = 0;
+  let failure: Error | undefined;
+  let acknowledgeClose: () => void = () => {};
+  const closed = new Promise<void>(resolve => {
+    acknowledgeClose = resolve;
+  });
+
+  const fail = (error: Error): void => {
+    failure ??= error;
+    for (const { reject } of pending.values()) {
+      reject(failure);
+    }
+    pending.clear();
+    for (const stop of active.values()) stop(failure);
+    active.clear();
+  };
+
+  const ready = new Promise<ServerBuildDescription | undefined>(
+    (resolve, reject) => {
+      worker.on('message', (message: ServerBuildWorkerResponse) => {
+        if (message.type === 'closed') {
+          acknowledgeClose();
+          return;
+        }
+        if (message.type === 'ready') {
+          resolve(message.description);
+          return;
+        }
+        const entry = pending.get(message.id);
+        pending.delete(message.id);
+        entry?.resolve(message);
+      });
+      worker.on('error', error => {
+        acknowledgeClose();
+        fail(normalizeEffectError(error));
+        reject(failure);
+      });
+      worker.on('exit', code => {
+        acknowledgeClose();
+        fail(new Error(`Server build worker exited with code ${code}`));
+        reject(failure);
+      });
+    }
+  );
+
+  const send = (
+    request: ServerBuildWorkerRequest,
+    transfer: ArrayBuffer[] = []
+  ): void => {
+    worker.postMessage(request, transfer);
+  };
+
+  // Import errors surface as worker 'error' events, an early exit as 'exit'.
+  const description = await ready;
+
+  return {
+    description,
+    async handler(request) {
+      const id = nextId++;
+      const body = request.body
+        ? new Uint8Array(await request.arrayBuffer())
+        : undefined;
+      let responseController:
+        | ReadableStreamDefaultController<Uint8Array>
+        | undefined;
+      const cleanup = (): void => {
+        active.delete(id);
+        request.signal.removeEventListener('abort', onAbort);
+      };
+      const stop = (error: Error): void => {
+        responseController?.error(error);
+        pending.get(id)?.reject(error);
+        pending.delete(id);
+        cleanup();
+      };
+      // Keep the relay alive after headers arrive: RSC may release a redirect
+      // or rejected status without ever consuming its response body.
+      const onAbort = (): void => {
+        send({ type: 'abort', id });
+        if (responseController)
+          stop(new Error('Server build request was aborted'));
+      };
+      const reply = await new Promise<Reply>((resolve, reject) => {
+        if (failure) {
+          reject(failure);
+          return;
+        }
+        pending.set(id, { resolve, reject });
+        active.set(id, stop);
+        request.signal.addEventListener('abort', onAbort, { once: true });
+        send(
+          {
+            type: 'request',
+            id,
+            url: request.url,
+            method: request.method,
+            headers: headerEntries(request.headers),
+            body,
+          },
+          body ? [body.buffer] : []
+        );
+        if (request.signal.aborted) onAbort();
+      }).catch(error => {
+        cleanup();
+        throw error;
+      });
+      if (!reply.ok) {
+        cleanup();
+        throw replyError(reply);
+      }
+      if (reply.type !== 'reply')
+        throw new Error('Unexpected server build response');
+      const { status, statusText, headers, hasBody } = reply.response;
+      const responseBody = hasBody
+        ? new ReadableStream<Uint8Array>(
+            {
+              start(controller) {
+                responseController = controller;
+              },
+              async pull(controller) {
+                try {
+                  const result = await new Promise<Reply>((resolve, reject) => {
+                    if (failure) {
+                      reject(failure);
+                      return;
+                    }
+                    pending.set(id, { resolve, reject });
+                    send({ type: 'read', id });
+                  });
+                  if (!result.ok) throw replyError(result);
+                  if (result.type !== 'body')
+                    throw new Error('Unexpected server build body');
+                  controller.enqueue(result.body);
+                  controller.close();
+                } catch (error) {
+                  controller.error(error);
+                } finally {
+                  cleanup();
+                }
+              },
+              cancel() {
+                send({ type: 'abort', id });
+                stop(new Error('Server build response was canceled'));
+              },
+            },
+            { highWaterMark: 0 }
+          )
+        : null;
+      if (!hasBody) cleanup();
+      return new Response(responseBody, {
+        status,
+        statusText,
+        headers,
+      });
+    },
+    async close() {
+      fail(new Error('Server build worker was closed'));
+      send({ type: 'close' });
+      await closed;
+      await worker.terminate();
+    },
+  };
+};