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

package/dist/plugin/react-static/renderPagesBatched.d.ts

@@ -0,0 +1,6 @@
+import type { RenderPagesFn } from "./types.js";
+/**
+ * Batched version of renderPages that renders pages in parallel batches
+ */
+export declare const renderPagesBatched: RenderPagesFn;
+//# sourceMappingURL=renderPagesBatched.d.ts.map

package/dist/plugin/react-static/renderPagesBatched.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderPagesBatched.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/renderPagesBatched.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAA2C,MAAM,YAAY,CAAC;AA0GzF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,aAkJhC,CAAC"}

package/dist/plugin/react-static/renderPagesBatched.js

@@ -0,0 +1,195 @@
+import { handleError } from "../error/handleError.js";
+import { fileWriter } from "./fileWriter.js";
+const DEFAULT_BATCH_SIZE = 8;
+function resolvePathWithManifest(path, manifest) {
+    const entry = manifest[path];
+    if (entry && entry.file) {
+        return entry.file;
+    }
+    return path;
+}
+/**
+ * Renders a single route completely, consuming all yields from renderPage
+ * and writing the RSC and HTML files
+ */
+async function renderSingleRoute(route, handlerOptions, renderPage, manifest) {
+    const { autoDiscoveredFiles, cssFilesByPage, ...options } = handlerOptions;
+    const { page, props, root, html } = autoDiscoveredFiles.urlMap?.get(route) || {};
+    if (!page) {
+        return { route, results: [], error: new Error(`No page found for route ${route}`) };
+    }
+    try {
+        const resolvedPagePath = page ? resolvePathWithManifest(page, manifest) : undefined;
+        const resolvedPropsPath = props ? resolvePathWithManifest(props, manifest) : undefined;
+        const resolvedRootPath = root ? resolvePathWithManifest(root, manifest) : undefined;
+        const resolvedHtmlPath = html ? resolvePathWithManifest(html, manifest) : undefined;
+        const routeHandlerOptions = {
+            ...options,
+            manifest,
+            route,
+            pagePath: resolvedPagePath,
+            propsPath: resolvedPropsPath,
+            rootPath: resolvedRootPath,
+            htmlPath: resolvedHtmlPath,
+            cssFiles: cssFilesByPage?.get(route) ?? new Map(),
+            globalCss: options.globalCss ?? new Map(),
+            id: `${route}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+        };
+        const pageRenderer = renderPage(routeHandlerOptions);
+        const results = [];
+        let routeError;
+        // Consume all yields from the page renderer and write files
+        for await (const result of pageRenderer) {
+            results.push(result);
+            // Track error results
+            if (result.type === "error" && result.error) {
+                routeError = result.error instanceof Error ? result.error : new Error(String(result.error));
+            }
+            // Write files for success and skip results
+            if ((result.type === "success" || result.type === "skip") && result.html && result.rsc) {
+                const rscWritePromise = fileWriter(result.rsc, "rsc", { ...options, route, logger: options.logger }, options.signal);
+                const htmlWritePromise = fileWriter(result.html, "html", { ...options, route, logger: options.logger }, options.signal);
+                await Promise.all([rscWritePromise, htmlWritePromise]);
+            }
+        }
+        // Return error if any result was an error
+        if (routeError) {
+            return { route, results, error: routeError };
+        }
+        return { route, results };
+    }
+    catch (error) {
+        return { route, results: [], error: error };
+    }
+}
+/**
+ * Splits array into chunks of specified size
+ */
+function chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+}
+/**
+ * Batched version of renderPages that renders pages in parallel batches
+ */
+export const renderPagesBatched = (routes, handlerOptions, renderPage) => {
+    const { autoDiscoveredFiles, manifest = {}, ...options } = handlerOptions;
+    const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    const completedRoutes = new Set();
+    const failedRoutes = new Map();
+    const results = new Map();
+    if (!autoDiscoveredFiles?.urlMap) {
+        return (async function* _renderPagesBatched() {
+            const errorResult = {
+                type: "error",
+                error: new Error("No urlMap provided to renderPages"),
+                route: "",
+                failedRoutes: new Map(),
+                completedRoutes: new Set(),
+                results: new Map(),
+            };
+            yield errorResult;
+            return errorResult;
+        })();
+    }
+    return (async function* _renderPagesBatched() {
+        const routeArray = Array.from(routes);
+        const batches = chunk(routeArray, batchSize);
+        if (options.verbose) {
+            options.logger?.info(`[renderPagesBatched] Rendering ${routeArray.length} pages in ${batches.length} batches of ${batchSize}`);
+        }
+        for (const batch of batches) {
+            // Check for abort signal
+            if (options.signal?.aborted) {
+                const abortResult = {
+                    type: "error",
+                    error: options.signal.reason || new Error("Build aborted"),
+                    route: batch[0] || "",
+                    failedRoutes,
+                    completedRoutes,
+                    results,
+                };
+                yield abortResult;
+                return abortResult;
+            }
+            // Render all pages in this batch concurrently
+            const batchPromises = batch.map(route => renderSingleRoute(route, handlerOptions, renderPage, manifest));
+            const batchResults = await Promise.all(batchPromises);
+            // Process results from this batch
+            for (const { route, results: pageResults, error } of batchResults) {
+                if (error) {
+                    const panicError = handleError({
+                        error,
+                        logger: options.logger,
+                        panicThreshold: options.panicThreshold,
+                        context: `renderPagesBatched(${route})`,
+                    });
+                    if (panicError != null) {
+                        failedRoutes.set(route, error);
+                        options.logger?.error(`[renderPagesBatched] Panic error for route ${route}: ${error.message}`);
+                    }
+                    else {
+                        options.logger?.warn(`[renderPagesBatched] Non-panic error for route ${route}: ${error.message}`);
+                    }
+                }
+                else {
+                    completedRoutes.add(route);
+                    // Yield each result from this page
+                    for (const result of pageResults) {
+                        if (result.type === "success" || result.type === "skip") {
+                            results.set(route, result);
+                            yield {
+                                type: "success",
+                                route,
+                                failedRoutes,
+                                completedRoutes,
+                                results,
+                            };
+                        }
+                    }
+                }
+            }
+            if (options.verbose) {
+                options.logger?.info(`[renderPagesBatched] Completed batch: ${completedRoutes.size}/${routeArray.length} pages`);
+            }
+        }
+        // Check if we should panic based on failed routes
+        if (failedRoutes.size > 0) {
+            const firstError = Array.from(failedRoutes.values())[0];
+            const panicError = handleError({
+                error: firstError,
+                logger: options.logger,
+                panicThreshold: options.panicThreshold,
+                context: `renderPagesBatched final check`,
+            });
+            if (panicError != null) {
+                if (options.verbose) {
+                    options.logger?.error(`[renderPagesBatched] Build failed due to panic threshold: ${failedRoutes.size} routes failed`);
+                }
+                // Yield error before returning
+                const errorResult = {
+                    type: "error",
+                    error: panicError,
+                    route: "",
+                    failedRoutes,
+                    completedRoutes,
+                    results,
+                };
+                yield errorResult;
+                return errorResult;
+            }
+        }
+        // Final success result
+        const finalResult = {
+            type: "success",
+            route: "",
+            failedRoutes,
+            completedRoutes,
+            results,
+        };
+        return finalResult;
+    })();
+};

package/dist/plugin/react-static/renderStreams.d.ts

@@ -1,9 +1,6 @@
-import type { CreateHandlerFn } from "../helpers/createHandler.js";
-import type { ReactStreamHandlerFn } from "../types.js";
-export type RenderStreamsReturn = [ReturnType<CreateHandlerFn>, ReturnType<CreateHandlerFn>];
-export type RenderStreamsFn = ReactStreamHandlerFn<RenderStreamsReturn>;
+import type { RenderStreamsFn } from "./types.js";
 /**
- * Creates handlers for both document and RSC streams
+ * Creates handlers for both Full RSC and Headless RSC streams
  */
 export declare const renderStreams: RenderStreamsFn;
 //# sourceMappingURL=renderStreams.d.ts.map

package/dist/plugin/react-static/renderStreams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderStreams.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/renderStreams.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD,MAAM,MAAM,mBAAmB,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC;AAG7F,MAAM,MAAM,eAAe,GAAG,oBAAoB,CAAC,mBAAmB,CAAC,CAAA;AAEvE;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,eAgB1B,CAAC"}
+{"version":3,"file":"renderStreams.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/renderStreams.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAMlD;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,eAgB3B,CAAC"}

package/dist/plugin/react-static/renderStreams.js

@@ -1,27 +1,39 @@
 /**
- * vite-plugin-react-server
- * Copyright (c) Nico Brinkkemper
- * MIT License
+ * renderStreams.ts
+ *
+ * PURPOSE: Creates specialized streams for React Server Components (RSC) rendering
+ *
+ * This module:
+ * 1. Creates Headless RSC stream (React.Fragment wrapper) for client-side navigation
+ *    - This stream is saved to .rsc files and used when navigating between pages
+ *    - The Fragment wrapper allows the browser to update only the necessary parts of the DOM
+ *    - This is more efficient than reloading the entire HTML document
+ * 2. Creates Full Document stream (Html wrapper) for initial page loads
+ *    - This stream includes the full HTML document structure
+ *    - Used for the initial page load when the browser needs the complete HTML
+ * 3. Sets up stream handlers with proper wrappers and options
+ * 4. Returns streams for renderPages to process
  */
-import { createHandler } from '../helpers/createHandler.js';
-import React__default from 'react';
-
-const renderStreams = (handler) => {
-  return [
-    /**
-     * This stream goes to the document worker for client side rendering with full HTML structure,
-     * links are already bubbled up in the static document which required us
-     * to include the head in the stream as well
-     */
-    createHandler(handler),
-    /**
-     * This stream is saved to index.rsc file (if configured) and can be used
-     * for navigating to pages (without the Html wrapper, but does contain
-     * css/head information that can bubble up to the browser's dom)
-     */
-    createHandler({ ...handler, HtmlComponent: React__default.Fragment })
-  ];
+import { createRenderToPipeableStreamHandler } from "../stream/createRenderToPipeableStreamHandler.server.js";
+import { assertReactServer } from "../config/getCondition.js";
+import { React } from "../vendor/vendor.server.js";
+assertReactServer();
+/**
+ * Creates handlers for both Full RSC and Headless RSC streams
+ */
+export const renderStreams = (handler) => {
+    return [
+        /**
+         * This stream goes to the document worker for client side rendering with full HTML structure,
+         * links are already bubbled up in the static document which required us
+         * to include the head in the stream as well
+         */
+        createRenderToPipeableStreamHandler(handler),
+        /**
+         * This stream is saved to index.rsc file (if configured) and can be used
+         * for navigating to pages (without the Html wrapper, but does contain
+         * css/head information that can bubble up to the browser's dom)
+         */
+        createRenderToPipeableStreamHandler({ ...handler, HtmlComponent: React.Fragment }),
+    ];
 };
-
-export { renderStreams };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/react-static/rscToHtmlStream.client.d.ts

@@ -0,0 +1,12 @@
+/**
+ * rscToHtmlStream.client.ts
+ *
+ * PURPOSE: Transforms RSC stream to HTML stream on client side
+ *
+ * This follows the client-side pattern where the main thread runs React Client Components:
+ *
+ * Client-side pattern: RSC chunks → Main thread HTML conversion (main thread is the HTML worker)
+ */
+import type { RscToHtmlStreamFn } from "./types.js";
+export declare const createRscToHtmlStream: RscToHtmlStreamFn;
+//# sourceMappingURL=rscToHtmlStream.client.d.ts.map

package/dist/plugin/react-static/rscToHtmlStream.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscToHtmlStream.client.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/rscToHtmlStream.client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpD,eAAO,MAAM,qBAAqB,EAAE,iBAgDnC,CAAC"}

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

@@ -0,0 +1,32 @@
+import { createHtmlStream } from "../stream/createHtmlStream.client.js";
+export 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,
+    });
+    // Handle abort signal
+    if (signal) {
+        signal.addEventListener("abort", () => {
+            if (verbose) {
+                logger?.info(`[createRscToHtmlStream:${route}] Abort signal received`);
+            }
+            htmlStream.abort();
+        });
+    }
+    return htmlStream;
+};

package/dist/plugin/react-static/rscToHtmlStream.d.ts

@@ -1,22 +1,4 @@
-/**
- * rscToHtmlStream.ts
- *
- * PURPOSE: Transforms RSC stream to HTML stream via worker communication
- *
- * This module:
- * 1. Takes RSC stream as input
- * 2. Communicates with worker to transform RSC to HTML
- * 3. Returns a writeable stream of HTML content
- * 4. Handles worker message processing and error cases
- */
-import { Transform } from "node:stream";
-import type { CreateHandlerOptions } from "../types.js";
-export type RscToHtmlOptions = Pick<CreateHandlerOptions, "worker" | "route" | "moduleRootPath" | "moduleBaseURL" | "pipeableStreamOptions" | "build" | "cssFiles" | "projectRoot">;
-/**
- * Creates a transform stream that converts RSC content to HTML via worker
- *
- * @param options The options for RSC to HTML transformation
- * @returns A transform stream that outputs HTML content
- */
-export declare function createRscToHtmlStream(options: RscToHtmlOptions): Transform;
+import type { RscToHtmlStreamFn } from "./types.js";
+declare const createRscToHtmlStream: RscToHtmlStreamFn;
+export { createRscToHtmlStream };
 //# sourceMappingURL=rscToHtmlStream.d.ts.map

package/dist/plugin/react-static/rscToHtmlStream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rscToHtmlStream.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/rscToHtmlStream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAKxD,MAAM,MAAM,gBAAgB,GAAG,IAAI,CACjC,oBAAoB,EAClB,QAAQ,GACR,OAAO,GACP,gBAAgB,GAChB,eAAe,GACf,uBAAuB,GACvB,OAAO,GACP,UAAU,GACV,aAAa,CAChB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CA8C1E"}
+{"version":3,"file":"rscToHtmlStream.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/rscToHtmlStream.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAKpD,QAAA,MAAQ,qBAAqB,mBAEqB,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

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

@@ -1,54 +1,5 @@
-/**
- * vite-plugin-react-server
- * Copyright (c) Nico Brinkkemper
- * MIT License
- */
-import { Transform } from 'node:stream';
-
-function createRscToHtmlStream(options) {
-  const worker = options.worker;
-  if (!("postMessage" in worker)) {
-    throw new Error("Worker is not a valid worker");
-  }
-  let sequence = 0;
-  const stream = new Transform({
-    transform(chunk, _encoding, callback) {
-      try {
-        worker.postMessage({
-          type: "RSC_CHUNK",
-          id: options.route,
-          chunk,
-          sequence: sequence++
-        });
-        callback();
-      } catch (error) {
-        callback(error);
-      }
-    },
-    flush(callback) {
-      try {
-        worker.postMessage({
-          type: "RSC_END",
-          id: options.route
-        });
-        callback();
-      } catch (error) {
-        callback(error);
-      }
-    }
-  });
-  worker.postMessage({
-    type: "ROUTE_READY",
-    id: options.route,
-    // replace server with client
-    moduleRootPath: options.moduleRootPath,
-    moduleBaseURL: options.moduleBaseURL,
-    cssFiles: options.cssFiles,
-    pipeableStreamOptions: options.pipeableStreamOptions,
-    projectRoot: options.projectRoot
-  });
-  return stream;
-}
-
+import { getCondition } from "../config/getCondition.js";
+const condition = getCondition("");
+const dir = new URL("./", import.meta.url);
+const { createRscToHtmlStream } = (await import(`${dir}/rscToHtmlStream.${condition}.js`));
 export { createRscToHtmlStream };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/react-static/rscToHtmlStream.server.d.ts

@@ -0,0 +1,3 @@
+import type { RscToHtmlStreamFn } from "./types.js";
+export declare const createRscToHtmlStream: RscToHtmlStreamFn;
+//# sourceMappingURL=rscToHtmlStream.server.d.ts.map

package/dist/plugin/react-static/rscToHtmlStream.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscToHtmlStream.server.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/rscToHtmlStream.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpD,eAAO,MAAM,qBAAqB,EAAE,iBA8DnC,CAAC"}

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

@@ -0,0 +1,39 @@
+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,
+    });
+    // Handle abort signal
+    if (signal) {
+        signal.addEventListener("abort", () => {
+            if (verbose) {
+                logger?.info(`[createRscToHtmlStream:${route}] Abort signal received`);
+            }
+            htmlStream.abort();
+        });
+    }
+    return htmlStream;
+};

package/dist/plugin/react-static/temporaryReferences.client.d.ts

@@ -0,0 +1,2 @@
+export declare const temporaryReferences: Set<unknown>;
+//# sourceMappingURL=temporaryReferences.client.d.ts.map

package/dist/plugin/react-static/temporaryReferences.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporaryReferences.client.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/temporaryReferences.client.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,cAAY,CAAA"}

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

@@ -0,0 +1 @@
+export const temporaryReferences = new Set();

package/dist/plugin/react-static/temporaryReferences.d.ts

@@ -1,2 +1,3 @@
-export declare const temporaryReferences: any;
+declare const temporaryReferences: WeakMap<any, any> | Set<any>;
+export { temporaryReferences };
 //# sourceMappingURL=temporaryReferences.d.ts.map

package/dist/plugin/react-static/temporaryReferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"temporaryReferences.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/temporaryReferences.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,KAAgC,CAAC"}
+{"version":3,"file":"temporaryReferences.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/temporaryReferences.ts"],"names":[],"mappings":"AAOA,QAAA,MAAQ,mBAAmB,8BAEgC,CAAC;AAE5D,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

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

@@ -1,11 +1,7 @@
-/**
- * vite-plugin-react-server
- * Copyright (c) Nico Brinkkemper
- * MIT License
- */
-import { createTemporaryReferenceSet } from 'react-server-dom-esm/server.node';
-
-const temporaryReferences = createTemporaryReferenceSet();
-
+import { getCondition } from "../config/getCondition.js";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const condition = getCondition("");
+const dir = dirname(fileURLToPath(import.meta.url));
+const { temporaryReferences } = (await import(`${dir}/temporaryReferences.${condition}.js`));
 export { temporaryReferences };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcG9yYXJ5UmVmZXJlbmNlcy5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2luL3JlYWN0LXN0YXRpYy90ZW1wb3JhcnlSZWZlcmVuY2VzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNyZWF0ZVRlbXBvcmFyeVJlZmVyZW5jZVNldCB9IGZyb20gXCJyZWFjdC1zZXJ2ZXItZG9tLWVzbS9zZXJ2ZXIubm9kZVwiO1xuXG5leHBvcnQgY29uc3QgdGVtcG9yYXJ5UmVmZXJlbmNlcyA9IGNyZWF0ZVRlbXBvcmFyeVJlZmVyZW5jZVNldCgpO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFFTyxNQUFNLHNCQUFzQiwyQkFBNEI7Ozs7In0=

package/dist/plugin/react-static/temporaryReferences.server.d.ts

@@ -0,0 +1,2 @@
+export declare const temporaryReferences: WeakMap<any, any>;
+//# sourceMappingURL=temporaryReferences.server.d.ts.map

package/dist/plugin/react-static/temporaryReferences.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporaryReferences.server.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/temporaryReferences.server.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB,mBAAgC,CAAC"}

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

@@ -0,0 +1,3 @@
+import { ReactDOMServer } from "../vendor/vendor.server.js";
+const { createTemporaryReferenceSet } = ReactDOMServer;
+export const temporaryReferences = createTemporaryReferenceSet();

package/dist/plugin/react-static/types.d.ts

@@ -1,12 +1,86 @@
-import type { FileWriteEvent } from "../types.js";
-export type ReactStaticEvent = FileWriteEvent | {
-    type: 'build.start';
-    data: {
-        pages: string[];
-        files: Array<[string, {
-            page: string;
-            props?: string;
-        }]>;
+import type { PassThrough, Readable } from "node:stream";
+import type { AutoDiscoveredFiles, BuildModuleLoader, CreateHandlerOptions, CssContent, RenderPageResult, RenderPagesResult, ResolvedUserOptions, StreamMetrics } from "../types.js";
+import type { Logger, Manifest, PreviewServer } from "vite";
+import type { OutputBundle } from "rollup";
+export type FileWriterOptions = Pick<CreateHandlerOptions, "verbose" | "panicThreshold" | "route" | "build" | "signal" | "worker" | "onEvent" | "logger">;
+export type FileWriterFn = (stream: Readable, fileType: "html" | "rsc", options: FileWriterOptions, signal?: AbortSignal) => Promise<void>;
+export type CreateBuildLoaderFn = (props: {
+    userOptions: ResolvedUserOptions;
+    serverManifest: Manifest;
+    staticManifest: Manifest;
+}, bundle: OutputBundle, temporaryReferences: WeakMap<any, any>, logger?: Logger) => BuildModuleLoader;
+export type CollectRscContentReturn = {
+    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+    abort: (reason?: unknown) => void;
+    metrics: StreamMetrics;
+    bufferedContent?: Buffer[];
+};
+export type CollectRscContentFn = (rsc: {
+    abort: (reason?: unknown) => void;
+    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+}, handlerOptions: CreateHandlerOptions) => Promise<CollectRscContentReturn>;
+export type CollectHtmlWorkerContentReturn = {
+    type: "success";
+    stream: {
+        abort: (reason?: unknown) => void;
+        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
     };
+    metrics: StreamMetrics;
+} | {
+    type: "error";
+    error: Error | null;
+    stream?: never;
+    metrics?: never;
+};
+export type CollectHtmlWorkerContentGenerator = AsyncGenerator<{
+    type: "progress";
+    message: string;
+    metrics?: Partial<StreamMetrics>;
+} | {
+    type: "chunk";
+    chunk: Buffer;
+} | CollectHtmlWorkerContentReturn, CollectHtmlWorkerContentReturn, unknown>;
+export type CollectHtmlContentFn = <Opt extends CreateHandlerOptions = CreateHandlerOptions>(rsc: {
+    abort: (reason?: unknown) => void;
+    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+}, handlerOptions: Opt) => Promise<{
+    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+    abort: (reason?: unknown) => void;
+    metrics: StreamMetrics;
+}>;
+export type ConfigurePreviewServerProps<Opt extends ResolvedUserOptions> = {
+    server: PreviewServer;
+    userOptions: Opt;
+};
+export type ConfigurePreviewServerFn = <Opt extends ResolvedUserOptions>(props: ConfigurePreviewServerProps<Opt>) => void;
+export type RenderPagesReturn = AsyncGenerator<RenderPagesResult, RenderPagesResult, unknown>;
+export type RenderPagesHandlerOptions = Omit<CreateHandlerOptions, "pagePath" | "route" | "cssFiles" | "propsPath" | "rootPath" | "htmlPath" | "pageProps" | "PageComponent" | "RootComponent" | "HtmlComponent" | "url"> & {
+    autoDiscoveredFiles: AutoDiscoveredFiles;
+    cssFilesByPage: Map<string, Map<string, CssContent>>;
+    serverPipeableStreamOptions: any;
+    staticManifest?: Manifest;
+};
+export type RenderPagesFn = (routes: string[], handlerOptions: RenderPagesHandlerOptions, renderPage: RenderPageFn) => RenderPagesReturn;
+export type RenderPageReturn = AsyncGenerator<RenderPageResult, void, unknown>;
+export type RenderPageFn = (options: CreateHandlerOptions) => RenderPageReturn;
+export type RenderStreamsReturn = [
+    {
+        abort: (reason?: unknown) => void;
+        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+        rscStream: PassThrough;
+    },
+    {
+        abort: (reason?: unknown) => void;
+        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+        rscStream: PassThrough;
+    }
+];
+export type RenderStreamsFn = <Opt extends CreateHandlerOptions = CreateHandlerOptions>(handler: Opt) => RenderStreamsReturn;
+export type RscToHtmlOptions = Pick<CreateHandlerOptions, "id" | "worker" | "htmlWorker" | "route" | "url" | "moduleRootPath" | "moduleBaseURL" | "moduleBasePath" | "clientPipeableStreamOptions" | "build" | "projectRoot" | "panicThreshold" | "verbose" | "signal" | "logger" | "htmlTimeout" | "onMetrics" | "rscStream"> & {
+    onError?: (error: Error, isPanic: boolean) => void;
+};
+export type RscToHtmlStreamFn = (options: RscToHtmlOptions) => {
+    abort: (reason?: unknown) => void;
+    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
 };
 //# sourceMappingURL=types.d.ts.map