feat: add source map support for production stack trace rewriting

packages/react-server/lib/build/server.mjs

@@ -531,5 +531,17 @@ export default async function serverBuild(root, options) {
       "utf8"
     );
   }
+
+  // Write build metadata with sourcemap option
+  await writeFile(
+    join(cwd, options.outDir, "server/build-meta.json"),
+    JSON.stringify({
+      sourcemap:
+        options.sourcemap !== false ? options.sourcemap || true : false,
+      buildTime: new Date().toISOString(),
+    }),
+    "utf8"
+  );
+
   return true;
 }

packages/react-server/lib/start/ssr-handler.mjs

@@ -1,6 +1,7 @@
+import { existsSync, readFileSync } from "node:fs";
 import { createRequire, register } from "node:module";
 import { join, relative } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { init$ as cache_init$, useCache } from "../../cache/index.mjs";
 import { context$, ContextStorage, getContext } from "../../server/context.mjs";
@@ -83,12 +84,16 @@ export default async function ssrHandler(root, options = {}) {
   }
   const [
     { render },
+    { default: buildMetadata },
     { default: Component, init$: root_init$ },
     { default: GlobalErrorComponent },
     { default: ErrorBoundary },
     rscSerializer,
   ] = await Promise.all([
     import(pathToFileURL(entryModule)),
+    import(pathToFileURL(join(cwd, options.outDir, "server/build-meta.json")), {
+      with: { type: "json" },
+    }),
     import(pathToFileURL(rootModule)),
     import(pathToFileURL(globalErrorModule)),
     errorBoundary
@@ -109,6 +114,34 @@ export default async function ssrHandler(root, options = {}) {
   const moduleCacheStorage = new ContextManager();
   await module_loader_init$(moduleLoader, moduleCacheStorage);
 
+  if (buildMetadata.sourcemap && buildMetadata.sourcemap !== false) {
+    const { default: sourceMapSupport } = await import("source-map-support");
+    sourceMapSupport.install({
+      environment: "node",
+      hookRequire: buildMetadata.sourcemap === "inline",
+      handleUncaughtExceptions: false,
+      retrieveSourceMap:
+        buildMetadata.sourcemap === "hidden"
+          ? (source) => {
+              logger.info(`Retrieving source map for ${source}`);
+              if (source.startsWith("file:")) {
+                const mapFilePath = fileURLToPath(source) + ".map";
+                if (existsSync(mapFilePath)) {
+                  return {
+                    url: source,
+                    map: readFileSync(mapFilePath, "utf8"),
+                  };
+                }
+              }
+              return null;
+            }
+          : undefined,
+    });
+    logger.info(
+      `Source map (${buildMetadata.sourcemap === true ? "file" : buildMetadata.sourcemap}) stack trace mapping support enabled`
+    );
+  }
+
   const importMap =
     configRoot.importMap || configRoot.resolve?.shared
       ? {

packages/react-server/package.json

@@ -163,6 +163,7 @@
     "socket.io": "^4.8.1",
     "socket.io-client": "^4.8.1",
     "source-map": "^0.7.4",
+    "source-map-support": "^0.5.21",
     "strip-ansi": "^7.1.0",
     "style-to-js": "^1.1.12",
     "unstorage": "^1.16.0",

packages/react-server/server/render-rsc.jsx

@@ -52,6 +52,34 @@ import {
 import { ServerFunctionNotFoundError } from "./action-state.mjs";
 import { cwd } from "../lib/sys.mjs";
 
+/**
+ * Helper to log errors with source-mapped stack traces.
+ * Forces Error.prepareStackTrace to run if installed by source-map-support.
+ */
+function logErrorWithStackTrace(logger, error) {
+  if (!error) return;
+  if (
+    error.stack.startsWith(
+      "Error: An error occurred in the Server Components render."
+    )
+  )
+    return;
+
+  // Access .stack to trigger Error.prepareStackTrace if it's been set
+  // source-map-support hooks into this to provide mapped stack traces
+  const stack = error.stack;
+
+  // Log the error with its prepared stack trace
+  if (logger?.error) {
+    logger.error(error);
+  } else {
+    console.error(error);
+  }
+
+  // Return the stack for potential further processing
+  return stack;
+}
+
 const serverReferenceMap = new Proxy(
   {},
   {
@@ -522,6 +550,10 @@ export async function render(Component, props = {}, options = {}) {
                   temporaryReferences,
                   onError(e) {
                     hasError = true;
+                    // Log error with source-mapped stack trace
+                    if (import.meta.env.PROD) {
+                      logErrorWithStackTrace(logger, e);
+                    }
                     const redirect = getContext(REDIRECT_CONTEXT);
                     if (redirect?.response) {
                       return `Location=${redirect.response.headers.get("location")}`;
@@ -660,6 +692,10 @@ export async function render(Component, props = {}, options = {}) {
               temporaryReferences,
               onError(e) {
                 hasError = true;
+                // Log error with source-mapped stack trace
+                if (import.meta.env.PROD) {
+                  logErrorWithStackTrace(logger, e);
+                }
                 const redirect = getContext(REDIRECT_CONTEXT);
                 if (redirect?.response) {
                   return resolve(redirect.response);
@@ -763,7 +799,8 @@ export async function render(Component, props = {}, options = {}) {
               if (!e.digest && digest) {
                 e.digest = digest;
               }
-              (logger ?? console).error(e);
+              // Log error with source-mapped stack trace
+              logErrorWithStackTrace(logger, e);
               hasError = true;
               if (!isStarted) {
                 ContextStorage.run(contextStore, async () => {
@@ -822,13 +859,15 @@ export async function render(Component, props = {}, options = {}) {
           );
         }
       } catch (e) {
-        logger.error(e);
+        // Log error with source-mapped stack trace
+        logErrorWithStackTrace(logger, e);
         getContext(ERROR_CONTEXT)?.(e)?.then(resolve, reject);
       }
     });
     return streaming;
   } catch (e) {
-    logger.error(e);
+    // Log error with source-mapped stack trace
+    logErrorWithStackTrace(logger, e);
     return new Response(null, {
       status: 500,
       statusText: "Internal Server Error",