vite-plugin-react-server 1.4.1 → 1.4.3

package/dist/plugin/react-static/renderPage.server.js

@@ -1,533 +1,510 @@
 /**
- * renderPage.server.ts
- *
- * PURPOSE: Server-side static page rendering for React Server Components
- *
- * ARCHITECTURE OVERVIEW:
- *
- * SERVER-SIDE vs CLIENT-SIDE:
- * - Server-side: RSC generation in main thread, HTML generation in worker
- * - Client-side: RSC generation in worker, HTML generation in main thread
- *
- * FLOW:
- * 1. Create headless RSC stream (for .rsc file)
- * 2. Create full RSC stream (for HTML generation)
- * 3. Create HTML transform stream that converts RSC to HTML
- * 4. Both streams are piped to file writers
- *
- * SIMPLIFIED APPROACH:
- * This implementation follows the same simple pattern as the client side,
- * avoiding complex backpressure handling and race conditions.
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
  */
-import { createRenderMetrics } from "../metrics/createRenderMetrics.js";
-import { routeToURL } from "../utils/routeToURL.js";
-import { handleError } from "../error/handleError.js";
-import { assertReactServer } from "../config/getCondition.js";
-import { renderRscStream } from "../stream/renderRscStream.server.js";
-import { createMainThreadHandlers } from "../stream/createMainThreadHandlers.js";
-import { createRscToHtmlStream } from "./rscToHtmlStream.server.js";
-import { resolveComponent } from "../helpers/resolveComponent.js";
-import { resolvePageAndProps } from "../helpers/resolvePageAndProps.js";
-import { Root as DefaultRoot } from "../components/root.js";
-import { Html as DefaultHtml } from "../components/html.js";
-import { createStreamMetrics } from "../metrics/createStreamMetrics.js";
-import { join } from "node:path";
-import { createHeadlessStreamState, trackHeadlessStreamError, hasHeadlessStreamError } from "../helpers/headlessStreamState.js";
-export const renderPage = async function* renderPage(handlerOptions) {
-    // Ensure we're in the correct environment
-    assertReactServer();
-    // Create metrics upfront with proper types
-    const baseDir = join(handlerOptions.build.outDir, handlerOptions.build.static);
-    const routePath = handlerOptions.route.replace(/^\//, "");
-    const htmlMetrics = createRenderMetrics({
-        route: handlerOptions.route,
-        type: "html",
-        fromMainThread: false, // Server: HTML rendered in worker
-        fromRscWorker: false,
-        fromHtmlWorker: true,
-        baseDir,
-        routePath,
-        fileName: handlerOptions.build.htmlOutputPath,
-        outputPath: join(baseDir, routePath, handlerOptions.build.htmlOutputPath),
-    });
-    const rscFullMetrics = createRenderMetrics({
-        route: handlerOptions.route,
-        type: "rsc-full",
-        fromMainThread: true, // Server: RSC rendered on main thread
-        fromRscWorker: false,
-        fromHtmlWorker: false,
-    });
-    const rscHeadlessMetrics = createRenderMetrics({
-        route: handlerOptions.route,
-        type: "rsc-headless",
-        fromMainThread: true, // Server: RSC rendered on main thread
-        fromRscWorker: false,
-        fromHtmlWorker: false,
-        baseDir,
-        routePath,
-        fileName: handlerOptions.build.rscOutputPath,
-        outputPath: join(baseDir, routePath, handlerOptions.build.rscOutputPath),
-    });
-    // Declare variables outside try block
-    let headlessRscHandler = null;
-    let fullRscHandler = null;
-    let htmlTransformStream = null;
-    // Error tracking variables for headless stream
-    let headlessStreamErrored = false;
-    let headlessError = null;
-    // Error tracking variables for HTML stream
-    let htmlStreamErrored = false;
-    let htmlStreamError = null;
-    // Server-side stream reuse storage (similar to client-side headlessStreamElements)
-    const headlessStreamState = createHeadlessStreamState();
-    try {
-        if (handlerOptions.verbose) {
-            handlerOptions.logger?.info(`[renderPage.server] Server-side rendering for route: ${handlerOptions.route}`);
-        }
-        // Set URL if not provided
-        if (!handlerOptions.url) {
-            handlerOptions.url = routeToURL(handlerOptions.route, handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath);
-        }
-        // Resolve components and props using the proper helper
-        let PageComponent = null;
-        let RootComponent = null;
-        let HtmlComponent = null;
-        let pageProps = {}; // Initialize as empty object - props function will populate it
-        // Use resolvePageAndProps helper to properly load page and props
-        if (handlerOptions.pagePath) {
-            try {
-                const pageAndPropsResult = await resolvePageAndProps({
-                    pagePath: handlerOptions.pagePath,
-                    pageExportName: handlerOptions.pageExportName,
-                    propsPath: handlerOptions.propsPath,
-                    propsExportName: handlerOptions.propsExportName,
-                    loader: handlerOptions.loader,
-                    verbose: handlerOptions.verbose,
-                    logger: handlerOptions.logger,
-                    route: handlerOptions.route,
-                    url: handlerOptions.url,
-                    moduleBaseURL: handlerOptions.moduleBaseURL,
-                    build: {
-                        rscOutputPath: handlerOptions.build.rscOutputPath,
-                    },
-                });
-                if (pageAndPropsResult.type === "success") {
-                    PageComponent = pageAndPropsResult.PageComponent;
-                    // Always use the props returned from the props function
-                    // Root components can handle empty props with their defaults
-                    pageProps = pageAndPropsResult.pageProps || {};
-                    if (handlerOptions.verbose) {
-                        handlerOptions.logger?.info(`[renderPage.server] Successfully loaded page and props for route ${handlerOptions.route}: pageProps=${JSON.stringify(pageProps)}`);
-                    }
-                }
-                else {
-                    handlerOptions.logger?.warn(`Failed to load page and props from ${handlerOptions.pagePath}: ${pageAndPropsResult.error?.message || "Unknown error"}`);
-                }
-            }
-            catch (error) {
-                handlerOptions.logger?.warn(`Error loading page and props from ${handlerOptions.pagePath}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // Load Root component
-        if (handlerOptions.rootPath) {
-            try {
-                const rootResult = await resolveComponent({
-                    componentPath: handlerOptions.rootPath,
-                    exportName: handlerOptions.rootExportName,
-                    loader: handlerOptions.loader,
-                });
-                if (rootResult.type === "success") {
-                    RootComponent = rootResult.component;
-                }
-                else {
-                    handlerOptions.logger?.warn(`Failed to load Root component from ${handlerOptions.rootPath}: ${rootResult.error?.message || "Unknown error"}`);
-                }
-            }
-            catch (error) {
-                handlerOptions.logger?.warn(`Error loading Root component from ${handlerOptions.rootPath}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // Load Html component
-        if (handlerOptions.htmlPath) {
-            try {
-                const htmlResult = await resolveComponent({
-                    componentPath: handlerOptions.htmlPath,
-                    exportName: handlerOptions.htmlExportName,
-                    loader: handlerOptions.loader,
-                });
-                if (htmlResult.type === "success") {
-                    HtmlComponent = htmlResult.component;
-                }
-                else {
-                    handlerOptions.logger?.warn(`Failed to load Html component from ${handlerOptions.htmlPath}: ${htmlResult.error?.message || "Unknown error"}`);
-                }
-            }
-            catch (error) {
-                handlerOptions.logger?.warn(`Error loading Html component from ${handlerOptions.htmlPath}: ${error instanceof Error ? error.message : String(error)}`);
-            }
+import { createRenderMetrics } from '../metrics/createRenderMetrics.js';
+import { routeToURL } from '../utils/routeToURL.js';
+import { handleError } from '../error/handleError.js';
+import { assertReactServer } from '../config/getCondition.js';
+import { renderRscStream } from '../stream/renderRscStream.server.js';
+import { createMainThreadHandlers } from '../stream/createMainThreadHandlers.js';
+import { createRscToHtmlStream } from './rscToHtmlStream.server.js';
+import { resolveComponent } from '../helpers/resolveComponent.js';
+import { resolvePageAndProps } from '../helpers/resolvePageAndProps.js';
+import { Root } from '../components/root.js';
+import { Html } from '../components/html.js';
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
+import { join } from 'node:path';
+import { trackHeadlessStreamError, createHeadlessStreamState, hasHeadlessStreamError } from '../helpers/headlessStreamState.js';
+
+const renderPage = async function* renderPage2(handlerOptions) {
+  assertReactServer();
+  const baseDir = join(
+    handlerOptions.build.outDir,
+    handlerOptions.build.static
+  );
+  const routePath = handlerOptions.route.replace(/^\//, "");
+  const htmlMetrics = createRenderMetrics({
+    route: handlerOptions.route,
+    type: "html",
+    fromMainThread: false,
+    // Server: HTML rendered in worker
+    fromRscWorker: false,
+    fromHtmlWorker: true,
+    baseDir,
+    routePath,
+    fileName: handlerOptions.build.htmlOutputPath,
+    outputPath: join(baseDir, routePath, handlerOptions.build.htmlOutputPath)
+  });
+  const rscFullMetrics = createRenderMetrics({
+    route: handlerOptions.route,
+    type: "rsc-full",
+    fromMainThread: true,
+    // Server: RSC rendered on main thread
+    fromRscWorker: false,
+    fromHtmlWorker: false
+  });
+  const rscHeadlessMetrics = createRenderMetrics({
+    route: handlerOptions.route,
+    type: "rsc-headless",
+    fromMainThread: true,
+    // Server: RSC rendered on main thread
+    fromRscWorker: false,
+    fromHtmlWorker: false,
+    baseDir,
+    routePath,
+    fileName: handlerOptions.build.rscOutputPath,
+    outputPath: join(baseDir, routePath, handlerOptions.build.rscOutputPath)
+  });
+  let headlessRscHandler = null;
+  let fullRscHandler = null;
+  let htmlTransformStream = null;
+  let headlessStreamErrored = false;
+  let headlessError = null;
+  let htmlStreamErrored = false;
+  let htmlStreamError = null;
+  const headlessStreamState = createHeadlessStreamState();
+  try {
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[renderPage.server] Server-side rendering for route: ${handlerOptions.route}`
+      );
+    }
+    if (!handlerOptions.url) {
+      handlerOptions.url = routeToURL(
+        handlerOptions.route,
+        handlerOptions.moduleBaseURL,
+        handlerOptions.build.rscOutputPath
+      );
+    }
+    let PageComponent = null;
+    let RootComponent = null;
+    let HtmlComponent = null;
+    let pageProps = {};
+    if (handlerOptions.pagePath) {
+      try {
+        const pageAndPropsResult = await resolvePageAndProps({
+          pagePath: handlerOptions.pagePath,
+          pageExportName: handlerOptions.pageExportName,
+          propsPath: handlerOptions.propsPath,
+          propsExportName: handlerOptions.propsExportName,
+          loader: handlerOptions.loader,
+          verbose: handlerOptions.verbose,
+          logger: handlerOptions.logger,
+          route: handlerOptions.route,
+          url: handlerOptions.url,
+          moduleBaseURL: handlerOptions.moduleBaseURL,
+          build: {
+            rscOutputPath: handlerOptions.build.rscOutputPath
+          }
+        });
+        if (pageAndPropsResult.type === "success") {
+          PageComponent = pageAndPropsResult.PageComponent;
+          pageProps = pageAndPropsResult.pageProps || {};
+          if (handlerOptions.verbose) {
+            handlerOptions.logger?.info(
+              `[renderPage.server] Successfully loaded page and props for route ${handlerOptions.route}: pageProps=${JSON.stringify(pageProps)}`
+            );
+          }
+        } else {
+          handlerOptions.logger?.warn(
+            `Failed to load page and props from ${handlerOptions.pagePath}: ${pageAndPropsResult.error?.message || "Unknown error"}`
+          );
         }
-        // Use defaults if components are still not loaded
-        if (!RootComponent) {
-            RootComponent = DefaultRoot;
+      } catch (error) {
+        handlerOptions.logger?.warn(
+          `Error loading page and props from ${handlerOptions.pagePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (handlerOptions.rootPath) {
+      try {
+        const rootResult = await resolveComponent({
+          componentPath: handlerOptions.rootPath,
+          exportName: handlerOptions.rootExportName,
+          loader: handlerOptions.loader
+        });
+        if (rootResult.type === "success") {
+          RootComponent = rootResult.component;
+        } else {
+          handlerOptions.logger?.warn(
+            `Failed to load Root component from ${handlerOptions.rootPath}: ${rootResult.error?.message || "Unknown error"}`
+          );
         }
-        if (!HtmlComponent) {
-            HtmlComponent = DefaultHtml;
+      } catch (error) {
+        handlerOptions.logger?.warn(
+          `Error loading Root component from ${handlerOptions.rootPath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (handlerOptions.htmlPath) {
+      try {
+        const htmlResult = await resolveComponent({
+          componentPath: handlerOptions.htmlPath,
+          exportName: handlerOptions.htmlExportName,
+          loader: handlerOptions.loader
+        });
+        if (htmlResult.type === "success") {
+          HtmlComponent = htmlResult.component;
+        } else {
+          handlerOptions.logger?.warn(
+            `Failed to load Html component from ${handlerOptions.htmlPath}: ${htmlResult.error?.message || "Unknown error"}`
+          );
         }
-        // Ensure we have all required components
-        if (!PageComponent || !RootComponent || !HtmlComponent) {
-            yield {
-                type: "error",
-                error: new Error(`Component resolution failed: missing required components (Page: ${!!PageComponent}, Root: ${!!RootComponent}, Html: ${!!HtmlComponent})`),
-                metrics: {
-                    rscFull: rscFullMetrics,
-                    rscHeadless: rscHeadlessMetrics,
-                    html: htmlMetrics,
-                },
-            };
-            return;
+      } catch (error) {
+        handlerOptions.logger?.warn(
+          `Error loading Html component from ${handlerOptions.htmlPath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (!RootComponent) {
+      RootComponent = Root;
+    }
+    if (!HtmlComponent) {
+      HtmlComponent = Html;
+    }
+    if (!PageComponent || !RootComponent || !HtmlComponent) {
+      yield {
+        type: "error",
+        error: new Error(
+          `Component resolution failed: missing required components (Page: ${!!PageComponent}, Root: ${!!RootComponent}, Html: ${!!HtmlComponent})`
+        ),
+        metrics: {
+          rscFull: rscFullMetrics,
+          rscHeadless: rscHeadlessMetrics,
+          html: htmlMetrics
         }
-        // Create handler options with resolved components and props
-        const uniqueId = handlerOptions.id ?? `${handlerOptions.route}?id=${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const newHandlerOptions = {
-            ...handlerOptions,
-            id: uniqueId,
-            url: `${handlerOptions.url}`,
-            route: `${handlerOptions.route}`,
-            PageComponent,
-            RootComponent,
-            HtmlComponent,
-            pageProps,
-        };
+      };
+      return;
+    }
+    const uniqueId = handlerOptions.id ?? `${handlerOptions.route}?id=${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    const newHandlerOptions = {
+      ...handlerOptions,
+      id: uniqueId,
+      url: `${handlerOptions.url}`,
+      route: `${handlerOptions.route}`,
+      PageComponent,
+      RootComponent,
+      HtmlComponent,
+      pageProps
+    };
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[renderPage.server] Created newHandlerOptions for route ${handlerOptions.route} with pageProps: ${JSON.stringify(pageProps)}`
+      );
+    }
+    const headlessHandlers = createMainThreadHandlers(
+      handlerOptions,
+      (error, isPanic) => {
         if (handlerOptions.verbose) {
-            handlerOptions.logger?.info(`[renderPage.server] Created newHandlerOptions for route ${handlerOptions.route} with pageProps: ${JSON.stringify(pageProps)}`);
+          handlerOptions.logger?.info(
+            `[renderPage.server] Headless stream error handler called for route ${handlerOptions.route}: ${error.message}, isPanic: ${isPanic}`
+          );
         }
-        // Create headless RSC handler (for .rsc file) - with proper error handling
-        const headlessHandlers = createMainThreadHandlers(handlerOptions, (error, isPanic) => {
-            if (handlerOptions.verbose) {
-                handlerOptions.logger?.info(`[renderPage.server] Headless stream error handler called for route ${handlerOptions.route}: ${error.message}, isPanic: ${isPanic}`);
-            }
-            // Track if the headless stream had errors
-            headlessStreamErrored = true;
-            headlessError = error instanceof Error ? error : new Error("Headless RSC stream failed");
-            // Track headless stream errors for conditional reuse logic (like RSC worker)
-            trackHeadlessStreamError(headlessStreamState, handlerOptions.route, headlessError);
-            if (handlerOptions.verbose) {
-                handlerOptions.logger?.info(`[renderPage.server] Stored headless stream error for route ${handlerOptions.route} in headlessStreamErrors map`);
-            }
-            // Store panic errors for later handling
-            if (isPanic) {
-                // For panic threshold "all_errors", the panic error will be handled by renderPages
-                if (handlerOptions.verbose) {
-                    handlerOptions.logger?.info(`[renderPage.server] Panic error detected for route ${handlerOptions.route}, will be handled by renderPages`);
-                }
-            }
-        });
-        // Override onData to track metrics
-        headlessHandlers.onData = (_id, chunk) => {
-            rscHeadlessMetrics.chunks++;
-            rscHeadlessMetrics.streamMetrics.bytes += chunk.length;
-        };
-        headlessRscHandler = renderRscStream({
-            ...newHandlerOptions,
-            htmlPath: '', // Headless RSC - no HTML wrapper
-            // If we expect errors, provide a safe Page component that doesn't throw
-            PageComponent: newHandlerOptions.PageComponent, // Use original for now, will be overridden if errors occur
-        }, headlessHandlers);
-        // Note: Panic errors will be yielded from the error handler when they occur
-        // No need to check shouldYieldPanicError here as it's set asynchronously
-        // Store PageComponent for reuse when headless stream completes (like RSC worker)
-        headlessRscHandler.rscStream.on('end', () => {
-            // Only store if this is a headless stream and no errors occurred (like RSC worker)
-            if (!hasHeadlessStreamError(headlessStreamState, handlerOptions.route)) {
-                headlessStreamState.elements.set(uniqueId, {
-                    PageComponent: newHandlerOptions.PageComponent,
-                    errored: false
-                });
-                if (handlerOptions.verbose) {
-                    handlerOptions.logger?.info(`[renderPage.server] Stored PageComponent for headless stream ${uniqueId}`);
-                }
-            }
-            else {
-                if (handlerOptions.verbose) {
-                    handlerOptions.logger?.info(`[renderPage.server] Headless stream errored for route ${handlerOptions.route}, not storing PageComponent for reuse`);
-                }
-            }
-        });
-        // Create full RSC handler (for HTML generation) - reuse headless stream elements if no errors
-        // For server-side, we create both streams in parallel like the client-side
-        let fullPanicError = null;
-        const fullHandlers = createMainThreadHandlers(handlerOptions, (error, isPanic) => {
-            // If this is a panic error, store it to be handled later
-            if (isPanic) {
-                fullPanicError = error instanceof Error ? error : new Error("Full RSC stream failed");
-            }
-        });
-        // Override onData to track metrics
-        fullHandlers.onData = (_id, chunk) => {
-            rscFullMetrics.chunks++;
-            rscFullMetrics.streamMetrics.bytes += chunk.length;
-        };
-        // Create full RSC handler options - use React.Fragment if headless stream had errors (like RSC worker)
-        // Check if there are any existing headless stream errors for this route
-        const hasExistingHeadlessError = hasHeadlessStreamError(headlessStreamState, handlerOptions.route);
-        const shouldUseFallback = headlessStreamErrored || hasExistingHeadlessError;
+        headlessStreamErrored = true;
+        headlessError = error instanceof Error ? error : new Error("Headless RSC stream failed");
+        trackHeadlessStreamError(headlessStreamState, handlerOptions.route, headlessError);
         if (handlerOptions.verbose) {
-            handlerOptions.logger?.info(`[renderPage.server] Creating full RSC handler options for route ${handlerOptions.route}: headlessStreamErrored=${headlessStreamErrored}, hasExistingHeadlessError=${hasExistingHeadlessError}, shouldUseFallback=${shouldUseFallback}`);
+          handlerOptions.logger?.info(
+            `[renderPage.server] Stored headless stream error for route ${handlerOptions.route} in headlessStreamErrors map`
+          );
+        }
+        if (isPanic) {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger?.info(
+              `[renderPage.server] Panic error detected for route ${handlerOptions.route}, will be handled by renderPages`
+            );
+          }
         }
-        // Create a wrapper PageComponent that returns null if there are headless stream errors
-        const SafePageComponent = (props) => {
-            // Check if there are any headless stream errors for this route
-            const hasError = hasHeadlessStreamError(headlessStreamState, handlerOptions.route);
-            if (hasError) {
-                return null;
-            }
-            return newHandlerOptions.PageComponent(props);
-        };
-        const fullRscHandlerOptions = {
-            ...newHandlerOptions,
-            htmlPath: undefined, // Full RSC - include HTML wrapper
-            headlessStreamElements: headlessStreamState.elements, // Pass the storage map for reuse
-            // Use SafePageComponent that returns null when there are headless stream errors
-            PageComponent: SafePageComponent,
-        };
-        // Create a PageComponent that uses React.use() to consume the headless stream and check for errors
-        // Store the headless stream elements for reuse (like RSC worker does)
-        // Listen for the headless stream to complete and store its elements
-        headlessRscHandler.rscStream.on('end', () => {
-            if (!hasHeadlessStreamError(headlessStreamState, handlerOptions.route)) {
-                if (handlerOptions.verbose) {
-                    handlerOptions.logger?.info(`[renderPage.server] Headless stream completed successfully for route ${handlerOptions.route}`);
-                }
-            }
+      }
+    );
+    headlessHandlers.onData = (_id, chunk) => {
+      rscHeadlessMetrics.chunks++;
+      rscHeadlessMetrics.streamMetrics.bytes += chunk.length;
+    };
+    headlessRscHandler = renderRscStream(
+      {
+        ...newHandlerOptions,
+        htmlPath: "",
+        // Headless RSC - no HTML wrapper
+        // If we expect errors, provide a safe Page component that doesn't throw
+        PageComponent: newHandlerOptions.PageComponent
+        // Use original for now, will be overridden if errors occur
+      },
+      headlessHandlers
+    );
+    headlessRscHandler.rscStream.on("end", () => {
+      if (!hasHeadlessStreamError(headlessStreamState, handlerOptions.route)) {
+        headlessStreamState.elements.set(uniqueId, {
+          PageComponent: newHandlerOptions.PageComponent,
+          errored: false
         });
         if (handlerOptions.verbose) {
-            handlerOptions.logger?.info(`[renderPage.server] Created PageComponent that uses React.use() to consume headless stream for route ${handlerOptions.route}`);
+          handlerOptions.logger?.info(`[renderPage.server] Stored PageComponent for headless stream ${uniqueId}`);
         }
-        fullRscHandler = renderRscStream(fullRscHandlerOptions, fullHandlers);
-        // Check for panic error after creating the handler
-        if (fullPanicError) {
-            yield {
-                type: "error",
-                error: fullPanicError,
-                metrics: {
-                    rscFull: rscFullMetrics,
-                    rscHeadless: rscHeadlessMetrics,
-                    html: htmlMetrics,
-                },
-            };
-            return;
+      } else {
+        if (handlerOptions.verbose) {
+          handlerOptions.logger?.info(`[renderPage.server] Headless stream errored for route ${handlerOptions.route}, not storing PageComponent for reuse`);
         }
-        // Create HTML transform stream - need createRscToHtmlStream for async server actions
-        htmlTransformStream = createRscToHtmlStream({
-            id: handlerOptions.id,
-            worker: handlerOptions.worker,
-            route: handlerOptions.route,
-            url: handlerOptions.url,
-            moduleRootPath: handlerOptions.moduleRootPath,
-            moduleBasePath: handlerOptions.moduleBasePath,
-            moduleBaseURL: handlerOptions.moduleBaseURL,
-            projectRoot: handlerOptions.projectRoot,
-            build: handlerOptions.build,
-            panicThreshold: handlerOptions.panicThreshold,
-            verbose: handlerOptions.verbose,
-            signal: handlerOptions.signal,
-            logger: handlerOptions.logger,
-            htmlWorker: handlerOptions.htmlWorker,
-            clientPipeableStreamOptions: handlerOptions.clientPipeableStreamOptions,
-            onMetrics: handlerOptions.onMetrics,
-            htmlTimeout: handlerOptions.htmlTimeout || 15000,
-            rscStream: fullRscHandler.rscStream,
-            onError: (error, isPanic) => {
-                // Track HTML stream errors
-                htmlStreamErrored = true;
-                htmlStreamError = error;
-                if (isPanic) {
-                    // This is a panic error, it should be yielded as an error result
-                    if (handlerOptions.verbose) {
-                        handlerOptions.logger?.error(`[renderPage.server] HTML stream panic error for route ${handlerOptions.route}: ${error.message}`);
-                    }
-                }
-                else {
-                    // For non-panic errors, just log them
-                    if (handlerOptions.verbose) {
-                        handlerOptions.logger?.warn(`[renderPage.server] HTML stream error for route ${handlerOptions.route}: ${error.message}`);
-                    }
-                }
-            },
-        });
-        // Create stream wrappers for file writing - simplified like client side
-        const rscStreamWrapper = {
-            pipe: (destination) => {
-                const streamMetrics = createStreamMetrics();
-                streamMetrics.startTime = performance.now();
-                // Use the headless RSC stream directly for the .rsc file
-                const rscFileStream = headlessRscHandler.rscStream;
-                rscFileStream.on("data", (chunk) => {
-                    streamMetrics.chunks++;
-                    streamMetrics.bytes += chunk.length;
-                });
-                rscFileStream.on("end", () => {
-                    streamMetrics.duration = performance.now() - streamMetrics.startTime;
-                    streamMetrics.endTime = performance.now();
-                    rscHeadlessMetrics.streamMetrics = streamMetrics;
-                    rscHeadlessMetrics.chunkRate = streamMetrics.chunks / (streamMetrics.duration / 1000);
-                    rscHeadlessMetrics.processingTime = streamMetrics.duration;
-                    rscHeadlessMetrics.memoryUsage = process.memoryUsage();
-                    rscHeadlessMetrics.chunks = streamMetrics.chunks;
-                });
-                rscFileStream.pipe(destination);
-                return destination;
-            },
-            abort: () => headlessRscHandler.abort(),
-        };
-        const htmlStreamWrapper = {
-            pipe: (destination) => {
-                // Use the HTML transform stream's pipe method directly (same as client side)
-                return htmlTransformStream.pipe(destination);
-            },
-            abort: () => {
-                htmlTransformStream.abort();
-            },
-            on: (event, listener) => {
-                // Forward error events from the HTML transform stream to the wrapper
-                if (event === 'error') {
-                    // Access the actual stream from the transform result
-                    const htmlStream = htmlTransformStream.htmlStream;
-                    if (htmlStream && typeof htmlStream.on === 'function') {
-                        htmlStream.on('error', listener);
-                    }
-                }
-                return htmlStreamWrapper;
-            },
-        };
-        // Wait for HTML stream to complete or error before yielding success
-        // This ensures that any errors from the HTML stream are caught before we yield success
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error(`HTML stream timeout for route ${handlerOptions.route}`));
-            }, handlerOptions.htmlTimeout || 15000);
-            // Check if HTML stream already errored
-            if (htmlStreamErrored) {
-                clearTimeout(timeout);
-                resolve(); // Let the panic threshold logic handle this at the renderPages level
-                return;
-            }
-            // Set up a flag to track if we've resolved
-            let resolved = false;
-            // Create a wrapper that resolves the promise when the stream completes
-            const originalPipe = htmlTransformStream.pipe;
-            htmlTransformStream.pipe = function (destination) {
-                const result = originalPipe.call(this, destination);
-                // Listen for the destination stream to end
-                destination.on('finish', () => {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        resolve();
-                    }
-                });
-                destination.on('error', (error) => {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        reject(error);
-                    }
-                });
-                return result;
-            };
-            // If we don't have a destination yet, resolve after a short delay
-            // This handles the case where the stream is created but not yet piped
-            setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    clearTimeout(timeout);
-                    resolve();
-                }
-            }, 100);
-        });
-        // Check for HTML stream errors after waiting for completion
-        if (htmlStreamErrored) {
-            yield {
-                type: "error",
-                error: htmlStreamError || new Error("HTML stream failed"),
-                metrics: {
-                    rscFull: rscFullMetrics,
-                    rscHeadless: rscHeadlessMetrics,
-                    html: htmlMetrics,
-                },
-            };
-            return;
+      }
+    });
+    let fullPanicError = null;
+    const fullHandlers = createMainThreadHandlers(
+      handlerOptions,
+      (error, isPanic) => {
+        if (isPanic) {
+          fullPanicError = error instanceof Error ? error : new Error("Full RSC stream failed");
         }
-        // Yield success result - simplified like client side
-        yield {
-            type: "success",
-            html: htmlStreamWrapper,
-            rsc: rscStreamWrapper,
-            metrics: {
-                rscFull: rscFullMetrics,
-                rscHeadless: rscHeadlessMetrics,
-                html: htmlMetrics,
-            },
-        };
+      }
+    );
+    fullHandlers.onData = (_id, chunk) => {
+      rscFullMetrics.chunks++;
+      rscFullMetrics.streamMetrics.bytes += chunk.length;
+    };
+    const hasExistingHeadlessError = hasHeadlessStreamError(headlessStreamState, handlerOptions.route);
+    const shouldUseFallback = headlessStreamErrored || hasExistingHeadlessError;
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[renderPage.server] Creating full RSC handler options for route ${handlerOptions.route}: headlessStreamErrored=${headlessStreamErrored}, hasExistingHeadlessError=${hasExistingHeadlessError}, shouldUseFallback=${shouldUseFallback}`
+      );
     }
-    catch (err) {
+    const SafePageComponent = (props) => {
+      const hasError = hasHeadlessStreamError(headlessStreamState, handlerOptions.route);
+      if (hasError) {
+        return null;
+      }
+      return newHandlerOptions.PageComponent(props);
+    };
+    const fullRscHandlerOptions = {
+      ...newHandlerOptions,
+      htmlPath: void 0,
+      // Full RSC - include HTML wrapper
+      headlessStreamElements: headlessStreamState.elements,
+      // Pass the storage map for reuse
+      // Use SafePageComponent that returns null when there are headless stream errors
+      PageComponent: SafePageComponent
+    };
+    headlessRscHandler.rscStream.on("end", () => {
+      if (!hasHeadlessStreamError(headlessStreamState, handlerOptions.route)) {
         if (handlerOptions.verbose) {
-            handlerOptions.logger?.error(`[renderPage.server] Error: ${JSON.stringify(err)}`);
+          handlerOptions.logger?.info(
+            `[renderPage.server] Headless stream completed successfully for route ${handlerOptions.route}`
+          );
         }
-        // Clean up any resources
-        try {
-            if (headlessRscHandler)
-                headlessRscHandler.abort();
-            if (fullRscHandler)
-                fullRscHandler.abort();
-            if (htmlTransformStream)
-                htmlTransformStream.abort();
+      }
+    });
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[renderPage.server] Created PageComponent that uses React.use() to consume headless stream for route ${handlerOptions.route}`
+      );
+    }
+    fullRscHandler = renderRscStream(fullRscHandlerOptions, fullHandlers);
+    if (fullPanicError) {
+      yield {
+        type: "error",
+        error: fullPanicError,
+        metrics: {
+          rscFull: rscFullMetrics,
+          rscHeadless: rscHeadlessMetrics,
+          html: htmlMetrics
         }
-        catch (cleanupError) {
-            handlerOptions.logger?.warn(`Failed to cleanup streams on error: ${cleanupError}`);
+      };
+      return;
+    }
+    htmlTransformStream = createRscToHtmlStream({
+      id: handlerOptions.id,
+      worker: handlerOptions.worker,
+      route: handlerOptions.route,
+      url: handlerOptions.url,
+      moduleRootPath: handlerOptions.moduleRootPath,
+      moduleBasePath: handlerOptions.moduleBasePath,
+      moduleBaseURL: handlerOptions.moduleBaseURL,
+      projectRoot: handlerOptions.projectRoot,
+      build: handlerOptions.build,
+      panicThreshold: handlerOptions.panicThreshold,
+      verbose: handlerOptions.verbose,
+      signal: handlerOptions.signal,
+      logger: handlerOptions.logger,
+      htmlWorker: handlerOptions.htmlWorker,
+      clientPipeableStreamOptions: handlerOptions.clientPipeableStreamOptions,
+      onMetrics: handlerOptions.onMetrics,
+      htmlTimeout: handlerOptions.htmlTimeout || 15e3,
+      rscStream: fullRscHandler.rscStream,
+      onError: (error, isPanic) => {
+        htmlStreamErrored = true;
+        htmlStreamError = error;
+        if (isPanic) {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger?.error(
+              `[renderPage.server] HTML stream panic error for route ${handlerOptions.route}: ${error.message}`
+            );
+          }
+        } else {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger?.warn(
+              `[renderPage.server] HTML stream error for route ${handlerOptions.route}: ${error.message}`
+            );
+          }
+        }
+      }
+    });
+    const rscStreamWrapper = {
+      pipe: (destination) => {
+        const streamMetrics = createStreamMetrics();
+        streamMetrics.startTime = performance.now();
+        const rscFileStream = headlessRscHandler.rscStream;
+        rscFileStream.on("data", (chunk) => {
+          streamMetrics.chunks++;
+          streamMetrics.bytes += chunk.length;
+        });
+        rscFileStream.on("end", () => {
+          streamMetrics.duration = performance.now() - streamMetrics.startTime;
+          streamMetrics.endTime = performance.now();
+          rscHeadlessMetrics.streamMetrics = streamMetrics;
+          rscHeadlessMetrics.chunkRate = streamMetrics.chunks / (streamMetrics.duration / 1e3);
+          rscHeadlessMetrics.processingTime = streamMetrics.duration;
+          rscHeadlessMetrics.memoryUsage = process.memoryUsage();
+          rscHeadlessMetrics.chunks = streamMetrics.chunks;
+        });
+        rscFileStream.pipe(destination);
+        return destination;
+      },
+      abort: () => headlessRscHandler.abort()
+    };
+    const htmlStreamWrapper = {
+      pipe: (destination) => {
+        return htmlTransformStream.pipe(destination);
+      },
+      abort: () => {
+        htmlTransformStream.abort();
+      },
+      on: (event, listener) => {
+        if (event === "error") {
+          const htmlStream = htmlTransformStream.htmlStream;
+          if (htmlStream && typeof htmlStream.on === "function") {
+            htmlStream.on("error", listener);
+          }
         }
-        const panicError = handleError({
-            error: err,
-            critical: false,
-            logger: handlerOptions.logger,
-            panicThreshold: handlerOptions.panicThreshold,
-            context: `RenderPage Error (${handlerOptions.route})`,
+        return htmlStreamWrapper;
+      }
+    };
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`HTML stream timeout for route ${handlerOptions.route}`));
+      }, handlerOptions.htmlTimeout || 15e3);
+      if (htmlStreamErrored) {
+        clearTimeout(timeout);
+        resolve();
+        return;
+      }
+      let resolved = false;
+      const originalPipe = htmlTransformStream.pipe;
+      htmlTransformStream.pipe = function(destination) {
+        const result = originalPipe.call(this, destination);
+        destination.on("finish", () => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            resolve();
+          }
+        });
+        destination.on("error", (error) => {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            reject(error);
+          }
         });
-        if (panicError != null) {
-            yield {
-                type: "error",
-                error: panicError,
-                metrics: {
-                    rscFull: rscFullMetrics,
-                    rscHeadless: rscHeadlessMetrics,
-                    html: htmlMetrics,
-                },
-            };
+        return result;
+      };
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          resolve();
+        }
+      }, 100);
+    });
+    if (htmlStreamErrored) {
+      yield {
+        type: "error",
+        error: htmlStreamError || new Error("HTML stream failed"),
+        metrics: {
+          rscFull: rscFullMetrics,
+          rscHeadless: rscHeadlessMetrics,
+          html: htmlMetrics
+        }
+      };
+      return;
+    }
+    yield {
+      type: "success",
+      html: htmlStreamWrapper,
+      rsc: rscStreamWrapper,
+      metrics: {
+        rscFull: rscFullMetrics,
+        rscHeadless: rscHeadlessMetrics,
+        html: htmlMetrics
+      }
+    };
+  } catch (err) {
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.error(`[renderPage.server] Error: ${JSON.stringify(err)}`);
+    }
+    try {
+      if (headlessRscHandler) headlessRscHandler.abort();
+      if (fullRscHandler) fullRscHandler.abort();
+      if (htmlTransformStream) htmlTransformStream.abort();
+    } catch (cleanupError) {
+      handlerOptions.logger?.warn(`Failed to cleanup streams on error: ${cleanupError}`);
+    }
+    const panicError = handleError({
+      error: err,
+      critical: false,
+      logger: handlerOptions.logger,
+      panicThreshold: handlerOptions.panicThreshold,
+      context: `RenderPage Error (${handlerOptions.route})`
+    });
+    if (panicError != null) {
+      yield {
+        type: "error",
+        error: panicError,
+        metrics: {
+          rscFull: rscFullMetrics,
+          rscHeadless: rscHeadlessMetrics,
+          html: htmlMetrics
         }
-        else {
-            yield {
-                type: "skip",
-                reason: err,
-                html: {
-                    pipe: (destination) => {
-                        destination.end();
-                        return destination;
-                    },
-                    abort: () => { },
-                },
-                rsc: {
-                    pipe: (destination) => {
-                        destination.end();
-                        return destination;
-                    },
-                    abort: () => { },
-                },
-                metrics: {
-                    rscFull: rscFullMetrics,
-                    rscHeadless: rscHeadlessMetrics,
-                    html: htmlMetrics,
-                },
-            };
+      };
+    } else {
+      yield {
+        type: "skip",
+        reason: err,
+        html: {
+          pipe: (destination) => {
+            destination.end();
+            return destination;
+          },
+          abort: () => {
+          }
+        },
+        rsc: {
+          pipe: (destination) => {
+            destination.end();
+            return destination;
+          },
+          abort: () => {
+          }
+        },
+        metrics: {
+          rscFull: rscFullMetrics,
+          rscHeadless: rscHeadlessMetrics,
+          html: htmlMetrics
         }
+      };
     }
+  }
 };
+
+export { renderPage };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"renderPage.server.js","sources":["../../../plugin/react-static/renderPage.server.ts"],"sourcesContent":["/**\n * renderPage.server.ts\n *\n * PURPOSE: Server-side static page rendering for React Server Components\n *\n * ARCHITECTURE OVERVIEW:\n * \n * SERVER-SIDE vs CLIENT-SIDE:\n * - Server-side: RSC generation in main thread, HTML generation in worker\n * - Client-side: RSC generation in worker, HTML generation in main thread\n * \n * FLOW:\n * 1. Create headless RSC stream (for .rsc file)\n * 2. Create full RSC stream (for HTML generation)\n * 3. Create HTML transform stream that converts RSC to HTML\n * 4. Both streams are piped to file writers\n * \n * SIMPLIFIED APPROACH:\n * This implementation follows the same simple pattern as the client side,\n * avoiding complex backpressure handling and race conditions.\n */\n\nimport { createRenderMetrics } from \"../metrics/createRenderMetrics.js\";\nimport { routeToURL } from \"../utils/routeToURL.js\";\nimport type { RenderPageFn } from \"./types.js\";\nimport { handleError } from \"../error/handleError.js\";\nimport { assertReactServer } from \"../config/getCondition.js\";\n\nimport { renderRscStream } from \"../stream/renderRscStream.server.js\";\nimport { createMainThreadHandlers } from \"../stream/createMainThreadHandlers.js\";\nimport { createRscToHtmlStream } from \"./rscToHtmlStream.server.js\";\nimport { resolveComponent } from \"../helpers/resolveComponent.js\";\nimport { resolvePageAndProps } from \"../helpers/resolvePageAndProps.js\";\nimport { Root as DefaultRoot } from \"../components/root.js\";\nimport { Html as DefaultHtml } from \"../components/html.js\";\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\nimport { join } from \"node:path\";\nimport { createHeadlessStreamState, trackHeadlessStreamError, hasHeadlessStreamError } from \"../helpers/headlessStreamState.js\";\n\nexport const renderPage: RenderPageFn = async function* renderPage(\n  handlerOptions\n) {\n  // Ensure we're in the correct environment\n  assertReactServer();\n\n  // Create metrics upfront with proper types\n  const baseDir = join(\n    handlerOptions.build.outDir,\n    handlerOptions.build.static\n  );\n  const routePath = handlerOptions.route.replace(/^\\//, \"\");\n\n  const htmlMetrics = createRenderMetrics({\n    route: handlerOptions.route,\n    type: \"html\",\n    fromMainThread: false, // Server: HTML rendered in worker\n    fromRscWorker: false,\n    fromHtmlWorker: true,\n    baseDir,\n    routePath,\n    fileName: handlerOptions.build.htmlOutputPath,\n    outputPath: join(baseDir, routePath, handlerOptions.build.htmlOutputPath),\n  });\n  \n  const rscFullMetrics = createRenderMetrics({\n    route: handlerOptions.route,\n    type: \"rsc-full\",\n    fromMainThread: true, // Server: RSC rendered on main thread\n    fromRscWorker: false,\n    fromHtmlWorker: false,\n  });\n  \n  const rscHeadlessMetrics = createRenderMetrics({\n    route: handlerOptions.route,\n    type: \"rsc-headless\",\n    fromMainThread: true, // Server: RSC rendered on main thread\n    fromRscWorker: false,\n    fromHtmlWorker: false,\n    baseDir,\n    routePath,\n    fileName: handlerOptions.build.rscOutputPath,\n    outputPath: join(baseDir, routePath, handlerOptions.build.rscOutputPath),\n  });\n\n  // Declare variables outside try block\n  let headlessRscHandler: any = null;\n  let fullRscHandler: any = null;\n  let htmlTransformStream: any = null;\n  \n  // Error tracking variables for headless stream\n  let headlessStreamErrored = false;\n  let headlessError: Error | null = null;\n  \n  // Error tracking variables for HTML stream\n  let htmlStreamErrored = false;\n  let htmlStreamError: Error | null = null;\n\n  // Server-side stream reuse storage (similar to client-side headlessStreamElements)\n  const headlessStreamState = createHeadlessStreamState();\n\n  try {\n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.info(\n        `[renderPage.server] Server-side rendering for route: ${handlerOptions.route}`\n      );\n    }\n\n    // Set URL if not provided\n    if (!handlerOptions.url) {\n      handlerOptions.url = routeToURL(\n        handlerOptions.route,\n        handlerOptions.moduleBaseURL,\n        handlerOptions.build.rscOutputPath\n      );\n    }\n\n    // Resolve components and props using the proper helper\n    let PageComponent: any = null;\n    let RootComponent: any = null;\n    let HtmlComponent: any = null;\n    let pageProps: any = {}; // Initialize as empty object - props function will populate it\n\n    // Use resolvePageAndProps helper to properly load page and props\n    if (handlerOptions.pagePath) {\n      try {\n        const pageAndPropsResult = await resolvePageAndProps({\n          pagePath: handlerOptions.pagePath,\n          pageExportName: handlerOptions.pageExportName,\n          propsPath: handlerOptions.propsPath,\n          propsExportName: handlerOptions.propsExportName,\n          loader: handlerOptions.loader,\n          verbose: handlerOptions.verbose,\n          logger: handlerOptions.logger,\n          route: handlerOptions.route,\n          url: handlerOptions.url,\n          moduleBaseURL: handlerOptions.moduleBaseURL,\n          build: {\n            rscOutputPath: handlerOptions.build.rscOutputPath,\n          },\n        });\n\n        if (pageAndPropsResult.type === \"success\") {\n          PageComponent = pageAndPropsResult.PageComponent;\n          // Always use the props returned from the props function\n          // Root components can handle empty props with their defaults\n          pageProps = pageAndPropsResult.pageProps || {};\n          \n          if (handlerOptions.verbose) {\n            handlerOptions.logger?.info(\n              `[renderPage.server] Successfully loaded page and props for route ${handlerOptions.route}: pageProps=${JSON.stringify(pageProps)}`\n            );\n          }\n        } else {\n          handlerOptions.logger?.warn(\n            `Failed to load page and props from ${handlerOptions.pagePath}: ${\n              pageAndPropsResult.error?.message || \"Unknown error\"\n            }`\n          );\n        }\n      } catch (error) {\n        handlerOptions.logger?.warn(\n          `Error loading page and props from ${handlerOptions.pagePath}: ${\n            error instanceof Error ? error.message : String(error)\n          }`\n        );\n      }\n    }\n\n    // Load Root component\n    if (handlerOptions.rootPath) {\n      try {\n        const rootResult = await resolveComponent({\n          componentPath: handlerOptions.rootPath,\n          exportName: handlerOptions.rootExportName,\n          loader: handlerOptions.loader,\n        });\n        if (rootResult.type === \"success\") {\n          RootComponent = rootResult.component;\n        } else {\n          handlerOptions.logger?.warn(\n            `Failed to load Root component from ${handlerOptions.rootPath}: ${\n              rootResult.error?.message || \"Unknown error\"\n            }`\n          );\n        }\n      } catch (error) {\n        handlerOptions.logger?.warn(\n          `Error loading Root component from ${handlerOptions.rootPath}: ${\n            error instanceof Error ? error.message : String(error)\n          }`\n        );\n      }\n    }\n\n    // Load Html component\n    if (handlerOptions.htmlPath) {\n      try {\n        const htmlResult = await resolveComponent({\n          componentPath: handlerOptions.htmlPath,\n          exportName: handlerOptions.htmlExportName,\n          loader: handlerOptions.loader,\n        });\n        if (htmlResult.type === \"success\") {\n          HtmlComponent = htmlResult.component;\n        } else {\n          handlerOptions.logger?.warn(\n            `Failed to load Html component from ${handlerOptions.htmlPath}: ${\n              htmlResult.error?.message || \"Unknown error\"\n            }`\n          );\n        }\n      } catch (error) {\n        handlerOptions.logger?.warn(\n          `Error loading Html component from ${handlerOptions.htmlPath}: ${\n            error instanceof Error ? error.message : String(error)\n          }`\n        );\n      }\n    }\n\n    // Use defaults if components are still not loaded\n    if (!RootComponent) {\n      RootComponent = DefaultRoot as any;\n    }\n    if (!HtmlComponent) {\n      HtmlComponent = DefaultHtml as any;\n    }\n\n    // Ensure we have all required components\n    if (!PageComponent || !RootComponent || !HtmlComponent) {\n      yield {\n        type: \"error\",\n        error: new Error(\n          `Component resolution failed: missing required components (Page: ${!!PageComponent}, Root: ${!!RootComponent}, Html: ${!!HtmlComponent})`\n        ),\n        metrics: {\n          rscFull: rscFullMetrics,\n          rscHeadless: rscHeadlessMetrics,\n          html: htmlMetrics,\n        },\n      };\n      return;\n    }\n\n    // Create handler options with resolved components and props\n    const uniqueId = handlerOptions.id ?? `${handlerOptions.route}?id=${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;\n    const newHandlerOptions = {\n      ...handlerOptions,\n      id: uniqueId,\n      url: `${handlerOptions.url}`,\n      route: `${handlerOptions.route}`,\n      PageComponent,\n      RootComponent,\n      HtmlComponent,\n      pageProps,\n    };\n    \n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.info(\n        `[renderPage.server] Created newHandlerOptions for route ${handlerOptions.route} with pageProps: ${JSON.stringify(pageProps)}`\n      );\n    }\n\n    // Create headless RSC handler (for .rsc file) - with proper error handling\n    const headlessHandlers = createMainThreadHandlers(\n      handlerOptions,\n      (error, isPanic) => {\n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.info(\n            `[renderPage.server] Headless stream error handler called for route ${handlerOptions.route}: ${error.message}, isPanic: ${isPanic}`\n          );\n        }\n        \n        // Track if the headless stream had errors\n        headlessStreamErrored = true;\n        headlessError = error instanceof Error ? error : new Error(\"Headless RSC stream failed\");\n        \n        // Track headless stream errors for conditional reuse logic (like RSC worker)\n        trackHeadlessStreamError(headlessStreamState, handlerOptions.route, headlessError);\n        \n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.info(\n            `[renderPage.server] Stored headless stream error for route ${handlerOptions.route} in headlessStreamErrors map`\n          );\n        }\n        \n        // Store panic errors for later handling\n        if (isPanic) {\n          // For panic threshold \"all_errors\", the panic error will be handled by renderPages\n          if (handlerOptions.verbose) {\n            handlerOptions.logger?.info(\n              `[renderPage.server] Panic error detected for route ${handlerOptions.route}, will be handled by renderPages`\n            );\n          }\n        }\n      }\n    );\n    \n    // Override onData to track metrics\n    headlessHandlers.onData = (_id, chunk) => {\n      rscHeadlessMetrics.chunks++;\n      rscHeadlessMetrics.streamMetrics.bytes += chunk.length;\n    };\n    \n    headlessRscHandler = renderRscStream(\n      {\n        ...newHandlerOptions,\n        htmlPath: '', // Headless RSC - no HTML wrapper\n        // If we expect errors, provide a safe Page component that doesn't throw\n        PageComponent: newHandlerOptions.PageComponent, // Use original for now, will be overridden if errors occur\n      },\n      headlessHandlers\n    );\n    \n    // Note: Panic errors will be yielded from the error handler when they occur\n    // No need to check shouldYieldPanicError here as it's set asynchronously\n\n    // Store PageComponent for reuse when headless stream completes (like RSC worker)\n    headlessRscHandler.rscStream.on('end', () => {\n      // Only store if this is a headless stream and no errors occurred (like RSC worker)\n      if (!hasHeadlessStreamError(headlessStreamState, handlerOptions.route)) {\n        headlessStreamState.elements.set(uniqueId, {\n          PageComponent: newHandlerOptions.PageComponent,\n          errored: false\n        });\n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.info(`[renderPage.server] Stored PageComponent for headless stream ${uniqueId}`);\n        }\n      } else {\n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.info(`[renderPage.server] Headless stream errored for route ${handlerOptions.route}, not storing PageComponent for reuse`);\n        }\n      }\n    });\n\n    // Create full RSC handler (for HTML generation) - reuse headless stream elements if no errors\n    // For server-side, we create both streams in parallel like the client-side\n    let fullPanicError: Error | null = null;\n    const fullHandlers = createMainThreadHandlers(\n      handlerOptions,\n      (error, isPanic) => {\n        // If this is a panic error, store it to be handled later\n        if (isPanic) {\n          fullPanicError = error instanceof Error ? error : new Error(\"Full RSC stream failed\");\n        }\n      }\n    );\n    \n    // Override onData to track metrics\n    fullHandlers.onData = (_id, chunk) => {\n      rscFullMetrics.chunks++;\n      rscFullMetrics.streamMetrics.bytes += chunk.length;\n    };\n    \n    // Create full RSC handler options - use React.Fragment if headless stream had errors (like RSC worker)\n    // Check if there are any existing headless stream errors for this route\n    const hasExistingHeadlessError = hasHeadlessStreamError(headlessStreamState, handlerOptions.route);\n    const shouldUseFallback = headlessStreamErrored || hasExistingHeadlessError;\n    \n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.info(\n        `[renderPage.server] Creating full RSC handler options for route ${handlerOptions.route}: headlessStreamErrored=${headlessStreamErrored}, hasExistingHeadlessError=${hasExistingHeadlessError}, shouldUseFallback=${shouldUseFallback}`\n      );\n    }\n    \n    // Create a wrapper PageComponent that returns null if there are headless stream errors\n    const SafePageComponent = (props: any) => {\n      // Check if there are any headless stream errors for this route\n      const hasError = hasHeadlessStreamError(headlessStreamState, handlerOptions.route);\n      if (hasError) {\n        return null;\n      }\n      return newHandlerOptions.PageComponent(props);\n    };\n    \n    const fullRscHandlerOptions = {\n      ...newHandlerOptions,\n      htmlPath: undefined, // Full RSC - include HTML wrapper\n      headlessStreamElements: headlessStreamState.elements, // Pass the storage map for reuse\n      // Use SafePageComponent that returns null when there are headless stream errors\n      PageComponent: SafePageComponent,\n    };\n    \n    \n    // Create a PageComponent that uses React.use() to consume the headless stream and check for errors\n\n    // Store the headless stream elements for reuse (like RSC worker does)\n    \n    // Listen for the headless stream to complete and store its elements\n    headlessRscHandler.rscStream.on('end', () => {\n      if (!hasHeadlessStreamError(headlessStreamState, handlerOptions.route)) {\n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.info(\n            `[renderPage.server] Headless stream completed successfully for route ${handlerOptions.route}`\n          );\n        }\n      }\n    });\n\n    \n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.info(\n        `[renderPage.server] Created PageComponent that uses React.use() to consume headless stream for route ${handlerOptions.route}`\n      );\n    }\n    \n    fullRscHandler = renderRscStream(fullRscHandlerOptions, fullHandlers);\n    \n    // Check for panic error after creating the handler\n    if (fullPanicError) {\n      yield {\n        type: \"error\",\n        error: fullPanicError,\n        metrics: {\n          rscFull: rscFullMetrics,\n          rscHeadless: rscHeadlessMetrics,\n          html: htmlMetrics,\n        },\n      };\n      return;\n    }\n\n    // Create HTML transform stream - need createRscToHtmlStream for async server actions\n    htmlTransformStream = createRscToHtmlStream({\n      id: handlerOptions.id,\n      worker: handlerOptions.worker,\n      route: handlerOptions.route,\n      url: handlerOptions.url,\n      moduleRootPath: handlerOptions.moduleRootPath,\n      moduleBasePath: handlerOptions.moduleBasePath,\n      moduleBaseURL: handlerOptions.moduleBaseURL,\n      projectRoot: handlerOptions.projectRoot,\n      build: handlerOptions.build,\n      panicThreshold: handlerOptions.panicThreshold,\n      verbose: handlerOptions.verbose,\n      signal: handlerOptions.signal,\n      logger: handlerOptions.logger,\n      htmlWorker: handlerOptions.htmlWorker,\n      clientPipeableStreamOptions: handlerOptions.clientPipeableStreamOptions,\n      onMetrics: handlerOptions.onMetrics,\n      htmlTimeout: handlerOptions.htmlTimeout || 15000,\n      rscStream: fullRscHandler.rscStream,\n      onError: (error, isPanic) => {\n        // Track HTML stream errors\n        htmlStreamErrored = true;\n        htmlStreamError = error;\n        \n        if (isPanic) {\n          // This is a panic error, it should be yielded as an error result\n          if (handlerOptions.verbose) {\n            handlerOptions.logger?.error(\n              `[renderPage.server] HTML stream panic error for route ${handlerOptions.route}: ${error.message}`\n            );\n          }\n        } else {\n          // For non-panic errors, just log them\n          if (handlerOptions.verbose) {\n            handlerOptions.logger?.warn(\n              `[renderPage.server] HTML stream error for route ${handlerOptions.route}: ${error.message}`\n            );\n          }\n        }\n      },\n    });\n\n    // Create stream wrappers for file writing - simplified like client side\n    const rscStreamWrapper = {\n      pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n        const streamMetrics = createStreamMetrics();\n        streamMetrics.startTime = performance.now();\n\n        // Use the headless RSC stream directly for the .rsc file\n        const rscFileStream = headlessRscHandler.rscStream;\n\n        rscFileStream.on(\"data\", (chunk: Buffer) => {\n          streamMetrics.chunks++;\n          streamMetrics.bytes += chunk.length;\n        });\n\n        rscFileStream.on(\"end\", () => {\n          streamMetrics.duration = performance.now() - streamMetrics.startTime;\n          streamMetrics.endTime = performance.now();\n\n          rscHeadlessMetrics.streamMetrics = streamMetrics;\n          rscHeadlessMetrics.chunkRate = streamMetrics.chunks / (streamMetrics.duration / 1000);\n          rscHeadlessMetrics.processingTime = streamMetrics.duration;\n          rscHeadlessMetrics.memoryUsage = process.memoryUsage();\n          rscHeadlessMetrics.chunks = streamMetrics.chunks;\n        });\n\n        rscFileStream.pipe(destination);\n        return destination;\n      },\n      abort: () => headlessRscHandler.abort(),\n    };\n\n    const htmlStreamWrapper = {\n      pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n        // Use the HTML transform stream's pipe method directly (same as client side)\n        return htmlTransformStream.pipe(destination);\n      },\n      abort: () => {\n        htmlTransformStream.abort();\n      },\n      on: (event: string, listener: (...args: any[]) => void) => {\n        // Forward error events from the HTML transform stream to the wrapper\n        if (event === 'error') {\n          // Access the actual stream from the transform result\n          const htmlStream = (htmlTransformStream as any).htmlStream;\n          if (htmlStream && typeof htmlStream.on === 'function') {\n            htmlStream.on('error', listener);\n          }\n        }\n        return htmlStreamWrapper;\n      },\n    };\n\n    // Wait for HTML stream to complete or error before yielding success\n    // This ensures that any errors from the HTML stream are caught before we yield success\n    await new Promise<void>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        reject(new Error(`HTML stream timeout for route ${handlerOptions.route}`));\n      }, handlerOptions.htmlTimeout || 15000);\n\n      // Check if HTML stream already errored\n      if (htmlStreamErrored) {\n        clearTimeout(timeout);\n        resolve(); // Let the panic threshold logic handle this at the renderPages level\n        return;\n      }\n\n      // Set up a flag to track if we've resolved\n      let resolved = false;\n      \n      // Create a wrapper that resolves the promise when the stream completes\n      const originalPipe = htmlTransformStream.pipe;\n      htmlTransformStream.pipe = function(destination: any) {\n        const result = originalPipe.call(this, destination);\n        \n        // Listen for the destination stream to end\n        destination.on('finish', () => {\n          if (!resolved) {\n            resolved = true;\n            clearTimeout(timeout);\n            resolve();\n          }\n        });\n        \n        destination.on('error', (error: Error) => {\n          if (!resolved) {\n            resolved = true;\n            clearTimeout(timeout);\n            reject(error);\n          }\n        });\n        \n        return result;\n      };\n      \n      // If we don't have a destination yet, resolve after a short delay\n      // This handles the case where the stream is created but not yet piped\n      setTimeout(() => {\n        if (!resolved) {\n          resolved = true;\n          clearTimeout(timeout);\n          resolve();\n        }\n      }, 100);\n    });\n\n    // Check for HTML stream errors after waiting for completion\n    if (htmlStreamErrored) {\n      yield {\n        type: \"error\",\n        error: htmlStreamError || new Error(\"HTML stream failed\"),\n        metrics: {\n          rscFull: rscFullMetrics,\n          rscHeadless: rscHeadlessMetrics,\n          html: htmlMetrics,\n        },\n      };\n      return;\n    }\n\n    // Yield success result - simplified like client side\n    yield {\n      type: \"success\",\n      html: htmlStreamWrapper,\n      rsc: rscStreamWrapper,\n      metrics: {\n        rscFull: rscFullMetrics,\n        rscHeadless: rscHeadlessMetrics,\n        html: htmlMetrics,\n      },\n    } as const;\n\n  } catch (err) {\n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.error(`[renderPage.server] Error: ${JSON.stringify(err)}`);\n    }\n\n    // Clean up any resources\n    try {\n      if (headlessRscHandler) headlessRscHandler.abort();\n      if (fullRscHandler) fullRscHandler.abort();\n      if (htmlTransformStream) htmlTransformStream.abort();\n    } catch (cleanupError: unknown) {\n      handlerOptions.logger?.warn(`Failed to cleanup streams on error: ${cleanupError}`);\n    }\n\n    const panicError = handleError({\n      error: err,\n      critical: false,\n      logger: handlerOptions.logger,\n      panicThreshold: handlerOptions.panicThreshold,\n      context: `RenderPage Error (${handlerOptions.route})`,\n    });\n\n    if (panicError != null) {\n      yield {\n        type: \"error\",\n        error: panicError,\n        metrics: {\n          rscFull: rscFullMetrics,\n          rscHeadless: rscHeadlessMetrics,\n          html: htmlMetrics,\n        },\n      };\n    } else {\n      yield {\n        type: \"skip\",\n        reason: err,\n        html: {\n          pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n            destination.end();\n            return destination;\n          },\n          abort: () => {},\n        },\n        rsc: {\n          pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n            destination.end();\n            return destination;\n          },\n          abort: () => {},\n        },\n        metrics: {\n          rscFull: rscFullMetrics,\n          rscHeadless: rscHeadlessMetrics,\n          html: htmlMetrics,\n        },\n      };\n    }\n  }\n};"],"names":["renderPage","DefaultRoot","DefaultHtml"],"mappings":"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"}