vite-plugin-react-server 1.4.1 → 1.4.3

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

@@ -1,32 +1,51 @@
-import { createHtmlStream } from "../stream/createHtmlStream.client.js";
-export const createRscToHtmlStream = function _createRscToHtmlStream(options) {
-    const { route, verbose, signal, logger, rscStream, 
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { createHtmlStream } from '../stream/createHtmlStream.client.js';
+
+const createRscToHtmlStream = function _createRscToHtmlStream(options) {
+  const {
+    route,
+    verbose,
+    signal,
+    logger,
+    rscStream,
     // Only pass the props the HTML stream actually needs
-    moduleRootPath, moduleBasePath, moduleBaseURL, clientPipeableStreamOptions, ...otherOptions } = options;
-    if (verbose) {
-        logger?.info(`[createRscToHtmlStream:${route}] Creating RSC to HTML transform stream (client-side, using createHtmlStream)`);
-    }
-    // Use the existing client-side createHtmlStream which handles RSC to HTML conversion
-    const htmlStream = createHtmlStream({
-        route,
-        rscStream,
-        logger,
-        verbose,
-        // Only pass the essential props
-        moduleRootPath,
-        moduleBasePath,
-        moduleBaseURL,
-        clientPipeableStreamOptions,
-        ...otherOptions,
+    moduleRootPath,
+    moduleBasePath,
+    moduleBaseURL,
+    clientPipeableStreamOptions,
+    ...otherOptions
+  } = options;
+  if (verbose) {
+    logger?.info(
+      `[createRscToHtmlStream:${route}] Creating RSC to HTML transform stream (client-side, using createHtmlStream)`
+    );
+  }
+  const htmlStream = createHtmlStream({
+    route,
+    rscStream,
+    logger,
+    verbose,
+    // Only pass the essential props
+    moduleRootPath,
+    moduleBasePath,
+    moduleBaseURL,
+    clientPipeableStreamOptions,
+    ...otherOptions
+  });
+  if (signal) {
+    signal.addEventListener("abort", () => {
+      if (verbose) {
+        logger?.info(`[createRscToHtmlStream:${route}] Abort signal received`);
+      }
+      htmlStream.abort();
     });
-    // Handle abort signal
-    if (signal) {
-        signal.addEventListener("abort", () => {
-            if (verbose) {
-                logger?.info(`[createRscToHtmlStream:${route}] Abort signal received`);
-            }
-            htmlStream.abort();
-        });
-    }
-    return htmlStream;
+  }
+  return htmlStream;
 };
+
+export { createRscToHtmlStream };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,39 +1,64 @@
-import { createHtmlStream } from "../stream/createHtmlStream.server.js";
-export const createRscToHtmlStream = function _createRscToHtmlStream(options) {
-    const { id, worker, htmlWorker, route, url, moduleBasePath, moduleBaseURL, moduleRootPath, projectRoot, verbose, panicThreshold, clientPipeableStreamOptions, signal, logger, build, } = options;
-    if (!worker) {
-        throw new Error("HTML worker is required for RSC to HTML stream");
-    }
-    if (verbose) {
-        logger?.info(`[createRscToHtmlStream:${route}] Creating RSC to HTML transform stream`);
-    }
-    // Use createHtmlStream which works correctly with the HTML worker
-    const htmlStream = createHtmlStream({
-        id,
-        url,
-        route,
-        rscStream: options.rscStream,
-        htmlWorker: htmlWorker || worker,
-        logger,
-        verbose,
-        moduleRootPath,
-        moduleBasePath,
-        moduleBaseURL,
-        projectRoot,
-        panicThreshold,
-        clientPipeableStreamOptions,
-        build,
-        onMetrics: options.onMetrics,
-        onError: options.onError,
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { createHtmlStream } from '../stream/createHtmlStream.server.js';
+
+const createRscToHtmlStream = function _createRscToHtmlStream(options) {
+  const {
+    id,
+    worker,
+    htmlWorker,
+    route,
+    url,
+    moduleBasePath,
+    moduleBaseURL,
+    moduleRootPath,
+    projectRoot,
+    verbose,
+    panicThreshold,
+    clientPipeableStreamOptions,
+    signal,
+    logger,
+    build
+  } = options;
+  if (!worker) {
+    throw new Error("HTML worker is required for RSC to HTML stream");
+  }
+  if (verbose) {
+    logger?.info(
+      `[createRscToHtmlStream:${route}] Creating RSC to HTML transform stream`
+    );
+  }
+  const htmlStream = createHtmlStream({
+    id,
+    url,
+    route,
+    rscStream: options.rscStream,
+    htmlWorker: htmlWorker || worker,
+    logger,
+    verbose,
+    moduleRootPath,
+    moduleBasePath,
+    moduleBaseURL,
+    projectRoot,
+    panicThreshold,
+    clientPipeableStreamOptions,
+    build,
+    onMetrics: options.onMetrics,
+    onError: options.onError
+  });
+  if (signal) {
+    signal.addEventListener("abort", () => {
+      if (verbose) {
+        logger?.info(`[createRscToHtmlStream:${route}] Abort signal received`);
+      }
+      htmlStream.abort();
     });
-    // Handle abort signal
-    if (signal) {
-        signal.addEventListener("abort", () => {
-            if (verbose) {
-                logger?.info(`[createRscToHtmlStream:${route}] Abort signal received`);
-            }
-            htmlStream.abort();
-        });
-    }
-    return htmlStream;
+  }
+  return htmlStream;
 };
+
+export { createRscToHtmlStream };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,3 +1,12 @@
-import { ReactDOMServer } from "../vendor/vendor.server.js";
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { ReactDOMServer } from '../vendor/vendor.server.js';
+
 const { createTemporaryReferenceSet } = ReactDOMServer;
-export const temporaryReferences = createTemporaryReferenceSet();
+const temporaryReferences = createTemporaryReferenceSet();
+
+export { temporaryReferences };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcG9yYXJ5UmVmZXJlbmNlcy5zZXJ2ZXIuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BsdWdpbi9yZWFjdC1zdGF0aWMvdGVtcG9yYXJ5UmVmZXJlbmNlcy5zZXJ2ZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVhY3RET01TZXJ2ZXIgfSBmcm9tIFwiLi4vdmVuZG9yL3ZlbmRvci5zZXJ2ZXIuanNcIjtcblxuY29uc3QgeyBjcmVhdGVUZW1wb3JhcnlSZWZlcmVuY2VTZXQgfSA9IFJlYWN0RE9NU2VydmVyO1xuXG5leHBvcnQgY29uc3QgdGVtcG9yYXJ5UmVmZXJlbmNlcyA9IGNyZWF0ZVRlbXBvcmFyeVJlZmVyZW5jZVNldCgpO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFFQSxNQUFNLEVBQUUsNkJBQWdDLEdBQUEsY0FBQTtBQUVqQyxNQUFNLHNCQUFzQiwyQkFBNEI7Ozs7In0=

package/dist/plugin/stream/createMainThreadHandlers.js

@@ -1,32 +1,41 @@
-import { handleError } from "../error/handleError.js";
-export function createMainThreadHandlers(handlerOptions, onError) {
-    return {
-        onError: (_id, error, context) => {
-            if (handlerOptions.verbose) {
-                handlerOptions.logger?.info(`[createMainThreadHandlers] onError called for route ${handlerOptions.route}: ${error}`);
-            }
-            const originalError = error instanceof Error ? error : new Error(String(error ?? "Unknown error"));
-            const panicError = handleError({
-                error: originalError,
-                critical: false,
-                logger: handlerOptions.logger,
-                panicThreshold: handlerOptions.panicThreshold,
-                context: `${context?.context || "Unknown"} for route ${handlerOptions.route}`,
-            });
-            if (handlerOptions.verbose) {
-                handlerOptions.logger?.info(`[createMainThreadHandlers] Calling onError callback for route ${handlerOptions.route} with panicError: ${!!panicError}`);
-            }
-            // Call the callback with the error and panic status
-            onError?.(panicError || originalError, !!panicError);
-        },
-        onData: (_id, _data) => {
-            // No-op for main thread
-        },
-        onEnd: (_id) => {
-            // No-op for main thread
-        },
-        onPostpone: (_id, _reason) => {
-            // No-op for main thread
-        },
-    };
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { handleError } from '../error/handleError.js';
+
+function createMainThreadHandlers(handlerOptions, onError) {
+  return {
+    onError: (_id, error, context) => {
+      if (handlerOptions.verbose) {
+        handlerOptions.logger?.info(
+          `[createMainThreadHandlers] onError called for route ${handlerOptions.route}: ${error}`
+        );
+      }
+      const originalError = error instanceof Error ? error : new Error(String(error ?? "Unknown error"));
+      const panicError = handleError({
+        error: originalError,
+        critical: false,
+        logger: handlerOptions.logger,
+        panicThreshold: handlerOptions.panicThreshold,
+        context: `${context?.context || "Unknown"} for route ${handlerOptions.route}`
+      });
+      if (handlerOptions.verbose) {
+        handlerOptions.logger?.info(
+          `[createMainThreadHandlers] Calling onError callback for route ${handlerOptions.route} with panicError: ${!!panicError}`
+        );
+      }
+      onError?.(panicError || originalError, !!panicError);
+    },
+    onData: (_id, _data) => {
+    },
+    onEnd: (_id) => {
+    },
+    onPostpone: (_id, _reason) => {
+    }
+  };
 }
+
+export { createMainThreadHandlers };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/stream/renderRscStream.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderRscStream.server.d.ts","sourceRoot":"","sources":["../../../plugin/stream/renderRscStream.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAIlE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,SAAS,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC,GACvF,eAAe,CAsJjB"}
+{"version":3,"file":"renderRscStream.server.d.ts","sourceRoot":"","sources":["../../../plugin/stream/renderRscStream.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAKlE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,SAAS,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC,GACvF,eAAe,CAwJjB"}

package/dist/plugin/stream/renderRscStream.server.js

@@ -1,153 +1,136 @@
-import { PassThrough } from "node:stream";
-import { createStreamMetrics } from "../metrics/createStreamMetrics.js";
-import { createReactElement } from "../helpers/createRscRenderHelpers.js";
-import { ReactDOMServer } from "../vendor/vendor.server.js";
 /**
- * Intuitive RSC stream renderer that works on both client and server
- *
- * Usage:
- * const result = renderRscStream(options, handlers);
- *
- * // Pipe to any destination
- * result.rscStream.pipe(fileStream);
- * result.pipe(response); // convenience method
- *
- * // Access the stream directly
- * result.stream.on('data', (chunk) => console.log(chunk));
- *
- * // Abort if needed
- * result.abort('User cancelled');
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
  */
-export function renderRscStream(options, handlers) {
-    const id = options.id || "";
-    const route = options.route;
-    const verbose = options.verbose || false;
-    const logger = options.logger;
+import { PassThrough } from 'node:stream';
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
+import { createReactElement } from '../helpers/createRscRenderHelpers.js';
+import { checkReactExperimental } from '../utils/checkReactVersion.js';
+import { ReactDOMServer } from '../vendor/vendor.server.js';
+
+function renderRscStream(options, handlers) {
+  const id = options.id || "";
+  const route = options.route;
+  const verbose = options.verbose || false;
+  const logger = options.logger;
+  try {
+    let reactElement;
     try {
-        // Create React element from options - wrap in try-catch to handle errors during element creation
-        let reactElement;
-        try {
-            reactElement = createReactElement(options, {
-                id,
+      reactElement = createReactElement(options, {
+        id,
+        route,
+        verbose,
+        logger,
+        reuseHeadlessStreamId: options.reuseHeadlessStreamId,
+        headlessStreamElements: options.headlessStreamElements,
+        headlessStreamErrors: options.headlessStreamErrors
+      });
+    } catch (elementError) {
+      if (verbose) {
+        logger?.error(`[renderRscStream:${route}] Error creating React element: ${elementError}`);
+      }
+      handlers?.onError?.(id, elementError, {
+        route,
+        context: "React Element Creation Error"
+      });
+      const errorStream = new PassThrough();
+      errorStream.end();
+      return {
+        type: "server",
+        rscStream: errorStream,
+        pipe: (destination) => errorStream.pipe(destination),
+        abort: () => {
+        },
+        metrics: createStreamMetrics()
+      };
+    }
+    const rscStream = new PassThrough();
+    const metrics = createStreamMetrics();
+    if (verbose) {
+      logger?.info(`[renderRscStream:${route}] Creating React stream for element`);
+    }
+    checkReactExperimental();
+    const reactStream = ReactDOMServer.renderToPipeableStream(
+      reactElement,
+      options.moduleBasePath || "",
+      {
+        ...options.serverPipeableStreamOptions,
+        onError: (error) => {
+          if (verbose) {
+            logger?.error(`[renderRscStream:${route}] React stream error: ${error}`);
+          }
+          handlers?.onError?.(id, error, {
+            route,
+            context: "React Stream Error"
+          });
+          if (options.onEvent) {
+            options.onEvent({
+              type: "route.error",
+              data: {
+                error,
                 route,
-                verbose,
-                logger,
-                reuseHeadlessStreamId: options.reuseHeadlessStreamId,
-                headlessStreamElements: options.headlessStreamElements,
-                headlessStreamErrors: options.headlessStreamErrors,
+                panicThreshold: options.panicThreshold
+              }
             });
-        }
-        catch (elementError) {
-            // Handle errors during React element creation
-            if (verbose) {
-                logger?.error(`[renderRscStream:${route}] Error creating React element: ${elementError}`);
+          }
+          setImmediate(() => {
+            if (!rscStream.destroyed) {
+              rscStream.end();
             }
-            // Call our error handler to process the error
-            handlers?.onError?.(id, elementError, {
-                route,
-                context: "React Element Creation Error",
-            });
-            // Return empty stream on error - API remains consistent
-            const errorStream = new PassThrough();
-            errorStream.end();
-            return {
-                type: "server",
-                rscStream: errorStream,
-                pipe: (destination) => errorStream.pipe(destination),
-                abort: () => { },
-                metrics: createStreamMetrics(),
-            };
-        }
-        // Create the output stream - this is what users will pipe to destinations
-        const rscStream = new PassThrough();
-        const metrics = createStreamMetrics();
-        if (verbose) {
-            logger?.info(`[renderRscStream:${route}] Creating React stream for element`);
-        }
-        // Render React to stream - let it flow naturally like the RSC worker
-        const reactStream = ReactDOMServer.renderToPipeableStream(reactElement, options.moduleBasePath || "", {
-            ...options.serverPipeableStreamOptions,
-            onError: (error) => {
-                if (verbose) {
-                    logger?.error(`[renderRscStream:${route}] React stream error: ${error}`);
-                }
-                // Call our error handler to process the error
-                handlers?.onError?.(id, error, {
-                    route,
-                    context: "React Stream Error",
-                });
-                // Emit route.error event to allow main thread to handle panic threshold logic (like client)
-                if (options.onEvent) {
-                    options.onEvent({
-                        type: "route.error",
-                        data: {
-                            error: error,
-                            route: route,
-                            panicThreshold: options.panicThreshold
-                        }
-                    });
-                }
-                // CRITICAL: Don't let the error propagate further - this prevents uncaught exceptions
-                // The error has been handled by our error handler, so we don't need to re-throw it
-                // Ensure stream is ended when error occurs to prevent hanging (like RSC worker does)
-                // Use setImmediate to ensure the error handler completes before ending the stream
-                setImmediate(() => {
-                    if (!rscStream.destroyed) {
-                        rscStream.end();
-                    }
-                    // Also abort the React stream to ensure it stops producing data
-                    if (reactStream && typeof reactStream.abort === 'function') {
-                        reactStream.abort();
-                    }
-                });
-            },
-            onPostpone: (reason) => {
-                if (verbose) {
-                    logger?.info(`[renderRscStream:${route}] Stream postponed: ${reason}`);
-                }
-                handlers?.onPostpone?.(id, reason);
-            },
-        });
-        // Pipe React output to our stream - let streams end naturally like the RSC worker does
-        reactStream.pipe(rscStream);
-        // Handle stream errors naturally - don't force completion
-        rscStream.on("error", (error) => {
-            if (verbose) {
-                logger?.error(`[renderRscStream:${route}] Stream error: ${error}`);
+            if (reactStream && typeof reactStream.abort === "function") {
+              reactStream.abort();
             }
-        });
-        // Return intuitive interface that works the same on client and server
-        return {
-            type: "server",
-            rscStream: rscStream, // Alias for compatibility with existing code
-            pipe: (destination) => rscStream.pipe(destination), // Convenience method
-            abort: (reason) => {
-                if (handlers?.onError) {
-                    handlers.onError(id, new Error(String(reason || "Stream aborted")), {
-                        route,
-                        context: "Stream Aborted",
-                    });
-                }
-                rscStream.end();
-            },
-            metrics,
-        };
-    }
-    catch (error) {
-        // Handle errors gracefully - always return a valid stream
-        handlers?.onError?.(id, error, {
+          });
+        },
+        onPostpone: (reason) => {
+          if (verbose) {
+            logger?.info(`[renderRscStream:${route}] Stream postponed: ${reason}`);
+          }
+          handlers?.onPostpone?.(id, reason);
+        }
+      }
+    );
+    reactStream.pipe(rscStream);
+    rscStream.on("error", (error) => {
+      if (verbose) {
+        logger?.error(`[renderRscStream:${route}] Stream error: ${error}`);
+      }
+    });
+    return {
+      type: "server",
+      rscStream,
+      // Alias for compatibility with existing code
+      pipe: (destination) => rscStream.pipe(destination),
+      // Convenience method
+      abort: (reason) => {
+        if (handlers?.onError) {
+          handlers.onError(id, new Error(String(reason || "Stream aborted")), {
             route,
-            context: "RSC Render Error",
-        });
-        // Return empty stream on error - API remains consistent
-        const errorStream = new PassThrough();
-        errorStream.end();
-        return {
-            type: "server",
-            rscStream: errorStream,
-            pipe: (destination) => errorStream.pipe(destination),
-            abort: () => { },
-            metrics: createStreamMetrics(),
-        };
-    }
+            context: "Stream Aborted"
+          });
+        }
+        rscStream.end();
+      },
+      metrics
+    };
+  } catch (error) {
+    handlers?.onError?.(id, error, {
+      route,
+      context: "RSC Render Error"
+    });
+    const errorStream = new PassThrough();
+    errorStream.end();
+    return {
+      type: "server",
+      rscStream: errorStream,
+      pipe: (destination) => errorStream.pipe(destination),
+      abort: () => {
+      },
+      metrics: createStreamMetrics()
+    };
+  }
 }
+
+export { renderRscStream };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"renderRscStream.server.js","sources":["../../../plugin/stream/renderRscStream.server.ts"],"sourcesContent":["import { PassThrough } from \"node:stream\";\nimport type { CreateHandlerOptions } from \"../types.js\";\nimport type { RscRenderResult } from \"./renderRscStream.types.js\";\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\nimport { createReactElement } from \"../helpers/createRscRenderHelpers.js\";\nimport { checkReactExperimental } from \"../utils/checkReactVersion.js\";\nimport { ReactDOMServer } from \"../vendor/vendor.server.js\";\nimport type { StreamHandlers } from \"../worker/types.js\";\n\n\n/**\n * Intuitive RSC stream renderer that works on both client and server\n * \n * Usage:\n * const result = renderRscStream(options, handlers);\n * \n * // Pipe to any destination\n * result.rscStream.pipe(fileStream);\n * result.pipe(response); // convenience method\n * \n * // Access the stream directly\n * result.stream.on('data', (chunk) => console.log(chunk));\n * \n * // Abort if needed\n * result.abort('User cancelled');\n */\nexport function renderRscStream(\n  options: CreateHandlerOptions,\n  handlers?: Pick<StreamHandlers<\"server\">, \"onError\" | \"onPostpone\" | \"onEnd\" | \"onData\">\n): RscRenderResult {\n  const id = options.id || \"\";\n  const route = options.route;\n  const verbose = options.verbose || false;\n  const logger = options.logger;\n\n  try {\n    // Create React element from options - wrap in try-catch to handle errors during element creation\n    let reactElement;\n    try {\n      reactElement = createReactElement(options, {\n        id,\n        route,\n        verbose,\n        logger,\n        reuseHeadlessStreamId: (options as any).reuseHeadlessStreamId,\n        headlessStreamElements: (options as any).headlessStreamElements,\n        headlessStreamErrors: (options as any).headlessStreamErrors,\n      });\n    } catch (elementError) {\n      // Handle errors during React element creation\n      if (verbose) {\n        logger?.error(`[renderRscStream:${route}] Error creating React element: ${elementError}`);\n      }\n      \n      // Call our error handler to process the error\n      handlers?.onError?.(id, elementError, {\n        route,\n        context: \"React Element Creation Error\",\n      });\n      \n      // Return empty stream on error - API remains consistent\n      const errorStream = new PassThrough();\n      errorStream.end();\n      \n      return {\n        type: \"server\" as const,\n        rscStream: errorStream,\n        pipe: (destination: any) => errorStream.pipe(destination),\n        abort: () => {},\n        metrics: createStreamMetrics(),\n      };\n    }\n    \n    // Create the output stream - this is what users will pipe to destinations\n    const rscStream = new PassThrough();\n    const metrics = createStreamMetrics();\n\n    if (verbose) {\n      logger?.info(`[renderRscStream:${route}] Creating React stream for element`);\n    }\n    \n    checkReactExperimental();\n\n    // Render React to stream - let it flow naturally like the RSC worker\n    const reactStream = ReactDOMServer.renderToPipeableStream(\n      reactElement,\n      options.moduleBasePath || \"\",\n      {\n        ...options.serverPipeableStreamOptions,\n        onError: (error: unknown) => {\n          if (verbose) {\n            logger?.error(`[renderRscStream:${route}] React stream error: ${error}`);\n          }\n          \n          // Call our error handler to process the error\n          handlers?.onError?.(id, error, {\n            route,\n            context: \"React Stream Error\",\n          });\n          \n          // Emit route.error event to allow main thread to handle panic threshold logic (like client)\n          if (options.onEvent) {\n            options.onEvent({\n              type: \"route.error\",\n              data: {\n                error: error,\n                route: route,\n                panicThreshold: options.panicThreshold\n              }\n            });\n          }\n          \n          // CRITICAL: Don't let the error propagate further - this prevents uncaught exceptions\n          // The error has been handled by our error handler, so we don't need to re-throw it\n          \n          // Ensure stream is ended when error occurs to prevent hanging (like RSC worker does)\n          // Use setImmediate to ensure the error handler completes before ending the stream\n          setImmediate(() => {\n            if (!rscStream.destroyed) {\n              rscStream.end();\n            }\n            // Also abort the React stream to ensure it stops producing data\n            if (reactStream && typeof reactStream.abort === 'function') {\n              reactStream.abort();\n            }\n          });\n        },\n        onPostpone: (reason: string) => {\n          if (verbose) {\n            logger?.info(`[renderRscStream:${route}] Stream postponed: ${reason}`);\n          }\n          handlers?.onPostpone?.(id, reason);\n        },\n      }\n    );\n\n    // Pipe React output to our stream - let streams end naturally like the RSC worker does\n    reactStream.pipe(rscStream);\n    \n    // Handle stream errors naturally - don't force completion\n    rscStream.on(\"error\", (error) => {\n      if (verbose) {\n        logger?.error(`[renderRscStream:${route}] Stream error: ${error}`);\n      }\n    });\n\n    // Return intuitive interface that works the same on client and server\n    return {\n      type: \"server\" as const,\n      rscStream: rscStream, // Alias for compatibility with existing code\n      pipe: (destination: any) => rscStream.pipe(destination), // Convenience method\n      abort: (reason?: unknown) => {\n        if (handlers?.onError) {\n          handlers.onError(id, new Error(String(reason || \"Stream aborted\")), {\n            route,\n            context: \"Stream Aborted\",\n          });\n        }\n        rscStream.end();\n      },\n      metrics,\n    };\n  } catch (error) {\n    // Handle errors gracefully - always return a valid stream\n    handlers?.onError?.(id, error, {\n      route,\n      context: \"RSC Render Error\",\n    });\n\n    // Return empty stream on error - API remains consistent\n    const errorStream = new PassThrough();\n    errorStream.end();\n    \n    return {\n      type: \"server\" as const,\n      rscStream: errorStream,\n      pipe: (destination: any) => errorStream.pipe(destination),\n      abort: () => {},\n      metrics: createStreamMetrics(),\n    };\n  }\n}\n\n\n\n"],"names":[],"mappings":"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"}