vite-plugin-react-server 1.4.2 → 1.4.3

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

@@ -1,555 +1,481 @@
 /**
- * renderPage.client.ts
- *
- * PURPOSE: Client-side static page rendering for React Server Components
- *
- * ARCHITECTURE OVERVIEW:
- *
- * CLIENT-SIDE vs SERVER-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. RSC Worker generates RSC content with HTML wrapper
- * 2. RSC content is buffered to allow dual consumption
- * 3. Buffered RSC stream is consumed twice:
- *    - For RSC file writing (index.rsc)
- *    - For HTML transformation (index.html)
- * 4. HTML transform processes RSC content in main thread
- * 5. Both files are written to filesystem
- *
- * KEY INSIGHT: Node.js streams can only be consumed once, so we buffer the RSC
- * content to allow it to be used for both RSC file generation and HTML transformation.
- * This follows the pattern from collectRscContent.ts.
- *
- * HELPER FUNCTIONS:
- * - createBufferedRscStream: Creates a buffered stream for dual consumption
- * - createRscToHtmlStream: Transforms RSC content to HTML in main thread
- *
- * USAGE:
- * ```typescript
- * const result = await renderPage({
- *   route: "/",
- *   pagePath: "src/page/page.tsx",
- *   // ... other options
- * });
- *
- * // result.html.pipe(htmlFileWriter);
- * // result.rsc.pipe(rscFileWriter);
- * ```
+ * 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 { assertNonReactServer } from "../config/getCondition.js";
-import { createRscStream } from "../stream/createRscStream.client.js";
-import { resolveComponents } from "../helpers/resolveComponents.client.js";
-import { join } from "node:path";
-import { createStreamMetrics } from "../metrics/createStreamMetrics.js";
-import { performance } from "node:perf_hooks";
-import { createRscToHtmlStream } from "./rscToHtmlStream.client.js";
+import { createRenderMetrics } from '../metrics/createRenderMetrics.js';
+import { routeToURL } from '../utils/routeToURL.js';
+import { handleError } from '../error/handleError.js';
+import { assertNonReactServer } from '../config/getCondition.js';
+import { createRscStream } from '../stream/createRscStream.client.js';
+import { resolveComponents } from '../helpers/resolveComponents.client.js';
+import { join } from 'node:path';
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
+import { performance } from 'node:perf_hooks';
+import { createRscToHtmlStream } from './rscToHtmlStream.client.js';
+
 assertNonReactServer();
-/**
- * Client version of renderPage that uses the react-client pattern
- * This works in REVERSE from the server plugin:
- * - Server: Main thread (RSC) + HTML worker (HTML)
- * - Client: RSC worker (RSC) + Main thread (HTML)
- */
-export const renderPage = async function* _renderPageClient(handlerOptions) {
+const renderPage = async function* _renderPageClient(handlerOptions) {
+  if (handlerOptions.verbose) {
+    handlerOptions.logger?.info(
+      `[renderPage.client] onEvent callback exists: ${!!handlerOptions.onEvent}`
+    );
+    handlerOptions.logger?.info(
+      `[renderPage.client] onMetrics callback exists: ${!!handlerOptions.onMetrics}`
+    );
+  }
+  let hasYielded = false;
+  let errorResult = null;
+  const wrappedOnEvent = (event) => {
+    if (handlerOptions.onEvent) {
+      handlerOptions.onEvent(event);
+    }
+    if (event.type === "route.error" && !hasYielded) {
+      hasYielded = true;
+      const panicError = handleError({
+        error: event.data.error,
+        logger: handlerOptions.logger,
+        panicThreshold: event.data.panicThreshold,
+        context: `route.error (${event.data.route})`
+      });
+      if (panicError != null) {
+        errorResult = {
+          type: "error",
+          error: panicError,
+          metrics: {
+            rscHeadless: { duration: 0, chunks: 0, bytes: 0 },
+            html: { duration: 0, chunks: 0, bytes: 0 }
+          }
+        };
+      } else {
+        errorResult = {
+          type: "skip",
+          reason: event.data.error.message || "Non-panic error occurred",
+          html: { duration: 0, chunks: 0, bytes: 0 },
+          rsc: { duration: 0, chunks: 0, bytes: 0 },
+          metrics: {
+            rscHeadless: { duration: 0, chunks: 0, bytes: 0 },
+            html: { duration: 0, chunks: 0, bytes: 0 }
+          }
+        };
+      }
+    }
+  };
+  if (!handlerOptions.pagePath && !handlerOptions.PageComponent) {
+    const emptyStreamWrapper = {
+      pipe: (destination) => {
+        destination.end();
+        return destination;
+      },
+      abort: () => {
+      }
+    };
+    yield {
+      type: "skip",
+      reason: "No pagePath and no PageComponent provided",
+      html: emptyStreamWrapper,
+      rsc: emptyStreamWrapper,
+      metrics: {
+        rscFull: createRenderMetrics({
+          route: handlerOptions.route,
+          type: "rsc-full",
+          fromMainThread: false,
+          fromRscWorker: true,
+          fromHtmlWorker: false
+        }),
+        rscHeadless: createRenderMetrics({
+          route: handlerOptions.route,
+          type: "rsc-headless",
+          fromMainThread: false,
+          fromRscWorker: true,
+          fromHtmlWorker: false
+        }),
+        html: createRenderMetrics({
+          route: handlerOptions.route,
+          type: "html",
+          fromMainThread: true,
+          fromRscWorker: false,
+          fromHtmlWorker: false
+        })
+      }
+    };
+    return;
+  }
+  if (!handlerOptions.url) {
+    handlerOptions.url = routeToURL(
+      handlerOptions.route,
+      handlerOptions.moduleBaseURL,
+      handlerOptions.build.rscOutputPath
+    );
+  }
+  const baseDir = join(
+    handlerOptions.build.outDir,
+    handlerOptions.build.static
+  );
+  const routePath = handlerOptions.route.replace(/^\//, "");
+  const htmlMetrics = createRenderMetrics({
+    route: handlerOptions.route,
+    type: "html",
+    fromMainThread: true,
+    // Client: HTML rendered on main thread
+    fromRscWorker: false,
+    fromHtmlWorker: false,
+    baseDir,
+    routePath,
+    fileName: handlerOptions.build.htmlOutputPath,
+    outputPath: join(baseDir, routePath, handlerOptions.build.htmlOutputPath)
+  });
+  const rscFullMetrics = createRenderMetrics({
+    route: handlerOptions.route,
+    type: "rsc-full",
+    fromMainThread: false,
+    fromRscWorker: true,
+    // Client: RSC rendered on RSC worker
+    fromHtmlWorker: false
+  });
+  const rscHeadlessMetrics = createRenderMetrics({
+    route: handlerOptions.route,
+    type: "rsc-headless",
+    fromMainThread: false,
+    fromRscWorker: true,
+    // Client: RSC rendered on RSC worker
+    fromHtmlWorker: false,
+    baseDir,
+    routePath,
+    fileName: handlerOptions.build.rscOutputPath,
+    outputPath: join(baseDir, routePath, handlerOptions.build.rscOutputPath)
+  });
+  let headlessRscStream = null;
+  let fullRscStream = null;
+  let htmlHandler = null;
+  try {
     if (handlerOptions.verbose) {
-        handlerOptions.logger?.info(`[renderPage.client] onEvent callback exists: ${!!handlerOptions.onEvent}`);
-        handlerOptions.logger?.info(`[renderPage.client] onMetrics callback exists: ${!!handlerOptions.onMetrics}`);
+      handlerOptions.logger?.info(
+        `[renderPage.client] Client-side rendering for route: ${handlerOptions.route}`
+      );
     }
-    // Track if we've yielded a result to prevent multiple yields
-    let hasYielded = false;
-    let errorResult = null;
-    // Create a wrapper around onEvent to handle route.error events
-    const wrappedOnEvent = (event) => {
-        // Call the original onEvent first
-        if (handlerOptions.onEvent) {
-            handlerOptions.onEvent(event);
-        }
-        // Handle route.error events by storing result for later yielding
-        if (event.type === "route.error" && !hasYielded) {
-            hasYielded = true;
-            // Check if this should cause a panic
-            const panicError = handleError({
-                error: event.data.error,
-                logger: handlerOptions.logger,
-                panicThreshold: event.data.panicThreshold,
-                context: `route.error (${event.data.route})`,
-            });
-            if (panicError != null) {
-                // This is a panic error, store error result
-                errorResult = {
-                    type: "error",
-                    error: panicError,
-                    metrics: {
-                        rscHeadless: { duration: 0, chunks: 0, bytes: 0 },
-                        html: { duration: 0, chunks: 0, bytes: 0 },
-                    },
-                };
-            }
-            else {
-                // This is a non-panic error, store skip result
-                errorResult = {
-                    type: "skip",
-                    reason: event.data.error.message || "Non-panic error occurred",
-                    html: { duration: 0, chunks: 0, bytes: 0 },
-                    rsc: { duration: 0, chunks: 0, bytes: 0 },
-                    metrics: {
-                        rscHeadless: { duration: 0, chunks: 0, bytes: 0 },
-                        html: { duration: 0, chunks: 0, bytes: 0 },
-                    },
-                };
-            }
-        }
+    const resolvePathWithManifest = (path, manifest2) => {
+      const entry = manifest2[path];
+      if (entry && entry.file) {
+        return entry.file;
+      }
+      return path;
     };
-    // Skip if no pagePath AND no PageComponent provided (fallback case)
-    if (!handlerOptions.pagePath && !handlerOptions.PageComponent) {
-        // Create empty stream wrappers for skip case
-        const emptyStreamWrapper = {
-            pipe: (destination) => {
-                destination.end();
-                return destination;
-            },
-            abort: () => {
-                // No cleanup needed
-            },
-        };
+    const manifest = handlerOptions.manifest || {};
+    const resolvedPagePath = handlerOptions.pagePath ? resolvePathWithManifest(handlerOptions.pagePath, manifest) : void 0;
+    const resolvedPropsPath = handlerOptions.propsPath ? resolvePathWithManifest(handlerOptions.propsPath, manifest) : void 0;
+    const resolvedRootPath = handlerOptions.rootPath ? resolvePathWithManifest(handlerOptions.rootPath, manifest) : void 0;
+    const resolvedHtmlPath = handlerOptions.htmlPath ? resolvePathWithManifest(handlerOptions.htmlPath, manifest) : void 0;
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(`[renderPage.client] Resolved paths for route ${handlerOptions.route}:`);
+      handlerOptions.logger?.info(`  page: ${handlerOptions.pagePath} -> ${resolvedPagePath}`);
+      handlerOptions.logger?.info(`  props: ${handlerOptions.propsPath} -> ${resolvedPropsPath}`);
+      handlerOptions.logger?.info(`  root: ${handlerOptions.rootPath} -> ${resolvedRootPath}`);
+      handlerOptions.logger?.info(`  html: ${handlerOptions.htmlPath} -> ${resolvedHtmlPath}`);
+      handlerOptions.logger?.info(`  manifest keys: ${Object.keys(manifest).join(", ")}`);
+      handlerOptions.logger?.info(`  HTML path issue: htmlPath='${handlerOptions.htmlPath}', resolved='${resolvedHtmlPath}', manifest has Html entry: ${!!manifest[handlerOptions.htmlPath || ""]}`);
+      handlerOptions.logger?.info(`  About to pass htmlPath='${resolvedHtmlPath}' to RSC stream`);
+    }
+    const worker = handlerOptions.worker ?? handlerOptions.rscWorker;
+    if (!worker) {
+      throw new Error("RSC worker is required for client-side component resolution");
+    }
+    try {
+      await resolveComponents({
+        route: handlerOptions.route,
+        pagePath: resolvedPagePath,
+        propsPath: resolvedPropsPath,
+        rootPath: resolvedRootPath,
+        htmlPath: resolvedHtmlPath,
+        pageExportName: handlerOptions.pageExportName,
+        propsExportName: handlerOptions.propsExportName,
+        rootExportName: handlerOptions.rootExportName,
+        htmlExportName: handlerOptions.htmlExportName,
+        worker,
+        rscWorker: worker,
+        onMetrics: handlerOptions.onMetrics,
+        logger: handlerOptions.logger,
+        verbose: handlerOptions.verbose
+      });
+    } catch (componentResolutionError) {
+      const error = componentResolutionError instanceof Error ? componentResolutionError : new Error(String(componentResolutionError));
+      const panicError = handleError({
+        error,
+        critical: false,
+        logger: handlerOptions.logger,
+        panicThreshold: handlerOptions.panicThreshold,
+        context: `Component resolution failed for route ${handlerOptions.route}`
+      });
+      if (panicError) {
         yield {
-            type: "skip",
-            reason: "No pagePath and no PageComponent provided",
-            html: emptyStreamWrapper,
-            rsc: emptyStreamWrapper,
-            metrics: {
-                rscFull: createRenderMetrics({
-                    route: handlerOptions.route,
-                    type: "rsc-full",
-                    fromMainThread: false,
-                    fromRscWorker: true,
-                    fromHtmlWorker: false,
-                }),
-                rscHeadless: createRenderMetrics({
-                    route: handlerOptions.route,
-                    type: "rsc-headless",
-                    fromMainThread: false,
-                    fromRscWorker: true,
-                    fromHtmlWorker: false,
-                }),
-                html: createRenderMetrics({
-                    route: handlerOptions.route,
-                    type: "html",
-                    fromMainThread: true,
-                    fromRscWorker: false,
-                    fromHtmlWorker: false,
-                }),
-            },
+          type: "error",
+          error: panicError,
+          metrics: {
+            rscFull: rscFullMetrics,
+            rscHeadless: rscHeadlessMetrics,
+            html: htmlMetrics
+          }
         };
         return;
+      }
+      handlerOptions.logger?.warn(
+        `[renderPage.client] Component resolution failed for route ${handlerOptions.route}, continuing with client-only HTML: ${error.message}`
+      );
+      const clientOnlyHtmlStreamWrapper = {
+        pipe: (destination) => {
+          const minimalHtml = `<!DOCTYPE html><html><head><link rel="expect" href="#«R»" blocking="render"/></head><body><div id="root"></div><template id="«R»"></template></body></html>`;
+          destination.write(minimalHtml);
+          destination.end();
+          return destination;
+        },
+        abort: () => {
+        }
+      };
+      const emptyRscStreamWrapper = {
+        pipe: (destination) => {
+          destination.end();
+          return destination;
+        },
+        abort: () => {
+        }
+      };
+      yield {
+        type: "skip",
+        reason: error,
+        html: clientOnlyHtmlStreamWrapper,
+        rsc: emptyRscStreamWrapper,
+        metrics: {
+          rscFull: rscFullMetrics,
+          rscHeadless: rscHeadlessMetrics,
+          html: htmlMetrics
+        }
+      };
+      return;
     }
-    if (!handlerOptions.url) {
-        handlerOptions.url = routeToURL(handlerOptions.route, handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath);
+    const newHandlerOptions = {
+      ...handlerOptions,
+      // Pass page paths to the RSC worker so it knows what to render
+      pagePath: resolvedPagePath,
+      propsPath: resolvedPropsPath,
+      rootPath: resolvedRootPath,
+      htmlPath: resolvedHtmlPath
+    };
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[renderPage.client] handlerOptions.clientPipeableStreamOptions: ${JSON.stringify(handlerOptions.clientPipeableStreamOptions)}`
+      );
+      handlerOptions.logger?.info(
+        `[renderPage.client] newHandlerOptions.clientPipeableStreamOptions: ${JSON.stringify(newHandlerOptions.clientPipeableStreamOptions)}`
+      );
+      handlerOptions.logger?.info(
+        `[renderPage.client] newHandlerOptions page paths: pagePath=${newHandlerOptions.pagePath}, propsPath=${newHandlerOptions.propsPath}, rootPath=${newHandlerOptions.rootPath}, htmlPath=${newHandlerOptions.htmlPath}`
+      );
     }
-    const baseDir = join(handlerOptions.build.outDir, handlerOptions.build.static);
-    const routePath = handlerOptions.route.replace(/^\//, "");
-    // Create metrics upfront with proper types - REVERSE from server
-    const htmlMetrics = createRenderMetrics({
-        route: handlerOptions.route,
-        type: "html",
-        fromMainThread: true, // Client: HTML rendered on main thread
-        fromRscWorker: false,
-        fromHtmlWorker: false,
-        baseDir,
-        routePath,
-        fileName: handlerOptions.build.htmlOutputPath,
-        outputPath: join(baseDir, routePath, handlerOptions.build.htmlOutputPath),
+    const uniqueId = handlerOptions.id ?? `${handlerOptions.route}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    const headlessRscStreamLocal = createRscStream({
+      ...newHandlerOptions,
+      id: `${handlerOptions.route}-headless-${uniqueId}`,
+      rscTimeout: handlerOptions.rscTimeout || 5e3,
+      onMetrics: handlerOptions.onMetrics,
+      // Headless RSC stream: page content only (for .rsc file)
+      htmlPath: "",
+      // No HTML wrapper - just page content
+      pagePath: newHandlerOptions.pagePath || "",
+      // Ensure pagePath is always a string
+      url: newHandlerOptions.url || "",
+      // Ensure url is always a string
+      pageProps: newHandlerOptions.pageProps || {},
+      // Ensure pageProps is always an object
+      onEvent: wrappedOnEvent
     });
-    const rscFullMetrics = createRenderMetrics({
-        route: handlerOptions.route,
-        type: "rsc-full",
-        fromMainThread: false,
-        fromRscWorker: true, // Client: RSC rendered on RSC worker
-        fromHtmlWorker: false,
+    const fullRscStreamLocal = createRscStream({
+      ...newHandlerOptions,
+      id: `${handlerOptions.route}-full-${uniqueId}`,
+      rscTimeout: handlerOptions.rscTimeout || 5e3,
+      onMetrics: handlerOptions.onMetrics,
+      // Full RSC stream: include HTML wrapper (for HTML generation)
+      // Pass through the resolved htmlPath so custom Html components work in client mode
+      htmlPath: resolvedHtmlPath,
+      pagePath: newHandlerOptions.pagePath || "",
+      // Ensure pagePath is always a string
+      url: newHandlerOptions.url || "",
+      // Ensure url is always a string
+      pageProps: newHandlerOptions.pageProps || {},
+      // Ensure pageProps is always an object
+      // Reuse headless stream elements - the worker will handle this with the unique ID
+      reuseHeadlessStreamId: headlessRscStreamLocal.id,
+      onEvent: wrappedOnEvent
     });
-    const rscHeadlessMetrics = createRenderMetrics({
-        route: handlerOptions.route,
-        type: "rsc-headless",
-        fromMainThread: false,
-        fromRscWorker: true, // Client: RSC rendered on RSC worker
-        fromHtmlWorker: false,
-        baseDir,
-        routePath,
-        fileName: handlerOptions.build.rscOutputPath,
-        outputPath: join(baseDir, routePath, handlerOptions.build.rscOutputPath),
+    headlessRscStream = headlessRscStreamLocal;
+    fullRscStream = fullRscStreamLocal;
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[renderPage.client] Creating HTML transform stream with clientPipeableStreamOptions: ${JSON.stringify(newHandlerOptions.clientPipeableStreamOptions)}`
+      );
+    }
+    const htmlTransformStream = createRscToHtmlStream({
+      ...newHandlerOptions,
+      htmlTimeout: handlerOptions.htmlTimeout || 15e3,
+      route: handlerOptions.route,
+      logger: handlerOptions.logger,
+      verbose: handlerOptions.verbose,
+      rscStream: fullRscStreamLocal.rscStream
     });
-    // Declare variables outside try block so they can be accessed in catch block
-    let headlessRscStream = null;
-    let fullRscStream = null;
-    let htmlHandler = null;
-    try {
-        if (handlerOptions.verbose) {
-            handlerOptions.logger?.info(`[renderPage.client] Client-side rendering for route: ${handlerOptions.route}`);
-        }
-        // Step 1: Resolve paths to built paths using the server manifest
-        // The client version needs to use the server manifest to get the built paths
-        // for the page components, not the static manifest
-        const resolvePathWithManifest = (path, manifest) => {
-            const entry = manifest[path];
-            if (entry && entry.file) {
-                return entry.file;
-            }
-            return path;
-        };
-        // Use manifest for page component resolution (client version works in reverse)
-        const manifest = handlerOptions.manifest || {};
-        const resolvedPagePath = handlerOptions.pagePath ? resolvePathWithManifest(handlerOptions.pagePath, manifest) : undefined;
-        const resolvedPropsPath = handlerOptions.propsPath ? resolvePathWithManifest(handlerOptions.propsPath, manifest) : undefined;
-        const resolvedRootPath = handlerOptions.rootPath ? resolvePathWithManifest(handlerOptions.rootPath, manifest) : undefined;
-        const resolvedHtmlPath = handlerOptions.htmlPath ? resolvePathWithManifest(handlerOptions.htmlPath, manifest) : undefined;
-        if (handlerOptions.verbose) {
-            handlerOptions.logger?.info(`[renderPage.client] Resolved paths for route ${handlerOptions.route}:`);
-            handlerOptions.logger?.info(`  page: ${handlerOptions.pagePath} -> ${resolvedPagePath}`);
-            handlerOptions.logger?.info(`  props: ${handlerOptions.propsPath} -> ${resolvedPropsPath}`);
-            handlerOptions.logger?.info(`  root: ${handlerOptions.rootPath} -> ${resolvedRootPath}`);
-            handlerOptions.logger?.info(`  html: ${handlerOptions.htmlPath} -> ${resolvedHtmlPath}`);
-            handlerOptions.logger?.info(`  manifest keys: ${Object.keys(manifest).join(', ')}`);
-            handlerOptions.logger?.info(`  HTML path issue: htmlPath='${handlerOptions.htmlPath}', resolved='${resolvedHtmlPath}', manifest has Html entry: ${!!manifest[handlerOptions.htmlPath || '']}`);
-            handlerOptions.logger?.info(`  About to pass htmlPath='${resolvedHtmlPath}' to RSC stream`);
-        }
-        const worker = handlerOptions.worker ?? handlerOptions.rscWorker;
-        // Step 2: Resolve components using the RSC worker with built paths
-        // This separates component resolution from RSC generation, making the
-        // subsequent RSC render completely synchronous
-        if (!worker) {
-            throw new Error("RSC worker is required for client-side component resolution");
-        }
-        // Preload components in the worker for faster subsequent RSC stream generation
-        try {
-            await resolveComponents({
-                route: handlerOptions.route,
-                pagePath: resolvedPagePath,
-                propsPath: resolvedPropsPath,
-                rootPath: resolvedRootPath,
-                htmlPath: resolvedHtmlPath,
-                pageExportName: handlerOptions.pageExportName,
-                propsExportName: handlerOptions.propsExportName,
-                rootExportName: handlerOptions.rootExportName,
-                htmlExportName: handlerOptions.htmlExportName,
-                worker: worker,
-                rscWorker: worker,
-                onMetrics: handlerOptions.onMetrics,
-                logger: handlerOptions.logger,
-                verbose: handlerOptions.verbose,
-            });
-        }
-        catch (componentResolutionError) {
-            // Handle component resolution failures gracefully
-            const error = componentResolutionError instanceof Error
-                ? componentResolutionError
-                : new Error(String(componentResolutionError));
-            // Check if this component resolution error should cause a panic based on panicThreshold
-            const panicError = handleError({
-                error,
-                critical: false,
-                logger: handlerOptions.logger,
-                panicThreshold: handlerOptions.panicThreshold,
-                context: `Component resolution failed for route ${handlerOptions.route}`,
-            });
-            // If this should cause a panic, yield error and return
-            if (panicError) {
-                yield {
-                    type: "error",
-                    error: panicError,
-                    metrics: {
-                        rscFull: rscFullMetrics,
-                        rscHeadless: rscHeadlessMetrics,
-                        html: htmlMetrics,
-                    },
-                };
-                return;
-            }
-            // Otherwise, treat this as a non-critical error and continue with client-only HTML
-            // This allows the build to complete with a client-only page
-            handlerOptions.logger?.warn(`[renderPage.client] Component resolution failed for route ${handlerOptions.route}, continuing with client-only HTML: ${error.message}`);
-            // Create a client-only HTML stream wrapper with minimal HTML
-            const clientOnlyHtmlStreamWrapper = {
-                pipe: (destination) => {
-                    // Write a minimal client-only HTML structure
-                    const minimalHtml = `<!DOCTYPE html><html><head><link rel="expect" href="#«R»" blocking="render"/></head><body><div id="root"></div><template id="«R»"></template></body></html>`;
-                    destination.write(minimalHtml);
-                    destination.end();
-                    return destination;
-                },
-                abort: () => {
-                    // No cleanup needed for simple HTML string
-                },
-            };
-            // Create an empty RSC stream wrapper
-            const emptyRscStreamWrapper = {
-                pipe: (destination) => {
-                    // No RSC content for failed component resolution
-                    destination.end();
-                    return destination;
-                },
-                abort: () => {
-                    // No cleanup needed
-                },
-            };
-            // Yield skip result with client-only HTML and empty RSC
-            yield {
-                type: "skip",
-                reason: error,
-                html: clientOnlyHtmlStreamWrapper,
-                rsc: emptyRscStreamWrapper,
-                metrics: {
-                    rscFull: rscFullMetrics,
-                    rscHeadless: rscHeadlessMetrics,
-                    html: htmlMetrics,
-                },
-            };
-            return;
-        }
-        // Step 2: Create handler options
-        // Components are now preloaded in the worker, so we can use the original handler options
-        const newHandlerOptions = {
-            ...handlerOptions,
-            // Pass page paths to the RSC worker so it knows what to render
-            pagePath: resolvedPagePath,
-            propsPath: resolvedPropsPath,
-            rootPath: resolvedRootPath,
-            htmlPath: resolvedHtmlPath,
-        };
-        if (handlerOptions.verbose) {
-            handlerOptions.logger?.info(`[renderPage.client] handlerOptions.clientPipeableStreamOptions: ${JSON.stringify(handlerOptions.clientPipeableStreamOptions)}`);
-            handlerOptions.logger?.info(`[renderPage.client] newHandlerOptions.clientPipeableStreamOptions: ${JSON.stringify(newHandlerOptions.clientPipeableStreamOptions)}`);
-            handlerOptions.logger?.info(`[renderPage.client] newHandlerOptions page paths: pagePath=${newHandlerOptions.pagePath}, propsPath=${newHandlerOptions.propsPath}, rootPath=${newHandlerOptions.rootPath}, htmlPath=${newHandlerOptions.htmlPath}`);
-        }
-        // Component resolution is already measured in resolveComponents
-        // No need to measure module resolution time here anymore
-        // Create headless RSC stream first (for .rsc file)
-        const uniqueId = handlerOptions.id ?? `${handlerOptions.route}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const headlessRscStreamLocal = createRscStream({
-            ...newHandlerOptions,
-            id: `${handlerOptions.route}-headless-${uniqueId}`,
-            rscTimeout: handlerOptions.rscTimeout || 5000,
-            onMetrics: handlerOptions.onMetrics,
-            // Headless RSC stream: page content only (for .rsc file)
-            htmlPath: '', // No HTML wrapper - just page content
-            pagePath: newHandlerOptions.pagePath || '', // Ensure pagePath is always a string
-            url: newHandlerOptions.url || '', // Ensure url is always a string
-            pageProps: newHandlerOptions.pageProps || {}, // Ensure pageProps is always an object
-            onEvent: wrappedOnEvent,
+    htmlHandler = {
+      htmlStream: htmlTransformStream,
+      abort: () => {
+        htmlTransformStream.abort();
+      }
+    };
+    const rscStreamWrapper = {
+      pipe: (destination) => {
+        const streamMetrics = createStreamMetrics();
+        streamMetrics.startTime = performance.now();
+        const rscFileStream = headlessRscStream.rscStream;
+        rscFileStream.on("data", (chunk) => {
+          streamMetrics.chunks++;
+          streamMetrics.bytes += chunk.length;
         });
-        // Create full RSC stream that reuses the headless stream elements
-        const fullRscStreamLocal = createRscStream({
-            ...newHandlerOptions,
-            id: `${handlerOptions.route}-full-${uniqueId}`,
-            rscTimeout: handlerOptions.rscTimeout || 5000,
-            onMetrics: handlerOptions.onMetrics,
-            // Full RSC stream: include HTML wrapper (for HTML generation)
-            // Pass through the resolved htmlPath so custom Html components work in client mode
-            htmlPath: resolvedHtmlPath,
-            pagePath: newHandlerOptions.pagePath || '', // Ensure pagePath is always a string
-            url: newHandlerOptions.url || '', // Ensure url is always a string
-            pageProps: newHandlerOptions.pageProps || {}, // Ensure pageProps is always an object
-            // Reuse headless stream elements - the worker will handle this with the unique ID
-            reuseHeadlessStreamId: headlessRscStreamLocal.id,
-            onEvent: wrappedOnEvent,
+        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;
         });
-        // Assign to the outer variables
-        headlessRscStream = headlessRscStreamLocal;
-        fullRscStream = fullRscStreamLocal;
-        // The headless stream will be consumed naturally by the file writing
-        // The full stream will reuse the headless stream elements for HTML generation
-        // Step 3: Create HTML transform stream
+        rscFileStream.pipe(destination);
+        return destination;
+      },
+      abort: () => headlessRscStream.abort()
+    };
+    const htmlStreamWrapper = {
+      pipe: (destination) => {
         if (handlerOptions.verbose) {
-            handlerOptions.logger?.info(`[renderPage.client] Creating HTML transform stream with clientPipeableStreamOptions: ${JSON.stringify(newHandlerOptions.clientPipeableStreamOptions)}`);
+          handlerOptions.logger?.info(
+            `[renderPage.client] Piping HTML stream to destination for route: ${handlerOptions.route}`
+          );
         }
-        // Create HTML stream using the full RSC stream (which reuses headless stream elements)
-        const htmlTransformStream = createRscToHtmlStream({
-            ...newHandlerOptions,
-            htmlTimeout: handlerOptions.htmlTimeout || 15000,
-            route: handlerOptions.route,
-            logger: handlerOptions.logger,
-            verbose: handlerOptions.verbose,
-            rscStream: fullRscStreamLocal.rscStream,
-        });
-        htmlHandler = {
-            htmlStream: htmlTransformStream,
-            abort: () => {
-                htmlTransformStream.abort();
-            }
-        };
-        // Create stream wrappers for file writing
-        const rscStreamWrapper = {
-            pipe: (destination) => {
-                const streamMetrics = createStreamMetrics();
-                streamMetrics.startTime = performance.now();
-                // Use the headless RSC stream directly for the .rsc file
-                const rscFileStream = headlessRscStream.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: () => headlessRscStream.abort(),
-        };
-        const htmlStreamWrapper = {
-            pipe: (destination) => {
-                if (handlerOptions.verbose) {
-                    handlerOptions.logger?.info(`[renderPage.client] Piping HTML stream to destination for route: ${handlerOptions.route}`);
-                }
-                // Use the HTML transform stream's pipe method directly (same as server side)
-                return htmlTransformStream.pipe(destination);
-            },
-            abort: () => {
-                fullRscStream.abort();
-                if (htmlHandler.abort) {
-                    htmlHandler.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;
-            },
-        };
-        // Don't emit initial metrics - wait for file writes to complete
-        // The onMetrics callback will be called after both file.write.done events
-        // Check if we have an error result to yield (with timeout protection)
-        // Wait a short time for any pending route.error events
-        await new Promise(resolve => setTimeout(resolve, 100));
-        if (errorResult) {
-            yield errorResult;
-            return;
+        return htmlTransformStream.pipe(destination);
+      },
+      abort: () => {
+        fullRscStream.abort();
+        if (htmlHandler.abort) {
+          htmlHandler.abort();
         }
-        yield {
-            type: "success",
-            html: htmlStreamWrapper,
-            rsc: rscStreamWrapper,
-            metrics: {
-                rscFull: rscFullMetrics,
-                rscHeadless: rscHeadlessMetrics,
-                html: htmlMetrics,
-            },
-        };
+      },
+      on: (event, listener) => {
+        if (event === "error") {
+          const htmlStream = htmlTransformStream.htmlStream;
+          if (htmlStream && typeof htmlStream.on === "function") {
+            htmlStream.on("error", listener);
+          }
+        }
+        return htmlStreamWrapper;
+      }
+    };
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    if (errorResult) {
+      yield errorResult;
+      return;
     }
-    catch (error) {
-        // Clean up resources
-        try {
-            if (headlessRscStream)
-                headlessRscStream.abort();
-            if (fullRscStream)
-                fullRscStream.abort();
-            if (htmlHandler?.abort)
-                htmlHandler.abort();
+    yield {
+      type: "success",
+      html: htmlStreamWrapper,
+      rsc: rscStreamWrapper,
+      metrics: {
+        rscFull: rscFullMetrics,
+        rscHeadless: rscHeadlessMetrics,
+        html: htmlMetrics
+      }
+    };
+  } catch (error) {
+    try {
+      if (headlessRscStream) headlessRscStream.abort();
+      if (fullRscStream) fullRscStream.abort();
+      if (htmlHandler?.abort) htmlHandler.abort();
+    } catch (cleanupError) {
+      handlerOptions.logger?.warn(`Failed to cleanup streams on error: ${cleanupError}`);
+    }
+    const panicError = handleError({
+      error,
+      logger: handlerOptions.logger,
+      panicThreshold: handlerOptions.panicThreshold
+    });
+    if (panicError != null) {
+      yield {
+        type: "error",
+        error: panicError,
+        metrics: {
+          rscFull: rscFullMetrics,
+          rscHeadless: rscHeadlessMetrics,
+          html: htmlMetrics
         }
-        catch (cleanupError) {
-            handlerOptions.logger?.warn(`Failed to cleanup streams on error: ${cleanupError}`);
+      };
+    } else {
+      const fallbackRscStream = createRscStream({
+        ...handlerOptions,
+        url: `${handlerOptions.url}`,
+        route: `${handlerOptions.route}`,
+        cssFiles: handlerOptions.cssFiles || /* @__PURE__ */ new Map(),
+        globalCss: handlerOptions.globalCss || /* @__PURE__ */ new Map(),
+        id: `${handlerOptions.route}-fallback-${Date.now()}`,
+        rscTimeout: handlerOptions.rscTimeout || 5e3,
+        onMetrics: handlerOptions.onMetrics,
+        // Use React.Fragment as fallback (same as server environment)
+        pagePath: "",
+        // This will cause the default page to be used, but we'll override it
+        pageProps: {}
+        // Ensure pageProps is always an object
+      });
+      const fallbackHtmlStream = createRscToHtmlStream({
+        id: handlerOptions.id,
+        route: handlerOptions.route,
+        url: handlerOptions.url,
+        moduleRootPath: handlerOptions.moduleRootPath,
+        moduleBasePath: handlerOptions.moduleBasePath,
+        moduleBaseURL: handlerOptions.moduleBaseURL,
+        projectRoot: handlerOptions.projectRoot,
+        panicThreshold: handlerOptions.panicThreshold,
+        verbose: handlerOptions.verbose,
+        signal: handlerOptions.signal,
+        logger: handlerOptions.logger,
+        htmlTimeout: handlerOptions.htmlTimeout,
+        clientPipeableStreamOptions: handlerOptions.clientPipeableStreamOptions,
+        onMetrics: handlerOptions.onMetrics,
+        build: handlerOptions.build
+      });
+      const clientOnlyHtmlStreamWrapper = {
+        pipe: (destination) => {
+          return fallbackHtmlStream.pipe(destination);
+        },
+        abort: () => {
+          fallbackRscStream.abort();
         }
-        const panicError = handleError({
-            error,
-            logger: handlerOptions.logger,
-            context: "renderPageClient",
-            panicThreshold: handlerOptions.panicThreshold,
-        });
-        if (panicError != null) {
-            yield {
-                type: "error",
-                error: panicError,
-                metrics: {
-                    rscFull: rscFullMetrics,
-                    rscHeadless: rscHeadlessMetrics,
-                    html: htmlMetrics,
-                },
-            };
+      };
+      const emptyRscStreamWrapper = {
+        pipe: (destination) => {
+          destination.end();
+          return destination;
+        },
+        abort: () => {
         }
-        else {
-            // For non-panic errors, we still want to write the HTML file (client-only)
-            // but skip the RSC file since there was a server error
-            // Create a fallback RSC stream with React.Fragment (same as server environment)
-            const fallbackRscStream = createRscStream({
-                ...handlerOptions,
-                url: `${handlerOptions.url}`,
-                route: `${handlerOptions.route}`,
-                cssFiles: handlerOptions.cssFiles || new Map(),
-                globalCss: handlerOptions.globalCss || new Map(),
-                id: `${handlerOptions.route}-fallback-${Date.now()}`,
-                rscTimeout: handlerOptions.rscTimeout || 5000,
-                onMetrics: handlerOptions.onMetrics,
-                // Use React.Fragment as fallback (same as server environment)
-                pagePath: '', // This will cause the default page to be used, but we'll override it
-                pageProps: {}, // Ensure pageProps is always an object
-            });
-            // Create HTML stream that processes the fallback RSC stream to ensure performance timing script is injected
-            const fallbackHtmlStream = createRscToHtmlStream({
-                id: handlerOptions.id,
-                route: handlerOptions.route,
-                url: handlerOptions.url,
-                moduleRootPath: handlerOptions.moduleRootPath,
-                moduleBasePath: handlerOptions.moduleBasePath,
-                moduleBaseURL: handlerOptions.moduleBaseURL,
-                projectRoot: handlerOptions.projectRoot,
-                panicThreshold: handlerOptions.panicThreshold,
-                verbose: handlerOptions.verbose,
-                signal: handlerOptions.signal,
-                logger: handlerOptions.logger,
-                htmlTimeout: handlerOptions.htmlTimeout,
-                clientPipeableStreamOptions: handlerOptions.clientPipeableStreamOptions,
-                onMetrics: handlerOptions.onMetrics,
-                build: handlerOptions.build,
-            });
-            // Create a wrapper that pipes the fallback RSC stream through the HTML transform
-            const clientOnlyHtmlStreamWrapper = {
-                pipe: (destination) => {
-                    // Pipe the fallback RSC stream through the HTML transform to ensure performance timing script is injected
-                    return fallbackHtmlStream.pipe(destination);
-                },
-                abort: () => {
-                    // Clean up the fallback RSC stream
-                    fallbackRscStream.abort();
-                },
-            };
-            // Create an empty RSC stream wrapper
-            const emptyRscStreamWrapper = {
-                pipe: (destination) => {
-                    // No RSC content for skipped routes
-                    destination.end();
-                    return destination;
-                },
-                abort: () => {
-                    // No cleanup needed
-                },
-            };
-            yield {
-                type: "skip",
-                reason: error,
-                html: clientOnlyHtmlStreamWrapper,
-                rsc: emptyRscStreamWrapper,
-                metrics: {
-                    rscFull: rscFullMetrics,
-                    rscHeadless: rscHeadlessMetrics,
-                    html: htmlMetrics,
-                },
-            };
+      };
+      yield {
+        type: "skip",
+        reason: error,
+        html: clientOnlyHtmlStreamWrapper,
+        rsc: emptyRscStreamWrapper,
+        metrics: {
+          rscFull: rscFullMetrics,
+          rscHeadless: rscHeadlessMetrics,
+          html: htmlMetrics
         }
+      };
     }
+  }
 };
+
+export { renderPage };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"renderPage.client.js","sources":["../../../plugin/react-static/renderPage.client.ts"],"sourcesContent":["/**\n * renderPage.client.ts\n *\n * PURPOSE: Client-side static page rendering for React Server Components\n *\n * ARCHITECTURE OVERVIEW:\n * \n * CLIENT-SIDE vs SERVER-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. RSC Worker generates RSC content with HTML wrapper\n * 2. RSC content is buffered to allow dual consumption\n * 3. Buffered RSC stream is consumed twice:\n *    - For RSC file writing (index.rsc)\n *    - For HTML transformation (index.html)\n * 4. HTML transform processes RSC content in main thread\n * 5. Both files are written to filesystem\n * \n * KEY INSIGHT: Node.js streams can only be consumed once, so we buffer the RSC\n * content to allow it to be used for both RSC file generation and HTML transformation.\n * This follows the pattern from collectRscContent.ts.\n * \n * HELPER FUNCTIONS:\n * - createBufferedRscStream: Creates a buffered stream for dual consumption\n * - createRscToHtmlStream: Transforms RSC content to HTML in main thread\n * \n * USAGE:\n * ```typescript\n * const result = await renderPage({\n *   route: \"/\",\n *   pagePath: \"src/page/page.tsx\",\n *   // ... other options\n * });\n * \n * // result.html.pipe(htmlFileWriter);\n * // result.rsc.pipe(rscFileWriter);\n * ```\n */\n\nimport { createRenderMetrics } from \"../metrics/createRenderMetrics.js\";\nimport type { RenderMetrics } from \"../metrics/types.js\";\nimport { routeToURL } from \"../utils/routeToURL.js\";\nimport type { RenderPageFn } from \"./types.js\";\nimport { handleError } from \"../error/handleError.js\";\nimport { assertNonReactServer } from \"../config/getCondition.js\";\n\nimport { createRscStream } from \"../stream/createRscStream.client.js\";\nimport { resolveComponents } from \"../helpers/resolveComponents.client.js\";\n\nimport { join } from \"node:path\";\n\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\nimport { performance } from \"node:perf_hooks\";\nimport { createRscToHtmlStream } from \"./rscToHtmlStream.client.js\";\n\n\n\nassertNonReactServer();\n\n/**\n * Client version of renderPage that uses the react-client pattern\n * This works in REVERSE from the server plugin:\n * - Server: Main thread (RSC) + HTML worker (HTML)\n * - Client: RSC worker (RSC) + Main thread (HTML)\n */\nexport const renderPage: RenderPageFn = async function* _renderPageClient(\n  handlerOptions\n) {\n  if (handlerOptions.verbose) {\n    handlerOptions.logger?.info(\n      `[renderPage.client] onEvent callback exists: ${!!handlerOptions.onEvent}`\n    );\n    handlerOptions.logger?.info(\n      `[renderPage.client] onMetrics callback exists: ${!!handlerOptions.onMetrics}`\n    );\n  }\n\n  // Track if we've yielded a result to prevent multiple yields\n  let hasYielded = false;\n  let errorResult: any = null;\n\n  // Create a wrapper around onEvent to handle route.error events\n  const wrappedOnEvent = (event: any) => {\n    // Call the original onEvent first\n    if (handlerOptions.onEvent) {\n      handlerOptions.onEvent(event);\n    }\n    \n    // Handle route.error events by storing result for later yielding\n    if (event.type === \"route.error\" && !hasYielded) {\n      hasYielded = true;\n      \n      // Check if this should cause a panic\n      const panicError = handleError({\n        error: event.data.error,\n        logger: handlerOptions.logger,\n        panicThreshold: event.data.panicThreshold,\n        context: `route.error (${event.data.route})`,\n      });\n      \n      if (panicError != null) {\n        // This is a panic error, store error result\n        errorResult = {\n          type: \"error\",\n          error: panicError,\n          metrics: {\n            rscHeadless: { duration: 0, chunks: 0, bytes: 0 },\n            html: { duration: 0, chunks: 0, bytes: 0 },\n          },\n        };\n      } else {\n        // This is a non-panic error, store skip result\n        errorResult = {\n          type: \"skip\",\n          reason: event.data.error.message || \"Non-panic error occurred\",\n          html: { duration: 0, chunks: 0, bytes: 0 },\n          rsc: { duration: 0, chunks: 0, bytes: 0 },\n          metrics: {\n            rscHeadless: { duration: 0, chunks: 0, bytes: 0 },\n            html: { duration: 0, chunks: 0, bytes: 0 },\n          },\n        };\n      }\n    }\n  };\n\n  // Skip if no pagePath AND no PageComponent provided (fallback case)\n  if (!handlerOptions.pagePath && !handlerOptions.PageComponent) {\n    // Create empty stream wrappers for skip case\n    const emptyStreamWrapper = {\n      pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n        destination.end();\n        return destination;\n      },\n      abort: () => {\n        // No cleanup needed\n      },\n    };\n\n    yield {\n      type: \"skip\",\n      reason: \"No pagePath and no PageComponent provided\",\n      html: emptyStreamWrapper,\n      rsc: emptyStreamWrapper,\n      metrics: {\n        rscFull: createRenderMetrics({\n          route: handlerOptions.route,\n          type: \"rsc-full\",\n          fromMainThread: false,\n          fromRscWorker: true,\n          fromHtmlWorker: false,\n        }) as RenderMetrics & { type: \"rsc-full\" },\n        rscHeadless: createRenderMetrics({\n          route: handlerOptions.route,\n          type: \"rsc-headless\",\n          fromMainThread: false,\n          fromRscWorker: true,\n          fromHtmlWorker: false,\n        }) as RenderMetrics & { type: \"rsc-headless\" },\n        html: createRenderMetrics({\n          route: handlerOptions.route,\n          type: \"html\",\n          fromMainThread: true,\n          fromRscWorker: false,\n          fromHtmlWorker: false,\n        }) as RenderMetrics & { type: \"html\" },\n      },\n    };\n    return;\n  }\n\n  if (!handlerOptions.url) {\n    handlerOptions.url = routeToURL(\n      handlerOptions.route,\n      handlerOptions.moduleBaseURL,\n      handlerOptions.build.rscOutputPath\n    );\n  }\n\n  const baseDir = join(\n    handlerOptions.build.outDir,\n    handlerOptions.build.static\n  );\n  const routePath = handlerOptions.route.replace(/^\\//, \"\");\n\n  // Create metrics upfront with proper types - REVERSE from server\n  const htmlMetrics = createRenderMetrics({\n    route: handlerOptions.route,\n    type: \"html\",\n    fromMainThread: true, // Client: HTML rendered on main thread\n    fromRscWorker: false,\n    fromHtmlWorker: false,\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: false,\n    fromRscWorker: true, // Client: RSC rendered on RSC worker\n    fromHtmlWorker: false,\n  });\n  \n  const rscHeadlessMetrics = createRenderMetrics({\n    route: handlerOptions.route,\n    type: \"rsc-headless\",\n    fromMainThread: false,\n    fromRscWorker: true, // Client: RSC rendered on RSC worker\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 so they can be accessed in catch block\n  let headlessRscStream: any = null;\n  let fullRscStream: any = null;\n  let htmlHandler: any = null;\n  \n\n\n  try {\n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.info(\n        `[renderPage.client] Client-side rendering for route: ${handlerOptions.route}`\n      );\n    }\n\n    // Step 1: Resolve paths to built paths using the server manifest\n    // The client version needs to use the server manifest to get the built paths\n    // for the page components, not the static manifest\n    const resolvePathWithManifest = (path: string, manifest: any): string => {\n      const entry = manifest[path];\n      if (entry && entry.file) {\n        return entry.file;\n      }\n      return path;\n    };\n\n    // Use manifest for page component resolution (client version works in reverse)\n    const manifest = handlerOptions.manifest || {};\n    const resolvedPagePath = handlerOptions.pagePath ? resolvePathWithManifest(handlerOptions.pagePath, manifest) : undefined;\n    const resolvedPropsPath = handlerOptions.propsPath ? resolvePathWithManifest(handlerOptions.propsPath, manifest) : undefined;\n    const resolvedRootPath = handlerOptions.rootPath ? resolvePathWithManifest(handlerOptions.rootPath, manifest) : undefined;\n    const resolvedHtmlPath = handlerOptions.htmlPath ? resolvePathWithManifest(handlerOptions.htmlPath, manifest) : undefined;\n\n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.info(`[renderPage.client] Resolved paths for route ${handlerOptions.route}:`);\n      handlerOptions.logger?.info(`  page: ${handlerOptions.pagePath} -> ${resolvedPagePath}`);\n      handlerOptions.logger?.info(`  props: ${handlerOptions.propsPath} -> ${resolvedPropsPath}`);\n      handlerOptions.logger?.info(`  root: ${handlerOptions.rootPath} -> ${resolvedRootPath}`);\n      handlerOptions.logger?.info(`  html: ${handlerOptions.htmlPath} -> ${resolvedHtmlPath}`);\n      handlerOptions.logger?.info(`  manifest keys: ${Object.keys(manifest).join(', ')}`);\n      handlerOptions.logger?.info(`  HTML path issue: htmlPath='${handlerOptions.htmlPath}', resolved='${resolvedHtmlPath}', manifest has Html entry: ${!!manifest[handlerOptions.htmlPath || '']}`);\n      handlerOptions.logger?.info(`  About to pass htmlPath='${resolvedHtmlPath}' to RSC stream`);\n    }\n    const worker = handlerOptions.worker ?? handlerOptions.rscWorker;\n\n    // Step 2: Resolve components using the RSC worker with built paths\n    // This separates component resolution from RSC generation, making the\n    // subsequent RSC render completely synchronous\n    if (!worker) {\n      throw new Error(\"RSC worker is required for client-side component resolution\");\n    }\n    \n    // Preload components in the worker for faster subsequent RSC stream generation\n    try {\n      await resolveComponents({\n        route: handlerOptions.route,\n        pagePath: resolvedPagePath,\n        propsPath: resolvedPropsPath,\n        rootPath: resolvedRootPath,\n        htmlPath: resolvedHtmlPath,\n        pageExportName: handlerOptions.pageExportName,\n        propsExportName: handlerOptions.propsExportName,\n        rootExportName: handlerOptions.rootExportName,\n        htmlExportName: handlerOptions.htmlExportName,\n        worker: worker,\n        rscWorker: worker,\n        onMetrics: handlerOptions.onMetrics,\n        logger: handlerOptions.logger,\n        verbose: handlerOptions.verbose,\n      });\n    } catch (componentResolutionError) {\n      // Handle component resolution failures gracefully\n      const error = componentResolutionError instanceof Error \n        ? componentResolutionError \n        : new Error(String(componentResolutionError));\n      \n      // Check if this component resolution error should cause a panic based on panicThreshold\n      const panicError = handleError({\n        error,\n        critical: false,\n        logger: handlerOptions.logger,\n        panicThreshold: handlerOptions.panicThreshold,\n        context: `Component resolution failed for route ${handlerOptions.route}`,\n      });\n      \n             // If this should cause a panic, yield error and return\n       if (panicError) {\n         yield {\n           type: \"error\",\n           error: panicError,\n           metrics: {\n             rscFull: rscFullMetrics,\n             rscHeadless: rscHeadlessMetrics,\n             html: htmlMetrics,\n           },\n         };\n         return;\n       }\n       \n       // Otherwise, treat this as a non-critical error and continue with client-only HTML\n       // This allows the build to complete with a client-only page\n       handlerOptions.logger?.warn(\n         `[renderPage.client] Component resolution failed for route ${handlerOptions.route}, continuing with client-only HTML: ${error.message}`\n       );\n       \n       // Create a client-only HTML stream wrapper with minimal HTML\n       const clientOnlyHtmlStreamWrapper = {\n         pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n           // Write a minimal client-only HTML structure\n           const minimalHtml = `<!DOCTYPE html><html><head><link rel=\"expect\" href=\"#«R»\" blocking=\"render\"/></head><body><div id=\"root\"></div><template id=\"«R»\"></template></body></html>`;\n           destination.write(minimalHtml);\n           destination.end();\n           return destination;\n         },\n         abort: () => {\n           // No cleanup needed for simple HTML string\n         },\n       };\n       \n       // Create an empty RSC stream wrapper\n       const emptyRscStreamWrapper = {\n         pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n           // No RSC content for failed component resolution\n           destination.end();\n           return destination;\n         },\n         abort: () => {\n           // No cleanup needed\n         },\n       };\n       \n       // Yield skip result with client-only HTML and empty RSC\n       yield {\n         type: \"skip\",\n         reason: error,\n         html: clientOnlyHtmlStreamWrapper,\n         rsc: emptyRscStreamWrapper,\n         metrics: {\n           rscFull: rscFullMetrics,\n           rscHeadless: rscHeadlessMetrics,\n           html: htmlMetrics,\n         },\n       };\n       return;\n    }\n\n    // Step 2: Create handler options\n    // Components are now preloaded in the worker, so we can use the original handler options\n    const newHandlerOptions = {\n      ...handlerOptions,\n      // Pass page paths to the RSC worker so it knows what to render\n      pagePath: resolvedPagePath,\n      propsPath: resolvedPropsPath,\n      rootPath: resolvedRootPath,\n      htmlPath: resolvedHtmlPath,\n    };\n\n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.info(\n        `[renderPage.client] handlerOptions.clientPipeableStreamOptions: ${JSON.stringify(handlerOptions.clientPipeableStreamOptions)}`\n      );\n      handlerOptions.logger?.info(\n        `[renderPage.client] newHandlerOptions.clientPipeableStreamOptions: ${JSON.stringify(newHandlerOptions.clientPipeableStreamOptions)}`\n      );\n      handlerOptions.logger?.info(\n        `[renderPage.client] newHandlerOptions page paths: pagePath=${newHandlerOptions.pagePath}, propsPath=${newHandlerOptions.propsPath}, rootPath=${newHandlerOptions.rootPath}, htmlPath=${newHandlerOptions.htmlPath}`\n      );\n    }\n\n    // Component resolution is already measured in resolveComponents\n    // No need to measure module resolution time here anymore\n\n    // Create headless RSC stream first (for .rsc file)\n    const uniqueId = handlerOptions.id ?? `${handlerOptions.route}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;\n    \n    const headlessRscStreamLocal = createRscStream({\n      ...newHandlerOptions,\n      id: `${handlerOptions.route}-headless-${uniqueId}`,\n      rscTimeout: handlerOptions.rscTimeout || 5000,\n      onMetrics: handlerOptions.onMetrics,\n      // Headless RSC stream: page content only (for .rsc file)\n      htmlPath: '', // No HTML wrapper - just page content\n      pagePath: newHandlerOptions.pagePath || '', // Ensure pagePath is always a string\n      url: newHandlerOptions.url || '', // Ensure url is always a string\n      pageProps: newHandlerOptions.pageProps || {}, // Ensure pageProps is always an object\n      onEvent: wrappedOnEvent,\n    });\n\n    // Create full RSC stream that reuses the headless stream elements\n    const fullRscStreamLocal = createRscStream({\n      ...newHandlerOptions,\n      id: `${handlerOptions.route}-full-${uniqueId}`,\n      rscTimeout: handlerOptions.rscTimeout || 5000,\n      onMetrics: handlerOptions.onMetrics,\n      // Full RSC stream: include HTML wrapper (for HTML generation)\n      // Pass through the resolved htmlPath so custom Html components work in client mode\n      htmlPath: resolvedHtmlPath,\n      pagePath: newHandlerOptions.pagePath || '', // Ensure pagePath is always a string\n      url: newHandlerOptions.url || '', // Ensure url is always a string\n      pageProps: newHandlerOptions.pageProps || {}, // Ensure pageProps is always an object\n      // Reuse headless stream elements - the worker will handle this with the unique ID\n      reuseHeadlessStreamId: headlessRscStreamLocal.id,\n      onEvent: wrappedOnEvent,\n    });\n\n    // Assign to the outer variables\n    headlessRscStream = headlessRscStreamLocal;\n    fullRscStream = fullRscStreamLocal;\n\n    // The headless stream will be consumed naturally by the file writing\n    // The full stream will reuse the headless stream elements for HTML generation\n\n    // Step 3: Create HTML transform stream\n    if (handlerOptions.verbose) {\n      handlerOptions.logger?.info(\n        `[renderPage.client] Creating HTML transform stream with clientPipeableStreamOptions: ${JSON.stringify(newHandlerOptions.clientPipeableStreamOptions)}`\n      );\n    }\n    // Create HTML stream using the full RSC stream (which reuses headless stream elements)\n    const htmlTransformStream = createRscToHtmlStream({\n      ...newHandlerOptions,\n      htmlTimeout: handlerOptions.htmlTimeout || 15000,\n      route: handlerOptions.route,\n      logger: handlerOptions.logger,\n      verbose: handlerOptions.verbose,\n      rscStream: fullRscStreamLocal.rscStream,\n    });\n\n    htmlHandler = {\n      htmlStream: htmlTransformStream,\n      abort: () => {\n        htmlTransformStream.abort();\n      }\n    };\n\n    // Create stream wrappers for file writing\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 = headlessRscStream.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: () => headlessRscStream.abort(),\n    };\n\n    const htmlStreamWrapper = {\n      pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.info(\n            `[renderPage.client] Piping HTML stream to destination for route: ${handlerOptions.route}`\n          );\n        }\n        \n        // Use the HTML transform stream's pipe method directly (same as server side)\n        return htmlTransformStream.pipe(destination);\n      },\n      abort: () => {\n        fullRscStream.abort();\n        if (htmlHandler.abort) {\n          htmlHandler.abort();\n        }\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    // Don't emit initial metrics - wait for file writes to complete\n    // The onMetrics callback will be called after both file.write.done events\n\n    // Check if we have an error result to yield (with timeout protection)\n    // Wait a short time for any pending route.error events\n    await new Promise(resolve => setTimeout(resolve, 100));\n    \n    if (errorResult) {\n      yield errorResult;\n      return;\n    }\n\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  } catch (error) {\n    // Clean up resources\n    try {\n      if (headlessRscStream) headlessRscStream.abort();\n      if (fullRscStream) fullRscStream.abort();\n      if (htmlHandler?.abort) htmlHandler.abort();\n    } catch (cleanupError: unknown) {\n      handlerOptions.logger?.warn(`Failed to cleanup streams on error: ${cleanupError}`);\n    }\n\n    const panicError = handleError({\n      error,\n      logger: handlerOptions.logger,\n      context: \"renderPageClient\",\n      panicThreshold: handlerOptions.panicThreshold,\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      // For non-panic errors, we still want to write the HTML file (client-only)\n      // but skip the RSC file since there was a server error\n      \n      // Create a fallback RSC stream with React.Fragment (same as server environment)\n      const fallbackRscStream = createRscStream({\n        ...handlerOptions,\n        url: `${handlerOptions.url}`,\n        route: `${handlerOptions.route}`,\n        cssFiles: handlerOptions.cssFiles || new Map(),\n        globalCss: handlerOptions.globalCss || new Map(),\n        id: `${handlerOptions.route}-fallback-${Date.now()}`,\n        rscTimeout: handlerOptions.rscTimeout || 5000,\n        onMetrics: handlerOptions.onMetrics,\n        // Use React.Fragment as fallback (same as server environment)\n        pagePath: '', // This will cause the default page to be used, but we'll override it\n        pageProps: {}, // Ensure pageProps is always an object\n      });\n      \n      // Create HTML stream that processes the fallback RSC stream to ensure performance timing script is injected\n      const fallbackHtmlStream = createRscToHtmlStream({\n        id: handlerOptions.id,\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        panicThreshold: handlerOptions.panicThreshold,\n        verbose: handlerOptions.verbose,\n        signal: handlerOptions.signal,\n        logger: handlerOptions.logger,\n        htmlTimeout: handlerOptions.htmlTimeout,\n        clientPipeableStreamOptions: handlerOptions.clientPipeableStreamOptions,\n        onMetrics: handlerOptions.onMetrics,\n        build: handlerOptions.build,\n      });\n      \n      // Create a wrapper that pipes the fallback RSC stream through the HTML transform\n      const clientOnlyHtmlStreamWrapper = {\n        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n          // Pipe the fallback RSC stream through the HTML transform to ensure performance timing script is injected\n          return fallbackHtmlStream.pipe(destination);\n        },\n        abort: () => {\n          // Clean up the fallback RSC stream\n          fallbackRscStream.abort();\n        },\n      };\n      \n      // Create an empty RSC stream wrapper\n      const emptyRscStreamWrapper = {\n        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n          // No RSC content for skipped routes\n          destination.end();\n          return destination;\n        },\n        abort: () => {\n          // No cleanup needed\n        },\n      };\n      \n      yield {\n        type: \"skip\",\n        reason: error,\n        html: clientOnlyHtmlStreamWrapper,\n        rsc: emptyRscStreamWrapper,\n        metrics: {\n          rscFull: rscFullMetrics,\n          rscHeadless: rscHeadlessMetrics,\n          html: htmlMetrics,\n        },\n      };\n    }\n  }\n}; "],"names":["manifest"],"mappings":"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"}