vite-plugin-react-server 1.2.0-alpha.0 → 1.2.0

package/dist/plugin/stream/index.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Consolidated streaming module for vite-plugin-react-server
+ *
+ * This module provides semantic streaming interfaces for React Server Components (RSC) and HTML rendering.
+ *
+ * ## Architecture Overview
+ *
+ * **Server Environment** (Node.js server):
+ * - `createRenderToPipeableStreamHandler.server` → React Elements → RSC Stream
+ * - `createRscStream.server` → Route + Components → RSC Stream (direct)
+ *
+ * **Client Environment** (Browser/client-side):
+ * - `createRenderToPipeableStreamHandler.client` → React Elements → HTML Stream
+ * - `createRscStream.client` → Route + Components → RSC Worker → RSC Stream
+ * - `createFromNodeStream.client` → RSC Stream → React Elements
+ *
+ * **Unified Interface**:
+ * - `createRscStream` → Automatic Environment Detection → RSC Stream
+ *
+ * ## When to Use Each Function
+ *
+ * ### For RSC Streams:
+ * - **Unified**: Use `createRscStream` for automatic environment handling
+ * - **Server-side**: Use `createRscStream.server` for direct RSC generation
+ * - **Client-side**: Use `createRscStream.client` for worker-based RSC generation
+ *
+ * ### For HTML Streams:
+ * - **Server-side**: Use `createRenderToPipeableStreamHandler.server` + HTML worker
+ * - **Client-side**: Use `createRenderToPipeableStreamHandler.client` for direct HTML generation
+ *
+ * ## Common Patterns
+ *
+ * ```typescript
+ * // 1. Unified RSC creation (recommended)
+ * const rscStream = await createRscStream({
+ *   route: "/about",
+ *   pagePath: "/src/pages/about.tsx",
+ *   // Environment-specific options are automatically handled
+ * });
+ *
+ * // 2. Create RSC for file writing (headless)
+ * const rscHeadless = await createRscStream({
+ *   route: "/about",
+ *   pagePath: "/src/pages/about.tsx",
+ *   htmlPath: "", // Empty for headless
+ * });
+ *
+ * // 3. Create RSC for HTML generation (full)
+ * const rscFull = await createRscStream({
+ *   route: "/about",
+ *   pagePath: "/src/pages/about.tsx",
+ *   htmlPath: "/src/pages/about.html.tsx", // HTML wrapper
+ * });
+ *
+ * // 4. Convert RSC to HTML
+ * const htmlStream = createRenderToPipeableStreamHandler({
+ *   route: "/about",
+ *   rscStream: rscFull.rscStream,
+ * });
+ *
+ * // 5. Convert RSC stream to React elements
+ * const elements = createFromNodeStream({
+ *   rscStream: rscStream.rscStream,
+ *   moduleBaseURL: "/",
+ * });
+ * ```
+ *
+ * ## Advanced Usage
+ *
+ * For advanced use cases, you can import environment-specific functions and types:
+ *
+ * ```typescript
+ * import {
+ *   createRscStream,
+ *   createRscStreamClient,
+ *   createRscStreamServer,
+ *   type ClientRscStreamOptions,
+ *   type ServerRscStreamOptions
+ * } from "./stream";
+ * ```
+ */
+import type { CreateHtmlStreamFn } from "./createHtmlStream.types.js";
+import type { CreateRscStreamFn } from "./createRscStream.types.js";
+import type { HandleRscStreamFn } from "./handleRscStream.types.js";
+export type { CreateRenderToPipeableStreamHandlerFn } from "./createRenderToPipeableStreamHandler.types.js";
+export type { CreateRscStreamFn, CreateRscStreamFnUnified, CreateRscStreamOptions, ClientRscStreamOptions, ServerRscStreamOptions, RscStreamResult, ClientRscStreamResult, ServerRscStreamResult, BaseRscStreamResult, } from "./createRscStream.types.js";
+export { validateRscStreamOptions, createBaseRscStreamResult, handleRscStreamError, createRscStreamMetrics, setupRscStreamEventHandlers, } from "./createRscStream.utils.js";
+export type { HandleRscStreamFn } from "./handleRscStream.types.js";
+export { createRscWorkerStream } from "./createRscWorkerStream.js";
+export type { RscWorkerStreamOptions } from "./createRscWorkerStream.js";
+export { pipeToResponse } from "../helpers/pipeToResponse.js";
+export { resolveStreamElements } from "../helpers/resolveStreamElements.js";
+export type { ResolveStreamElementsOptions } from "../helpers/resolveStreamElements.types.js";
+export declare const handleRscStream: HandleRscStreamFn, createRscStream: CreateRscStreamFn, createHtmlStream: CreateHtmlStreamFn;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugin/stream/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/stream/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAGpE,YAAY,EAAE,qCAAqC,EAAE,MAAM,gDAAgD,CAAC;AAE5G,YAAY,EACV,iBAAiB,EACjB,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACtB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,4BAA4B,CAAC;AAKpC,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,sBAAsB,EACtB,2BAA2B,GAC5B,MAAM,4BAA4B,CAAC;AAGpC,YAAY,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAGpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,YAAY,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,YAAY,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AAK9F,eAAO,MACL,eAAe,qBACf,eAAe,qBACf,gBAAgB,oBAKjB,CAAC"}

package/dist/plugin/stream/index.js

@@ -0,0 +1,21 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { getCondition } from '../config/getCondition.js';
+export { createBaseRscStreamResult, createRscStreamMetrics, handleRscStreamError, setupRscStreamEventHandlers, validateRscStreamOptions } from './createRscStream.utils.js';
+export { createRscWorkerStream } from './createRscWorkerStream.js';
+export { pipeToResponse } from '../helpers/pipeToResponse.js';
+export { resolveStreamElements } from '../helpers/resolveStreamElements.js';
+
+const dir = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+const condition = getCondition("");
+const {
+  handleRscStream,
+  createRscStream,
+  createHtmlStream
+} = await import(`${dir}/index.${condition}.js`);
+
+export { createHtmlStream, createRscStream, handleRscStream };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/stream/index.server.d.ts

@@ -0,0 +1,7 @@
+export * from "./handleRscStream.server.js";
+export * from "./createRscStream.server.js";
+export * from "./createRenderToPipeableStreamHandler.server.js";
+export * from "./createFromNodeStream.server.js";
+export * from "./createHtmlStream.server.js";
+export * from "./createRscWorkerStream.js";
+//# sourceMappingURL=index.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.server.d.ts","sourceRoot":"","sources":["../../../plugin/stream/index.server.ts"],"names":[],"mappings":"AACA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAG5C,cAAc,iDAAiD,CAAC;AAGhE,cAAc,kCAAkC,CAAC;AAGjD,cAAc,8BAA8B,CAAC;AAG7C,cAAc,4BAA4B,CAAC"}

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

@@ -0,0 +1,11 @@
+// RSC Stream handling
+export * from "./handleRscStream.server.js";
+export * from "./createRscStream.server.js";
+// RSC Stream creation
+export * from "./createRenderToPipeableStreamHandler.server.js";
+// Node Stream handling
+export * from "./createFromNodeStream.server.js";
+// HTML Stream creation
+export * from "./createHtmlStream.server.js";
+// Worker Stream handling - using unified API
+export * from "./createRscWorkerStream.js";

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

@@ -0,0 +1,21 @@
+import type { CreateHandlerOptions } from "../types.js";
+import type { RscRenderResult } from "./renderRscStream.types.js";
+import type { StreamHandlers } from "../worker/types.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');
+ */
+export declare function renderRscStream(options: CreateHandlerOptions, handlers?: Pick<StreamHandlers<"server">, "onError" | "onPostpone" | "onEnd" | "onData">): RscRenderResult;
+//# sourceMappingURL=renderRscStream.server.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,153 @@
+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');
+ */
+export function renderRscStream(options, handlers) {
+    const id = options.id || "";
+    const route = options.route;
+    const verbose = options.verbose || false;
+    const logger = options.logger;
+    try {
+        // Create React element from options - wrap in try-catch to handle errors during element creation
+        let reactElement;
+        try {
+            reactElement = createReactElement(options, {
+                id,
+                route,
+                verbose,
+                logger,
+                reuseHeadlessStreamId: options.reuseHeadlessStreamId,
+                headlessStreamElements: options.headlessStreamElements,
+                headlessStreamErrors: options.headlessStreamErrors,
+            });
+        }
+        catch (elementError) {
+            // Handle errors during React element creation
+            if (verbose) {
+                logger?.error(`[renderRscStream:${route}] Error creating React element: ${elementError}`);
+            }
+            // 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}`);
+            }
+        });
+        // 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, {
+            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(),
+        };
+    }
+}

package/dist/plugin/stream/renderRscStream.types.d.ts

@@ -0,0 +1,36 @@
+import type { PassThrough } from "node:stream";
+import type { CreateHandlerOptions, StreamMetrics } from "../types.js";
+export type RscRenderResult = {
+    type: "server";
+    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+    abort: (reason?: unknown) => void;
+    rscStream: PassThrough;
+    metrics: StreamMetrics;
+};
+export type RscStreamHandlers = {
+    onError: (id: string, error: unknown, errorInfo?: {
+        route?: string;
+        context?: string;
+    }) => void;
+    onData: (id: string, data: Uint8Array) => void;
+    onEnd: (id: string) => void;
+    onPostpone?: (id: string, reason: string) => void;
+    onRscRender: (id: string, message: any) => void;
+};
+export type RscRenderFn = (options: CreateHandlerOptions, handlers: RscStreamHandlers) => RscRenderResult;
+export type RscRenderContext = {
+    id: string;
+    route: string;
+    verbose: boolean;
+    logger?: any;
+    reuseHeadlessStreamId?: string;
+    headlessStreamElements?: Map<string, any>;
+    headlessStreamErrors?: Map<string, any>;
+    panicError?: Error;
+};
+export type StreamErrorHandler = {
+    handleError: (error: unknown, errorContext: string) => void;
+    abort: (reason?: unknown) => void;
+    isAbortable: () => boolean;
+};
+//# sourceMappingURL=renderRscStream.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderRscStream.types.d.ts","sourceRoot":"","sources":["../../../plugin/stream/renderRscStream.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEvE,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,CAAC,QAAQ,SAAS,MAAM,CAAC,cAAc,EAC3C,WAAW,EAAE,QAAQ,KAClB,QAAQ,CAAC;IACd,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAClC,SAAS,EAAE,WAAW,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;CACxB,CAAC;AAGF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAChG,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IAC/C,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,CACxB,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,iBAAiB,KACxB,eAAe,CAAC;AAErB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,sBAAsB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1C,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACxC,UAAU,CAAC,EAAE,KAAK,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5D,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAClC,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B,CAAC"}

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

@@ -0,0 +1 @@
+export {};

package/dist/plugin/stream/renderRscStreamHelpers.server.d.ts

@@ -0,0 +1,9 @@
+import { PassThrough } from "node:stream";
+import type { CreateHandlerOptions } from "../types.js";
+import type { StreamHandlers } from "../worker/types.js";
+/**
+ * Server-specific React stream creation with error handling
+ * This function is only available in server environments
+ */
+export declare function createReactStream(element: React.ReactElement, options: CreateHandlerOptions, handlers: Pick<StreamHandlers<"server">, "onError" | "onPostpone" | "onEnd" | "onData">): PassThrough;
+//# sourceMappingURL=renderRscStreamHelpers.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderRscStreamHelpers.server.d.ts","sourceRoot":"","sources":["../../../plugin/stream/renderRscStreamHelpers.server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,KAAK,CAAC,YAAY,EAC3B,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,SAAS,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC,GACtF,WAAW,CAyEb"}

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

@@ -0,0 +1,63 @@
+import { PassThrough } from "node:stream";
+import { ReactDOMServer } from "../vendor/vendor.server.js";
+/**
+ * Server-specific React stream creation with error handling
+ * This function is only available in server environments
+ */
+export function createReactStream(element, options, handlers) {
+    const { route, verbose, logger } = options;
+    // Create the React stream using ReactDOMServer.renderToPipeableStream
+    const streamOptions = {
+        ...options.serverPipeableStreamOptions,
+        onError: (error) => {
+            if (verbose) {
+                logger?.error(`[createReactStream:${route}] React stream error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (typeof handlers.onError === "function") {
+                handlers.onError(route, error);
+            }
+            if (typeof options?.serverPipeableStreamOptions?.onError === "function") {
+                options.serverPipeableStreamOptions.onError(error);
+            }
+        },
+        onPostpone: (reason) => {
+            if (verbose) {
+                logger?.info(`[createReactStream:${route}] Stream postponed: ${reason}`);
+            }
+            if (typeof handlers.onPostpone === "function") {
+                handlers.onPostpone(route, reason);
+            }
+            if (typeof options?.serverPipeableStreamOptions?.onPostpone === "function") {
+                options.serverPipeableStreamOptions.onPostpone(reason);
+            }
+        },
+    };
+    if (verbose) {
+        logger?.info(`[createReactStream:${route}] Creating React stream for element`);
+    }
+    const { pipe } = ReactDOMServer.renderToPipeableStream(element, options.moduleBasePath || "", streamOptions);
+    if (verbose) {
+        logger?.info(`[createReactStream:${route}] React stream created, got pipe function`);
+    }
+    // Create a PassThrough stream that can be consumed
+    const passThrough = new PassThrough();
+    if (typeof handlers.onError === "function") {
+        passThrough.on("error", (error) => {
+            if (verbose) {
+                logger?.error(`[createReactStream:${route}] PassThrough stream error: ${error}`);
+            }
+            if (typeof handlers.onError === "function") {
+                handlers.onError(route, error);
+            }
+        });
+    }
+    // Pipe the React stream to our PassThrough
+    if (verbose) {
+        logger?.info(`[createReactStream:${route}] Piping React stream to PassThrough`);
+    }
+    pipe(passThrough);
+    if (verbose) {
+        logger?.info(`[createReactStream:${route}] React stream piped, returning PassThrough`);
+    }
+    return passThrough;
+}

package/dist/plugin/stream/server.js

@@ -0,0 +1,12 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+export { handleRscStream } from './handleRscStream.server.js';
+export { createRscStream } from './createRscStream.server.js';
+export { createRenderToPipeableStreamHandler } from './createRenderToPipeableStreamHandler.server.js';
+export { createFromNodeStream } from './createFromNodeStream.server.js';
+export { createHtmlStream } from './createHtmlStream.server.js';
+export { createRscWorkerStream } from './createRscWorkerStream.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7OzsifQ==

package/dist/plugin/stream/setMaxListeners.d.ts

@@ -0,0 +1,16 @@
+import type { MessagePort } from "node:worker_threads";
+/**
+ * Type-safe helper to set max listeners on MessagePort.
+ *
+ * MessagePort extends EventTarget (at runtime), which has setMaxListeners.
+ * However, the TypeScript types don't reflect this, so we use a type assertion.
+ * This is safe because MessagePort is an EventTarget at runtime in Node.js.
+ */
+export declare function setMaxListenersOnPort(port: MessagePort, maxListeners: number): void;
+/**
+ * Unref a MessagePort so it doesn't keep the event loop alive.
+ * Always unref ports — only active message listeners should keep the process alive,
+ * not the port's existence.
+ */
+export declare function unrefPort(port: MessagePort): void;
+//# sourceMappingURL=setMaxListeners.d.ts.map

package/dist/plugin/stream/setMaxListeners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setMaxListeners.d.ts","sourceRoot":"","sources":["../../../plugin/stream/setMaxListeners.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,YAAY,EAAE,MAAM,GACnB,IAAI,CAKN;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAIjD"}

package/dist/plugin/stream/setMaxListeners.js

@@ -0,0 +1,16 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+function setMaxListenersOnPort(port, maxListeners) {
+  port.setMaxListeners(maxListeners);
+}
+function unrefPort(port) {
+  if (typeof port.unref === "function") {
+    port.unref();
+  }
+}
+
+export { setMaxListenersOnPort, unrefPort };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0TWF4TGlzdGVuZXJzLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW4vc3RyZWFtL3NldE1heExpc3RlbmVycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IE1lc3NhZ2VQb3J0IH0gZnJvbSBcIm5vZGU6d29ya2VyX3RocmVhZHNcIjtcblxuLyoqXG4gKiBUeXBlLXNhZmUgaGVscGVyIHRvIHNldCBtYXggbGlzdGVuZXJzIG9uIE1lc3NhZ2VQb3J0LlxuICogXG4gKiBNZXNzYWdlUG9ydCBleHRlbmRzIEV2ZW50VGFyZ2V0IChhdCBydW50aW1lKSwgd2hpY2ggaGFzIHNldE1heExpc3RlbmVycy5cbiAqIEhvd2V2ZXIsIHRoZSBUeXBlU2NyaXB0IHR5cGVzIGRvbid0IHJlZmxlY3QgdGhpcywgc28gd2UgdXNlIGEgdHlwZSBhc3NlcnRpb24uXG4gKiBUaGlzIGlzIHNhZmUgYmVjYXVzZSBNZXNzYWdlUG9ydCBpcyBhbiBFdmVudFRhcmdldCBhdCBydW50aW1lIGluIE5vZGUuanMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZXRNYXhMaXN0ZW5lcnNPblBvcnQoXG4gIHBvcnQ6IE1lc3NhZ2VQb3J0LFxuICBtYXhMaXN0ZW5lcnM6IG51bWJlclxuKTogdm9pZCB7XG4gIC8vIE1lc3NhZ2VQb3J0IGV4dGVuZHMgRXZlbnRUYXJnZXQgYXQgcnVudGltZSwgd2hpY2ggaGFzIHNldE1heExpc3RlbmVyc1xuICAvLyBUeXBlU2NyaXB0IHR5cGVzIGRvbid0IGV4cG9zZSB0aGlzLCBzbyB3ZSB1c2UgYSB0eXBlIGFzc2VydGlvblxuICAvLyBUaGlzIGlzIHNhZmUgYmVjYXVzZSBhbGwgTWVzc2FnZVBvcnQgaW5zdGFuY2VzIGhhdmUgc2V0TWF4TGlzdGVuZXJzIGluIE5vZGUuanNcbiAgKHBvcnQgYXMgdW5rbm93biBhcyB7IHNldE1heExpc3RlbmVyczogKG46IG51bWJlcikgPT4gdm9pZCB9KS5zZXRNYXhMaXN0ZW5lcnMobWF4TGlzdGVuZXJzKTtcbn1cblxuLyoqXG4gKiBVbnJlZiBhIE1lc3NhZ2VQb3J0IHNvIGl0IGRvZXNuJ3Qga2VlcCB0aGUgZXZlbnQgbG9vcCBhbGl2ZS5cbiAqIEFsd2F5cyB1bnJlZiBwb3J0cyDigJQgb25seSBhY3RpdmUgbWVzc2FnZSBsaXN0ZW5lcnMgc2hvdWxkIGtlZXAgdGhlIHByb2Nlc3MgYWxpdmUsXG4gKiBub3QgdGhlIHBvcnQncyBleGlzdGVuY2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB1bnJlZlBvcnQocG9ydDogTWVzc2FnZVBvcnQpOiB2b2lkIHtcbiAgaWYgKHR5cGVvZiAocG9ydCBhcyBhbnkpLnVucmVmID09PSBcImZ1bmN0aW9uXCIpIHtcbiAgICAocG9ydCBhcyBhbnkpLnVucmVmKCk7XG4gIH1cbn1cblxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBU08sU0FBUyxxQkFBQSxDQUNkLE1BQ0EsWUFDTSxFQUFBO0FBSU4sRUFBQyxJQUFBLENBQTZELGdCQUFnQixZQUFZLENBQUE7QUFDNUY7QUFPTyxTQUFTLFVBQVUsSUFBeUIsRUFBQTtBQUNqRCxFQUFJLElBQUEsT0FBUSxJQUFhLENBQUEsS0FBQSxLQUFVLFVBQVksRUFBQTtBQUM3QyxJQUFDLEtBQWEsS0FBTSxFQUFBO0FBQUE7QUFFeEI7Ozs7In0=

package/dist/plugin/transformer/createTransformerPlugin.d.ts

@@ -0,0 +1,18 @@
+import type { VitePluginFn } from "../types.js";
+export interface TransformerPluginOptions {
+    name: string;
+    /**
+     * Optional. If omitted, sensible defaults are applied based on `name`:
+     * - name === "client" -> ["client", "ssr"]
+     * - name === "server" -> ["server"]
+     */
+    allowedEnvironments?: ("client" | "server" | "ssr")[];
+    /**
+     * Optional. If omitted, sensible defaults are applied based on `name`:
+     * - name === "client" -> "client"
+     * - name === "server" -> "server"
+     */
+    defaultEnvironment?: "client" | "server" | "ssr";
+}
+export declare const createTransformerPlugin: (options: TransformerPluginOptions) => VitePluginFn;
+//# sourceMappingURL=createTransformerPlugin.d.ts.map

package/dist/plugin/transformer/createTransformerPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTransformerPlugin.d.ts","sourceRoot":"","sources":["../../../plugin/transformer/createTransformerPlugin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAchD,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,CAAC,QAAQ,GAAG,QAAQ,GAAG,KAAK,CAAC,EAAE,CAAC;IACtD;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK,CAAC;CAClD;AAED,eAAO,MAAM,uBAAuB,GAClC,SAAS,wBAAwB,KAChC,YAiWF,CAAC"}