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

package/dist/plugin/helpers/headlessStreamState.js

@@ -0,0 +1,81 @@
+/**
+ * Manages headless stream state for error tracking and element reuse.
+ * Used by both client and server workflows for consistent behavior.
+ */
+/**
+ * Creates a new headless stream state manager.
+ */
+export function createHeadlessStreamState() {
+    return {
+        elements: new Map(),
+        errors: new Map(),
+    };
+}
+/**
+ * Tracks a headless stream error for a route.
+ *
+ * @param state - The headless stream state
+ * @param route - The route that had an error
+ * @param error - The error that occurred
+ */
+export function trackHeadlessStreamError(state, route, error) {
+    state.errors.set(route, error);
+}
+/**
+ * Checks if a route has a headless stream error.
+ *
+ * @param state - The headless stream state
+ * @param route - The route to check
+ * @returns true if the route has a headless stream error
+ */
+export function hasHeadlessStreamError(state, route) {
+    return state.errors.has(route);
+}
+/**
+ * Gets the headless stream error for a route.
+ *
+ * @param state - The headless stream state
+ * @param route - The route to get the error for
+ * @returns The error if it exists, undefined otherwise
+ */
+export function getHeadlessStreamError(state, route) {
+    return state.errors.get(route);
+}
+/**
+ * Stores headless stream elements for reuse.
+ *
+ * @param state - The headless stream state
+ * @param streamId - The stream ID
+ * @param data - The stream data to store
+ */
+export function storeHeadlessStreamElements(state, streamId, data) {
+    state.elements.set(streamId, data);
+}
+/**
+ * Gets headless stream elements for reuse.
+ *
+ * @param state - The headless stream state
+ * @param streamId - The stream ID
+ * @returns The stream data if it exists, undefined otherwise
+ */
+export function getHeadlessStreamElements(state, streamId) {
+    return state.elements.get(streamId);
+}
+/**
+ * Cleans up headless stream elements after use.
+ *
+ * @param state - The headless stream state
+ * @param streamId - The stream ID to clean up
+ */
+export function cleanupHeadlessStreamElements(state, streamId) {
+    state.elements.delete(streamId);
+}
+/**
+ * Clears all headless stream errors for a route.
+ *
+ * @param state - The headless stream state
+ * @param route - The route to clear errors for
+ */
+export function clearHeadlessStreamErrors(state, route) {
+    state.errors.delete(route);
+}

package/dist/plugin/helpers/hydrateUserOptions.d.ts

@@ -4,6 +4,6 @@ export declare function hydrateUserOptions(options: SerializedUserOptions): {
     userOptions: ResolvedUserOptions;
 } | {
     type: "error";
-    error: Error;
+    error: unknown;
 };
 //# sourceMappingURL=hydrateUserOptions.d.ts.map

package/dist/plugin/helpers/hydrateUserOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydrateUserOptions.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/hydrateUserOptions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE9E,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,qBAAqB,GAC7B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,mBAAmB,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAiBzF"}
+{"version":3,"file":"hydrateUserOptions.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/hydrateUserOptions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE9E,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,qBAAqB,GAC7B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,mBAAmB,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAiB3F"}

package/dist/plugin/helpers/hydrateUserOptions.js

@@ -14,9 +14,9 @@ function hydrateUserOptions(options) {
     const userOptions = result.userOptions;
     return { type: "success", userOptions };
   } catch (error) {
-    return { type: "error", error: error instanceof Error ? error : new Error(String(error)) };
+    return { type: "error", error };
   }
 }
 
 export { hydrateUserOptions };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHlkcmF0ZVVzZXJPcHRpb25zLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW4vaGVscGVycy9oeWRyYXRlVXNlck9wdGlvbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcmVzb2x2ZU9wdGlvbnMgfSBmcm9tIFwiLi4vY29uZmlnL3Jlc29sdmVPcHRpb25zLmpzXCI7XG5pbXBvcnQgdHlwZSB7IFJlc29sdmVkVXNlck9wdGlvbnMsIFNlcmlhbGl6ZWRVc2VyT3B0aW9ucyB9IGZyb20gXCIuLi90eXBlcy5qc1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gaHlkcmF0ZVVzZXJPcHRpb25zKFxuICBvcHRpb25zOiBTZXJpYWxpemVkVXNlck9wdGlvbnNcbik6IHsgdHlwZTogXCJzdWNjZXNzXCI7IHVzZXJPcHRpb25zOiBSZXNvbHZlZFVzZXJPcHRpb25zIH0gfCB7IHR5cGU6IFwiZXJyb3JcIjsgZXJyb3I6IHVua25vd24gfSB7XG4gIHRyeSB7XG4gICAgLy8gcmVzb2x2ZU9wdGlvbnMgYWxyZWFkeSBoYW5kbGVzIHJlZ2V4IGRlc2VyaWFsaXphdGlvbiB0aHJvdWdoIGRlc2VyaWFsaXplUmVnRXhwKClcbiAgICAvLyBDYXN0IHRoZSBzZXJpYWxpemVkIG9wdGlvbnMgYmFjayB0byB0aGUgZXhwZWN0ZWQgaW5wdXQgZm9ybWF0IGZvciByZXNvbHZlT3B0aW9uc1xuICAgIGNvbnN0IHJlc3VsdCA9IHJlc29sdmVPcHRpb25zKG9wdGlvbnMgYXMgYW55KTtcbiAgICBcbiAgICBpZiAocmVzdWx0LnR5cGUgPT09IFwiZXJyb3JcIikge1xuICAgICAgcmV0dXJuIHJlc3VsdDtcbiAgICB9XG4gICAgXG4gICAgLy8gcmVzb2x2ZU9wdGlvbnMgYWxyZWFkeSBjcmVhdGVzIHRoZSB1c2VyT3B0aW9ucyB3aXRoIGFsbCBuZWVkZWQgcHJvcGVydGllc1xuICAgIGNvbnN0IHVzZXJPcHRpb25zID0gcmVzdWx0LnVzZXJPcHRpb25zO1xuICAgIFxuICAgIHJldHVybiB7IHR5cGU6IFwic3VjY2Vzc1wiLCB1c2VyT3B0aW9ucyB9O1xuICB9IGNhdGNoIChlcnJvcikge1xuICAgIHJldHVybiB7IHR5cGU6IFwiZXJyb3JcIiwgZXJyb3I6IGVycm9yIH07XG4gIH1cbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBR08sU0FBUyxtQkFDZCxPQUMyRixFQUFBO0FBQzNGLEVBQUksSUFBQTtBQUdGLElBQU0sTUFBQSxNQUFBLEdBQVMsZUFBZSxPQUFjLENBQUE7QUFFNUMsSUFBSSxJQUFBLE1BQUEsQ0FBTyxTQUFTLE9BQVMsRUFBQTtBQUMzQixNQUFPLE9BQUEsTUFBQTtBQUFBO0FBSVQsSUFBQSxNQUFNLGNBQWMsTUFBTyxDQUFBLFdBQUE7QUFFM0IsSUFBTyxPQUFBLEVBQUUsSUFBTSxFQUFBLFNBQUEsRUFBVyxXQUFZLEVBQUE7QUFBQSxXQUMvQixLQUFPLEVBQUE7QUFDZCxJQUFPLE9BQUEsRUFBRSxJQUFNLEVBQUEsT0FBQSxFQUFTLEtBQWEsRUFBQTtBQUFBO0FBRXpDOzs7OyJ9

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

@@ -7,13 +7,9 @@ export * from "./requestToRoute.js";
 export * from "./serializeUserOptions.js";
 export * from "./cleanObject.js";
 export * from "./inputNormalizer.js";
-export * from "./collectBundleManifestCss.js";
 export * from "./collectManifestCss.js";
 export * from "./collectViteModuleGraphCss.js";
 export * from "./createCssProps.js";
-export * from "./createRscStream.js";
-export * from "./createHandler.js";
-export * from "./createEventHandler.js";
 export * from "./hydrateUserOptions.js";
 export * from "./formatMetrics.js";
 export * from "./metrics.js";
@@ -22,5 +18,16 @@ export * from "./getBundleManifest.js";
 export * from "./moduleRefs.js";
 export * from "./moduleResolver.js";
 export * from "./stashReturnValue.js";
-export * from "./defaultFileWriter.js";
+export * from "./workerManager.js";
+export * from "./validateRscRenderMessage.js";
+export * from "./resolveRenderUrl.js";
+export * from "./mergeMessageWithDefaults.js";
+export * from "./resolveWithDefaultRootAndHtml.js";
+export { resolveComponents as resolveComponentsClient } from "./resolveComponents.client.js";
+export * from "./logRenderStart.js";
+export * from "./createSerializableHandlerOptions.js";
+export * from "./createPatternMatcher.js";
+export * from "./createUnifiedCssProcessor.js";
+declare const handleServerAction: any;
+export { handleServerAction };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/index.ts"],"names":[],"mappings":"AACA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AAGpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAG7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/index.ts"],"names":[],"mappings":"AAGA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AAMpC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAG7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,OAAO,EAAE,iBAAiB,IAAI,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7F,cAAc,qBAAqB,CAAC;AACpC,cAAc,uCAAuC,CAAC;AAEtD,cAAc,2BAA2B,CAAC;AAE1C,cAAc,gCAAgC,CAAC;AAO/C,QAAA,MAAQ,kBAAkB,KAIzB,CAAC;AAEF,OAAO,EAAG,kBAAkB,EAAE,CAAC"}

package/dist/plugin/helpers/index.js

@@ -3,6 +3,7 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
+import { getCondition } from '../config/getCondition.js';
 export { getRouteFiles } from './getRouteFiles.js';
 export { resolvePage } from './resolvePage.js';
 export { resolveProps } from './resolveProps.js';
@@ -15,17 +16,30 @@ export { createInputNormalizer } from './inputNormalizer.js';
 export { collectManifestCss } from './collectManifestCss.js';
 export { collectViteModuleGraphCss } from './collectViteModuleGraphCss.js';
 export { createCssProps } from './createCssProps.js';
-export { createRscStream } from './createRscStream.js';
-export { createHandler } from './createHandler.js';
-export { createEventHandler } from './createEventHandler.js';
 export { hydrateUserOptions } from './hydrateUserOptions.js';
 export { tryManifest } from './tryManifest.js';
 export { getBundleManifest } from './getBundleManifest.js';
 export { getModuleRef, moduleRefs } from './moduleRefs.js';
 export { getSource, loadClientSource, resolve, resolveClientImport, setStashedGetSource, setStashedResolve } from './moduleResolver.js';
 export { clearStashedReturnValues, stashReturnValue } from './stashReturnValue.js';
+export { clearWorker, getWorker, setWorker } from './workerManager.js';
+export { validateRscRenderMessage } from './validateRscRenderMessage.js';
+export { resolveRenderUrl } from './resolveRenderUrl.js';
+export { mergeMessageWithDefaults } from './mergeMessageWithDefaults.js';
+export { resolveWithDefaultRootAndHtml } from './resolveWithDefaultRootAndHtml.js';
+export { resolveComponents as resolveComponentsClient } from './resolveComponents.client.js';
+export { logRenderStart } from './logRenderStart.js';
+export { createSerializableHandlerOptions } from './createSerializableHandlerOptions.js';
+export { createPatternMatcher } from './createPatternMatcher.js';
+export { combineCssFiles, createUnifiedCssProcessor, processCssFromStaticBuild, processInlineCssForState } from './createUnifiedCssProcessor.js';
 export { formatMetrics, logMetrics } from '../metrics/formatMetrics.js';
 export { collectStreamMetrics } from '../metrics/collectStreamMetrics.js';
 export { createRenderMetrics } from '../metrics/createRenderMetrics.js';
 export { createStreamMetrics } from '../metrics/createStreamMetrics.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+
+const condition = getCondition("");
+const dirname = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+const { handleServerAction } = await import(`${dirname}/handleServerAction.${condition}.js`);
+
+export { handleServerAction };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/helpers/logRenderStart.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "vite";
+/**
+ * Logs render start if verbose mode is enabled
+ *
+ * This helper provides consistent logging across different render contexts:
+ * - RSC worker renders
+ * - HTML worker renders
+ * - Client-side renders
+ * - Server-side renders
+ *
+ * @param route - The route being rendered
+ * @param verbose - Whether verbose logging is enabled
+ * @param logger - The logger instance to use
+ * @param context - Optional context identifier (e.g., "rsc-worker", "html-worker", "client", "server")
+ */
+export declare function logRenderStart(route: string, verbose: boolean, logger: Logger, context?: string): void;
+//# sourceMappingURL=logRenderStart.d.ts.map

package/dist/plugin/helpers/logRenderStart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logRenderStart.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/logRenderStart.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,MAAiB,GACzB,IAAI,CAIN"}

package/dist/plugin/helpers/logRenderStart.js

@@ -0,0 +1,13 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+function logRenderStart(route, verbose, logger, context = "render") {
+  if (verbose) {
+    logger.info(`[${context}:${route}] Starting render for route: ${route}`);
+  }
+}
+
+export { logRenderStart };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nUmVuZGVyU3RhcnQuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BsdWdpbi9oZWxwZXJzL2xvZ1JlbmRlclN0YXJ0LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTG9nZ2VyIH0gZnJvbSBcInZpdGVcIjtcblxuLyoqXG4gKiBMb2dzIHJlbmRlciBzdGFydCBpZiB2ZXJib3NlIG1vZGUgaXMgZW5hYmxlZFxuICogXG4gKiBUaGlzIGhlbHBlciBwcm92aWRlcyBjb25zaXN0ZW50IGxvZ2dpbmcgYWNyb3NzIGRpZmZlcmVudCByZW5kZXIgY29udGV4dHM6XG4gKiAtIFJTQyB3b3JrZXIgcmVuZGVyc1xuICogLSBIVE1MIHdvcmtlciByZW5kZXJzICBcbiAqIC0gQ2xpZW50LXNpZGUgcmVuZGVyc1xuICogLSBTZXJ2ZXItc2lkZSByZW5kZXJzXG4gKiBcbiAqIEBwYXJhbSByb3V0ZSAtIFRoZSByb3V0ZSBiZWluZyByZW5kZXJlZFxuICogQHBhcmFtIHZlcmJvc2UgLSBXaGV0aGVyIHZlcmJvc2UgbG9nZ2luZyBpcyBlbmFibGVkXG4gKiBAcGFyYW0gbG9nZ2VyIC0gVGhlIGxvZ2dlciBpbnN0YW5jZSB0byB1c2VcbiAqIEBwYXJhbSBjb250ZXh0IC0gT3B0aW9uYWwgY29udGV4dCBpZGVudGlmaWVyIChlLmcuLCBcInJzYy13b3JrZXJcIiwgXCJodG1sLXdvcmtlclwiLCBcImNsaWVudFwiLCBcInNlcnZlclwiKVxuICovXG5leHBvcnQgZnVuY3Rpb24gbG9nUmVuZGVyU3RhcnQoXG4gIHJvdXRlOiBzdHJpbmcsXG4gIHZlcmJvc2U6IGJvb2xlYW4sXG4gIGxvZ2dlcjogTG9nZ2VyLFxuICBjb250ZXh0OiBzdHJpbmcgPSBcInJlbmRlclwiXG4pOiB2b2lkIHtcbiAgaWYgKHZlcmJvc2UpIHtcbiAgICBsb2dnZXIuaW5mbyhgWyR7Y29udGV4dH06JHtyb3V0ZX1dIFN0YXJ0aW5nIHJlbmRlciBmb3Igcm91dGU6ICR7cm91dGV9YCk7XG4gIH1cbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQWdCTyxTQUFTLGNBQ2QsQ0FBQSxLQUFBLEVBQ0EsT0FDQSxFQUFBLE1BQUEsRUFDQSxVQUFrQixRQUNaLEVBQUE7QUFDTixFQUFBLElBQUksT0FBUyxFQUFBO0FBQ1gsSUFBQSxNQUFBLENBQU8sS0FBSyxDQUFJLENBQUEsRUFBQSxPQUFPLElBQUksS0FBSyxDQUFBLDZCQUFBLEVBQWdDLEtBQUssQ0FBRSxDQUFBLENBQUE7QUFBQTtBQUUzRTs7OzsifQ==

package/dist/plugin/helpers/mergeMessageWithDefaults.d.ts

@@ -0,0 +1,90 @@
+import type { ResolvedUserOptions } from "../types.js";
+import type { RscRenderMessage } from "../worker/rsc/types.js";
+/**
+ * Merges message values with defaults, prioritizing message values
+ *
+ * @param message - The RSC render message containing values to merge
+ * @param defaultUserOptions - Default user options to fall back to
+ * @returns Merged values with message values taking precedence
+ */
+export declare function mergeMessageWithDefaults(message: RscRenderMessage, defaultUserOptions?: Partial<ResolvedUserOptions>): {
+    cssFiles: Map<string, import("../types.js").StyleCssProps | import("../types.js").LinkCssProps> & Map<string, import("../types.js").CssContent>;
+    as?: keyof import("react").JSX.IntrinsicElements | import("react").JSXElementConstructor<any> | undefined;
+    children?: import("react").ReactNode;
+    pageProps?: any;
+    manifest: import("vite").Manifest;
+    globalCss: Map<string, import("../types.js").StyleCssProps | import("../types.js").LinkCssProps> & Map<string, import("../types.js").CssContent>;
+    server?: import("vite").ViteDevServer | undefined;
+    css: import("../types.js").RootOptions<boolean>;
+    worker?: import("worker_threads").Worker | undefined;
+    dev: Pick<ResolvedUserOptions["dev"], "useHtmlWorker" | "useRscWorker">;
+    htmlWorkerPath: string;
+    rscWorkerPath: string;
+    htmlTimeout: number;
+    fileWriteTimeout: number;
+    workerShutdownTimeout: number;
+    clientPipeableStreamOptions?: import("react-dom/server").RenderToPipeableStreamOptions | undefined;
+    components?: {
+        Html?: import("../types.js").HtmlComponentType<any, keyof import("react").JSX.IntrinsicElements | import("react").JSXElementConstructor<any>, boolean | undefined, import("react").ReactNode> | undefined;
+        Root?: import("../types.js").RootComponentType<any, keyof import("react").JSX.IntrinsicElements | import("react").JSXElementConstructor<any>, boolean | undefined, import("react").ReactNode> | undefined;
+        Page?: import("../types.js").PageComponentType<any, import("react").ReactNode> | undefined;
+    } | undefined;
+    reuseHeadlessStreamId?: string | undefined;
+    headlessStreamElements?: Map<string, {
+        PageComponent: any;
+        errored: boolean;
+    }> | undefined;
+    signal?: AbortSignal | undefined;
+    PageComponent?: any;
+    staticManifest?: import("vite").Manifest | undefined;
+    serverManifest?: import("vite").Manifest | undefined;
+    clientManifest?: import("vite").Manifest | undefined;
+    rscWorker?: import("worker_threads").Worker | undefined;
+    htmlWorker?: import("worker_threads").Worker | undefined;
+    importedCss?: Set<string> | undefined;
+    rscStream?: import("stream").Readable | undefined;
+    htmlStream?: import("stream").Readable | undefined;
+    metrics?: import("../types.js").StreamMetrics | undefined;
+    url?: string;
+    resolvedPageProps?: Record<string, unknown>;
+    dataPort: MessagePort;
+    controlPort: MessagePort;
+    options: Omit<import("../types.js").CreateHandlerOptions<ResolvedUserOptions>, "onEvent" | "onMetrics" | "loader" | "build" | "autoDiscover" | "normalizer" | "moduleID" | "url" | "logger"> & {
+        cssFiles?: Map<string, import("../types.js").CssContent>;
+        globalCss?: Map<string, import("../types.js").CssContent>;
+        url?: string;
+        build: Omit<import("../types.js").CreateHandlerOptions<ResolvedUserOptions>["build"], "entryFileNames" | "chunkFileNames" | "assetFileNames" | "pages"> & {
+            pages: string[];
+        };
+        PageComponent?: any;
+        pageProps?: any;
+        RootComponent?: any;
+        HtmlComponent?: any;
+        resolvedPageProps?: Record<string, unknown>;
+    };
+    type: "INIT";
+    id: string;
+    route: string;
+    pagePath: string;
+    propsPath: string | undefined;
+    rootPath: string | undefined;
+    htmlPath: string | undefined;
+    rootExportName: string;
+    htmlExportName: string;
+    pageExportName: string;
+    propsExportName: string;
+    projectRoot: string;
+    moduleRootPath: string;
+    moduleBaseURL: string;
+    moduleBasePath: string;
+    moduleBase: string;
+    serverPipeableStreamOptions: any;
+    verbose: boolean;
+    build: Omit<Pick<Required<import("../types.js").BuildConfig>, "client" | "server" | "static" | "outDir" | "assetsDir" | "pages" | "preserveModulesRoot" | "rscOutputPath" | "htmlOutputPath">, "entryFileNames" | "assetFileNames" | "chunkFileNames" | "pages"> & {
+        pages: string[];
+    };
+    rscTimeout: number;
+    panicThreshold: import("../types.js").PanicThreshold;
+    publicOrigin: string;
+};
+//# sourceMappingURL=mergeMessageWithDefaults.d.ts.map

package/dist/plugin/helpers/mergeMessageWithDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeMessageWithDefaults.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/mergeMessageWithDefaults.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,gBAAgB,EACzB,kBAAkB,GAAE,OAAO,CAAC,mBAAmB,CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAmEuE,CAAC;iBAAwC,CAAC;WAAkC,CAAC;;;;qBAA0Q,CAAC;iBAAoB,CAAC;qBAAwB,CAAC;qBAAwB,CAAC;yBAA+G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;EAD5oB"}

package/dist/plugin/helpers/mergeMessageWithDefaults.js

@@ -0,0 +1,67 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { DEFAULT_CONFIG } from '../config/defaults.js';
+
+function mergeMessageWithDefaults(message, defaultUserOptions = {}) {
+  const options = message.options || {};
+  const {
+    type = "INIT",
+    id,
+    route = options.route,
+    pagePath = options.pagePath,
+    propsPath = options.propsPath,
+    rootPath = options.rootPath,
+    htmlPath = options.htmlPath,
+    rootExportName = options.rootExportName ?? defaultUserOptions.rootExportName ?? DEFAULT_CONFIG.ROOT_EXPORT_NAME,
+    htmlExportName = options.htmlExportName ?? defaultUserOptions.htmlExportName ?? DEFAULT_CONFIG.HTML_EXPORT_NAME,
+    pageExportName = options.pageExportName ?? defaultUserOptions.pageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT_NAME,
+    propsExportName = options.propsExportName ?? defaultUserOptions.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT_NAME,
+    projectRoot = options.projectRoot ?? defaultUserOptions.projectRoot,
+    moduleRootPath = options.moduleRootPath ?? defaultUserOptions.moduleRootPath ?? "",
+    moduleBaseURL = options.moduleBaseURL ?? defaultUserOptions.moduleBaseURL ?? DEFAULT_CONFIG.MODULE_BASE_URL,
+    moduleBasePath = options.moduleBasePath ?? defaultUserOptions.moduleBasePath ?? DEFAULT_CONFIG.MODULE_BASE_PATH,
+    moduleBase = options.moduleBase ?? defaultUserOptions.moduleBase ?? "",
+    serverPipeableStreamOptions = options.serverPipeableStreamOptions ?? defaultUserOptions.serverPipeableStreamOptions,
+    verbose = options.verbose ?? defaultUserOptions.verbose ?? DEFAULT_CONFIG.VERBOSE,
+    build = options.build ?? defaultUserOptions.build ?? DEFAULT_CONFIG.BUILD,
+    rscTimeout = options.rscTimeout ?? defaultUserOptions.rscTimeout ?? DEFAULT_CONFIG.RSC_TIMEOUT,
+    panicThreshold = options.panicThreshold ?? defaultUserOptions.panicThreshold ?? DEFAULT_CONFIG.PANIC_THRESHOLD,
+    publicOrigin = options.publicOrigin ?? defaultUserOptions.publicOrigin ?? DEFAULT_CONFIG.PUBLIC_ORIGIN,
+    HtmlComponent: _htmlComponent = options.HtmlComponent,
+    // Ignore message component, use parameter
+    RootComponent: _rootComponent = options.RootComponent,
+    // Ignore message component, use parameter
+    ...rest
+  } = { ...message, ...options };
+  return {
+    type,
+    id,
+    route,
+    pagePath,
+    propsPath,
+    rootPath,
+    htmlPath,
+    rootExportName,
+    htmlExportName,
+    pageExportName,
+    propsExportName,
+    projectRoot,
+    moduleRootPath,
+    moduleBaseURL,
+    moduleBasePath,
+    moduleBase,
+    serverPipeableStreamOptions,
+    verbose,
+    build,
+    rscTimeout,
+    panicThreshold,
+    publicOrigin,
+    ...rest
+  };
+}
+
+export { mergeMessageWithDefaults };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/helpers/pipeToResponse.d.ts

@@ -0,0 +1,19 @@
+import type { ServerResponse } from "node:http";
+import type { ReadableStream } from "node:stream/web";
+import type { Logger } from "vite";
+import type { PanicThreshold } from "../types.js";
+export interface PipeToResponseOptions {
+    stream: ReadableStream<Uint8Array> | any;
+    response: ServerResponse;
+    contentType: string;
+    logger: Logger;
+    verbose?: boolean;
+    panicThreshold?: PanicThreshold;
+    context?: string;
+}
+/**
+ * Pipes a ReadableStream to an HTTP response with proper error handling and headers.
+ * This is a common pattern used across the plugin for streaming responses.
+ */
+export declare function pipeToResponse(options: PipeToResponseOptions): void;
+//# sourceMappingURL=pipeToResponse.d.ts.map

package/dist/plugin/helpers/pipeToResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeToResponse.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/pipeToResponse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC;IACzC,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAsDnE"}

package/dist/plugin/helpers/pipeToResponse.js

@@ -0,0 +1,55 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { Readable } from 'node:stream';
+import { handleError } from '../error/handleError.js';
+import { getNodeEnv } from '../config/getNodeEnv.js';
+
+function pipeToResponse(options) {
+  const { stream, response, contentType, logger, verbose = false, panicThreshold = "none", context = "pipeToResponse" } = options;
+  if (!response.writable) {
+    if (verbose) {
+      logger.warn(`[${context}] Response not writable, skipping pipe`);
+    }
+    return;
+  }
+  const readable = Readable.fromWeb(stream);
+  let headersSent = false;
+  readable.on("data", (chunk) => {
+    if (!headersSent) {
+      response.setHeader("Content-Type", contentType);
+      response.setHeader("Transfer-Encoding", "chunked");
+      response.setHeader("Connection", "keep-alive");
+      headersSent = true;
+    }
+    response.write(chunk);
+  });
+  readable.on("end", () => {
+    response.end();
+  });
+  readable.on("error", (error) => {
+    const panicError = handleError({
+      error,
+      logger,
+      mode: getNodeEnv(),
+      panicThreshold});
+    if (panicError != null) {
+      throw panicError;
+    }
+    if (verbose) {
+      logger.info(`[${context}] Stream error caught, headersSent: ${headersSent}, setting status to 500`);
+    }
+    if (!headersSent) {
+      response.statusCode = 500;
+      response.setHeader("Content-Type", "text/x-component; charset=utf-8");
+      response.end();
+    } else {
+      response.end();
+    }
+  });
+}
+
+export { pipeToResponse };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/helpers/requestInfo.d.ts

@@ -1,17 +1,18 @@
-import type { ResolvedUserOptions } from "../types.js";
-import { type Connect, type Logger } from "vite";
+import type { CreateHandlerOptions } from "../types.js";
+import { type Connect } from "vite";
 /**
  * # Request info
  *
  * Does the initial work to check if the request is for html, rsc, json, js, css, server-action, or something else not handled by this plugin.
  *
  * @param req
- * @param userOptions
+ * @param handlerOptions
  * @param hostDir
  * @returns
  */
-export declare function requestInfo(req: Connect.IncomingMessage, userOptions: Pick<ResolvedUserOptions, "normalizer" | "build" | "autoDiscover" | "verbose" | "moduleBasePath" | "moduleBaseURL" | "verbose">, hostDir: string, logger?: Logger): {
+export declare function requestInfo(req: Connect.IncomingMessage, handlerOptions: Pick<CreateHandlerOptions, "normalizer" | "build" | "autoDiscover" | "verbose" | "moduleBasePath" | "moduleBaseURL" | "verbose" | "logger">, hostDir: string): {
     route: string;
+    url: string;
     ext: string;
     isHtmlRequest?: undefined;
     isRscRequest?: undefined;
@@ -39,6 +40,7 @@ export declare function requestInfo(req: Connect.IncomingMessage, userOptions: P
     isFormActionRequest?: undefined;
 } | {
     route: string;
+    url: string;
     ext: string;
     isHtmlRequest: boolean;
     isRscRequest: boolean | undefined;

package/dist/plugin/helpers/requestInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requestInfo.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/requestInfo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAgB,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AAI/D;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,CAAC,eAAe,EAC5B,WAAW,EAAE,IAAI,CACf,mBAAmB,EACjB,YAAY,GACZ,OAAO,GACP,cAAc,GACd,SAAS,GACT,gBAAgB,GAChB,eAAe,GACf,SAAS,CACZ,EACD,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuLhC"}
+{"version":3,"file":"requestInfo.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/requestInfo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAKpC;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,CAAC,eAAe,EAC5B,cAAc,EAAE,IAAI,CAClB,oBAAoB,EAClB,YAAY,GACZ,OAAO,GACP,cAAc,GACd,SAAS,GACT,gBAAgB,GAChB,eAAe,GACf,SAAS,GACT,QAAQ,CACX,EACD,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0MhB"}